Argument Self-loop (write -> self-check -> ledger -> revise)

Purpose: upgrade C5 from “generate text” to “execute argument actions under explicit constraints”.

This skill operationalizes the mechanism you described as a reusable, pipeline-native component:

• - write section-by-section
• self-check paragraph-by-paragraph
• maintain a small argument ledger that makes dependencies explicit
• revise only what fails until the chain is continuous

It complements (not replaces) the other self-loops:

• - evidence-selfloop: blocks writing when packs are not writeable (do not pad)
• INLINECODE1: blocks template voice, missing sections/leads, scope/citation violations
• INLINECODE2 (this skill): blocks argument discontinuity and premise drift (even when prose is fluent)

Core idea: two intermediate artifacts (never in the paper)

This skill treats “argument structure” as a first-class intermediate artifact, like evidence packs.

Outputs:

• - output/SECTION_ARGUMENT_SUMMARIES.jsonl (structured; per-section/per-paragraph argument moves)
• INLINECODE4 (compact narrative + dependency map; not a prose restatement)
• INLINECODE5 (PASS/FAIL + actionable edits)

These files are not reader-facing and must never be merged into output/DRAFT.md.

Downstream:

• - paragraph-curator uses output/SECTION_ARGUMENT_SUMMARIES.jsonl (moves/outputs) + the ## Consistency Contract to run a controlled select->evaluate->subset->fuse pass without changing citation keys.

What this self-loop enforces (your 3 invariants)

After you complete a section (H3 or key front matter), the section must satisfy:

1) Correct narrative linkage (paragraph-to-paragraph)

• - the relation between adjacent paragraphs is explicit (cause/contrast/refinement/boundary)
• no silent topic-switch; no “jump cut”

2) Closed argument loop (section-level)
The section answers, in its own text (not in a hidden outline):

• - what question is it resolving?
• what argument path does it take?
• what is the conclusion?
• what premises does the conclusion rely on?

3) Premises + definitions are explicit and stable

• - new terms / protocol assumptions are defined at first use
• the definition matches global usage (no drift)
• task/metric/constraint assumptions do not silently change across sections

The self-check must result in concrete edits: add a missing definition, add a bridge sentence, add an explicit contrast, add a scope boundary, delete/reorder a paragraph, or strengthen the local conclusion.

Paragraph contract (argument actions)

Every paragraph must execute at least one argument action and be locally self-consistent.
Use this action set (can be combined, but never empty):

• - Claim: a testable judgement/conclusion (avoid generic background)
• INLINECODE11: introduce a concept, assumption, task definition, protocol, comparison set
• INLINECODE12: reasoning chain or evidence support (including citations)
• INLINECODE13: clarify differences, remove ambiguity
• INLINECODE14: applicability limits, failure modes, threats to validity
• INLINECODE15: a reusable takeaway / constraint that downstream paragraphs can rely on

One-sentence self-check (per paragraph):

• - "This paragraph’s action(s) are: <…>. Its output is: <…>."

If you cannot answer, the paragraph must be rewritten/merged/split until the action and output are clear.

How to run it (LLM-first workflow)

1) Pick the scope of this pass

• - default: run it after writer-selfloop PASS, before merge
• incremental: run it after finishing 1-2 H3s, so you catch drift early

2) For each target section file (start with H3 bodies)

• - read the section
• do a paragraph-by-paragraph action labeling in the ledger, not in the prose
• identify failures (missing definition, missing bridge, missing conclusion, implicit premise)
• apply the fix to the section file (sections/S<sub_id>.md) without changing citation keys

3) Update the two-level ledger

• - write/update the record for that section in INLINECODE18
• update output/ARGUMENT_SKELETON.md so it reflects:

4) Write output/ARGUMENT_SELFLOOP_TODO.md

• - - Status: FAIL + a list of concrete edits when any section fails
• INLINECODE22 only when all required sections are coherent and premises are stable

5) Rerun until PASS

Output contract

output/ARGUMENT_SELFLOOP_TODO.md

Must exist and start with:

• - INLINECODE24

Recommended structure (keep it short and debuggable):

• - INLINECODE25
• INLINECODE26 (per file)
• INLINECODE27

output/SECTION_ARGUMENT_SUMMARIES.jsonl

JSONL (one record per section/subsection).

Required fields per record:

• - kind: h3 | front_matter | discussion | conclusion (minimal set)
• INLINECODE34: for H3 use the subsection id (e.g., "3.2")
• INLINECODE36
• INLINECODE37, section_title (for H3)
• INLINECODE39: what this unit does in the paper (e.g., mechanism, evaluation_lens, risk_lens, synthesis)
• INLINECODE44: list of premises/definitions it assumes
• INLINECODE45: list of premises/definitions/conclusions it introduces
• INLINECODE46: list of objects, each with:

Notes:

• - This is an intermediate ledger: short, structural, no prose restatement.
• Do not paste long sentences from the draft. Use short summaries.

output/ARGUMENT_SKELETON.md

A compact narrative/dependency map (not a retelling of the paper).

It should include:

• - each H2/H3's necessity (what gap it fills)
• explicit dependencies (premises consumed, outputs produced)
• a global Consistency Contract section (single source of truth) that must not drift across edits:

Minimum format requirement:

• - output/ARGUMENT_SKELETON.md must contain a heading line: INLINECODE58

Change rule (regression trigger):

• - If you change any definition/protocol assumption/term naming, update the Consistency Contract first, then revise the affected sections/*.md to match, and rerun this self-loop until PASS.

Keep it "writer-facing": no reader signposting, no “in this section we…”.

Routing rules (avoid polishing around missing substance)

• - If a section cannot produce a justified claim without new evidence: STOP and route to evidence-selfloop.
• If a section fails due to template voice / missing citations / out-of-scope keys: route to writer-selfloop / citation-* first.
• This skill is for argument continuity and premise hygiene, not for adding new facts.

Script (generator + validator)

This skill includes a validator script so the pipeline can block on missing ledgers.
It does not write paper prose, but it does generate the required ledger artifacts from existing sections/*.md files and then validates coverage/consistency.

Quick Start

• - INLINECODE64

All Options

• - INLINECODE65
• INLINECODE66
• INLINECODE67
• INLINECODE68
• INLINECODE69

Examples

• - Validate the ledgers exist + are PASS + cover all H3: