elanous 0.2.35 → 0.2.37

package/graphs/work/recipes.yaml

@@ -1,2 +1,47 @@
 # work-research-report-rehearsal has no command nodes; its behavior is in called graph units.
-{}
+draft-close-decide:
+  command: 'bun scripts/graph-units/draft-close-node.ts decide'
+  dry_run_command: 'bun scripts/graph-units/draft-close-node.ts decide'
+  timeout_ms: 10000
+draft-close-emit-harvest:
+  command: 'bun scripts/graph-units/draft-close-node.ts emit harvest'
+  dry_run_command: 'bun scripts/graph-units/draft-close-node.ts emit harvest'
+  timeout_ms: 10000
+draft-close-emit-close-candidate:
+  command: 'bun scripts/graph-units/draft-close-node.ts emit close-candidate'
+  dry_run_command: 'bun scripts/graph-units/draft-close-node.ts emit close-candidate'
+  timeout_ms: 10000
+draft-close-emit-hold:
+  command: 'bun scripts/graph-units/draft-close-node.ts emit hold'
+  dry_run_command: 'bun scripts/graph-units/draft-close-node.ts emit hold'
+  timeout_ms: 10000
+e1:
+  command: >-
+    bun -e 'const c=await Bun.file(process.env.ELANOUS_GRAPH_CONTEXT).json(); const i=c.input??{}; const emit=x=>console.log(JSON.stringify(x)); const repo=process.env.ELANOUS_GRAPH_DIR+"/../.."; const run=(a)=>Bun.spawnSync(["git","-C",repo,...a],{stdout:"pipe",stderr:"pipe"}); const paths=Array.isArray(i.paths)?i.paths.filter(x=>typeof x==="string"&&!x.startsWith("/")&&!x.split("/").includes("..")):[]; if(i.main?.ref!=="origin/main"||!i.main?.sha||!Array.isArray(i.candidates)||i.candidates.length!==1||!paths.length){emit({outcome:"hold",reason:"main-candidate-or-scope-required",evidence:["E1 requires origin/main, one candidate, and declared relative scope paths"]});process.exit(0)} const head=run(["rev-parse","HEAD"]), ref=run(["rev-parse","--verify","origin/main"]), branch=run(["branch","--show-current"]), dirty=run(["status","--porcelain"]); if(head.exitCode!==0||ref.exitCode!==0||branch.exitCode!==0||dirty.exitCode!==0){emit({outcome:"hold",reason:"main-check-unreadable",evidence:["E1 could not verify checkout, branch, or worktree"]});process.exit(0)} const mainSha=ref.stdout.toString().trim(), checkoutSha=head.stdout.toString().trim(), branchName=branch.stdout.toString().trim(); if(mainSha!==i.main.sha||checkoutSha!==i.main.sha||branchName!=="main"||dirty.stdout.toString().trim()){emit({outcome:"hold",reason:"main-checkout-not-clean",branch:branchName,head:checkoutSha,evidence:["E1 requires clean main at supplied origin/main SHA"]});process.exit(0)} const candidate=i.candidates[0]; if(!Number.isSafeInteger(candidate.pr)||candidate.pr<1){emit({outcome:"hold",reason:"candidate-pr-missing",evidence:["E1 candidate has no valid PR number"]});process.exit(0)} const p=Bun.spawnSync(["gh","pr","view",String(candidate.pr),"--json","state,mergeCommit"],{cwd:repo,stdout:"pipe",stderr:"pipe"}); if(p.exitCode!==0){emit({outcome:"hold",reason:"pr-unreadable",pr:candidate.pr,evidence:["E1 gh pr view failed rc="+p.exitCode+" · "+p.stderr.toString().trim().slice(-300)]});process.exit(0)} let pr; try{pr=JSON.parse(p.stdout.toString())}catch{emit({outcome:"hold",reason:"pr-json-invalid",pr:candidate.pr,evidence:["E1 PR response was not JSON"]});process.exit(0)} if(pr.state!=="MERGED"){emit({outcome:"fail",reason:"pr-not-merged",pr:candidate.pr,evidence:["E1 PR state="+String(pr.state)]});process.exit(0)} const mergeSha=pr.mergeCommit?.oid; if(!/^[a-f0-9]{40}$/i.test(mergeSha??"")){emit({outcome:"hold",reason:"merge-sha-missing",pr:candidate.pr,evidence:["E1 merged PR has no full merge SHA"]});process.exit(0)} if(candidate.mergeSha&&candidate.mergeSha!==mergeSha){emit({outcome:"hold",reason:"candidate-merge-sha-mismatch",pr:candidate.pr,mergeSha,evidence:["E1 supplied merge SHA differs from GitHub"]});process.exit(0)} const ancestry=run(["merge-base","--is-ancestor",mergeSha,"origin/main"]); if(ancestry.exitCode!==0){emit({outcome:ancestry.exitCode===1?"fail":"hold",reason:ancestry.exitCode===1?"merge-not-in-main":"ancestry-unreadable",pr:candidate.pr,mergeSha,evidence:["E1 git merge-base --is-ancestor rc="+ancestry.exitCode]});process.exit(0)} const diff=run(["diff","--name-only",mergeSha+"^",mergeSha,"--",...paths]); if(diff.exitCode!==0){emit({outcome:"hold",reason:"scope-diff-unreadable",pr:candidate.pr,mergeSha,evidence:["E1 candidate scope diff could not be read"]});process.exit(0)} const changed=diff.stdout.toString().trim().split(/\r?\n/).filter(Boolean), scopePaths=paths.filter(x=>changed.includes(x)); if(!scopePaths.length){emit({outcome:"hold",reason:"scope-not-proven",pr:candidate.pr,mergeSha,evidence:["E1 merge diff does not touch declared cell paths"]});process.exit(0)} emit({outcome:"pass",pr:candidate.pr,mergeSha,branch:branchName,head:checkoutSha,scopePaths,evidence:["E1 merged PR is in origin/main and its merge diff covers declared cell scope"]});'
+  timeout_ms: 30000
+e2:
+  command: >-
+    bun -e 'const c=await Bun.file(process.env.ELANOUS_GRAPH_CONTEXT).json(); const i=c.input??{}; const emit=x=>console.log(JSON.stringify(x)); const repo=process.env.ELANOUS_GRAPH_DIR+"/../.."; const prior=c.outputs?.e1; if(prior?.outcome!=="pass"){emit({outcome:"hold",reason:"e1-not-passed",evidence:["E2 refused because E1 did not pass"]});process.exit(0)} const text=[i.title,i.evidence].filter(x=>typeof x==="string").join("\n"); const match=text.match(/완료 경계 증거 명령\s*:\s*([^\r\n]+)/); if(!match){emit({outcome:"hold",reason:"command-missing",evidence:["E2 no exact completion command in title/evidence"]});process.exit(0)} const command=match[1].trim(); const {parseGreenCloseEvidenceCommand,runGreenCloseEvidenceTest}=await import(repo+"/src/task-agent/green-close-recipe.ts"); const parsed=parseGreenCloseEvidenceCommand(command); if(!parsed.ok){emit({outcome:"hold",reason:"e2-command-not-allowed",command,evidence:["E2 accepts only bun test with repository-relative test paths and optional -t/--timeout; shell syntax and other commands are rejected"]});process.exit(0)} const sha=Bun.spawnSync(["git","-C",repo,"rev-parse","HEAD"],{stdout:"pipe",stderr:"pipe"}); if(sha.exitCode!==0||sha.stdout.toString().trim()!==i.main?.sha){emit({outcome:"hold",reason:"main-checkout-mismatch",command,evidence:["E2 checkout is not the supplied main SHA"]});process.exit(0)} let result; try{result=runGreenCloseEvidenceTest(repo,i.main.sha,parsed.args)}catch(error){emit({outcome:"hold",reason:"e2-readonly-worktree-failed",command,evidence:["E2 could not create or run the read-only test worktree: "+String(error).slice(-400)]});process.exit(0)} const measured=result.reason==="completion-command-passed"||result.reason==="completion-command-failed"; emit({outcome:!measured?"hold":result.exitCode===0?"pass":"fail",reason:result.reason,command,exitCode:result.exitCode,stdout:result.stdout,stderr:result.stderr,evidence:["E2 executed argv [bun,test,...] in a detached read-only worktree at "+i.main.sha+"; rc="+String(result.exitCode)]});'
+
+  timeout_ms: 930000
+e3:
+  command: >-
+    bun -e 'const c=await Bun.file(process.env.ELANOUS_GRAPH_CONTEXT).json(); const i=c.input??{}; const emit=x=>console.log(JSON.stringify(x)); const repo=process.env.ELANOUS_GRAPH_DIR+"/../.."; const e2=c.outputs?.e2; if(e2?.outcome!=="pass"){emit({outcome:"hold",verdict:"unmeasured",reason:"e2-not-passed",evidence:["E3 refused because E2 did not pass"]});process.exit(0)} const paths=Array.isArray(i.paths)?i.paths.filter(x=>typeof x==="string"):[]; const tests=paths.filter(x=>/\.test\.[cm]?[jt]sx?$/.test(x)); const production=paths.filter(x=>/\.[cm]?[jt]sx?$/.test(x)&&! /\.test\.[cm]?[jt]sx?$/.test(x)); if(!tests.length||!production.length){emit({outcome:"missing",verdict:"missing",reason:"test-or-production-path-missing",evidence:["E3 needs declared production and test paths"]});process.exit(0)} const {parseGreenCloseEvidenceCommand,analyzeProductionAssertion}=await import(repo+"/src/task-agent/green-close-recipe.ts"); const parsed=parseGreenCloseEvidenceCommand(String(e2.command??"")); if(!parsed.ok){emit({outcome:"hold",verdict:"unmeasured",reason:"e2-command-not-allowed",evidence:["E3 cannot consume an unapproved E2 command"]});process.exit(0)} const tsTestPaths=tests.filter(testPath=>parsed.args.includes(testPath)); let sawCall=false; for(const testPath of tsTestPaths){let source; try{source=await Bun.file(new URL(testPath,"file://"+repo+"/")).text()}catch{continue} const result=analyzeProductionAssertion(source,testPath,production.map(p=>new URL(p,"file://"+repo+"/").pathname)); sawCall ||= result.called; if(result.asserted){emit({outcome:"pass",verdict:"pass",reason:"test-asserts-imported-production-result",testPath,productionPaths:production,evidence:["E3 same test/it block imports a declared production entry, calls it, and asserts its result or a simple value alias"]});process.exit(0)}} if(sawCall){emit({outcome:"hold",verdict:"unmeasured",reason:"e3-no-assertion",evidence:["E3 found a production call in the commanded test file, but no assertion in that same test/it block consumes its result"]});process.exit(0)} emit({outcome:"missing",verdict:"missing",reason:"no-asserted-production-call",evidence:["E3 no commanded test block asserted a call to an import from a declared production path"]});'
+
+  timeout_ms: 30000
+produce:
+  command: >-
+    bun -e 'const c=await Bun.file(process.env.ELANOUS_GRAPH_CONTEXT).json(); const i=c.input??{}; const repo=process.env.ELANOUS_GRAPH_DIR+"/../.."; const context=process.env.ELANOUS_GRAPH_CONTEXT??"", marker=context.lastIndexOf("/graph-runs/"); const root=marker>=0?context.slice(0,marker):""; const {produceBoundaryProof}=await import(repo+"/src/task-agent/boundary-proof-producer.ts"); console.log(JSON.stringify(produceBoundaryProof({title:String(i.title??""),cellId:String(i.cellId??""),mainSha:String(i.main?.sha??""),mapRunId:String(i.mapRunId??""),cardId:String(i.cardId??""),graphRunId:String(c.runId??""),stateRoot:root,repoRoot:repo})));'
+  timeout_ms: 930000
+boundary:
+  command: >-
+    bun -e 'const c=await Bun.file(process.env.ELANOUS_GRAPH_CONTEXT).json(); const i=c.input??{}; const e1=c.outputs?.e1??{}, e2=c.outputs?.e2??{}, produced=c.outputs?.produce??{}; const repo=process.env.ELANOUS_GRAPH_DIR+"/../.."; const {verifyGreenCloseBoundary}=await import(repo+"/src/task-agent/green-close-recipe.ts"); const context=process.env.ELANOUS_GRAPH_CONTEXT??"", marker=context.lastIndexOf("/graph-runs/"); const root=marker>=0?context.slice(0,marker):""; console.log(JSON.stringify(verifyGreenCloseBoundary({title:String(i.title??""),evidence:String(i.evidence??""),paths:Array.isArray(i.paths)?i.paths:[],changedPaths:Array.isArray(e1.scopePaths)?e1.scopePaths:[],cellId:String(i.cellId??""),mainSha:String(i.main?.sha??""),stateRoot:root,repoRoot:repo,command:String(e2.command??""),mapRunId:String(i.mapRunId??""),cardId:String(i.cardId??""),graphRunId:String(c.runId??""),proofRef:String(produced.proofRef??"")})));'
+  timeout_ms: 30000
+make-test:
+  command: >-
+    bun -e 'const c=await Bun.file(process.env.ELANOUS_GRAPH_CONTEXT).json(); const i=c.input??{}; const e3=c.outputs?.e3??{}; const row={outcome:"mock-pr",kind:"mock-pr",cellId:i.cellId,version:i.version,reason:e3.reason??"production-entry-unproven",mockScenarioId:"MS-05",mockRequest:{state:"requested",prCreated:false,productionPaths:(i.paths??[]).filter(x=>typeof x==="string"&&!/\.test\.[cm]?[jt]sx?$/.test(x)),testPaths:(i.paths??[]).filter(x=>typeof x==="string"&&/\.test\.[cm]?[jt]sx?$/.test(x)),e3:e3.evidence??[]},evidence:["E3 is unproved; request an MS-05 production-entry mock test. No PR or checklist write is performed."]}; console.log(JSON.stringify(row));'
+  timeout_ms: 30000
+result:
+  command: >-
+    bun -e 'const c=await Bun.file(process.env.ELANOUS_GRAPH_CONTEXT).json(); const i=c.input??{}; const o=c.outputs??{}; const e1=o.e1??{}, e2=o.e2??{}, e3=o.e3??{}, produce=o.produce??{}, boundary=o.boundary??{}, mock=o["make-test"]??{}; let kind="hold", reason=e1.reason??"e1-unmeasured"; if(e1.outcome==="pass"){reason=e2.reason??"e2-unmeasured"; if(e2.outcome==="fail")kind="implementation-remains"; else if(e2.outcome==="pass"){reason=e3.reason??"e3-unmeasured"; if(e3.outcome==="pass"){reason=produce.reason??"boundary-unproven"; if(produce.outcome==="pass"){reason=boundary.reason??"boundary-unproven"; if(boundary.outcome==="pass")kind="green-candidate"}} else if(e3.outcome==="missing"&&mock.outcome==="mock-pr"){kind="mock-pr";reason=mock.reason}}} const row={outcome:"ok",cellId:i.cellId,version:i.version,kind,reason,...(e1.pr?{pr:e1.pr}:{}),...(e1.mergeSha?{mergeSha:e1.mergeSha}:{}),...(e2.command?{command:e2.command}:{}),...(Number.isSafeInteger(e2.exitCode)?{exitCode:e2.exitCode}:{}),...(e3.verdict?{e3:{verdict:e3.verdict,reason:e3.reason,testPath:e3.testPath,productionPaths:e3.productionPaths}}:{}),...(mock.mockScenarioId?{mockScenarioId:mock.mockScenarioId,mockRequest:mock.mockRequest}:{}),evidence:[...(e1.evidence??[]),...(e2.evidence??[]),...(e3.evidence??[]),...(produce.evidence??[]),...(boundary.evidence??[]),...(mock.evidence??[])]}; console.log(JSON.stringify(row));'
+  timeout_ms: 30000

package/graphs/work/research-report.yaml

@@ -1,5 +1,7 @@
 graph_id: work-research-report-rehearsal
 version: 1
+# TASK-HAND-GRAPH-RUN — `tasks hand --completion research-report` 가 이 조합을 실제 graph run(runGraph)으로 발사한다.
+launcher: graph-run
 entry_node: make-doc
 terminal_nodes: [done, failed]
 nodes:

package/graphs/work/run-research.yaml

@@ -0,0 +1,35 @@
+# DEFAULT-HANDS — «실행·조사» 손의 기본 조합 (RFC-loop-agent-map §A4c · 0.2.37).
+# 종결 종류별 조합(artifact·content·ops-action·watch-brief·decision-support)이 아직 없을 때
+# `tasks hand --completion <종류>` 가 이 판으로 내려간다 — 기본 손은 «개발»(코드 하니스)이 아니라 이쪽이다.
+# 만든다(④) → 확인한다(⑥) 두 동사만 쓴다: 종결은 종류별 «확인 증거»(`completion-evidence.ts`)가 닫는다.
+graph_id: work-run-research
+version: 1
+launcher: graph-run
+entry_node: make-doc
+terminal_nodes: [done, failed]
+nodes:
+  - node_id: make-doc
+    kind: subgraph
+    recipe: none
+    max_visits: 3
+    call: verb-make-doc@1
+    covers: [research, make]
+    budget: { inner_steps: 16 }
+    contract: { inputs: [ask, context, prior], tools: worktree-write, outputs: [result, evidence] }
+  - node_id: verify
+    kind: subgraph
+    recipe: none
+    max_visits: 3
+    call: verb-verify@1
+    covers: [verify, execute]
+    budget: { inner_steps: 16 }
+    contract: { inputs: [ask, context, prior], tools: read-and-run-tests, outputs: [result, evidence] }
+  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }
+  - { node_id: failed, kind: gate, recipe: none, max_visits: 1 }
+edges:
+  - from: make-doc
+    on: outcome
+    map: { done: verify, rework: make-doc, needs-human: failed, failed: failed }
+  - from: verify
+    on: outcome
+    map: { done: done, rework: make-doc, needs-human: failed, failed: failed }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elanous",
   "mcpName": "io.github.ElanvitalAI/elanous",
-  "version": "0.2.35",
+  "version": "0.2.37",
   "description": "Self-healing coding harness where eyes, hands, and memory all turn on one sentence — it authors its own goals, implements them in isolated worktrees, and reviews its own work.",
   "license": "Apache-2.0",
   "author": "Elanvital AI",

package/scripts/__fixtures__/authoring-paths-10x3.json

@@ -0,0 +1,32 @@
+[
+  {"task":"TASK-01","path":"text","landed":true,"rounds":4,"procedureSteps":["compose-complication","marker-self-check"]},
+  {"task":"TASK-02","path":"text","landed":true,"rounds":3,"procedureSteps":["compose-complication","marker-self-check"]},
+  {"task":"TASK-03","path":"text","landed":false,"rounds":5,"procedureSteps":["compose-complication","marker-self-check"]},
+  {"task":"TASK-04","path":"text","landed":false,"rounds":6,"procedureSteps":["compose-complication","marker-self-check"]},
+  {"task":"TASK-05","path":"text","landed":false,"rounds":4,"procedureSteps":["compose-complication","marker-self-check"]},
+  {"task":"TASK-06","path":"text","landed":false,"rounds":5,"procedureSteps":["compose-complication","marker-self-check"]},
+  {"task":"TASK-07","path":"text","landed":false,"rounds":3,"procedureSteps":["compose-complication","marker-self-check"]},
+  {"task":"TASK-08","path":"text","landed":false,"rounds":4,"procedureSteps":["compose-complication","marker-self-check"]},
+  {"task":"TASK-09","path":"text","landed":false,"rounds":5,"procedureSteps":["compose-complication","marker-self-check"]},
+  {"task":"TASK-10","path":"text","landed":false,"rounds":4,"procedureSteps":["compose-complication","marker-self-check"]},
+  {"task":"TASK-01","path":"elaboration","landed":true,"rounds":2,"procedureSteps":["marker-self-check","elaboration-card","fixture-stage"]},
+  {"task":"TASK-02","path":"elaboration","landed":true,"rounds":3,"procedureSteps":["marker-self-check","elaboration-card","fixture-stage"]},
+  {"task":"TASK-03","path":"elaboration","landed":true,"rounds":2,"procedureSteps":["marker-self-check","elaboration-card","fixture-stage"]},
+  {"task":"TASK-04","path":"elaboration","landed":true,"rounds":1,"procedureSteps":["marker-self-check","elaboration-card","fixture-stage"]},
+  {"task":"TASK-05","path":"elaboration","landed":true,"rounds":3,"procedureSteps":["marker-self-check","elaboration-card","fixture-stage"]},
+  {"task":"TASK-06","path":"elaboration","landed":true,"rounds":2,"procedureSteps":["marker-self-check","elaboration-card","fixture-stage"]},
+  {"task":"TASK-07","path":"elaboration","landed":false,"rounds":3,"procedureSteps":["marker-self-check","elaboration-card","fixture-stage"]},
+  {"task":"TASK-08","path":"elaboration","landed":false,"rounds":2,"procedureSteps":["marker-self-check","elaboration-card","fixture-stage"]},
+  {"task":"TASK-09","path":"elaboration","landed":false,"rounds":3,"procedureSteps":["marker-self-check","elaboration-card","fixture-stage"]},
+  {"task":"TASK-10","path":"elaboration","landed":false,"rounds":2,"procedureSteps":["marker-self-check","elaboration-card","fixture-stage"]},
+  {"task":"TASK-01","path":"implementation","landed":true,"rounds":1,"procedureSteps":["elaboration-card","focused-test","entrypoint-wiring","typecheck"]},
+  {"task":"TASK-02","path":"implementation","landed":true,"rounds":2,"procedureSteps":["elaboration-card","focused-test","entrypoint-wiring","typecheck"]},
+  {"task":"TASK-03","path":"implementation","landed":true,"rounds":1,"procedureSteps":["elaboration-card","focused-test","entrypoint-wiring","typecheck"]},
+  {"task":"TASK-04","path":"implementation","landed":true,"rounds":1,"procedureSteps":["elaboration-card","focused-test","entrypoint-wiring","typecheck"]},
+  {"task":"TASK-05","path":"implementation","landed":true,"rounds":2,"procedureSteps":["elaboration-card","focused-test","entrypoint-wiring","typecheck"]},
+  {"task":"TASK-06","path":"implementation","landed":true,"rounds":1,"procedureSteps":["elaboration-card","focused-test","entrypoint-wiring","typecheck"]},
+  {"task":"TASK-07","path":"implementation","landed":true,"rounds":2,"procedureSteps":["elaboration-card","focused-test","entrypoint-wiring","typecheck"]},
+  {"task":"TASK-08","path":"implementation","landed":true,"rounds":1,"procedureSteps":["elaboration-card","focused-test","entrypoint-wiring","typecheck"]},
+  {"task":"TASK-09","path":"implementation","landed":true,"rounds":1,"procedureSteps":["elaboration-card","focused-test","entrypoint-wiring","typecheck"]},
+  {"task":"TASK-10","path":"implementation","landed":true,"rounds":2,"procedureSteps":["elaboration-card","focused-test","entrypoint-wiring","typecheck"]}
+]

