Command Reference

Every command, what it dispatches, and what it produces

Quick Lookup

Command Flags / Modes What It Does
/new-project [topic] — Full orchestrated pipeline: idea to paper
/discover interview, lit, data, ideate Discovery phase: interview, literature, data, ideation
/strategize strategy, pap, pap interactive, theory Empirical strategy, pre-analysis plan, or formal theory section
/analyze [dataset] --dual [langs] End-to-end data analysis (single or parallel language)
/explain [script \| all] --quiz, --grade, --microworld, --status Explainer + quiz for agent-written code; feeds the INV-26 understanding gate
/write [section] intro, strategy, results, conclusion, data, model, abstract, full, humanize, style-guide Draft sections, strip AI patterns, or extract personal voice
/paper-format [mode] audit, scaffold, table1, show Apply and check the paper house style (INV-23/24/25)
/review [file] --peer [journal], --peer --r2, --stress [journal], --methods, --theory, --proofread, --code, --replicate [lang], --all Quality reviews (routes by target + flags)
/coherence [file] --deep, --fix, --strict, --json Internal-consistency audit: refs, citations, numbers vs. tables, notation
/deepread [section] --dry-run, --segment segNN, --skeptic Deep technical read on Codex, no Claude tokens (runs only when typed)
/revise [report] — R&R cycle: classify + route referee comments
/talk create, audit, compile; formats: job-market, seminar, short, lightning; --beamer Presentations (Quarto RevealJS default, Beamer opt-in)
/submit target, package, audit, final Submission pipeline
/tools commit, compile, validate-bib, lint, journal, context, deploy, learn, dashboard, upgrade Utilities
/dashboard refresh, create, add-changelog TITLE Build or refresh project_dashboard.html
/checkpoint --auto, --memory-only, --scaffold-only, --dry-run, --setup-obsidian Session handoff: memory + logs + Obsidian
/freeze [dirs] off Block edits outside specified directories until turned off
/careful off Block destructive bash commands until turned off

Detailed Skill Reference

/new-project

Syntax: /new-project [topic] or /new-project interactive

What happens:

  1. Enter plan mode. Create the folder scaffold (data/, scripts/, paper/, quality_reports/). Draft a high-level plan and save it to quality_reports/plans/. Wait for user approval.
  2. Run /discover interview to produce the research specification and domain profile.
  3. Run /discover lit and /discover data in parallel — librarian and explorer agents search for literature and datasets.
  4. Run /strategize to design the identification strategy. If the paper type calls for formal theory, also run /strategize theory.
  5. Run /analyze and /write to implement the strategy in code and draft the manuscript.
  6. Run /review --all and /review --peer for quality scoring and simulated peer review.
  7. Optionally run /submit for journal targeting and replication packaging.

Modes / Flags: None. This skill is always orchestrated through the full pipeline.

Agents dispatched:

Phase Agents Gate
Discovery Direct interview; librarian + librarian-critic; explorer + explorer-critic Research spec exists
Strategy Strategist + strategist-critic; optionally theorist + theorist-critic Strategist-critic verdict SOUND or MINOR ISSUES; theorist-critic >= 80 if theory
Execution Data-engineer + coder + coder-critic; writer Score >= 80
Peer Review Editor + domain-referee + methods-referee; all critics in parallel Editorial decision
Submission Coder + verifier; orchestrator Score >= 95, all components >= 80, every non-conditional component scored, understanding gate (INV-26)

Output artifacts:

  • quality_reports/research_spec_[topic].md
  • .claude/references/domain-profile.md
  • quality_reports/strategy_memo_[topic].md
  • scripts/R/ (analysis scripts)
  • paper/sections/ (LaTeX drafts)
  • quality_reports/reviews/ (referee reports)

What to do next: The pipeline pauses at each phase transition for your approval. Review the research spec, strategy memo, analysis results, and referee feedback at each gate before proceeding.

/discover

Syntax: /discover [mode] [topic or query]

What happens:

  1. Detect mode from arguments: interview (default), lit, data, or ideate.
  2. Read .claude/references/domain-profile.md for field calibration.
  3. Dispatch the appropriate agent(s).
  4. Run the paired critic (for lit and data modes).
  5. Save outputs to quality_reports/.

Modes / Flags:

Mode Description
interview (default) Structured 5–8 exchange conversation to formalize a research idea
lit [topic] Literature search with citation chains, proximity scores (1–5), and critic review
data [question] Dataset discovery with feasibility grades (A/B/C/D) and 5-point critique
ideate [topic] Generate 3–5 ranked research questions with strategies

Agents dispatched:

Mode Agents Output Path
interview Direct conversation (no agent dispatch) quality_reports/research_spec_[topic].md, .claude/references/domain-profile.md, quality_reports/decisions/discovery_[topic].md
lit Librarian + librarian-critic quality_reports/lit_review_[topic].md + HTML report + BibTeX entries
data Explorer + explorer-critic quality_reports/data_exploration_[topic].md
ideate Direct generation quality_reports/research_ideas_[topic].md

Output artifacts:

  • Interview: Research specification, domain profile (if still template), decision record documenting rejected alternatives.
  • Literature: Annotated bibliography with proximity scores, BibTeX entries, frontier map, interactive HTML report. Unverified citations marked % UNVERIFIED.
  • Data: Ranked dataset list with feasibility grades. Each dataset assessed on measurement validity, sample selection, external validity, identification compatibility, and known issues. Includes a rejection table for discarded datasets.
  • Ideation: 3–5 research questions ranked by feasibility and novelty, each with a candidate identification strategy.

What to do next: After interview, review the research spec and confirm it matches your vision. After lit or data, check coverage gaps flagged by the critic. Proceed to /strategize once discovery outputs exist.

/strategize

Syntax: /strategize [mode] [question or spec path]

What happens:

  1. Read discovery outputs (research spec, literature review, data assessment) and domain profile.
  2. Output a mandatory Pre-Strategy Report (or Pre-Theory Report) proving inputs were loaded.
  3. Dispatch the creator agent (Strategist or Theorist).
  4. Dispatch the paired critic for adversarial review (4 sequential phases, early-stop on critical gaps).
  5. Iterate up to 3 rounds if critical issues found.
  6. Save the memo, review, and decision record.

Modes / Flags:

Mode Description
strategy (default) Design identification strategy for any of the 4 paper types
pap [spec] Draft pre-analysis plan in AEA/OSF/EGAP format
pap interactive Guided 6-question PAP interview, then draft
theory [target] Formal theory section: assumptions, theorems, proofs

Agents dispatched:

Mode Agents Output Path
strategy Strategist + strategist-critic quality_reports/strategy_memo_[topic].md, quality_reports/strategy_memo_[topic]_review.md, quality_reports/decisions/strategy_[topic].md
pap Strategist (PAP mode); optionally strategist-critic quality_reports/pre_analysis_plan_[topic].md
theory Theorist + theorist-critic quality_reports/theory/[topic]/theory_memo.md, assumptions.tex, results.tex, proofs.tex, notation_glossary.md

Output artifacts:

  • Strategy: Strategy memo (design choice, estimand, assumptions, pseudo-code, robustness plan, falsification tests, top 5 referee objections). Decision record with rejected alternatives and invalidation conditions. HTML report.
  • PAP: Full pre-analysis plan with 10 standard sections. Platform-adapted for AEA/OSF/EGAP. ASSUMED placeholders flagged with a pre-registration checklist. Adapted for observational studies when applicable.
  • Theory: Theory memo, LaTeX files for assumptions/results/proofs, notation glossary. Decision record linking each theorem to its empirical claim. Theorist-critic score contributes 20% to weighted aggregate when present.

What to do next: Review the strategy memo carefully — it becomes the contract the Coder implements. Confirm the identification strategy, assumptions, and robustness plan. For theory mode, verify proof correctness and assumption minimality before proceeding.

/analyze

Syntax: /analyze [dataset path or goal] or /analyze --dual r,python

What happens:

  1. Output a mandatory Pre-Code Report proving the strategy memo, domain profile, and naming map were loaded.
  2. If raw data provided, dispatch Data-engineer for cleaning, variable construction, and summary statistics.
  3. Dispatch Coder for the main specification, robustness checks, and publication-ready output.
  4. Dispatch coder-critic for the full 16-category review.
  5. Iterate up to 3 rounds on critical or major issues.
  6. Once coder-critic passes (>= 80), dispatch the explainer for a delta-explainer and quiz per script (see /explain).
  7. Present results summary with estimates, scripts, outputs, and code review score.

Modes / Flags:

Mode Description
default Single-language analysis (R by default, or as declared in CLAUDE.md)
--dual [lang1,lang2] Parallel analysis in two languages with cross-language comparison

Agents dispatched:

Mode Agents Output Path
default Data-engineer + Coder + coder-critic scripts/R/, paper/tables/, paper/figures/, quality_reports/results_summary.md
--dual Data-engineer + 2 Coders (parallel) + 2 coder-critics + comparison Same as above for both languages + quality_reports/cross_language_comparison.md

Output artifacts:

  • Numbered scripts in scripts/R/ (or language-appropriate directory) following the standard layout: 00_master, 01_setup, 02_data_preparation, 03_descriptive, 04_estimation, 05_robustness, 06_figures, 07_tables.
  • Publication-ready tables (.tex) in paper/tables/. Bare tabular environments only — no \begin{table} wrappers.
  • Publication-ready figures (.pdf) in paper/figures/. No titles inside figures.
  • results_summary.md with all point estimates, standard errors, sample sizes, and anomaly flags. This is the mandatory handoff artifact to the Writer.
  • .rds files for every computed object (model fits, cleaned data, summary statistics).
  • Code review report in quality_reports/.

What to do next: Read results_summary.md to understand the findings. Check that estimates align with your expectations. Review the code review report for any unresolved issues. Proceed to /write to draft the paper.

/explain

Syntax: /explain [script path | all] [--quiz | --grade | --microworld | --status]

Correctness is what /review checks; comprehension is what this checks.

What happens:

  1. Run scripts/explainer_status.py: one row per script, CURRENT, STALE (script changed since its explainer), or MISSING.
  2. Dispatch the explainer with the script, strategy memo, and results_summary.md. It writes a delta-explainer (only what departs from the memo, plus a sample-construction ledger), a 5-question quiz, and a separate answer key.
  3. If the ledger comes back NOT INSTRUMENTED, offer to have the coder print drop counts, then re-run and re-explain. The explainer never guesses a count.
  4. Ask all five questions at once, no answers in view. Grade against the key: pass = 4/5 with Q1 correct.
  5. Log the attempt to quality_reports/explainers/understanding_log.md.

Modes / Flags:

Invocation Description
/explain [script] Explainer + quiz, then offer to run the quiz
/explain all Every script --status flags as missing or stale
--quiz Ask the five questions, grade, log
--grade Grade answers already in the conversation
--microworld Also build an interactive single-file HTML micro-world
--status Coverage table only

Agents dispatched: Explainer; coder only if the ledger needs instrumenting.

Output artifacts:

  • quality_reports/explainers/{script}_explainer.md, {script}_quiz.md, {script}_quiz_key.md
  • quality_reports/explainers/understanding_log.md

Gate: INV-26. /write results warns when the script behind the tables has no passing attempt; /submit blocks until every script behind a paper exhibit has a current explainer and a passing attempt at its current fingerprint. Pass/fail only — it never enters the weighted score.

/write

Syntax: /write [section or mode] [file path]

What happens:

  1. Read all available context: existing draft, research spec, strategy memo, domain profile, bibliography, generated tables and figures, results_summary.md.
  2. Detect paper type (reduced-form, structural, theory+empirics, descriptive) from the strategy memo.
  3. Load personal style guide from .claude/references/personal-style-guide.md if it exists.
  4. Dispatch Writer with type-specific section templates and paragraph-level argument moves.
  5. Run cleanup pass to strip AI writing patterns.
  6. Present through drafting gates, pausing for approval.

Modes / Flags:

Mode Description
intro Introduction with type-specific moves (preview, result, contribution)
strategy Empirical strategy (reduced-form), model + estimation (structural), or model + tests (theory+empirics)
results Results narration adapted to output type (tables, event studies, counterfactuals)
conclusion Conclusion with type-appropriate ending
data Data section (expanded for descriptive papers)
model Model section (structural or theory+empirics only)
abstract Abstract, 100–150 words (requires other sections first)
full All sections in sequence with 3 drafting gates
humanize [file] Strip 24 AI writing patterns without rewriting content
style-guide [dir] One-shot extraction of personal voice from prior papers

