@eir-labs/coltrane 0.4.0

package/skills/statutory-checklist/meta.json

@@ -0,0 +1,10 @@
+{
+  "slug": "statutory-checklist",
+  "version": 1,
+  "skill_type": "verification",
+  "input_type": "statute-assessments",
+  "output_type": "statutory-checklist",
+  "determinism_ratio": 1.0,
+  "permission": { "tier": 0 },
+  "description": "Scaffold the patentability statutory checklist (§101 eligibility, §102 anticipation, §103 obviousness, §112 enablement+definiteness): every statute always present with its question; the examiner fills each verdict. all_cleared is derived (true iff every statute is marked cleared). Deterministic structure — the rubric the adversary cannot skip a statute on."
+}

package/skills/statutory-checklist/skill.mjs

@@ -0,0 +1,25 @@
+// statutory-checklist — the §101/§102/§103/§112 rubric the examiner must complete in full.
+// Pure/deterministic. Every statute is always present with its question; the examiner supplies
+// per-statute { cleared, rejection } in input.assessments keyed by statute. all_cleared is
+// derived (true iff every statute is explicitly cleared) — an unaddressed statute is NOT cleared,
+// so the adversary cannot pass a claim by silence.
+const STATUTES = [
+  { statute: "§101", question: "Is the claim directed to patent-eligible subject matter (not an abstract idea / law of nature without an inventive concept)?" },
+  { statute: "§102", question: "Is the claim anticipated — does a single prior-art reference disclose every element?" },
+  { statute: "§103", question: "Is the claim obvious over a combination of references to a person of ordinary skill?" },
+  { statute: "§112", question: "Is the claim enabled and definite — could a skilled person build it, and is each term bounded?" },
+];
+export default function run(input) {
+  const a = (input && typeof input.assessments === "object" && input.assessments) || {};
+  const checklist = STATUTES.map((s) => {
+    const got = a[s.statute] || {};
+    return {
+      statute: s.statute,
+      question: s.question,
+      cleared: got.cleared === true,
+      rejection: typeof got.rejection === "string" ? got.rejection : null,
+    };
+  });
+  const all_cleared = checklist.every((c) => c.cleared);
+  return { checklist, all_cleared, statutes_checked: STATUTES.map((s) => s.statute) };
+}

package/skills/summarize-tight/fixtures/basic.json

@@ -0,0 +1,13 @@
+{
+  "id": "basic",
+  "description": "contract: produces the typed output. Runs once the reasoning half is resolved in eval mode — see skills open questions.",
+  "input": {
+    "text": "the new index halves p99 latency; it shipped tuesday"
+  },
+  "assertions": [
+    {
+      "path": "summary",
+      "op": "is_string"
+    }
+  ]
+}

package/skills/summarize-tight/meta.json

@@ -0,0 +1,20 @@
+{
+  "slug": "summarize-tight",
+  "version": 1,
+  "skill_type": "analysis",
+  "permission": {
+    "tier": 0
+  },
+  "domain": "demo",
+  "output_schema": {
+    "type": "object",
+    "properties": {
+      "summary": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "summary"
+    ]
+  }
+}

package/skills/summarize-tight/skill.md

@@ -0,0 +1 @@
+Compose the gist in one tight clause. Use only the supplied facts; no filler.

package/skills/verdict-gate/fixtures/basic.json

@@ -0,0 +1,9 @@
+{
+  "id": "fileable-with-coverage-and-survival",
+  "description": "FILEABLE with a patent corpus searched and a survived round passes through",
+  "input": { "recommended": "FILEABLE", "corpora_searched": ["USPTO PatentsView", "literature"], "survival_count": 1 },
+  "assertions": [
+    { "path": "recommended", "op": "equals", "value": "FILEABLE" },
+    { "path": "gated", "op": "equals", "value": false }
+  ]
+}

package/skills/verdict-gate/meta.json

@@ -0,0 +1,10 @@
+{
+  "slug": "verdict-gate",
+  "version": 1,
+  "skill_type": "verification",
+  "input_type": "triage-verdict",
+  "output_type": "triage-verdict",
+  "determinism_ratio": 1.0,
+  "permission": { "tier": 0 },
+  "description": "The hard guard that sits as its own chair between the judge's candidate verdict and the sealed triage-verdict: a FILEABLE candidate lacking patent-corpus coverage OR a survived examine round is deterministically downgraded to INSUFFICIENT-EVIDENCE, with the gate reasons recorded. Runtime enforcement, not prompt guidance — the wrong verdict cannot be sealed."
+}

package/skills/verdict-gate/skill.mjs

@@ -0,0 +1,82 @@
+// verdict-gate — the hard guard on the triage verdict. Pure/deterministic.
+//
+// Runs as a skill-backed CHAIR (not bound prompt guidance): the gate is the seat between the
+// judge's candidate verdict and the final triage-verdict, so a FILEABLE the evidence doesn't
+// support can never be sealed downstream:
+//   - coverage gate: FILEABLE requires a patent corpus to have actually been searched
+//     (>=1 patent corpus named in corpora_searched). Searched-and-found-nothing still counts;
+//     never-searched does not.
+//   - survival gate: FILEABLE requires survival_count >= 1 (the claim cleared an examine round).
+// A FILEABLE failing either is downgraded to INSUFFICIENT-EVIDENCE with the reason recorded.
+// Non-FILEABLE candidates pass through unchanged.
+//
+// As a chair, its input is the MERGE of its depends_on roles (the judge's candidate verdict +
+// the search coverage-report + the latest examine-round-record), so it reads:
+//   recommended      ← the candidate verdict
+//   corpora_searched ← the coverage-report (entries may be strings OR {corpus,status} objects)
+//   survival_count   ← explicit, else derived from the examine-round-record's `survived` boolean
+// It seals a triage-verdict: a deterministic recommended + rationale, plus the gate provenance.
+const PATENT_CORPUS = /patent|patentsview|uspto|espacenet|lens/i;
+
+// A coverage-report corpus entry is either a bare string or an object {corpus|name, status}.
+function corpusName(c) {
+  if (typeof c === "string") return c;
+  if (c && typeof c === "object") return String(c.corpus ?? c.name ?? "");
+  return "";
+}
+
+export default function run(input) {
+  const recommended = String((input && input.recommended) || "");
+  const corpora = Array.isArray(input && input.corpora_searched) ? input.corpora_searched : [];
+  // survival_count is preferred when supplied; otherwise derive it from the examine-round-record's
+  // `survived` boolean (survived → the claim cleared >=1 round). Absent both → 0 (never survived).
+  let survival = Number(input && input.survival_count);
+  if (!Number.isFinite(survival) || (input && input.survival_count == null)) {
+    survival = input && input.survived === true ? 1 : 0;
+  }
+  const hasPatentCoverage = corpora.some((c) => PATENT_CORPUS.test(corpusName(c)));
+
+  const gate_reasons = [];
+  let finalRec = recommended;
+  if (recommended === "FILEABLE") {
+    if (!hasPatentCoverage) {
+      finalRec = "INSUFFICIENT-EVIDENCE";
+      gate_reasons.push("coverage gate: no patent corpus was searched — novelty cannot be asserted");
+    } else if (survival < 1) {
+      finalRec = "INSUFFICIENT-EVIDENCE";
+      gate_reasons.push("survival gate: the claim did not survive an examine round");
+    }
+  }
+  const gated = finalRec !== recommended;
+  // Deterministic rationale — the gate does NOT borrow the candidate's prose (the merged blob
+  // can carry other roles' `rationale`); it states the gate outcome plainly. The judge's full
+  // reasoning lives in the separately-sealed verdict-record.
+  const rationale = gated
+    ? `Gated to ${finalRec} from ${recommended}: ${gate_reasons.join("; ")}.`
+    : `${finalRec} upheld — patent coverage: ${hasPatentCoverage}; survived rounds: ${survival}.`;
+  return {
+    recommended: finalRec,
+    rationale,
+    original_recommended: recommended,
+    gated,
+    gate_reasons,
+    has_patent_coverage: hasPatentCoverage,
+    survival_count: survival,
+    // The evidence this verification rests on, as the Verdict core requires (#227/#228).
+    // Not decoration: these are the two gates above, restated as the auditable record of
+    // what was actually checked. The gate already computed both — it simply never wrote
+    // them down, so a sealed triage-verdict named its conclusion but not its grounds.
+    checks: [
+      {
+        method: "coverage-gate",
+        target_ref: "coverage-report.corpora_searched",
+        result: hasPatentCoverage ? "pass" : "fail",
+      },
+      {
+        method: "survival-gate",
+        target_ref: "examine-round-record.survived",
+        result: survival >= 1 ? "pass" : "fail",
+      },
+    ],
+  };
+}

package/standards/e2e-suite-v0.json

@@ -0,0 +1,44 @@
+{
+  "slug": "e2e-suite-v0",
+  "domain": "e2e",
+  "agent_slugs": [
+    "e2e-runner",
+    "e2e-suite-judge"
+  ],
+  "phases": [
+    {
+      "name": "run",
+      "chairs": [
+        {
+          "role": "verify",
+          "agent_slug": "e2e-runner",
+          "depends_on": [],
+          "input_contract": [],
+          "output_contract": [
+            "e2e-verdict"
+          ],
+          "required_skills": []
+        }
+      ]
+    },
+    {
+      "name": "judge",
+      "chairs": [
+        {
+          "role": "judge",
+          "agent_slug": "e2e-suite-judge",
+          "depends_on": [
+            "verify"
+          ],
+          "input_contract": [
+            "e2e-verdict"
+          ],
+          "output_contract": [
+            "e2e-report"
+          ],
+          "required_skills": []
+        }
+      ]
+    }
+  ]
+}

package/standards/patent-triage-v0.json

@@ -0,0 +1,98 @@
+{
+  "slug": "patent-triage-v0",
+  "domain": null,
+  "description": "Patentability check / patent triage v0. Takes an invention description and produces the cleanest single-sentence independent claim plus named failure modes; searches a prior-art corpus for nearest-neighbor matches and aggregates a novelty-verdict; refines the claim under the single-cleave discipline given the novelty-verdict; judges GO / NO-GO / NEEDS-WORK with an optional provisional-draft.",
+  "agent_slugs": [
+    "diamond-cutter",
+    "novelty-searcher",
+    "claim-rewriter",
+    "verdict-judger"
+  ],
+  "phases": [
+    {
+      "name": "cleave",
+      "chairs": [
+        {
+          "role": "cleave",
+          "agent_slug": "diamond-cutter",
+          "depends_on": [],
+          "input_contract": [],
+          "output_contract": [
+            "claim-draft",
+            "failure-modes"
+          ],
+          "required_skills": [
+            "diamond-cutting-discipline"
+          ]
+        }
+      ],
+      "intent": "Find the clean cleave plane. From the invention-spec, produce one single-sentence independent claim, enumerate ≥3 named failure modes with bounds, and enumerate ≥5 distinctions (what this is NOT relative to prior art). Outputs: claim-draft + failure-modes."
+    },
+    {
+      "name": "search-novelty",
+      "chairs": [
+        {
+          "role": "search-novelty",
+          "agent_slug": "novelty-searcher",
+          "depends_on": [],
+          "input_contract": [],
+          "output_contract": [
+            "prior-art-hit",
+            "novelty-verdict"
+          ],
+          "required_skills": [
+            "diamond-cutting-discipline"
+          ]
+        }
+      ],
+      "intent": "Search a prior-art corpus (patents + literature) for nearest-neighbor matches to the claim; report hits with similarity scores; aggregate into a novelty-verdict (PASS / FAIL / TOO-CLOSE-TO-CALL). Outputs: prior-art-hit (list) + novelty-verdict."
+    },
+    {
+      "name": "refine-claim",
+      "chairs": [
+        {
+          "role": "refine-claim",
+          "agent_slug": "claim-rewriter",
+          "depends_on": [],
+          "input_contract": [],
+          "output_contract": [
+            "claim-draft"
+          ],
+          "required_skills": [
+            "diamond-cutting-discipline"
+          ]
+        }
+      ],
+      "intent": "Rewrite the claim to maximize defensible scope given the novelty-verdict; enforce single-cleave discipline (one independent claim, ≤3 functional elements joined by `comprising`). Output: refined claim-draft."
+    },
+    {
+      "name": "judge",
+      "chairs": [
+        {
+          "role": "judge",
+          "agent_slug": "verdict-judger",
+          "depends_on": [],
+          "input_contract": [],
+          "output_contract": [
+            "triage-verdict",
+            "provisional-draft"
+          ],
+          "optional_outputs": [
+            "provisional-draft"
+          ],
+          "required_skills": [
+            "diamond-cutting-discipline"
+          ]
+        }
+      ],
+      "intent": "Produce the final FILEABLE / REFINE-FIRST / NOT-FILEABLE verdict with named axis of refinement when needed. When FILEABLE, also produce a provisional-draft skeleton. Outputs: triage-verdict (always) + provisional-draft (FILEABLE only)."
+    }
+  ],
+  "input_types": [
+    "invention-spec"
+  ],
+  "output_types": [
+    "triage-verdict",
+    "provisional-draft"
+  ]
+}

package/standards/patent-triage-v1.json

@@ -0,0 +1,84 @@
+{
+  "slug": "patent-triage-v1",
+  "domain": "patent-triage",
+  "description": "Patentability triage v1 — grounded and adversarial. analyze the disclosure -> draft the broadest defensible claim + dependent tree -> search patents AND literature (coverage-report attests the corpus) -> map element x reference anticipation -> examine (adversary tries to reject on every statute) -> amend to survive -> judge renders the candidate verdict -> gate (a deterministic skill-backed chair) hard-guards it (no FILEABLE without patent coverage + a survived round; INSUFFICIENT-EVIDENCE otherwise) -> draft a provisional with real enablement only when FILEABLE. The gate is runtime enforcement, not prompt guidance. The examine<->amend loop is caller-driven up to max_examine_rounds; survival is a predecessor chain over examine-round-records.",
+  "agent_slugs": [
+    "disclosure-analyst",
+    "claim-architect",
+    "prior-art-scout",
+    "anticipation-mapper",
+    "patent-examiner",
+    "claim-amender",
+    "triage-judge",
+    "spec-drafter"
+  ],
+  "phases": [
+    {
+      "name": "analyze",
+      "chairs": [
+        { "role": "analyze", "agent_slug": "disclosure-analyst", "depends_on": [], "input_contract": [], "output_contract": ["invention-analysis"], "required_skills": [] }
+      ],
+      "intent": "De-spin the disclosure: state the real technical contribution, contrast it with what the inventor claims is novel, enumerate candidate inventive concepts (plural) and embodiments."
+    },
+    {
+      "name": "claim",
+      "chairs": [
+        { "role": "claim", "agent_slug": "claim-architect", "depends_on": ["analyze"], "input_contract": ["invention-analysis"], "output_contract": ["claim-draft"], "required_skills": ["claim-element-decompose", "diamond-cutting-discipline"] }
+      ],
+      "intent": "Cut the broadest defensible independent claim AND a dependent fallback tree; grade the cleave; name every stripped feature as representation vs load-bearing."
+    },
+    {
+      "name": "search",
+      "chairs": [
+        { "role": "search", "agent_slug": "prior-art-scout", "depends_on": ["claim"], "input_contract": ["claim-draft"], "output_contract": ["prior-art-hit", "novelty-verdict", "coverage-report"], "required_skills": ["query-expand", "patent-fetch", "citation-verify"] }
+      ],
+      "intent": "Search patents (USPTO PatentsView) AND literature per claim element; retrieve + verify each hit (fetched, not snippet); emit a coverage-report attesting which corpora were actually searched."
+    },
+    {
+      "name": "map",
+      "chairs": [
+        { "role": "map", "agent_slug": "anticipation-mapper", "depends_on": ["claim", "search"], "input_contract": ["claim-draft", "prior-art-hit"], "output_contract": ["novelty-analysis"], "required_skills": ["element-mapping-matrix"] }
+      ],
+      "intent": "Build the element x reference anticipation matrix (§102 per element + §103 obviousness combinations) with a derived coverage_fraction. Evidence only — no rejection call."
+    },
+    {
+      "name": "examine",
+      "chairs": [
+        { "role": "examine", "agent_slug": "patent-examiner", "depends_on": ["claim", "map"], "input_contract": ["claim-draft", "novelty-analysis"], "output_contract": ["examiner-rejection"], "required_skills": ["statutory-checklist"] }
+      ],
+      "intent": "Adversary: try to reject the claim on every statute (§101/§102/§103/§112) via the statutory checklist; silence on a statute is not a clear. The only seat that rejects."
+    },
+    {
+      "name": "amend",
+      "chairs": [
+        { "role": "amend", "agent_slug": "claim-amender", "depends_on": ["claim", "examine"], "input_contract": ["claim-draft", "examiner-rejection"], "output_contract": ["examine-round-record"], "required_skills": ["claim-element-decompose"] }
+      ],
+      "intent": "Narrow the claim to overcome the rejections or concede; seal an examine-round-record chained to its predecessor so survival is recomputable across rounds."
+    },
+    {
+      "name": "judge",
+      "chairs": [
+        { "role": "judge", "agent_slug": "triage-judge", "depends_on": ["search", "map", "examine", "amend"], "input_contract": ["coverage-report", "novelty-analysis", "examiner-rejection", "examine-round-record"], "output_contract": ["triage-verdict", "verdict-record"], "required_skills": ["citation-verify"] }
+      ],
+      "intent": "Render the CANDIDATE verdict (FILEABLE / REFINE-FIRST / NOT-FILEABLE / INSUFFICIENT-EVIDENCE) from the evidence and seal a verdict-record with predecessor links to the disclosure, coverage-report, and final examine-round-record. The hard gate is a separate deterministic chair downstream — the judge states its honest recommendation; it does not enforce the gate itself."
+    },
+    {
+      "name": "gate",
+      "chairs": [
+        { "role": "gate", "skill_slug": "verdict-gate", "depends_on": ["judge", "search", "amend"], "input_contract": ["triage-verdict", "coverage-report", "examine-round-record"], "output_contract": ["triage-verdict"], "required_skills": [] }
+      ],
+      "intent": "The hard guard, as deterministic code (no model): downgrade a FILEABLE candidate to INSUFFICIENT-EVIDENCE unless a patent corpus was actually searched (coverage gate) AND the claim survived >=1 examine round (survival gate). Seals the final, gated triage-verdict the drafter acts on — runtime enforcement, not prompt guidance."
+    },
+    {
+      "name": "draft",
+      "chairs": [
+        { "role": "draft", "agent_slug": "spec-drafter", "depends_on": ["claim", "gate"], "input_contract": ["claim-draft", "triage-verdict"], "output_contract": ["provisional-draft"], "required_skills": [] }
+      ],
+      "intent": "Only on a FILEABLE verdict (the gated one from the gate chair): a provisional with real §112 enablement — at least one worked embodiment + how-to-build, the surviving claim tree, and an abstract. On any other verdict, nothing."
+    }
+  ],
+  "max_examine_rounds": 3,
+  "eval_slugs": ["claim-tree-eval", "enablement-eval"],
+  "input_types": ["invention-disclosure"],
+  "output_types": ["triage-verdict", "verdict-record", "provisional-draft"]
+}