package/scripts/boundary-proof-mapping-audit.ts

@@ -0,0 +1,88 @@
+import { parseGreenCloseEvidenceCommand } from '../src/task-agent/green-close-recipe.js';
+import { readFileSync } from 'node:fs';
+
+type ChecklistItem = { id: string; owner?: string; status: string; title: string };
+type ChecklistStatus = { version: string; items: ChecklistItem[] };
+
+function validStatus(value: unknown, version: string): value is ChecklistStatus {
+  if (!value || typeof value !== 'object') return false;
+  const status = value as Record<string, unknown>;
+  return status.version === version && Array.isArray(status.items) && status.items.length > 0
+    && status.items.every((item: unknown) => {
+      if (!item || typeof item !== 'object') return false;
+      const row = item as Record<string, unknown>;
+      return typeof row.id === 'string' && typeof row.status === 'string'
+        && typeof row.title === 'string'
+        && (row.owner === undefined || typeof row.owner === 'string');
+    });
+}
+
+export type AuditRow = {
+  id: string;
+  owner: string;
+  state: 'mapped-unverified' | 'test-run-review-required' | 'manual-verifier-required' | 'invalid-boundary';
+  liveBoundary: string | null;
+  evidenceCommand: string | null;
+  reason: string;
+};
+
+function lines(title: string, label: string): string[] {
+  return title.split('\n').map((line) => line.trim())
+    .filter((line) => line.startsWith(label) || line.startsWith(`- ${label}`))
+    .map((line) => line.replace(/^-\s*/, '').slice(label.length).trim());
+}
+
+/** Read-only inventory. A command that can run still needs a human check that it proves the live clause. */
+export function auditBoundaryMappings(status: ChecklistStatus): AuditRow[] {
+  return status.items.filter((item) => item.status === 'yellow' && item.title.includes('완료 경계 실물:'))
+    .map((item): AuditRow => {
+      const live = lines(item.title, '완료 경계 실물:');
+      const commands = lines(item.title, '완료 경계 증거 명령:');
+      const mappings = lines(item.title, '완료 경계 실물 검증:');
+      const base = { id: item.id, owner: item.owner ?? 'unknown',
+        liveBoundary: live.length === 1 ? live[0]! : null,
+        evidenceCommand: commands.length === 1 ? commands[0]! : null };
+      if (live.length !== 1 || !live[0] || commands.length > 1 || mappings.length > 1)
+        return { ...base, state: 'invalid-boundary', reason: 'ambiguous-or-empty-boundary-line' };
+      if (mappings.length === 1)
+        return { ...base, state: 'mapped-unverified', reason: 'typed-mapping-needs-production-replay' };
+      if (commands.length === 1 && parseGreenCloseEvidenceCommand(commands[0]!).ok)
+        return { ...base, state: 'test-run-review-required', reason: 'test-command-syntax-only-live-assertion-unproven' };
+      return { ...base, state: 'manual-verifier-required', reason: 'no-supported-direct-verifier-mapping' };
+    });
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const version = args[0] === '--version' ? args[1] : undefined;
+  const snapshot = args[2] === '--snapshot' ? args[3] : undefined;
+  const validShape = args.length === 3 && args[2] === '--json'
+    || args.length === 5 && args[2] === '--snapshot' && !!snapshot && args[4] === '--json';
+  if (!version || !/^\d+\.\d+\.\d+$/.test(version) || !validShape) {
+    process.stderr.write('usage: bun scripts/boundary-proof-mapping-audit.ts --version X.Y.Z [--snapshot status.json] --json\n');
+    process.exit(2);
+  }
+  try {
+    let raw: string;
+    if (snapshot) {
+      raw = readFileSync(snapshot, 'utf8');
+    } else {
+      const child = Bun.spawnSync(['eln', 'release', 'checklist', 'status', '--version', version, '--json'],
+        { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
+      if (child.exitCode !== 0) throw new Error(`checklist status failed rc=${child.exitCode}: ${new TextDecoder().decode(child.stderr).trim()}`);
+      raw = new TextDecoder().decode(child.stdout);
+    }
+    const status = JSON.parse(raw) as unknown;
+    if (!validStatus(status, version)) throw new Error('checklist snapshot version mismatch or invalid inventory');
+    const rows = auditBoundaryMappings(status);
+    const byState = Object.fromEntries(['mapped-unverified', 'test-run-review-required',
+      'manual-verifier-required', 'invalid-boundary'].map((state) =>
+      [state, rows.filter((row) => row.state === state).length]));
+    const yellowTotal = status.items.filter((item) => item.status === 'yellow').length;
+    process.stdout.write(`${JSON.stringify({ version, yellowTotal,
+      yellowLive: rows.length, yellowWithoutLive: yellowTotal - rows.length, byState, rows })}\n`);
+  } catch (error) {
+    process.stderr.write(`boundary proof mapping audit: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  }
+}

package/scripts/ci-typecheck-changed.ts

@@ -1316,6 +1316,129 @@ export function typecheckDispatchFlags(flags: GateRemoteFlags, env: NodeJS.Proce
     ? { ...flags, remote: 'node-b' } : flags;
 }
 
+// ── WSL-GATE-ENV (0.2.36) — base 환경 해석 · 원격 push 실패 «원인» 보고 ─────────────────────────
+//   🩸 wsl·node-c 가 «같은 head·base» 를 쟀는데 introduced·preexisting 이 갈렸고, 남는 출력은
+//      `push-failed rc=128: …` 한 줄이었다. 그 한 줄로는 «미러 쓰기 권한» 인지 «base 가 달랐다» 인지
+//      읽을 수 없었고, base env 가 원격에 무엇으로 전달됐는지도 어디에도 찍히지 않았다.
+//   ⇒ (1) 원격 디스패치마다 base env 를 `ref@sha` 로 «풀어서» 한 줄 찍는다 — 두 호스트가 같은 줄을
+//        찍는 것이 교차 측정의 전제다. (2) push 실패는 rc·문면으로 «권한/자격증명» 과 «그 밖»을 가르고
+//        처방을 같이 찍는다. (3) base ref 를 이 트리에서 풀 수 없으면 원격을 «띄우지 않고» 멈춘다 —
+//        다른 base 로 잰 판정을 두 호스트가 «같다»고 믿게 만든 것이 이 칸의 사고였다.
+//   ⛔ 로컬 경로(--local · Pod · CI)의 출력·원장 형식은 건드리지 않는다 — 아래 줄은 원격 디스패치 안에서만 나온다.
+const BASE_ENV_KEYS = ['NODE_OPTIONS', 'TSC_BASE_REF', 'TSC_HEAP_MB'] as const;
+
+export interface RemoteBaseEnv {
+  /** 원격으로 push 해 sha 로 받아야 하는 ref. TSC_BASE_REF 가 없으면 비어 있다(merge-base 는 HEAD 의 조상이라 HEAD 와 함께 간다). */
+  refs: string[];
+  /** 무엇을 base 로 골랐나 — TSC_BASE_REF 의 ref 이름, 없으면 `merge-base(origin/main)`. */
+  baseLabel: string;
+  /** base 를 이 트리에서 푼 sha — 두 호스트가 같은 값을 찍어야 교차 측정이 성립한다. */
+  baseSha?: string;
+  /** 원격 명령에 전달하는 env 키들. */
+  keys: string[];
+  /** 원격 명령 앞에 붙일 `KEY=VALUE`. TSC_BASE_REF 는 «항상» 이 트리에서 고정한 sha 로 넘긴다
+   *  (ref 는 dispatch 가 push 한 sha · 없으면 merge-base sha) — 원격이 제 origin/main 으로 다시 풀지 않는다. */
+  forward: (sha: (ref: string) => string) => string[];
+  /** 이 트리에서 base 를 sha 로 고정할 수 없을 때의 사유 — 있으면 원격 디스패치를 멈춘다. */
+  failure?: string;
+}
+
+const firstErrorLine = (thrown: unknown): string => (thrown instanceof Error ? thrown.message : String(thrown)).split('\n')[0].trim();
+
+export function remoteBaseEnv(
+  env: NodeJS.ProcessEnv,
+  resolve: (ref: string) => string = (ref) => execFileSync('git', ['rev-parse', '--verify', '--quiet', ref], { encoding: 'utf8' }).trim(),
+  mergeBase: () => string = () => execFileSync('git', ['merge-base', 'HEAD', 'origin/main'], { encoding: 'utf8' }).trim(),
+): RemoteBaseEnv {
+  const baseRef = env.TSC_BASE_REF;
+  let baseSha: string | undefined;
+  let failure: string | undefined;
+  if (baseRef) {
+    try { baseSha = resolve(baseRef) || undefined; } catch (thrown) {
+      failure = `TSC_BASE_REF=${baseRef} 를 이 트리에서 sha 로 풀 수 없다 (${firstErrorLine(thrown) || 'git rev-parse 실패'})`;
+    }
+    if (!baseSha && !failure) failure = `TSC_BASE_REF=${baseRef} 를 이 트리에서 sha 로 풀 수 없다 (git rev-parse 빈 출력)`;
+  } else {
+    // TSC_BASE_REF 가 없으면 원격 쪽 기본(merge-base(origin/main))을 «여기서» 미리 풀어 sha 로 못 박는다 —
+    //   원격 미러의 origin/main 은 이 트리와 다를 수 있다(같은 head 인데 base 가 갈린 이 칸의 사고 · 리뷰 r1 must-fix).
+    try { baseSha = mergeBase() || undefined; } catch (thrown) {
+      failure = `merge-base(HEAD, origin/main) 을 이 트리에서 풀 수 없다 (${firstErrorLine(thrown) || 'git merge-base 실패'})`;
+    }
+    if (!baseSha && !failure) failure = 'merge-base(HEAD, origin/main) 을 이 트리에서 풀 수 없다 (git merge-base 빈 출력)';
+  }
+  const passKeys = BASE_ENV_KEYS.filter((key) => key !== 'TSC_BASE_REF' && env[key]);
+  return {
+    refs: baseRef ? [baseRef] : [],
+    baseLabel: baseRef || 'merge-base(origin/main)',
+    baseSha,
+    keys: ['TSC_BASE_REF', ...passKeys],
+    forward: (sha) => [`TSC_BASE_REF=${baseRef ? sha(baseRef) : baseSha}`, ...passKeys.map((key) => `${key}=${env[key]}`)],
+    failure,
+  };
+}
+
+/** 두 호스트가 같은 head·base 를 쟀는지 «눈으로» 비교할 수 있는 한 줄. 호스트 이름만 다르다. */
+export function describeRemoteBaseEnv(env: RemoteBaseEnv, host: string): string {
+  const base = `${env.baseLabel}@${env.baseSha ?? '미해석'}`;
+  return `[tsc-gate] base env [${host}] — base=${base} · refs=${env.refs.length} · forward=${env.keys.join(',') || '없음'}`;
+}
+
+export type RemoteInfraCause = 'base-env' | 'push-permission' | 'push-failed' | 'other';
+
+export interface RemoteDiagnosis { cause: RemoteInfraCause; message: string; hints: string[] }
+
+/** push 거부 문면에서 «미러 쓰기 권한·자격증명» 을 가리키는 신호. */
+export const PUSH_PERMISSION_SIGNAL = /permission denied|publickey|could not read (?:Username|Password)|authentication failed|host key verification failed|access denied|terminal prompts disabled/i;
+
+export const BASE_ENV_HINTS = [
+  'base 는 두 호스트가 «같은 커밋» 이어야 한다 — 위 base= 줄에서 @뒤 sha 가 같은지 먼저 본다.',
+  'TSC_BASE_REF 는 양쪽 트리에 존재하는 ref(또는 sha)로 준다 — 한쪽에만 있는 브랜치면 introduced 가 갈린다.',
+];
+
+export function baseEnvDiagnosis(env: RemoteBaseEnv, host: string): RemoteDiagnosis | undefined {
+  if (!env.failure) return undefined;
+  return { cause: 'base-env', message: `${env.failure} — ${host} 를 띄우지 않는다`, hints: BASE_ENV_HINTS };
+}
+
+export function formatRemoteDiagnosis(diagnosis: RemoteDiagnosis): string[] {
+  return [
+    `[tsc-gate] ⛔ 원격 판정 실패 원인 [${diagnosis.cause}] — ${diagnosis.message}`,
+    ...diagnosis.hints.map((hint) => `[tsc-gate]   ${hint}`),
+  ];
+}
+
+export function diagnoseRemoteOutcome(
+  outcome: { kind: 'ran' | 'busy' | 'infra'; reason?: string },
+  host: string,
+  env: RemoteBaseEnv,
+): RemoteDiagnosis | undefined {
+  const base = baseEnvDiagnosis(env, host);
+  if (base) return base;
+  if (outcome.kind !== 'infra') return undefined;
+  const reason = outcome.reason ?? '';
+  const push = /^push-failed rc=(\d+)/.exec(reason);
+  if (!push) return {
+    cause: 'other',
+    message: `원격 판정 인프라 실패 — ${reason}`,
+    hints: [`같은 head·base 인데 이 호스트에서만 실패하면 위 base env 줄을 호스트끼리 비교한다.`],
+  };
+  const rc = Number(push[1]);
+  if (rc === 128 && PUSH_PERMISSION_SIGNAL.test(reason)) return {
+    cause: 'push-permission',
+    message: `원격 push 거부 rc=128 — ${host} 미러에 쓰기 권한/자격증명이 없다`,
+    hints: [
+      `호스트 접근부터 확인: ssh -o BatchMode=yes ${host} true (rc=0 이어야 한다 — 아니면 키·호스트 항목 문제다)`,
+      `미러 쓰기 확인: ssh ${host} -- 'test -w <mirror>.git' — 권한이 없으면 ELANOUS_GATE_REMOTE_MIRROR 로 쓰기 가능한 미러를 준다`,
+      'push 는 자격증명이 없으면 «터미널 프롬프트 없이» 죽는다 — 대화형 ssh 로 한 번 손으로 push 해 rc 를 본다.',
+    ],
+  };
+  return {
+    cause: 'push-failed',
+    message: `원격 push 실패 rc=${rc} — ${host}`,
+    hints: [`push 출력: ${reason}`, '미러 경로·디스크 여유를 확인하고, 반복되면 같은 트리에서 손으로 push 해 원문을 남긴다.'],
+  };
+}
+
 if (import.meta.main) void (async () => {
   // GATE-REMOTE (10-06): the only accepted arguments are the dispatch flags `--remote [host]` / `--local` — they choose
   //   «where» the same commit is measured, never «what» (the base stays merge-base(origin/main) on both sides).
@@ -1333,15 +1456,26 @@ if (import.meta.main) void (async () => {
   const repo = sh('git rev-parse --show-toplevel').trim();
   const onMbp = forbidFullTypecheckOnLocal(process.env, hostname(), repo);
   const dispatchFlags = typecheckDispatchFlags(flags, process.env, hostname(), repo);
-  const baseRef = process.env.TSC_BASE_REF;
-  const passEnv = (sha: (ref: string) => string) => (['NODE_OPTIONS', 'TSC_BASE_REF', 'TSC_HEAP_MB'] as const).filter((key) => process.env[key])
-    .map((key) => `${key}=${key === 'TSC_BASE_REF' && baseRef !== 'origin/main' ? sha(baseRef!) : process.env[key]}`);
+  const baseEnv = remoteBaseEnv(process.env);
+  // 원격만 재는 자리에서 base ref 를 «이 트리에서» 못 풀면, 두 호스트가 «다른 base» 로 잰 판정을
+  //   «같은 답»처럼 찍게 된다 — 그래서 띄우지 않고 멈춘다(원인과 처방을 남긴다). --local 은 그대로 간다.
+  if (baseEnv.failure && dispatchFlags.remote !== undefined && !flags.local) {
+    for (const line of formatRemoteDiagnosis(baseEnvDiagnosis(baseEnv, dispatchFlags.remote === true ? '기본 원격' : dispatchFlags.remote)!)) console.error(line);
+    console.error('[tsc-gate]   ⇒ 원격을 띄우지 않는다. base 를 양쪽 호스트가 «같이» 푸는 ref/sha 로 고친 뒤 다시 돌려라.');
+    process.exit(2);
+  }
   // exitCode, not exit(): piped stdout/stderr drain before the process ends.
   process.exitCode = await dispatchHeavyCheck({
     tool: 'ci-typecheck-changed', repo, flags: dispatchFlags, explicitRemoteOnly: dispatchFlags.remote !== undefined,
     stableCheckout: true, installPwa: true,
-    remoteArgv: (sha) => { const vars = passEnv(sha); return [...(vars.length ? ['env', ...vars] : []), 'bun', 'run', 'scripts/ci-typecheck-changed.ts', '--local']; },
-    refs: baseRef ? [baseRef] : [],
+    remoteArgv: (sha) => { const vars = baseEnv.forward(sha); return [...(vars.length ? ['env', ...vars] : []), 'bun', 'run', 'scripts/ci-typecheck-changed.ts', '--local']; },
+    refs: baseEnv.refs,
+    // 원격 판정이 «무엇으로» 났는지 호스트마다 같은 문면으로 남긴다 — 교차 측정의 대조 줄.
+    onRemoteOutcome: (outcome, host) => {
+      console.error(describeRemoteBaseEnv(baseEnv, host));
+      const diagnosis = diagnoseRemoteOutcome(outcome, host, baseEnv);
+      if (diagnosis) for (const line of formatRemoteDiagnosis(diagnosis)) console.error(line);
+    },
     runLocal: () => { runGate({ forbidFullLocal: onMbp }); return 0; },
   });
 })();

package/scripts/codex-fallback-live-probe.ts

@@ -18,6 +18,7 @@ import {
   type FallbackDecision,
   type FallbackStep,
   type RotationOutcome,
+  type StayReason,
 } from '../src/oauth/fallback-chain.js';
 import {
   codexStoreKey,
@@ -52,13 +53,12 @@ export type LiveProbeInputs = {
   readonly grokAvailableSource: 'resolveGrokCredential';
 } & GrokQuotaProbeFields;
 
-export type LiveProbeLine = LiveProbeInputs & {
-  readonly action: FallbackDecision['action'];
-  readonly why?: string;
-  readonly backend?: 'grok';
-  readonly to?: string;
-  readonly inputKind: 'live';
-};
+export type LiveProbeLine = LiveProbeInputs & (
+  | { readonly action: 'stay'; readonly why: StayReason; readonly backend?: never; readonly to?: never }
+  | { readonly action: 'switch-backend'; readonly backend: 'grok' | 'claude' | 'openrouter'; readonly model?: string; readonly why?: never; readonly to?: never }
+  | { readonly action: 'codex-rotate'; readonly to: string; readonly why?: never; readonly backend?: never }
+  | { readonly action: 'codex-credits'; readonly to?: string; readonly why?: never; readonly backend?: never }
+) & { readonly inputKind: 'live' };
 
 function isStayRotationReason(value: string): value is StayRotationReason {
   return (STAY_REASONS as readonly string[]).includes(value);
@@ -172,14 +172,16 @@ export function probeLine(
   inputs: LiveProbeInputs,
   decision: FallbackDecision,
 ): LiveProbeLine {
-  return {
-    ...inputs,
-    action: decision.action,
-    inputKind: 'live',
-    ...(decision.action === 'stay' ? { why: decision.why } : {}),
-    ...(decision.action === 'switch-backend' ? { backend: decision.backend } : {}),
-    ...(decision.action === 'codex-rotate' ? { to: decision.to.name } : {}),
-  };
+  switch (decision.action) {
+    case 'stay':
+      return { ...inputs, action: 'stay', why: decision.why, inputKind: 'live' };
+    case 'switch-backend':
+      return { ...inputs, action: 'switch-backend', backend: decision.backend, inputKind: 'live' };
+    case 'codex-rotate':
+      return { ...inputs, action: 'codex-rotate', to: decision.to.name, inputKind: 'live' };
+    case 'codex-credits':
+      return { ...inputs, action: 'codex-credits', ...(decision.to ? { to: decision.to.name } : {}), inputKind: 'live' };
+  }
 }
 
 /** status CLI 출력에서 JSON 객체만 잘라 읽는다. 선행 로그가 있어도 이유를 손으로 박지 않는다. */

package/scripts/coord-role-pack.ts

@@ -25,7 +25,7 @@ const KNOWHOW_PATH = 'docs/roles/OP/KNOWHOW.md';
  * 카드 제목 문법은 src/seat-loop/knowhow-lint.ts 의 CARD_HEADING 과 같아야 한다.
  * 다르면 린트가 카드로 못 본 제목이 자를 때 조용히 사라지거나, 번호만 잘려 엉뚱한 아이디로 제외 기록에 남는다.
  */
-const CARD_HEADING = /^[ \t]{0,3}##\s+(K-[A-Za-z]+-\d+)(?=$|\s|:|—)(.*)$/u;
+const CARD_HEADING = /^[ \t]{0,3}##\s+(K-[A-Za-z]+(?:-[A-Za-z]{1,4})?-\d+)(?=$|\s|:|—)(.*)$/u;
 const CARD_HEADING_LIKE = /^[ \t]{0,3}##\s*(K-[^\s:]*)/iu;
 const SECTION_HEADING = /^[ \t]{0,3}##\s/u;