Agents dispatched:

Mode Agent Output Path
[section] / full Writer paper/sections/[section].tex
humanize Writer (cleanup mode) Edited file in place
style-guide Writer (style-extraction mode) .claude/references/personal-style-guide.md

Output artifacts:

  • LaTeX section files in paper/sections/.
  • Claim-source map in quality_reports/claim_source_map_[project].md linking every numerical claim to its source table, figure, or computation.
  • Personal style guide (for style-guide mode) documenting sentence-length distribution, passive-voice frequency, lexicon patterns, and citation conventions.

What to do next: Review each drafted section for accuracy and voice. The Writer uses TBD placeholders for missing results — fill these in or re-run after /analyze completes. Run /review --proofread for manuscript polish, or /review --peer for simulated peer review.

/paper-format

Syntax: /paper-format [audit | scaffold | table1 | show] [target file] (default: audit)

Applies the mandatory paper house style. The specification lives in .claude/rules/paper-organization.md; this skill operationalizes it. The writer-critic and verifier enforce the same invariants.

Modes / Flags:

Mode Description
audit [main.tex] (default) Pass/fail list against INV-23 (floats collected at the end of main.tex, none in section files), INV-24 (Table 1 = pre-treatment characteristics, two group columns, no difference/SD/p-value column), INV-25 (threeparttable / subcaption wrappers), booktabs. No edits unless asked
scaffold [main.tex] Insert the TABLES and FIGURES blocks after the bibliography and move inline floats into them
table1 Build Table 1 from the project’s panel: bare tabular plus the canonical wrapper in main.tex
show Print the table, figure, and Table 1 templates for copy-paste

Agents dispatched: None.

What to do next: Fix float placement with scaffold, then re-run audit. /coherence also flags INV-23 and INV-24 violations mechanically.

/review

Syntax: /review [file path or --flag] [journal]

The most polymorphic skill in the system. Routing depends on file type and flags.

What happens:

  1. Detect review mode from arguments: auto-detect by file extension, or use explicit flag.
  2. Dispatch the appropriate critic agent(s).
  3. Run the mechanical pass before the judgment review: lint for code reviews, scripts/style_metrics.py whenever the writer-critic is dispatched (it has no Bash, so /review hands it the counts).
  4. Produce scored reports. Critics never edit files — they produce reports only.
  5. Save reports to quality_reports/ with HTML versions and dashboard refresh.

Modes / Flags:

Flag Description
(auto .tex paper) Comprehensive review: writer-critic + strategist-critic + verifier in parallel
(auto .R/.py/.jl) Code review: coder-critic standalone (categories 5–16)
(auto .tex in talks/) Talk review: storyteller-critic
--peer [journal] Full simulated peer review: editor desk review, referee dispatch on a fenced copy of the manuscript, editorial decision
--peer --r2 [journal] R&R round 2: same referees remember prior reports
--stress [journal] Hostile stress test: adversarial dispositions, double critical pet peeves
--methods [file] Causal audit only: strategist-critic 4-phase review
--theory [file] Proof audit only: theorist-critic 4-phase review (logical validity, assumption minimality, citations, linkage)
--proofread [file] Manuscript polish only: style_metrics.py counts, then writer-critic categories 4, 5, 6, 8 of 8
--code [file] Code review only: coder-critic categories 5–16 (no strategy comparison)
--replicate [lang] Cross-language replication: re-implement in target language, compare outputs
--all All critics in parallel; scripts/score.py computes the weighted aggregate

Flag combinations: --peer and --r2 combine (for R&R second round). --peer and --stress are mutually exclusive — --stress replaces the peer flow with adversarial dispositions. All other flags are standalone and do not combine.

Agents dispatched:

Flag Agents Output Path
(auto .tex) writer-critic + strategist-critic + verifier quality_reports/
(auto code) coder-critic quality_reports/[file]_code_review.md
--peer Editor + domain-referee + methods-referee (3 sequential phases; referees read a fenced copy outside the repo) quality_reports/reviews/YYYY-MM-DD_desk_review.md, _referee_domain.md, _referee_methods.md, _editorial_decision.md
--peer --r2 Same referees (reload dispositions from round 1) quality_reports/reviews/ with _r2 suffix
--stress Editor + 2 adversarial referees (SKEPTIC disposition, 2 critical pet peeves each) quality_reports/reviews/
--methods strategist-critic quality_reports/[file]_strategy_review.md
--theory theorist-critic quality_reports/theory_[topic]_review.md
--proofread writer-critic quality_reports/[file]_proofread_report.md
--code coder-critic quality_reports/[file]_code_review.md
--replicate Coder (replication) + coder-critic Replicated script + comparison report
--all All critics in parallel (theorist-critic included when theory section exists) quality_reports/ + weighted aggregate score (computed by score.py)

Peer review details: The editor reads the paper and decides DESK REJECT or SEND TO REFEREES. If sent, the editor assigns each referee a disposition (STRUCTURAL, CREDIBILITY, MEASUREMENT, POLICY, THEORY, or SKEPTIC) plus one critical and one constructive pet peeve from the journal’s referee pool. Both referees review independently and blind. In round 1 they read a fenced copy of the manuscript outside the repository, away from earlier verdicts in quality_reports/reviews/; --peer --r2 deliberately reuses round 1. Every major comment must include “what would change my mind.” The editor then classifies each concern as FATAL, ADDRESSABLE, or TASTE and produces an editorial decision: Accept / Minor Revisions / Major Revisions / Reject. When a journal name is provided, the entire flow calibrates to that journal’s profile.

R&R rounds: Round 2 skips desk review. Same referees check whether each prior concern was resolved, partially resolved, or not addressed. Round 3 (max) allows Accept, Minor, or Reject only.

Scoring:

Mode Blocking? Gate
Comprehensive Yes 80 commit, 90 PR
Peer Review Yes Editorial decision
Stress Test Advisory Non-blocking
Code Review Yes 80 commit
Causal Audit Yes Verdict: SOUND or MINOR ISSUES to proceed
Proofread Yes (paper), advisory (talks) 80 commit

What to do next: Read the reports. For peer review, address MUST items first, then SHOULD items. For code review, fix critical and major issues, then re-run. For --all, check which components are below 80 and focus there.

/coherence

Syntax: /coherence [file path] [--deep] [--fix] [--strict] [--json]

Is the paper internally sound? Not whether it is any good — that is /review. Every deterministic finding is checkable: a reference resolves or it does not, a number appears in the cited table or it does not.

What happens:

  1. Layer 1 (always): scripts/paper_coherence.py checks cross-references, citation keys, \input and graphics targets, claim numbers against the cells of the tables they cite, derived arithmetic, orphan floats, duplicate macros, abstract length (INV-5), and Table 1 columns (INV-24). Standard library only; exits 1 on a blocking finding.
  2. Layer 2 (--deep): coherence-finder runs once per non-empty check group (specification, claims, continuity, notation, theory), each in its own context; one coherence-skeptic per group with findings tries to refute them; coherence-consolidator merges and ranks the survivors.
  3. Save the report and refresh the dashboard.

Modes / Flags:

Invocation Description
/coherence Layer 1 over the whole paper
/coherence [file] Layer 1 scoped to one file
--deep Layer 1 + the reasoning pass (advisory, never blocks)
--fix Apply only unambiguous mechanical fixes (a mistyped label, a wrong graphic extension). Never edits a claim number
--strict Promote minor findings to blocking (before submission)
--json Emit the index only, no markdown

Agents dispatched: None for Layer 1. With --deep: coherence-finder × check group, coherence-skeptic × group with findings, coherence-consolidator once.

Output artifacts: quality_reports/coherence/YYYY-MM-DD_report.md and quality_reports/coherence/index.json.

What to do next: Fix blocking findings first; the report gives the nearest table cell for each number mismatch. A PASS with 0 table cells indexed means the tables could not be parsed, not that the paper is sound. Run this before /deepread and /review --peer.

/deepread

Syntax: /deepread [--dry-run | --segment segNN | --skeptic | path/to/section.tex]

A referee-grade technical reading of a near-final draft. Every model call runs on Codex (codex exec, read-only sandbox), so a run costs no Claude tokens. Runs only when you type it; never edits the paper.