package/standards/seed-from-local-repos-v0.json

@@ -0,0 +1,115 @@
+{
+  "slug": "seed-from-local-repos-v0",
+  "domain": "seeding",
+  "description": "Day-1 bootstrap-the-bootstrap. Run once when a user first clones coltrane-oss. Conducts a sweep of the user's existing local repos, distills implicit patterns into draft agents/standards/types, and lets the user accept/reject before adoption. The cold-start solution: instead of preseeding abstract defaults, the framework LEARNS the user from their own work and then tunes the preseed to their domain. Seeding exercise, not ongoing crawl.",
+  "agent_slugs": [
+    "domain-explorer",
+    "problem-definer",
+    "solution-developer",
+    "delivery-finalizer"
+  ],
+  "phases": [
+    {
+      "name": "discover",
+      "chairs": [
+        {
+          "role": "discover",
+          "agent_slug": "domain-explorer",
+          "depends_on": [],
+          "input_contract": [],
+          "output_contract": [
+            "repo-survey"
+          ],
+          "required_skills": []
+        }
+      ],
+      "intent": "Diverge. Scan the user's home directory (default: ~/) for git repositories. Per repo, produce a survey-level signal: README first lines, manifest files, commit rhythm (30d), top-level structure, CLAUDE.md/.claude presence. Survey only — no deep code read, no file-by-file analysis. Bounded by parameters fixed at the start of the run: top-N most-recently-touched repos (default N=20), max-depth 1 below ~/, skip node_modules + venv + .git internals."
+    },
+    {
+      "name": "define",
+      "chairs": [
+        {
+          "role": "define",
+          "agent_slug": "problem-definer",
+          "depends_on": [],
+          "input_contract": [],
+          "output_contract": [
+            "project-charter"
+          ],
+          "required_skills": []
+        }
+      ],
+      "intent": "Converge. From the repo-survey cohort, extract a pattern-extraction interpretation: user_signature (one-line characterization), recurrent_workflows (multi-step sequences observed across repos), agent_like_roles (implicit roles the user plays), recurrent_domain_shapes (data shapes the user repeatedly works with). State the prediction: these N patterns are real and these M agents/standards/types are worth drafting. Abort condition: pattern_extraction.confidence_band = low across all observations. Out of scope for this phase: proposing anything specific to a future project — this phase only names the user's existing work-shape. Freeze the prediction before continuing."
+    },
+    {
+      "name": "develop",
+      "chairs": [
+        {
+          "role": "develop",
+          "agent_slug": "solution-developer",
+          "depends_on": [],
+          "input_contract": [],
+          "output_contract": [
+            "Artifact"
+          ],
+          "required_skills": []
+        }
+      ],
+      "intent": "Generate drafts. For each agent_like_role → emit a draft-agent-profile with proposed primitives + system_prompt + tools_allowlist. For each recurrent_workflow → emit a draft-standard with phases. For each recurrent_domain_shape → emit a draft-domain-type with extends + schema. All start at user_acceptance: pending. Present drafts to the user inline (conductor mode). User reviews + responds (accept / reject / refine). On accept: write to .coltrane/agents/, .coltrane/standards/, .coltrane/types/. On refine: user edits inline, then accept. On reject: discard. NEVER auto-adopt — user accepts every artifact at the boundary."
+    },
+    {
+      "name": "deliver",
+      "chairs": [
+        {
+          "role": "deliver",
+          "agent_slug": "delivery-finalizer",
+          "depends_on": [],
+          "input_contract": [],
+          "output_contract": [
+            "Verdict"
+          ],
+          "required_skills": []
+        }
+      ],
+      "intent": "Finalize and report. Emit a seeding-verdict: how many surveyed, how many extracted, how many drafted, how many accepted/refined/rejected per kind. Classify the run: complete (every kind had ≥1 acceptance), partial (some kinds empty), refined (user refined heavily — different result than expected), aborted-low-confidence (low confidence + no acceptances), aborted-by-user (user stopped mid-flight). Update the user's README to mirror the active fleet (Claude-maintained 'active projects' section)."
+    }
+  ],
+  "execution_modes": {
+    "conductor_mode": {
+      "default": true,
+      "description": "User clones coltrane-oss, says 'let's do seed-from-local-repos-v0' or 'fan out and learn about my work from my local repos'. Claude reads this standard, walks the 4 phases, prompts the user at each phase boundary + each draft-acceptance moment.",
+      "user_invocation_examples": [
+        "let's do seed-from-local-repos-v0",
+        "fan out and learn about my work from my local repos",
+        "learn my work",
+        "seed coltrane from my existing repos"
+      ]
+    },
+    "dispatch_mode": {
+      "description": "Power-user: each phase dispatched as a subagent via Task tool. Allowlist enforcement at the subagent boundary."
+    },
+    "score_is_the_same": "The standard JSON IS the score regardless of mode."
+  },
+  "outputs": {
+    "discover": [
+      "repo-survey"
+    ],
+    "define": [
+      "pattern-extraction"
+    ],
+    "develop": [
+      "draft-agent-profile",
+      "draft-standard",
+      "draft-domain-type"
+    ],
+    "deliver": [
+      "seeding-verdict"
+    ]
+  },
+  "out_of_scope": [
+    "NOT an ongoing crawl — this is a one-time seeding exercise. Re-running it later is allowed (e.g., quarterly) but each run is a discrete cycle.",
+    "NOT a code-aware deep read — survey-level only. Repo-survey signals capture shape, not mechanism.",
+    "NOT auto-adoption — every draft requires user accept at the develop→deliver seam.",
+    "NOT scanning everything — bounded by top-N + max-depth + skip-list. Fixed at the start of the run."
+  ]
+}

