elanous 0.2.36 → 0.2.38

package/graphs/release/release-loop.yaml

@@ -12,6 +12,7 @@ dry_run_await_approval: true
 terminal_nodes: [done, failed]
 nodes:
   - { node_id: version-release, kind: git, recipe: 'cmd:version-release', max_visits: 1 }
+  - { node_id: traffic-cut-start, kind: gate, recipe: 'cmd:traffic-cut-start', max_visits: 1 }
   - { node_id: cutoff, kind: judge, recipe: 'cmd:cutoff', max_visits: 1 }
   - { node_id: checklist-gate, kind: gate, recipe: 'cmd:checklist-gate', max_visits: 1 }
   # cmd:docs dispatches by graph node ID: bounded prefetch before gate, TUI join after upgrade, docs write after both.
@@ -39,6 +40,7 @@ nodes:
   - { node_id: approve-publish, kind: hitl, recipe: 'approval:publish', max_visits: 1 }
   - { node_id: publish, kind: git, recipe: 'cmd:publish-command', max_visits: 1, notify: { on: [ok, fail] } }
   - { node_id: npm-publish, kind: git, recipe: 'cmd:npm-publish', max_visits: 1 }
+  - { node_id: traffic-npm-published, kind: gate, recipe: 'cmd:traffic-npm-published', max_visits: 1 }
   - { node_id: docs-land, kind: git, recipe: 'cmd:docs-land', max_visits: 1 }
   - { node_id: verify, kind: gate, recipe: 'cmd:verify', max_visits: 1, notify: { on: [ok, fail] } }
   - { node_id: traffic-verify-complete, kind: gate, recipe: 'cmd:traffic-verify-complete', max_visits: 1 }
@@ -47,35 +49,40 @@ nodes:
   - { node_id: ops-upgrade, kind: agent, recipe: 'cmd:ops-upgrade', max_visits: 1 }
   - { node_id: version-dev-bump, kind: git, recipe: 'cmd:version-dev-bump', max_visits: 1 }
   - { node_id: version-dev-bump-after-failure, kind: git, recipe: 'cmd:version-dev-bump', max_visits: 1 }
+  - { node_id: traffic-failed-restore, kind: gate, recipe: 'cmd:traffic-failed-restore', max_visits: 1 }
   - { node_id: done, kind: gate, max_visits: 1 }
   - { node_id: failed, kind: gate, max_visits: 1 }
 edges:
-  - { from: version-release, on: outcome, map: { ok: cutoff, fail: failed, error: failed } }
-  - { from: cutoff, on: outcome, map: { ok: checklist-gate, fail: failed, error: failed } }
-  - { from: checklist-gate, on: outcome, map: { ok: export-check, fail: failed, error: failed } }
-  - { from: export-check, on: outcome, map: { ok: prefetch, fail: failed, error: failed } }
+  - { from: version-release, on: outcome, map: { ok: traffic-cut-start, fail: failed, error: failed } }
+  # Advisory traffic writes report failure to OP; release steps still proceed on fail/error.
+  - { from: traffic-cut-start, on: outcome, map: { ok: cutoff, fail: cutoff, error: cutoff } }
+  - { from: cutoff, on: outcome, map: { ok: checklist-gate, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: checklist-gate, on: outcome, map: { ok: export-check, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: export-check, on: outcome, map: { ok: prefetch, fail: traffic-failed-restore, error: traffic-failed-restore } }
   # Prefetch never gates: even a crashed prefetch node is a cache miss — the late nodes take their original paths.
   - { from: prefetch, on: outcome, map: { ok: gate, fail: gate, error: gate } }
   - { from: gate, on: outcome, map: { ok: traffic-gate-passed, fail: gate-triage, error: gate-triage } }
   # Warning-only: the transition result stays truthful; every outcome continues to the next release node.
   - { from: traffic-gate-passed, on: outcome, map: { ok: mac-smoke, fail: mac-smoke, error: mac-smoke } }
-  - { from: gate-triage, on: outcome, map: { ok: failed, fail: failed, error: failed } }
+  - { from: gate-triage, on: outcome, map: { ok: traffic-failed-restore, fail: traffic-failed-restore, error: traffic-failed-restore } }
   # Warning-only: a macOS failure or unmeasured run never blocks publishing — auto-approve shows it as a warning row.
   - { from: mac-smoke, on: outcome, map: { ok: pwa, fail: pwa, error: pwa } }
-  - { from: pwa, on: outcome, map: { ok: prepare, fail: failed, error: failed } }
-  - { from: prepare, on: outcome, map: { ok: upgrade, fail: failed, error: failed } }
-  - { from: upgrade, on: outcome, map: { ok: tui, fail: failed, error: failed } }
-  - { from: tui, on: outcome, map: { ok: docs, fail: failed, error: failed } }
-  - { from: docs, on: outcome, map: { ok: known-issues, fail: failed, error: failed } }
-  - { from: known-issues, on: outcome, map: { ok: notes-check, fail: failed, error: failed } }
+  - { from: pwa, on: outcome, map: { ok: prepare, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: prepare, on: outcome, map: { ok: upgrade, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: upgrade, on: outcome, map: { ok: tui, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: tui, on: outcome, map: { ok: docs, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: docs, on: outcome, map: { ok: known-issues, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: known-issues, on: outcome, map: { ok: notes-check, fail: traffic-failed-restore, error: traffic-failed-restore } }
   # RELEASE-GRAPH-SELFHEAL: fail/error re-enter notes-check through one repair; publish still requires a passing recheck.
   - { from: notes-check, on: outcome, map: { ok: auto-approve, fail: notes-repair, error: notes-repair } }
-  - { from: notes-repair, on: outcome, map: { ok: notes-recheck, fail: failed, error: failed } }
-  - { from: notes-recheck, on: outcome, map: { ok: auto-approve, fail: failed, error: failed } }
+  - { from: notes-repair, on: outcome, map: { ok: notes-recheck, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: notes-recheck, on: outcome, map: { ok: auto-approve, fail: traffic-failed-restore, error: traffic-failed-restore } }
   - { from: auto-approve, on: outcome, map: { ok: publish, fail: approve-publish, error: approve-publish } }
-  - { from: approve-publish, on: outcome, map: { ok: publish, fail: failed } }
-  - { from: publish, on: outcome, map: { ok: npm-publish, fail: failed, error: failed } }
-  - { from: npm-publish, on: outcome, map: { ok: docs-land, fail: failed, error: failed } }
+  - { from: approve-publish, on: outcome, map: { ok: publish, fail: traffic-failed-restore } }
+  - { from: publish, on: outcome, map: { ok: npm-publish, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: npm-publish, on: outcome, map: { ok: traffic-npm-published, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  # Publication already happened; a traffic write failure must not skip docs-land.
+  - { from: traffic-npm-published, on: outcome, map: { ok: docs-land, fail: docs-land, error: docs-land } }
   # RELEASE-DEVBUMP-ALWAYS: after a successful publish every fail/error routes through version-dev-bump —
   # a published release always hands main to its own next -dev, then still finishes failed.
   - { from: docs-land, on: outcome, map: { ok: verify, fail: version-dev-bump-after-failure, error: version-dev-bump-after-failure } }
@@ -85,5 +92,6 @@ edges:
   - { from: vault-note, on: outcome, map: { ok: release-story, fail: release-story, error: release-story } }
   - { from: release-story, on: outcome, map: { ok: ops-upgrade, fail: ops-upgrade, error: ops-upgrade } }
   - { from: ops-upgrade, on: outcome, map: { ok: version-dev-bump, fail: version-dev-bump, error: version-dev-bump } }
-  - { from: version-dev-bump, on: outcome, map: { ok: done, fail: failed, error: failed } }
-  - { from: version-dev-bump-after-failure, on: outcome, map: { ok: failed, fail: failed, error: failed } }
+  - { from: version-dev-bump, on: outcome, map: { ok: done, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: version-dev-bump-after-failure, on: outcome, map: { ok: traffic-failed-restore, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: traffic-failed-restore, on: outcome, map: { ok: failed, fail: failed, error: failed } }

package/graphs/work/draft-close.yaml

@@ -0,0 +1,54 @@
+graph_id: work-draft-close
+version: 1
+launcher: graph-run
+entry_node: decide
+terminal_nodes: [done, failed]
+runner_inputs: [mapRunId, snapshotTime, inventoryComplete, inventory, mainSha, item]
+nodes:
+  - node_id: decide
+    kind: observe
+    recipe: 'cmd:draft-close-decide'
+    max_visits: 1
+    contract:
+      inputs: [mapRunId, snapshotTime, inventoryComplete, inventory, mainSha, item]
+      tools: read-only
+      outputs: [outcome, result, evidence]
+  - node_id: harvest
+    kind: observe
+    recipe: 'cmd:draft-close-emit-harvest'
+    max_visits: 1
+    contract:
+      inputs: [result, evidence]
+      tools: none
+      outputs: [outcome, result, evidence]
+  - node_id: close-candidate
+    kind: observe
+    recipe: 'cmd:draft-close-emit-close-candidate'
+    max_visits: 1
+    contract:
+      inputs: [result, evidence]
+      tools: none
+      outputs: [outcome, result, evidence]
+  - node_id: hold
+    kind: observe
+    recipe: 'cmd:draft-close-emit-hold'
+    max_visits: 1
+    contract:
+      inputs: [result, evidence]
+      tools: none
+      outputs: [outcome, result, evidence]
+  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }
+  - { node_id: failed, kind: observe, recipe: none, max_visits: 1 }
+edges:
+  - from: decide
+    on: outcome
+    map: { harvest: harvest, 'close-candidate': close-candidate, hold: hold, failed: failed }
+  - from: harvest
+    on: outcome
+    map: { done: done, failed: failed }
+  - from: close-candidate
+    on: outcome
+    map: { done: done, failed: failed }
+  - from: hold
+    on: outcome
+    map: { done: done, failed: failed }

package/graphs/work/green-close.yaml

@@ -0,0 +1,37 @@
+# GREEN-CLOSE-RECIPE: deterministic evidence walk; no checklist writes.
+graph_id: green-close
+version: 1
+entry_node: e1
+terminal_nodes: [done, failed]
+nodes:
+  - { node_id: e1, kind: observe, recipe: 'cmd:e1', max_visits: 1 }
+  - { node_id: e2, kind: gate, recipe: 'cmd:e2', max_visits: 1 }
+  - { node_id: e3, kind: judge, recipe: 'cmd:e3', max_visits: 1 }
+  - { node_id: produce, kind: observe, recipe: 'cmd:produce', max_visits: 1 }
+  - { node_id: boundary, kind: gate, recipe: 'cmd:boundary', max_visits: 1 }
+  - { node_id: make-test, kind: agent, recipe: 'cmd:make-test', max_visits: 1 }
+  - { node_id: result, kind: observe, recipe: 'cmd:result', max_visits: 1 }
+  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }
+  - { node_id: failed, kind: gate, recipe: none, max_visits: 1 }
+edges:
+  - from: e1
+    on: outcome
+    map: { pass: e2, fail: result, hold: result }
+  - from: e2
+    on: outcome
+    map: { pass: e3, fail: result, hold: result }
+  - from: e3
+    on: outcome
+    map: { pass: produce, missing: make-test, hold: result }
+  - from: produce
+    on: outcome
+    map: { pass: boundary, hold: result }
+  - from: boundary
+    on: outcome
+    map: { pass: result, hold: result }
+  - from: make-test
+    on: outcome
+    map: { 'mock-pr': result, hold: result }
+  - from: result
+    on: outcome
+    map: { ok: done, fail: failed }

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/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.36",
+  "version": "0.2.38",
   "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/ask-op-inbox-once.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env bun
+/** Drain the coordinator inbox once without running the orchestrator graph. */
+import { runCoordinatorInboxOnce, type InboxOnceOptions } from '../src/loops/orchestrator/inbox-once.js';
+
+export function runAskOpInboxCli(options: InboxOnceOptions = {}) {
+  return runCoordinatorInboxOnce(options);
+}
+
+if (import.meta.main) {
+  try {
+    const result = await runAskOpInboxCli();
+    console.log(JSON.stringify(result));
+  } catch (error) {
+    console.error(`coordinator inbox: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  }
+}

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/brand/check.ts

@@ -104,9 +104,8 @@ function isEnglishDocument(content: string, file: string, scope: Scope): boolean
   return /\b[A-Za-z]{2,}(?:\s+[A-Za-z]{2,}){2,}\b/.test(body);
 }
 
-function findInFile(file: string, rules: Rule[], scope: Scope): Finding[] {
+function findInContent(file: string, content: string, rules: Rule[], scope: Scope): Finding[] {
   const findings: Finding[] = [];
-  const content = readFileSync(file, 'utf8');
   const html = ['.html', '.htm'].includes(extname(file).toLowerCase());
   const englishDocument = isEnglishDocument(content, file, scope);
   const markdown = ['.md', '.mdx'].includes(extname(file).toLowerCase());
@@ -144,14 +143,24 @@ function findInFile(file: string, rules: Rule[], scope: Scope): Finding[] {
   return findings;
 }
 
+function applicableRules(scope: Scope, rulesPath: string): Rule[] {
+  return loadRules(rulesPath).filter((rule) => scope === 'any' || rule.scope.includes('any') || rule.scope.includes(scope));
+}
+
+/** Scan in-memory text (for example a PR body) with the same rules as file scans. */
+export function checkBrandText(text: string, label: string, scope: Scope = 'public-docs', rulesPath = defaultRules): Finding[] {
+  if (!existsSync(rulesPath)) throw new Error(BRAND_RULES_UNMEASURED);
+  return findInContent(label, text, applicableRules(scope, rulesPath), scope);
+}
+
 export function checkBrand(scope: Scope, paths: string[], rulesPath = defaultRules): { files: number; findings: Finding[]; rules: number; missing: boolean; message?: string } {
   if (!existsSync(rulesPath)) {
     debug.log('brand.check', 'run', { scope, files: 0, findings: 0, rules: 0, missing: true, message: BRAND_RULES_UNMEASURED });
     return { files: 0, findings: [], rules: 0, missing: true, message: BRAND_RULES_UNMEASURED };
   }
-  const applicable = loadRules(rulesPath).filter((rule) => scope === 'any' || rule.scope.includes('any') || rule.scope.includes(scope));
+  const applicable = applicableRules(scope, rulesPath);
   const files = filesAt(paths);
-  const findings = files.flatMap((file) => findInFile(file, applicable, scope));
+  const findings = files.flatMap((file) => findInContent(file, readFileSync(file, 'utf8'), applicable, scope));
   debug.log('brand.check', 'run', { scope, files: files.length, findings: findings.length, rules: applicable.length });
   return { files: files.length, findings, rules: applicable.length, missing: false };
 }

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/fleet/node-setup.sh

@@ -1,13 +1,13 @@
 #!/bin/bash
 # 로컬 플릿 노드 셋업 — 원격 맥 한 대를 «Pod 풀 ⊕ 시험 샤딩» 노드로 (MANUAL-local-fleet-node-setup).
-#   bash scripts/fleet/node-setup.sh <호스트> [--check]
+#   bash scripts/fleet/node-setup.sh <호스트> [--check|--light-worker|--inspection-window active|inactive]
 #   <호스트>  ssh 로 닿는 이름(예: node-b · node-c) — 이 맥에서 `ssh -o BatchMode=yes <호스트> true` 가 돼야 한다.
 #   --check  영구 설정을 바꾸지 않고 상태만 본다(단계마다 ✓ · ✗ · → 할 일). DNS 점검용 Pod 는 잠깐 만들었다 지운다.
 #   원격 `uname -s` = Linux(WSL Ubuntu 등)면 brew·OrbStack·Chrome·~/.zshenv 대신 리눅스 갈래(scripts/fleet/node-setup-linux.sh)를 탄다.
 # ⭐ 단계마다 «이미 돼 있으면 건너뛴다» — 몇 번 돌려도 같은 결과(재현 가능한 셋업).
 # ⛔ 원격의 다른 컨테이너·앱은 건드리지 않는다. 이 맥의 ~/.kube/config 는 바꾸기 전에 백업한다.
 set -u
-HOST="${1:?usage: node-setup.sh <host> [--check]}"; CHECK=0; [ "${2:-}" = "--check" ] && CHECK=1
+HOST="${1:?usage: node-setup.sh <host> [--check|--inspection-window]}"; CHECK=0; [ "${2:-}" = "--check" ] && CHECK=1
 ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
 K3S_IMAGE="${ELANOUS_FLEET_K3S_IMAGE:-rancher/k3s:v1.36.4-k3s1}"   # 풀의 모든 노드가 «같은 판» — 판이 갈리면 같은 Job 이 노드마다 다르게 돈다
 API_PORT="${ELANOUS_FLEET_API_PORT:-6550}"
@@ -15,6 +15,36 @@ CLUSTER=elanous-pool; CTX="pool-$HOST"
 BUN_VER="$(bun --version 2>/dev/null)"                              # 이 맥과 같은 bun
 unset HTTPS_PROXY https_proxy HTTP_PROXY http_proxy ALL_PROXY all_proxy
 R() { ssh -o BatchMode=yes -o ConnectTimeout=10 "$HOST" "export PATH=\$HOME/.bun/bin:/opt/homebrew/bin:/usr/local/bin:\$HOME/.orbstack/bin:\$PATH HOMEBREW_NO_AUTO_UPDATE=1; unset HTTPS_PROXY https_proxy HTTP_PROXY http_proxy ALL_PROXY all_proxy; $1"; }
+LOCK_TIMEOUT="${FLEET_INSPECTION_LOCK_TIMEOUT_SECONDS:-300}"
+LOCK_RETRY="${FLEET_INSPECTION_LOCK_RETRY_SECONDS:-2}"
+if ! [[ "$LOCK_TIMEOUT" =~ ^[1-9][0-9]*$ ]] || ! [[ "$LOCK_RETRY" =~ ^[0-9]+([.][0-9]+)?$ ]]; then
+  echo "invalid inspection-window lock timeout or retry interval" >&2
+  exit 2
+fi
+LOCK_COMMAND="set -eu; mkdir -p \"\$HOME/.elanous\" || { echo 'inspection window lock parent creation failed: ~/.elanous' >&2; exit 1; }; lock=\"\$HOME/.elanous/inspection-window.lock\"; started=\$(date +%s) || { echo 'inspection window lock clock read failed' >&2; exit 1; }; while ! mkdir \"\$lock\" 2>/dev/null; do now=\$(date +%s) || { echo 'inspection window lock clock read failed' >&2; exit 1; }; elapsed=\$((now - started)); if [ \"\$elapsed\" -ge $LOCK_TIMEOUT ]; then echo 'inspection window lock acquisition timed out' >&2; exit 1; fi; sleep $LOCK_RETRY; done; if ! printf '%s\\n' '$HOST' > \"\$lock/owner\"; then if rm -f \"\$lock/owner\" && rmdir \"\$lock\"; then trap - EXIT; echo 'inspection window lock owner write failed' >&2; else echo 'inspection window lock owner write failed; cleanup failed' >&2; fi; exit 1; fi; trap 'rm -f \"\$lock/owner\"; rmdir \"\$lock\"' EXIT"
+if [ "${2:-}" = --inspection-window ]; then
+  WINDOW_STATE="${3:-}"
+  case "$WINDOW_STATE" in
+    active|inactive) ;;
+    *) echo "✗ inspection-window state must be active or inactive" >&2; exit 2 ;;
+  esac
+  R "$LOCK_COMMAND; tmp=\"\$HOME/.elanous/inspection-window.tmp.\$\$\"; printf '%s\\n' '$WINDOW_STATE' > \"\$tmp\"; mv \"\$tmp\" \"\$HOME/.elanous/inspection-window\"; echo 'inspection window state updated: $WINDOW_STATE'"
+  exit $?
+fi
+if [ "${2:-}" = --light-worker ]; then
+  WORKER_COMMAND="${ELANOUS_FLEET_LIGHT_WORKER_COMMAND:-scripts/fleet/run-light-worker.sh}"
+  if [ -z "$WORKER_COMMAND" ] || [[ "$WORKER_COMMAND" = /* ]] || [[ "$WORKER_COMMAND" = *[!a-zA-Z0-9_./-]* ]]; then
+    echo "✗ invalid light-worker command" >&2
+    exit 2
+  fi
+  if [ "$WORKER_COMMAND" != scripts/fleet/run-light-worker.sh ]; then
+    echo "✗ light-worker command must use the installed fleet entrypoint" >&2
+    exit 2
+  fi
+  ssh -o BatchMode=yes -o ConnectTimeout=10 "$HOST" "export PATH=\\$HOME/.bun/bin:/opt/homebrew/bin:/usr/local/bin:\\$HOME/.orbstack/bin:\\$PATH; mkdir -p ~/.elanous && cat > ~/.elanous/run-light-worker.sh && chmod 700 ~/.elanous/run-light-worker.sh" < "$ROOT/scripts/fleet/run-light-worker.sh" || { echo "✗ light-worker entrypoint installation failed" >&2; exit 1; }
+  R "$LOCK_COMMAND; state=\$(cat \"\$HOME/.elanous/inspection-window\") || { echo 'inspection-window status unavailable; light-worker blocked' >&2; exit 1; }; case \"\$state\" in active) echo 'inspection window active; light-worker skipped'; exit 0 ;; inactive) \"\$HOME/.elanous/run-light-worker.sh\" ;; *) echo 'invalid inspection-window status; light-worker blocked' >&2; exit 1 ;; esac"
+  exit $?
+fi
 ok() { printf '  ✓ %s\n' "$1"; }; bad() { printf '  ✗ %s\n' "$1"; FAIL=1; }; todo() { printf '  → %s\n' "$1"; TODO=$((TODO+1)); }
 FAIL=0; TODO=0
 echo "▶ 노드 $HOST$([ $CHECK = 1 ] && echo ' (점검만)')"

package/scripts/fleet/run-light-worker.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+set -euo pipefail
+
+SINCE="${ELANOUS_FLEET_USAGE_SINCE:-24h}"
+if [[ "$SINCE" = *[!a-zA-Z0-9smhdw]* ]]; then
+  echo "invalid usage lookback window" >&2
+  exit 2
+fi
+exec elanous logs --all --include-test --event llm-usage --since "$SINCE" --limit 50000 --json --json-data