What happens:

  1. scripts/deepread.py splits the paper into sections (via paper_coherence.py --segments), each carrying the tables, notes, and equations it cites.
  2. Readers comment on each segment in parallel: general always, rigor if it has equations, evidence if it has tables, skeptic with --skeptic.
  3. One verifier per segment tries to refute each comment; a consolidator merges duplicates and ranks; an overall assessment closes the report.

Modes / Flags:

Flag Description
--dry-run Print segments, agent count, and projected token cost, then stop. Run this first
--segment segNN One section only
--skeptic Add the adversarial reader (~+50% cost)
--jobs N, --min-segment-words N, --debug DIR, --out PATH Parallelism, segment merging, raw transcripts, report path

Agents dispatched: None — Codex readers driven by a Python script, with prompts in scripts/deepread_prompts/. Requires the codex CLI.

Output artifacts: quality_reports/deepread/YYYY-MM-DD_report.md — funnel (comments raised vs. survived, tokens spent vs. projected), overall assessment, and comments anchored to exact quotes. No score, no verdict.

What to do next: Run /coherence first so the readers do not spend comments on stale numbers. A full run on a 14-segment paper measured ~2.4M Codex tokens and ~30 minutes.

/revise

Syntax: /revise [referee-report-path] [paper-path]

What happens:

  1. Read the referee report(s) and the current paper.
  2. Classify every referee comment into one of 5 categories.
  3. Build a tracking document with counts and priorities.
  4. Dispatch agents for routable items (Writer for text changes, flag Coder tasks for user approval).
  5. Draft a point-by-point LaTeX response letter.
  6. Flag all DISAGREE items for mandatory user review.

Modes / Flags: None. This skill handles real R&R responses (not simulated reviews — use /review --peer for that).

Agents dispatched:

Classification Routed To Action
NEW ANALYSIS Coder (flagged for user approval first) Create analysis task
CLARIFICATION Writer Draft rewritten section
REWRITE Writer Structural revision
DISAGREE User (mandatory) Diplomatic pushback drafted, flagged for review
MINOR Writer Fix directly

Output artifacts:

  • quality_reports/referee_response_tracker.md — summary counts, action items by priority (HIGH/MEDIUM/FLAGGED/LOW)
  • quality_reports/referee_response_[journal]_[date].tex — LaTeX response letter with referee quotes, color-coded responses, page references
  • Revised section files in paper/sections/ (for CLARIFICATION and REWRITE items)

What to do next: Review all DISAGREE items — these require your judgment. Approve NEW ANALYSIS tasks before they execute. Check the response letter tone matches your voice. Proceed to /review --peer --r2 to simulate the next referee round.

/talk

Syntax: /talk [mode] [format] [--beamer] [file]

Quarto RevealJS is the default output format. Beamer is available via --beamer for departments or conferences that require PDF slides.

What happens:

  1. Parse mode (create, audit, compile) and format (job-market, seminar, short, lightning).
  2. For create: read the paper, extract key content, dispatch Storyteller to build the slide file, then dispatch storyteller-critic for review.
  3. For audit: run visual quality checks on existing slides.
  4. For compile: run quarto render (default) or latexmk (Beamer).

Modes / Flags:

Mode Description
create job-market 40–50 slides, 45–60 min, full story (Quarto RevealJS)
create seminar 25–35 slides, 30–45 min, motivation + main result + robustness
create short 10–15 slides, 15 min, question + method + key result
create lightning 3–5 slides, 5 min, hook + one result + so-what
create [format] --beamer Beamer LaTeX instead of Quarto RevealJS
audit [file] Visual layout check (overflow, fonts, sizing)
compile [file] Quarto or XeLaTeX compilation

Agents dispatched:

Mode Agents Output Path
create Storyteller + storyteller-critic paper/quarto/[format]_talk.qmd
create --beamer Storyteller + storyteller-critic paper/talks/[format]_talk.tex
audit Visual checks (no agent dispatch) Advisory report
compile Compilation only Compiled HTML or PDF

Output artifacts:

  • Quarto .qmd (default) or Beamer .tex file.
  • Storyteller-critic review in quality_reports/[format]_talk_review.md.
  • Talk scores are advisory (non-blocking).

What to do next: Review the generated slides against your paper. Check that all claims are traceable to the manuscript. Run /talk audit to catch overflow and sizing issues. Compile with /talk compile.

/submit