package/standards/sub_thread_invocation.json

@@ -0,0 +1,50 @@
+{
+  "slug": "sub_thread_invocation",
+  "domain": "self_judge",
+  "agent_slugs": [
+    "sub_thread_trace_sensor",
+    "sub_thread_soft_judge"
+  ],
+  "phases": [
+    {
+      "name": "sense",
+      "chairs": [
+        {
+          "role": "sense",
+          "agent_slug": "sub_thread_trace_sensor",
+          "depends_on": [],
+          "input_contract": [],
+          "output_contract": [
+            "parsed-conversation-trace"
+          ],
+          "required_skills": []
+        }
+      ]
+    },
+    {
+      "name": "interpret",
+      "chairs": [
+        {
+          "role": "interpret",
+          "agent_slug": "sub_thread_soft_judge",
+          "depends_on": [],
+          "input_contract": [],
+          "output_contract": [
+            "soft-verdict"
+          ],
+          "required_skills": []
+        }
+      ]
+    }
+  ],
+  "identity": {
+    "id": "sub_thread_invocation@1",
+    "name": "Sub-thread invocation soft-judge",
+    "version": 1,
+    "purpose": "Self-referential: coltrane judges coltrane's own phase-15 e2e sub-thread tests on four soft criteria the hard-asserts can't reach. SENSE parses a transcript + recorder log into a turn list; INTERPRET LLM-scores parent-context preservation, child stay-on-task, inter-turn coherence, and graceful degradation."
+  },
+  "prompt_templates": {
+    "sense": "You are the SENSE phase of the sub_thread_invocation standard.\n\nINPUT: gig_input.transcript_path (string, absolute) + gig_input.recorder_log_path (string, absolute). Either file may be empty or missing — that is itself a finding and must be reported verbatim.\n\nTASK: parse the transcript (typically stream-json from `claude -p --output-format stream-json`) into a structured `parsed-conversation-trace`. For each turn extract: parent_session_id (null if root), child_session_id, prompt (user/parent prompt text), response (assistant text), timestamp (ISO8601 or null), tool_calls (array, may be empty). Also report whether the recorder log was empty.\n\nOUTPUT (single JSON object, no fence, no prose):\n{\n  \"transcript_path\": \"<echo of input>\",\n  \"recorder_log_path\": \"<echo of input>\",\n  \"transcript_present\": <bool>,\n  \"recorder_log_present\": <bool>,\n  \"recorder_log_empty\": <bool>,\n  \"turns\": [\n    { \"turn_idx\": 0, \"parent_session_id\": null, \"child_session_id\": \"<sid>\", \"prompt\": \"<text>\", \"response\": \"<text>\", \"timestamp\": \"<iso or null>\", \"tool_calls\": [] }\n  ],\n  \"notes\": \"<any honesty-note about parse failures or empty inputs>\"\n}\n\nIf the transcript file is missing or empty, set transcript_present=false, turns=[], and put the diagnosis in `notes`. Do NOT fabricate turns.",
+    "interpret": "You are the INTERPRET phase of the sub_thread_invocation standard — the soft-judge.\n\nINPUT: a `parsed-conversation-trace` from the SENSE phase (gig_input.trace).\n\nTASK: score the conversation on four soft criteria the hard-asserts cannot reach. Each criterion gets a 0-100 score and a rationale grounded in the actual turns (or, if turns=[], a rationale that names exactly why the criterion cannot be judged from this trace).\n\nCRITERIA:\n  a. parent_context_preservation: when the child --resumes with a follow-up, does the parent's named context (deals, units, north-stars, prior outputs) survive into the child's next response? Look for echoes of prior-turn entities.\n  b. child_stay_on_task: across N turns, does the assistant stay focused on the parent's original ask, or drift to unrelated content?\n  c. inter_turn_coherence: do successive responses build on each other (referencing prior turns, accumulating state) or read as disjoint single-shots?\n  d. graceful_degradation: if the conversation exceeds the context window or hits a structural failure, does the response degrade gracefully (summarize + continue, name the limit) or hard-fail (stack trace, silent corruption)?\n\nnot-judgeable CASE: if turns=[] (because the underlying test failed before producing a transcript), do NOT fabricate scores. Set each score to null and put the diagnosis in `rationale`. Set `overall_verdict_shade` to \"unjudgeable\".\n\nVERDICT SHADE (overall):\n  - \"full-soft-pass\": all four scores >= 70, no structural failures\n  - \"partly\": at least one score >= 70 AND no score in {null, 0..29}, OR mixed signal\n  - \"fail\": any score < 30 OR a structural failure observed\n  - \"unjudgeable\": turns=[] or trace insufficient\n\nOUTPUT (single JSON object, no fence, no prose):\n{\n  \"criteria\": {\n    \"parent_context_preservation\": { \"score\": <0-100 or null>, \"rationale\": \"<text>\" },\n    \"child_stay_on_task\":          { \"score\": <0-100 or null>, \"rationale\": \"<text>\" },\n    \"inter_turn_coherence\":        { \"score\": <0-100 or null>, \"rationale\": \"<text>\" },\n    \"graceful_degradation\":        { \"score\": <0-100 or null>, \"rationale\": \"<text>\" }\n  },\n  \"overall_verdict_shade\": \"full-soft-pass | partly | fail | unjudgeable\",\n  \"top_insight\": \"<the one finding the hard-asserts missed; ground it in a specific turn or in the structural absence of one>\"\n}"
+  }
+}

package/standards/summarize.json

@@ -0,0 +1,40 @@
+{
+  "slug": "summarize",
+  "domain": "demo",
+  "agent_slugs": [
+    "sensor",
+    "summarizer"
+  ],
+  "phases": [
+    {
+      "name": "sense",
+      "chairs": [
+        {
+          "role": "sense",
+          "agent_slug": "sensor",
+          "depends_on": [],
+          "input_contract": [],
+          "output_contract": [
+            "raw-note"
+          ],
+          "required_skills": []
+        }
+      ]
+    },
+    {
+      "name": "interpret",
+      "chairs": [
+        {
+          "role": "interpret",
+          "agent_slug": "summarizer",
+          "depends_on": [],
+          "input_contract": [],
+          "output_contract": [
+            "summary"
+          ],
+          "required_skills": []
+        }
+      ]
+    }
+  ]
+}