Syntax: /submit [mode] [journal]

What happens:

  1. Detect mode from arguments: target, package, audit, or final.
  2. For target: analyze contribution and recommend journals.
  3. For package: build AEA-compliant replication package with master script and documentation.
  4. For audit: run 10-point replication verification.
  5. For final: run comprehensive review + replication audit + gate enforcement (python3 scripts/score.py --gate submission, then python3 scripts/verify.py --mode submission).

Modes / Flags:

Mode Description
target Rank 3 journals by contribution fit, methodology fit, audience, desk rejection risk
package Build replication package: master script, README, data docs, codebook
audit 10-check verification of replication package
final [journal] Full gate: score >= 95, all components >= 80, every non-conditional component scored, and the understanding gate (INV-26, see /explain). Produces cover letter or blocks with issues

Agents dispatched:

Mode Agents Output Path
target Orchestrator (journal selection) quality_reports/journal_recommendations_[date].md
package Coder + Verifier paper/replication/
audit Verifier (10 checks) Pass/fail audit report
final All agents + gate enforcement quality_reports/quality_gate_[date].md + HTML report

Output artifacts:

  • Target: Ranked journal list with rationale.
  • Package: Master script, README, data documentation, codebook in paper/replication/.
  • Audit: Pass/fail on 10 checks (master script runs, tables reproduce, figures reproduce, README complete, data docs present, numbered script order, dependencies listed, runtime documented, output paths match, no hardcoded paths).
  • Final: Quality gate report. If PASS: cover letter draft + submission checklist. If FAIL: blocking issues listed.

What to do next: For target, pick a journal and confirm before proceeding. For package, run audit to verify completeness. For final, if it passes, review the cover letter draft and submit. If it fails, fix blocking issues and re-run.

/tools

Syntax: /tools [subcommand] [args]

Each subcommand is lightweight — no multi-agent orchestration.

Subcommands:

Subcommand Description
commit [message] Stage changes, run score.py --gate commit, create commit. Stops and names the low components if the score is below 80; passes with a notice when nothing is scored yet. Never stages .env or credentials. The git pre-commit gate (hooks) runs on every commit, including ones made outside this skill.
compile [file] LaTeX compilation via latexmk. Routes to paper/ or paper/talks/ based on file location.
validate-bib Cross-reference all \cite{} keys against Bibliography_base.bib. Reports missing, unused, and duplicate entries.
lint [file\|dir] Grep-based mechanical linting for R/Python/Julia against prohibited patterns. Catches setwd(), absolute paths, missing seed, T/F literals, sapply(), and more. Severity-graded (HIGH/MEDIUM/LOW). Advisory here; the git pre-commit gate blocks HIGH findings in staged analysis scripts.
journal Regenerate the research journal timeline from quality reports and git history.
context Show current context usage and session health. Check whether auto-compact is approaching.
dashboard [--open] Alias kept for /dashboard: runs generate_dashboard.py and opens the page by default.
deploy Render Quarto guide site and publish to GitHub Pages.
learn Extract reusable knowledge from the current session into auto-memory.
upgrade Upgrade to the latest clo-author release. Shows the plan and waits for approval. Replaces .claude/ (keeps the domain profile, custom journal profiles, and settings.local.json; your additions to settings.json move into settings.local.json), the scaffold scripts in scripts/ marked clo-author: infrastructure plus scripts/deepread_prompts/, and .githooks/ (then runs install-hooks.sh). Copies paper/preambles/header.tex only if missing. Never touches your analysis scripts, paper/, or data/. Finishes by running check_scaffold.py and test_hooks.py. See Upgrading.

What to do next: Run validate-bib before commits to catch broken citations. Run lint before /review --code to clear mechanical violations. Run /dashboard after any significant work to refresh the project overview.

/dashboard

Syntax: /dashboard [refresh | create | add-changelog TITLE]

Builds project_dashboard.html: one scrollable page with ten sections (overview, data, identification, literature, code, quality, history, plans, paper, changelog). scripts/generate_dashboard.py writes the operational skeleton; Claude hand-writes the research sections.

Modes / Flags:

Mode Description
refresh (default) Rebuild the operational sections (data, code, quality, history) from disk. Authored research sections and the changelog are preserved. If no dashboard exists yet, the script creates the skeleton first
create generate_dashboard.py --fresh, then ask for the research question, causal chain, contributions, and risks and write those sections
add-changelog TITLE Append a dated changelog entry (append-only)

Agents dispatched: None.

Output artifacts: project_dashboard.html in the project root. The Code section shows each script’s understanding status (PASSED / UNTESTED / STALE / MISSING) from explainer_status.py — the early warning for the INV-26 gate at /submit.

/freeze

Syntax: /freeze [dirs] or /freeze off

Edit guard. Blocks Write and Edit operations on files outside the specified directories until you turn it off.

What happens:

  1. Parse directory arguments from the command.
  2. Write guard configuration to .claude/state/session-guards.json.
  3. The session-guard.py PreToolUse hook enforces the restriction on every subsequent Edit or Write.
  4. Confirm what is frozen and what remains editable.

Examples:

Command Effect
/freeze paper/ Only allow edits in paper/
/freeze scripts/ data/ Only allow edits in scripts/ and data/
/freeze off Deactivate — all paths editable again

Behavior:

  • .claude/ is always editable regardless of freeze scope (we cannot freeze ourselves out of configuration changes)
  • Paths are relative to the project root
  • Persists until /freeze off — the guard file stays on disk across conversations and nothing clears it automatically (session-guard)
  • Only blocks Claude’s Edit and Write tools, not the user’s editor

When to use: During focused writing sessions (freeze everything except paper/), during code review (freeze everything except notes), or when editing data pipelines (freeze paper/ to prevent accidental manuscript changes).

/careful

Syntax: /careful or /careful off

Destructive command guard. Blocks Bash commands matching dangerous patterns before they execute, until you turn it off. It does not prompt before file writes.

What happens:

  1. Write guard configuration to .claude/state/session-guards.json.
  2. The session-guard.py PreToolUse hook tests every Bash command against destructive patterns.
  3. Matching commands are blocked with an explanation.

Blocked patterns:

Pattern What It Catches
rm -rf / rm -r Recursive force delete
git reset --hard Discard all uncommitted changes
git push --force / -f Overwrite remote history
git clean -f Delete untracked files
git checkout -- . Discard all working tree changes
git branch -D Force-delete branch
DROP TABLE / DROP DATABASE SQL destruction
chmod 777 Overly permissive permissions

Behavior:

  • Persists until /careful off — the guard file stays on disk across conversations and nothing clears it automatically
  • Only blocks Claude’s Bash tool, not the user’s terminal
  • Non-destructive commands pass through without delay
  • rm without -rf (single file deletion) is still allowed

When to use: Before deadlines, on critical branches, or whenever an extra safety net is worth the occasional blocked command. The cost is near-zero — the hook only fires on Bash calls, and pattern matching takes microseconds.

/checkpoint

Syntax: /checkpoint [--flag]

What happens:

  1. Gather context: run git log, git diff, scan today’s plans and session logs.
  2. Detect Obsidian configuration (.claude/state/obsidian-config.md).
  3. Draft a compact checkpoint summary: what happened, memory updates, scaffold updates, Obsidian updates.
  4. Present for user confirmation (one prompt, not five).
  5. Save to all targets in parallel: auto-memory, SESSION_REPORT, research journal, Obsidian (if configured), dashboard refresh.
  6. Confirm what was saved.

Flags:

Flag Effect
--auto Skip user confirmation, save immediately
--memory-only Only update Claude Code auto-memory
--scaffold-only Memory + SESSION_REPORT + research journal, skip Obsidian
--dry-run Show what would be saved without saving
--setup-obsidian Walk through creating .claude/state/obsidian-config.md from the example template

Agents dispatched: None. This is a direct operation with no agent dispatch.

Output artifacts:

  • ~/.claude/projects/.../memory/ — auto-memory files for future conversations.
  • SESSION_REPORT.md (project root) — append-only session log entry.
  • quality_reports/research_journal.md — agent-invocation trail (only if agent work happened).
  • Obsidian vault updates (only if configured): project-note journal entry, dashboard row, daily journal.
  • Refreshed project_dashboard.html.

What to do next: Run this before /compact, before ending a session, or whenever the user says “checkpoint,” “save progress,” or “wrap up.” The next session reads these artifacts to resume context.