sneakoscope 5.1.2 → 5.5.0

package/dist/core/feature-fixtures.js

@@ -1,4 +1,5 @@
 import { PACKAGE_VERSION } from './fsx.js';
+export { runFeatureFixture } from './feature-fixture-executor.js';
 export const FEATURE_FIXTURE_SCHEMA = 'sks.feature-fixtures.v1';
 export const FEATURE_QUALITY_LEVELS = Object.freeze([
     'runtime_verified',
@@ -32,7 +33,7 @@ const FIXTURES = Object.freeze({
         quality: 'static_contract',
         reason: 'UI command opens a localhost dashboard; release fixture tracks the CLI contract without launching a server.'
     }),
-    'cli-run': fixture('execute_and_validate_artifacts', 'sks run "fixture" --mock --json', ['run-classification.json', 'completion-proof.json', 'evidence-index.json', 'route-completion-contract.json', 'trust-report.json'], 'pass'),
+    'cli-run': fixture('execute_and_validate_artifacts', 'sks run "fixture" --mock --json', ['run-classification.json', 'completion-proof.json', 'evidence-index.json', 'route-completion-contract.json', 'trust-report.json', 'work-order-ledger.json'], 'blocked', { reason: 'finalizeMockRun() in run-command.ts intentionally hardcodes gate.passed=false for every --mock invocation so a mock run can never claim a real completion; it does write all declared artifacts, including a work-order-ledger honestly closed to blocked (18차).' }),
     'cli-status': fixture('execute', 'sks status --json', [], 'pass'),
     'cli-usage': fixture('execute', 'sks usage overview', [], 'pass'),
     'cli-quickstart': fixture('execute', 'sks quickstart', [], 'pass'),
@@ -46,27 +47,27 @@ const FIXTURES = Object.freeze({
     'cli-selftest': fixture('execute', 'sks selftest --mock', [], 'pass'),
     'cli-git': fixture('execute', 'sks git policy --json', [], 'pass'),
     'cli-uninstall': fixture('execute', 'sks uninstall --dry-run --json', [], 'pass'),
-    'cli-goal': fixture('execute_and_validate_artifacts', 'sks goal status latest --json', ['goal-workflow.json'], 'pass'),
+    'cli-goal': fixture('execute_and_validate_artifacts', 'sks goal create "Fixture smoke: create a minimal Node.js CLI health-check script" --json', ['goal-workflow.json', 'work-order-ledger.json'], 'blocked', { timeout_ms: 300000, reason: 'goal create drives a real loop-graph -> $Naruto multi-agent orchestration pass that requires live agent infrastructure (GPT dispatch, zellij dashboard, verification DAG) unavailable in a fixture/CI sandbox, so loop_result/gate legitimately reports blocked (naruto_*_missing, loop-graph-proof.json_missing) and the command exits 1 by design; goal-workflow.json and a work-order-ledger honestly closed to blocked (18차) are still written.' }),
     'cli-seo-geo-optimizer': fixture('execute_and_validate_artifacts', 'sks seo-geo-optimizer fixture --mode seo --json', ['search-visibility/site-inventory.json', 'search-visibility/seo-findings.json', 'search-visibility/verification-report.json', 'seo-gate.json', 'completion-proof.json'], 'pass'),
-    'cli-research': fixture('execute_and_validate_artifacts', 'sks research status latest --json', ['research-gate.json', 'completion-proof.json'], 'pass'),
-    'cli-qa-loop': fixture('execute_and_validate_artifacts', 'sks qa-loop status latest --json', ['qa-loop-proof.json', 'completion-proof.json'], 'pass'),
-    'cli-ppt': fixture('execute_and_validate_artifacts', 'sks ppt fixture --mock --json', ['ppt-imagegen-review-gate.json', 'completion-proof.json'], 'pass'),
-    'cli-image-ux-review': fixture('execute_and_validate_artifacts', 'sks image-ux-review status latest --json', ['image-ux-generated-review-ledger.json', 'image-voxel-ledger.json'], 'pass'),
+    'cli-research': fixture('execute_and_validate_artifacts', 'sks research run latest --mock --json', ['research-gate.json', 'completion-proof.json'], 'blocked', { timeout_ms: 180000, reason: '"run" (not "status") is the command that actually writes research-gate.json/completion-proof.json, but research is a two-step prepare-then-run workflow gated by an active-route-not-closed check between steps that a single fixture command cannot express; on a hermetic run "latest" will not be a properly prepared+closed research mission.' }),
+    'cli-qa-loop': fixture('execute_and_validate_artifacts', 'sks qa-loop run latest --mock --json', ['qa-gate.json', 'completion-proof.json'], 'pass', { timeout_ms: 180000 }),
+    'cli-ppt': fixture('mock', 'sks ppt fixture --mock --json', ['ppt-imagegen-review-gate.json', 'completion-proof.json'], 'pass', { reason: 'mockPptFixtureGate() in ppt-command.ts hardcodes an honest blocked gate and the handler unconditionally sets process.exitCode=1 by design so a mock PPT build can never claim a real pass; it does write the declared artifacts.' }),
+    'cli-image-ux-review': fixture('execute_and_validate_artifacts', 'sks image-ux-review fixture --mock --json', ['completion-proof.json', 'image-voxel-ledger.json', 'image-ux-generated-review-ledger.json'], 'blocked', { reason: 'Same as route-image-ux-review: the image-ux-review fixture command intentionally always exits 1 by design (honest mock, cannot claim a real completion), even though it does write all declared artifacts.' }),
     'cli-computer-use': fixture('real_optional', 'sks computer-use status --json', [], 'pass'),
-    'cli-pipeline': fixture('execute_and_validate_artifacts', 'sks pipeline status latest --json', ['pipeline-plan.json'], 'pass'),
-    'cli-validate-artifacts': fixture('execute_and_validate_artifacts', 'sks validate-artifacts latest --json', ['validation-report.json'], 'pass'),
-    'cli-hproof': fixture('execute_and_validate_artifacts', 'sks hproof check latest', ['completion-proof.json'], 'pass'),
+    'cli-pipeline': fixture('execute_and_validate_artifacts', 'sks pipeline plan latest --agents 1 --json', ['pipeline-plan.json'], 'pass'),
+    'cli-validate-artifacts': fixture('execute_and_validate_artifacts', 'sks validate-artifacts latest --json', ['artifact-validation.json'], 'pass'),
+    'cli-hproof': fixture('execute_and_validate_artifacts', 'sks hproof check latest', ['done-gate.evaluated.json'], 'pass'),
     'cli-proof-field': fixture('execute', 'sks proof-field scan --json --intent fixture', [], 'pass'),
-    'cli-recallpulse': fixture('execute_and_validate_artifacts', 'sks recallpulse status latest --json', ['recallpulse-report.json'], 'pass'),
-    'cli-agent': fixture('execute_and_validate_artifacts', 'sks agent run fixture --mock --json', ['agents/agent-central-ledger.json', 'agents/agent-task-board.json', 'agents/agent-leases.json', 'agents/agent-no-overlap-proof.json', 'agents/agent-session-cleanup.json', 'agents/agent-proof-evidence.json', 'agents/agent-effort-policy.json'], 'pass'),
-    'cli-gx': fixture('execute_and_validate_artifacts', 'sks gx validate fixture', ['gx-validation.json'], 'pass'),
+    'cli-recallpulse': fixture('execute_and_validate_artifacts', 'sks recallpulse run latest --json', ['mission-status-ledger.json'], 'pass'),
+    'cli-agent': fixture('execute_and_validate_artifacts', 'sks agent run fixture --mock --json', ['agents/agent-central-ledger.json', 'agents/agent-task-board.json', 'agents/agent-leases.json', 'agents/agent-no-overlap-proof.json', 'agents/agent-session-cleanup.json', 'agents/agent-proof-evidence.json', 'agents/agent-effort-policy.json'], 'pass', { timeout_ms: 120000 }),
+    'cli-gx': fixture('execute_and_validate_artifacts', 'sks gx validate fixture --mock', ['gx-validation.json'], 'blocked', { reason: 'gxValidateFixture() intentionally exits non-zero (execution_class: mock_fixture) for an honest mock/blocked result; without --mock the command crashes on a missing cartridge instead.' }),
     'cli-perf': fixture('execute', 'sks perf cold-start --json --iterations 1', [], 'pass'),
     'cli-bench': fixture('execute_and_validate_artifacts', 'sks bench core --tier npx-one-shot --json --iterations 1', ['.sneakoscope/reports/performance/core-bench.json'], 'pass'),
-    'cli-code-structure': fixture('execute', 'sks code-structure scan --json', [], 'pass'),
+    'cli-code-structure': fixture('execute', 'sks code-structure scan --json', [], 'pass', { timeout_ms: 180000 }),
     'cli-rust': fixture('execute', 'sks rust smoke --json', [], 'pass'),
     'cli-skill-dream': fixture('execute', 'sks skill-dream status --json', [], 'pass'),
     'cli-gc': fixture('execute', 'sks gc --dry-run --json', [], 'pass'),
-    'cli-memory': fixture('execute', 'sks memory --dry-run --json', [], 'pass'),
+    'cli-memory': fixture('execute', 'sks memory --dry-run --json', [], 'pass', { timeout_ms: 300000 }),
     'cli-stats': fixture('execute', 'sks stats --json', [], 'pass'),
     'cli-dollar-commands': fixture('execute', 'sks dollar-commands --json', [], 'pass'),
     'cli-fast-mode': fixture('execute', 'sks fast-mode status --json', [], 'pass'),
@@ -79,19 +80,27 @@ const FIXTURES = Object.freeze({
     'cli-deps': fixture('execute', 'sks deps check --json', [], 'pass'),
     'cli-auth': fixture('execute', 'sks auth status --json', [], 'pass'),
     'cli-codex-native': fixture('execute', 'sks codex-native status --json', [], 'pass'),
-    'cli-zellij': fixture('mock', 'npm run zellij:capability --silent', [], 'pass'),
-    'cli-tmux': fixture('mock', 'removed runtime migration notice: sks tmux --json', [], 'pass'),
+    'cli-zellij': fixture('execute', 'npm run zellij:capability --silent', [], 'pass'),
+    'cli-tmux': fixture('not_available', null, [], 'not_required', {
+        quality: 'missing',
+        reason: 'tmux runtime was removed from SKS (see tmuxCommand in basic-cli.ts and `sks tmux` deprecation notice); the prior fixture command string was not a real invocable command ("removed runtime migration notice: sks tmux --json"), so it is reclassified as not_available instead of being mislabeled mock.',
+        root_mode: 'source_checkout_required'
+    }),
     'cli-mad': fixture('execute', 'sks mad --help', [], 'pass'),
     'cli-mad-sks': fixture('static', 'sks mad-sks status --json', [], 'pass'),
     'cli-auto-review': fixture('execute', 'sks auto-review status --json', [], 'pass'),
-    'cli-commit': fixture('mock', 'sks commit --dry-run', [], 'pass'),
-    'cli-commit-and-push': fixture('mock', 'sks commit-and-push --dry-run', [], 'pass'),
+    'cli-commit': fixture('mock', 'sks commit --dry-run', [], 'pass', {
+        reason: 'simpleGitCommitCommand() in git-simple.ts performs a real `git add -A && git commit` against whatever repo cwd it runs in; it has no --dry-run implementation (argValue() only reads --message/-m/--json, so --dry-run is silently ignored) and would mutate git history if actually spawned by an automated fixture runner. Left as documented mock rather than execute a real commit or invent an unsupported --dry-run mode.'
+    }),
+    'cli-commit-and-push': fixture('mock', 'sks commit-and-push --dry-run', [], 'pass', {
+        reason: 'Same underlying simpleGitCommitCommand() as cli-commit plus a real `git push`; genuinely destructive (commits and pushes to the remote) with no real --dry-run support. Left as documented mock rather than execute a real commit+push or invent an unsupported --dry-run mode.'
+    }),
     'cli-context7': fixture('real_optional', 'sks context7 check --json', [], 'pass'),
     'cli-insane-search': fixture('execute', 'sks insane-search doctor --json', [], 'pass'),
     'cli-ultra-search': fixture('execute', 'sks ultra-search doctor --json', [], 'pass'),
     'cli-xai': fixture('real_optional', 'sks xai check --json', [], 'pass'),
     'cli-task': fixture('execute', 'sks task instant --plan --json', [], 'pass'),
-    'cli-release': fixture('execute', 'sks release affected --json', [], 'pass'),
+    'cli-release': fixture('execute', 'sks release affected --json', [], 'blocked', { reason: '18차: the phantom requiredSections schema mismatch (five_lane_review/integration_evidence/session_cleanup, from commit d4526f84 with no producer ever wired up) has been fixed -- missing_sections is now honestly empty. The release-gate DAG still legitimately fails/blocks on other real gates (e.g. release:readiness) independent of this fix, so the command still exits non-zero and this fixture stays honestly blocked rather than claiming full green.' }),
     'cli-triwiki': fixture('execute', 'sks triwiki index --json', [], 'pass'),
     'cli-daemon': fixture('execute', 'sks daemon status --json', [], 'pass'),
     'cli-all-features': fixture('execute_and_validate_artifacts', 'sks all-features complete --json', [`.sneakoscope/reports/all-feature-completion-${PACKAGE_VERSION}.json`], 'pass'),
@@ -99,7 +108,7 @@ const FIXTURES = Object.freeze({
     'cli-eval': fixture('execute', 'sks eval run --mock --json', [], 'pass'),
     'cli-harness': fixture('execute', 'sks harness fixture --mock --json', [], 'pass'),
     'cli-naruto': fixture('execute_and_validate_artifacts', 'sks naruto run "fixture" --backend fake --work-items 4 --json', ['completion-proof.json', 'naruto-gate.json'], 'pass'),
-    'cli-team': fixture('execute_and_validate_artifacts', 'sks team "fixture" --mock --clones 4 --backend fake --work-items 4 --json', ['naruto-gate.json', 'team-alias-to-naruto.json'], 'pass'),
+    'cli-team': fixture('execute_and_validate_artifacts', 'sks team "fixture" --mock --clones 4 --backend fake --work-items 4 --json', ['naruto-gate.json', 'team-alias-to-naruto.json'], 'pass', { timeout_ms: 90000 }),
     'cli-reasoning': fixture('execute', 'sks reasoning status --json', [], 'pass'),
     'cli-profile': fixture('execute', 'sks profile status --json', [], 'pass'),
     'skill-db-safety-guard': fixture('execute_and_validate_artifacts', 'sks db check --sql "SELECT 1" --json', ['db-operation-report.json', 'completion-proof.json'], 'pass'),
@@ -117,50 +126,84 @@ const FIXTURES = Object.freeze({
     'cli-proof': fixture('execute_and_validate_artifacts', 'sks proof smoke --json', ['.sneakoscope/proof/latest.json'], 'pass'),
     'cli-trust': fixture('execute_and_validate_artifacts', 'sks trust report latest --json', ['trust-report.json'], 'pass'),
     'cli-wrongness': fixture('execute_and_validate_artifacts', 'sks wrongness add --kind missing_evidence --claim "fixture wrongness" --json', ['.sneakoscope/wiki/wrongness-ledger.json'], 'pass'),
-    'route-team': fixture('execute_and_validate_artifacts', 'sks team "fixture" --mock --clones 4 --backend fake --work-items 4 --json', ['naruto-gate.json', 'team-alias-to-naruto.json'], 'pass'),
+    'route-team': fixture('execute_and_validate_artifacts', 'sks team "fixture" --mock --clones 4 --backend fake --work-items 4 --json', ['naruto-gate.json', 'team-alias-to-naruto.json', 'work-order-ledger.json'], 'pass', { timeout_ms: 90000 }),
     'route-team-alias': fixture('execute_and_validate_artifacts', 'sks team "fixture" --mock --clones 4 --backend fake --work-items 4 --json', ['naruto-gate.json', 'team-alias-to-naruto.json'], 'pass'),
-    'route-naruto': fixture('execute_and_validate_artifacts', 'sks naruto run "fixture" --clones 4 --backend fake --work-items 4 --json', ['agents/agent-proof-evidence.json', 'agents/agent-scheduler-state.json'], 'pass'),
-    'route-work': fixture('execute_and_validate_artifacts', 'sks naruto run "fixture" --backend fake --work-items 4 --json', ['completion-proof.json', 'naruto-gate.json'], 'pass'),
-    'route-swarm': fixture('execute_and_validate_artifacts', 'sks naruto run "fixture" --backend fake --work-items 4 --json', ['completion-proof.json', 'naruto-gate.json'], 'pass'),
+    'route-naruto': fixture('execute_and_validate_artifacts', 'sks naruto run "fixture" --clones 4 --backend fake --work-items 4 --json', ['agents/agent-proof-evidence.json', 'agents/agent-scheduler-state.json', 'work-order-ledger.json'], 'pass', { timeout_ms: 90000 }),
+    'route-work': fixture('execute_and_validate_artifacts', 'sks naruto run "fixture" --backend fake --work-items 4 --json', ['naruto-gate.json', 'work-order-ledger.json'], 'pass', { timeout_ms: 285000, reason: 'naruto-command.ts never invokes the route-finalizer/completion-proof pipeline; naruto-gate.json is the real artifact it writes.' }),
+    'route-swarm': fixture('execute_and_validate_artifacts', 'sks naruto run "fixture" --backend fake --work-items 4 --json', ['naruto-gate.json', 'work-order-ledger.json'], 'pass', { timeout_ms: 285000, reason: 'Same as route-work: naruto-command.ts never invokes the completion-proof pipeline.' }),
     'route-plan': fixture('execute', 'sks plan "fixture" --json', [], 'pass'),
     'route-review': fixture('execute', 'sks review --diff HEAD --json', [], 'pass'),
-    'route-shadowclone': fixture('mock', '$ShadowClone alias of $Naruto shadow-clone swarm route', [], 'pass'),
-    'route-kagebunshin': fixture('mock', '$Kagebunshin alias of $Naruto shadow-clone swarm route', [], 'pass'),
-    'route-qa-loop': fixture('execute_and_validate_artifacts', 'sks qa-loop run latest --mock --json', ['completion-proof.json', 'qa-gate.json'], 'pass'),
-    'route-research': fixture('execute_and_validate_artifacts', 'sks research run latest --mock --json', ['completion-proof.json', 'research-gate.json'], 'pass'),
-    'route-ppt': fixture('execute_and_validate_artifacts', 'sks ppt fixture --mock --json', ['completion-proof.json', { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }, 'ppt-imagegen-review-gate.json', 'ppt-slide-issue-ledger.json'], 'pass'),
-    'route-image-ux-review': fixture('execute_and_validate_artifacts', 'sks image-ux-review fixture --mock --json', ['completion-proof.json', { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }, 'image-ux-generated-review-ledger.json'], 'pass'),
-    'route-computer-use': fixture('execute_and_validate_artifacts', 'sks computer-use import-fixture --mock --json', ['computer-use-evidence-ledger.json', { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }, 'completion-proof.json'], 'pass'),
-    'route-cu': fixture('mock', '$CU mock evidence ledger', ['computer-use-evidence-ledger.json', 'image-voxel-ledger.json', 'completion-proof.json'], 'pass'),
+    'route-shadowclone': fixture('mock', '$ShadowClone alias of $Naruto shadow-clone swarm route', [], 'pass', {
+        reason: 'Pure alias of $Naruto; no independent behavior to verify beyond route-naruto\'s own execute_and_validate_artifacts fixture.'
+    }),
+    'route-kagebunshin': fixture('mock', '$Kagebunshin alias of $Naruto shadow-clone swarm route', [], 'pass', {
+        reason: 'Pure alias of $Naruto; no independent behavior to verify beyond route-naruto\'s own execute_and_validate_artifacts fixture.'
+    }),
+    'route-qa-loop': fixture('execute_and_validate_artifacts', 'sks qa-loop run latest --mock --json', ['completion-proof.json', 'qa-gate.json'], 'blocked', { timeout_ms: 180000, reason: 'qaLoopRun() resolves "latest" via the same globally-unscoped findLatestMission used everywhere else and qa-loop is a two-step prepare-then-run workflow gated between steps by an active-route-not-closed check a single fixture command cannot express.' }),
+    'route-research': fixture('execute_and_validate_artifacts', 'sks research run latest --mock --json', ['completion-proof.json', 'research-gate.json'], 'pass', { timeout_ms: 180000 }),
+    'route-ppt': fixture('mock', 'sks ppt fixture --mock --json', ['completion-proof.json', { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }, 'ppt-imagegen-review-gate.json', 'ppt-slide-issue-ledger.json'], 'pass', { reason: 'Underlying command intentionally exits non-zero and reports ok:false by honest design (mockPptFixtureGate() hardcodes a blocked mock PPT gate); it does write all four declared artifacts.' }),
+    'route-image-ux-review': fixture('mock', 'sks image-ux-review fixture --mock --json', ['completion-proof.json', { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }, 'image-ux-generated-review-ledger.json'], 'pass', { reason: 'imageUxFixture() intentionally overrides the gate to passed:false/execution_class:mock_fixture and always exits non-zero for mock fixture runs so they can never claim a real pass; it does write the declared artifacts.' }),
+    'route-computer-use': fixture('execute_and_validate_artifacts', 'sks computer-use import-fixture --mock --json', ['computer-use-evidence-ledger.json', { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }, 'completion-proof.json'], 'blocked', { reason: 'importFixture() unconditionally sets process.exitCode=1 by design (execution_class: mock_fixture) so a mock Computer Use import can never claim a real pass.' }),
+    'route-cu': fixture('mock', '$CU mock evidence ledger', ['computer-use-evidence-ledger.json', 'image-voxel-ledger.json', 'completion-proof.json'], 'pass', {
+        reason: 'Underlying command (`sks cu import-fixture --mock`, same handler as route-computer-use) intentionally exits non-zero for mock Computer Use evidence imports (import-fixture in computer-use-command.ts always sets ok:false/process.exitCode=1, by honest design: mock evidence can never claim a real Computer Use verification). It does write the declared artifacts, but an execute_and_validate_artifacts fixture would need to special-case exit-code-1-as-expected for this one command, which would weaken the generic exit-code pass/fail contract; left as documented mock rather than encode that special case.'
+    }),
     'route-dfix': fixture('execute_and_validate_artifacts', 'sks dfix fixture --json', ['completion-proof.json', 'dfix-gate.json', 'dfix-verification.json'], 'pass'),
-    'route-answer': fixture('mock', '$Answer answer-only route policy', [], 'pass'),
-    'route-goal': fixture('mock', '$Goal bridge route', ['goal-workflow.json', 'completion-proof.json'], 'pass'),
+    'route-answer': fixture('mock', '$Answer answer-only route policy', [], 'pass', {
+        reason: 'Policy-only route (answer-only conversational mode with no writes); nothing executable to run beyond static contract text.'
+    }),
+    'route-goal': fixture('mock', '$Goal bridge route', ['goal-workflow.json', 'completion-proof.json'], 'pass', {
+        reason: 'sks goal create "<prompt>" --json never calls maybeFinalizeRoute, so it does not write completion-proof.json even on success; live-testing it also surfaced a real defect (loop-worker-runtime.ts omitted an explicit `agents` value, so buildAgentRoster() fell back to DEFAULT_AGENT_COUNT=5 while maxAgentCount was capped to the loop\'s smaller worker budget, throwing "Agent count 5 exceeds max N" for any ordinary fixture prompt) which has been fixed in this change, but goal-workflow.json/completion-proof.json parity still requires either wiring maybeFinalizeRoute into goalCreate or relaxing this fixture\'s expected_artifacts, both out of scope here; left as documented mock.'
+    }),
     'route-insane-search': fixture('execute', 'sks run "$Insane-Search source intelligence fixture" --execute --json', [], 'pass'),
     'route-insanesearch': fixture('execute', 'sks run "$InsaneSearch source intelligence fixture" --execute --json', [], 'pass'),
     'route-ultra-search': fixture('execute', 'sks run "$Ultra-Search source intelligence fixture" --execute --json', [], 'pass'),
     'route-ultrasearch': fixture('execute', 'sks run "$UltraSearch source intelligence fixture" --execute --json', [], 'pass'),
     'route-seo-geo-optimizer': fixture('execute_and_validate_artifacts', 'sks seo-geo-optimizer fixture --mode geo --json', ['search-visibility/site-inventory.json', 'search-visibility/geo-findings.json', 'search-visibility/verification-report.json', 'geo-gate.json', 'completion-proof.json'], 'pass'),
-    'route-autoresearch': fixture('mock', '$AutoResearch fixture route', ['research-gate.json', 'completion-proof.json'], 'pass'),
-    'route-mad-sks': fixture('mock', '$MAD-SKS permission gate + sql_plane route', [{ path: 'mad-sks-gate.json', schema: 'sks.mad-sks-gate.v1' }, 'completion-proof.json'], 'pass'),
-    'route-from-chat-img': fixture('mock', '$From-Chat-IMG visual work order route', ['from-chat-img-work-order.md', 'image-voxel-ledger.json', 'completion-proof.json'], 'pass'),
-    'route-ux-review': fixture('mock', '$UX-Review image UX alias route', ['image-ux-generated-review-ledger.json', 'image-voxel-ledger.json'], 'pass'),
-    'route-db': fixture('execute_and_validate_artifacts', 'sks db check --sql "SELECT 1" --json', ['completion-proof.json', 'db-operation-report.json'], 'pass'),
-    'route-mad-db': fixture('mock', '$MAD-DB deprecated alias to $MAD-SKS sql-plane contract', ['mad-sks-gate.json', 'completion-proof.json'], 'pass'),
+    'route-autoresearch': fixture('mock', '$AutoResearch fixture route', ['research-gate.json', 'completion-proof.json'], 'pass', {
+        reason: 'Producing research-gate.json + completion-proof.json requires the two-step `research prepare` then `research run latest --mock --autoresearch --json` sequence (same as route-research\'s safe-args setup step), which a single spawned command cannot express; the $AutoResearch pipeline-dispatch route (`sks run "$AutoResearch ..."`) instead writes autoresearch-gate.json, a different contract. Left as documented mock pending multi-step fixture setup support.'
+    }),
+    'route-mad-sks': fixture('mock', '$MAD-SKS permission gate + sql_plane route', [{ path: 'mad-sks-gate.json', schema: 'sks.mad-sks-gate.v1' }, 'completion-proof.json'], 'pass', {
+        reason: 'mad-sks-gate.json is written by materializeAutoSealedMadSks() inside prepareClarificationGate() in pipeline-internals/runtime-core.ts, which only runs via the real Codex App route dispatch pipeline (prepareRoute), not via `sks run "<prompt>" --json` (that CLI command only classifies the route in lightweight prepare mode and never calls prepareRoute); `sks run ... --execute` instead maps $MAD-SKS to team execution, a different path entirely. No safe single sks CLI invocation reaches materializeAutoSealedMadSks; verified live in a hermetic run where mad-sks-gate.json was not produced. Left as documented mock.'
+    }),
+    'route-from-chat-img': fixture('mock', '$From-Chat-IMG visual work order route', ['from-chat-img-work-order.md', 'image-voxel-ledger.json', 'completion-proof.json'], 'pass', {
+        reason: 'hasFromChatImgSignal() routes $From-Chat-IMG to the full Naruto multi-agent work-order pipeline (routes.ts routeById(\'Naruto\')), which requires real chat-screenshot attachments to produce from-chat-img-work-order.md; there is no lightweight deterministic `--mock` single-command invocation that produces this route\'s specific work-order/coverage artifacts the way route-naruto\'s generic fixture prompt does. Left as documented mock.'
+    }),
+    'route-ux-review': fixture('mock', 'sks image-ux-review fixture --mock --json', ['completion-proof.json', { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }, 'image-ux-generated-review-ledger.json'], 'pass', { reason: 'Alias of route-image-ux-review ($UX-Review -> $Image-UX-Review); shares the identical underlying command and the same intentional exit-1/ok:false mock-fixture hardening in imageUxFixture().' }),
+    'route-db': fixture('execute_and_validate_artifacts', 'sks db check --sql "SELECT 1" --json', ['completion-proof.json', 'db-operation-report.json'], 'pass', { timeout_ms: 120000 }),
+    'route-mad-db': fixture('mock', '$MAD-DB deprecated alias to $MAD-SKS sql-plane contract', ['mad-sks-gate.json', 'completion-proof.json'], 'pass', {
+        reason: 'Deprecated alias of $MAD-SKS; shares the same gap as route-mad-sks (mad-sks-gate.json is only written via the real Codex App route dispatch pipeline, not any safe single sks CLI invocation). Left as documented mock alongside route-mad-sks.'
+    }),
     'route-wiki': fixture('execute_and_validate_artifacts', 'sks wiki image-ingest test/fixtures/images/one-by-one.png --json', [{ path: 'completion-proof.json', schema: 'sks.completion-proof.v1' }, { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }], 'pass'),
-    'route-gx': fixture('execute_and_validate_artifacts', 'sks gx validate fixture --mock --json', ['completion-proof.json', { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }, 'gx-validation.json'], 'pass'),
-    'route-sks': fixture('mock', '$SKS control-surface route', ['completion-proof.json'], 'pass'),
+    'route-gx': fixture('execute_and_validate_artifacts', 'sks gx validate fixture --mock --json', ['completion-proof.json', { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }, 'gx-validation.json'], 'blocked', { reason: 'gxValidateFixture() intentionally exits non-zero (execution_class: mock_fixture) for an honest mock/blocked result; it does write all three declared artifacts.' }),
+    'route-sks': fixture('mock', '$SKS control-surface route', ['completion-proof.json'], 'pass', {
+        reason: 'Pure control-surface alias route with no independent behavior beyond the underlying CLI command fixtures it dispatches to.'
+    }),
     'route-fast-mode': fixture('execute', 'sks fast-mode status --json', [], 'pass'),
-    'route-fast-on': fixture('mock', '$Fast-On covered by hermetic fast-mode blackbox toggle test', [], 'pass'),
-    'route-fast-off': fixture('mock', '$Fast-Off covered by hermetic fast-mode blackbox toggle test', [], 'pass'),
+    'route-fast-on': fixture('mock', '$Fast-On covered by hermetic fast-mode blackbox toggle test', [], 'pass', {
+        reason: 'Toggle-only dollar-command alias; behavior is covered by the hermetic fast-mode blackbox toggle test suite, not a standalone CLI invocation.'
+    }),
+    'route-fast-off': fixture('mock', '$Fast-Off covered by hermetic fast-mode blackbox toggle test', [], 'pass', {
+        reason: 'Toggle-only dollar-command alias; behavior is covered by the hermetic fast-mode blackbox toggle test suite, not a standalone CLI invocation.'
+    }),
     'route-local-model': fixture('execute', 'sks with-local-llm status --json', [], 'pass'),
-    'route-with-local-llm-on': fixture('mock', '$with-local-llm-on covered by hermetic local-model dollar-command blackbox toggle test', [], 'pass'),
-    'route-with-local-llm-off': fixture('mock', '$with-local-llm-off covered by hermetic local-model dollar-command blackbox toggle test', [], 'pass'),
-    'route-help': fixture('mock', '$Help lightweight route', [], 'pass'),
-    'route-commit': fixture('mock', '$Commit git route', ['completion-proof.json'], 'pass'),
-    'route-commit-and-push': fixture('mock', '$Commit-And-Push git route', ['completion-proof.json'], 'pass'),
-    'route-release-review': fixture('mock', 'sks agent run "release audit" --route "$Release-Review" --agents 10 --concurrency 5 --mock --json', ['release-review-native-agent-plan.json', 'agents/agent-proof-evidence.json', 'agents/agent-effort-policy.json'], 'pass'),
-    'route-native-agent-intake': fixture('mock', 'sks agent run "fixture" --route "$Team" --agents 5 --concurrency 5 --mock --json', ['agents/agent-central-ledger.json', 'agents/agent-task-board.json', 'agents/agent-leases.json', 'agents/agent-no-overlap-proof.json', 'agents/agent-session-cleanup.json', 'agents/agent-proof-evidence.json', 'agents/agent-effort-policy.json'], 'pass'),
-    'proof-agent-evidence': fixture('mock', 'sks naruto run "fixture" --backend fake --work-items 4 --json', ['naruto-gate.json', 'agents/agent-proof-evidence.json'], 'pass')
+    'route-with-local-llm-on': fixture('mock', '$with-local-llm-on covered by hermetic local-model dollar-command blackbox toggle test', [], 'pass', {
+        reason: 'Toggle-only dollar-command alias; behavior is covered by the hermetic local-model dollar-command blackbox toggle test suite, not a standalone CLI invocation.'
+    }),
+    'route-with-local-llm-off': fixture('mock', '$with-local-llm-off covered by hermetic local-model dollar-command blackbox toggle test', [], 'pass', {
+        reason: 'Toggle-only dollar-command alias; behavior is covered by the hermetic local-model dollar-command blackbox toggle test suite, not a standalone CLI invocation.'
+    }),
+    'route-help': fixture('mock', '$Help lightweight route', [], 'pass', {
+        reason: 'Pure alias of the cli-help command; no independent behavior to verify beyond cli-help\'s own execute fixture.'
+    }),
+    'route-commit': fixture('mock', '$Commit git route', ['completion-proof.json'], 'pass', {
+        reason: 'Dollar-command alias of cli-commit; dispatches to the same simpleGitCommitCommand() that performs a real `git add -A && git commit` with no working --dry-run mode, so it is not safe to execute from an automated fixture runner. Left as documented mock alongside cli-commit.'
+    }),
+    'route-commit-and-push': fixture('mock', '$Commit-And-Push git route', ['completion-proof.json'], 'pass', {
+        reason: 'Dollar-command alias of cli-commit-and-push; dispatches to the same simpleGitCommitCommand() that performs a real commit and `git push` with no working --dry-run mode. Left as documented mock alongside cli-commit-and-push.'
+    }),
+    'route-release-review': fixture('execute_and_validate_artifacts', 'sks agent run "release audit" --route "$Release-Review" --agents 10 --concurrency 5 --mock --json', ['release-review-native-agent-plan.json', 'agents/agent-proof-evidence.json', 'agents/agent-effort-policy.json'], 'pass', { timeout_ms: 90000 }),
+    'route-native-agent-intake': fixture('execute_and_validate_artifacts', 'sks agent run "fixture" --route "$Team" --agents 5 --concurrency 5 --mock --json', ['agents/agent-central-ledger.json', 'agents/agent-task-board.json', 'agents/agent-leases.json', 'agents/agent-no-overlap-proof.json', 'agents/agent-session-cleanup.json', 'agents/agent-proof-evidence.json', 'agents/agent-effort-policy.json'], 'pass', { timeout_ms: 90000 }),
+    'proof-agent-evidence': fixture('execute_and_validate_artifacts', 'sks naruto run "fixture" --backend fake --work-items 4 --json', ['naruto-gate.json', 'agents/agent-proof-evidence.json'], 'pass', { timeout_ms: 240000 })
 });
 const STATIC_CONTRACT_FEATURES = new Set([
     'cli-wizard',

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '5.1.2';
+export const PACKAGE_VERSION = '5.5.0';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/loops/loop-decomposer.js

@@ -23,14 +23,15 @@ export function decomposeRequestIntoLoopDomains(request, changedFiles = []) {
             id: rule.id,
             dirs: rule.dirs.filter((dir) => !dir.includes('*')),
             files: matchedFiles,
-            gates: rule.gates
+            gates: rule.gates,
+            covers_work_order_items: []
         });
     }
     if (selected.size === 0 && explicitFiles.length) {
-        selected.set('loop-general-coding', { id: 'loop-general-coding', dirs: [], files: explicitFiles, gates: ['loop:affected'] });
+        selected.set('loop-general-coding', { id: 'loop-general-coding', dirs: [], files: explicitFiles, gates: ['loop:affected'], covers_work_order_items: [] });
     }
     if (selected.size === 0) {
-        selected.set('loop-general-coding', { id: 'loop-general-coding', dirs: ['src'], files: [], gates: ['loop:affected'] });
+        selected.set('loop-general-coding', { id: 'loop-general-coding', dirs: ['src'], files: [], gates: ['loop:affected'], covers_work_order_items: [] });
     }
     return [...selected.values()];
 }

package/dist/core/loops/loop-planner.js

@@ -9,7 +9,9 @@ import { readInitDeepMemory, readInitDeepMemoryHints } from '../codex-app/codex-
 export async function planLoopsFromRequest(input) {
     const parallelism = input.parallelism || 'balanced';
     const maxLoops = Math.max(1, Math.min(32, input.maxLoops || 8));
-    const domains = decomposeRequestIntoLoopDomains(input.request).slice(0, maxLoops);
+    const allDomains = decomposeRequestIntoLoopDomains(input.request);
+    const domains = allDomains.slice(0, maxLoops);
+    const domainsTruncated = allDomains.slice(maxLoops).map((domain) => domain.id);
     const actionNodes = domains.map((domain) => {
         const loopId = `loop-${domain.id}`;
         const ownerScope = inferLoopOwnerScope({ domain });
@@ -28,7 +30,7 @@ export async function planLoopsFromRequest(input) {
         });
         return { ...nodeBase, gates: selectLoopGates({ node: nodeBase, changedFiles: [...ownerScope.files, ...ownerScope.directories], risk }) };
     });
-    const integrationOwner = inferLoopOwnerScope({ domain: { id: 'integration', dirs: [], files: [], gates: ['release:dag-full-coverage'] }, integration: true });
+    const integrationOwner = inferLoopOwnerScope({ domain: { id: 'integration', dirs: [], files: [], gates: ['release:dag-full-coverage'], covers_work_order_items: [] }, integration: true });
     const integrationRisk = classifyLoopRisk({ loop_id: 'loop-integration', owner_scope: integrationOwner, level: 'L1-assisted' });
     const integrationBase = makeNode({
         missionId: input.missionId,
@@ -92,7 +94,9 @@ export async function planLoopsFromRequest(input) {
             goal_compat_artifact: input.sourceCommand === 'goal' ? `.sneakoscope/missions/${input.missionId}/goal-compat.json` : null,
             source_command: input.sourceCommand
         },
-        blockers: []
+        blockers: [],
+        domains_truncated: domainsTruncated,
+        unassigned_work_order_items: [...domainsTruncated]
     };
     const projectMemory = await readInitDeepMemory(input.root).catch(() => null);
     if (projectMemory) {

package/dist/core/loops/loop-worker-runtime.js

@@ -74,6 +74,12 @@ async function runLoopWorkerNative(input) {
         backend: 'codex-sdk',
         readonly: input.phase === 'checker',
         workspaceWrite: input.phase === 'maker',
+        // Bug fix: agents must be explicitly bounded to workerCount here. Without it,
+        // buildAgentRoster()'s normalizeAgentCount() falls back to DEFAULT_AGENT_COUNT (5)
+        // while maxAgentCount below is capped to workerCount, so any loop node with a
+        // worker_count/max_subagents budget under 5 (the common case) threw
+        // "Agent count 5 exceeds max N" instead of clamping to the smaller budget.
+        agents: Math.max(1, workerCount),
         desiredWorkItemCount: workGraph.total_work_items,
         minimumWorkItems: 1,
         maxAgentCount: Math.max(1, workerCount),

package/dist/core/naruto/naruto-real-worker-child.js

@@ -136,7 +136,7 @@ function startDeadmanHeartbeat(input) {
                 schema: 'sks.naruto-actual-worker-heartbeat.v1',
                 ts: nowIso(),
                 item_id: input.intake.item.id,
-                status: 'blocked',
+                status: 'timed_out',
                 elapsed_ms: elapsedMs,
                 progress: null
             }, 2 * 1024 * 1024).catch(() => undefined);

package/dist/core/pipeline-internals/runtime-gates.js

@@ -7,7 +7,7 @@ import { evaluateQaGate } from '../qa-loop.js';
 import { PPT_REQUIRED_GATE_FIELDS } from '../ppt.js';
 import { validateFinalHonestModeReport } from '../artifact-schemas.js';
 import { IMAGE_UX_REVIEW_GATE_ARTIFACT, IMAGE_UX_REVIEW_POLICY_ARTIFACT, IMAGE_UX_REVIEW_SCREEN_INVENTORY_ARTIFACT, IMAGE_UX_REVIEW_GENERATED_REVIEW_LEDGER_ARTIFACT, IMAGE_UX_REVIEW_ISSUE_LEDGER_ARTIFACT, IMAGE_UX_REVIEW_ITERATION_REPORT_ARTIFACT, IMAGE_UX_REVIEW_REQUIRED_GATE_FIELDS, IMAGE_UX_REVIEW_REFERENCE_GATE_FIELDS, IMAGE_UX_REVIEW_HONEST_MODE_ARTIFACT, imageUxReviewGateAllowsReferenceCloseout } from '../image-ux-review.js';
-import { CODEX_WEB_VERIFICATION_EVIDENCE_SOURCE, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, evidenceMentionsForbiddenBrowserAutomation, reflectionRequiredForRoute } from '../routes.js';
+import { CODEX_WEB_VERIFICATION_EVIDENCE_SOURCE, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, evidenceMentionsForbiddenBrowserAutomation, reflectionRequiredForRoute, routeById } from '../routes.js';
 import { validateRouteCompletionProof } from '../proof/route-proof-gate.js';
 import { routeFromState, routeRequiresCompletionProof } from '../proof/route-proof-policy.js';
 import { AGENT_INTAKE_STAGE_ID } from '../agents/agent-schema.js';
@@ -17,6 +17,7 @@ import { MISTAKE_RECALL_ARTIFACT, mistakeRecallGateStatus } from '../mistake-rec
 import { SSOT_GUARD_ARTIFACT, validateSsotGuardArtifact } from '../safety/ssot-guard.js';
 import { validateTeamRuntimeArtifacts } from '../team-dag.js';
 import { checkStopGate } from '../stop-gate/stop-gate-check.js';
+import { readWorkOrderLedger, evaluateWorkOrderCoverage } from '../work-order-ledger.js';
 import { clarificationStopReason, context7Evidence, hasContext7DocsEvidence, hasSubagentEvidence, subagentEvidence, } from './runtime-core.js';
 import { projectTriwikiToAgentsMd } from '../triwiki/agents-md-projector.js';
 const REFLECTION_ARTIFACT = 'reflection.md';
@@ -74,6 +75,27 @@ async function reflectionGateStatus(root, state = {}, jsonCache) {
     }
     return { ok, missing };
 }
+// The single choke point every route's stop decision passes through
+// (hookStop -> evaluateStop). A work-order-ledger.json here means SOME
+// code already committed to tracking this mission's work items; once that
+// commitment exists, stop must not be allowed while items remain
+// unresolved (neither verified nor honestly blocked), or an omission can
+// reach "done" silently. Missions with no ledger are unaffected (routes
+// that haven't adopted per-item tracking yet, or non-work routes).
+async function workOrderCoverageGateStatus(root, state = {}) {
+    const id = state?.mission_id;
+    if (!id)
+        return { ok: true, blockers: [] };
+    const ledger = await readWorkOrderLedger(missionDir(root, id));
+    if (!ledger) {
+        const route = routeById(routeFromState(state));
+        if (route?.coverage_required)
+            return { ok: false, blockers: ['work_order_ledger_missing'] };
+        return { ok: true, blockers: [] };
+    }
+    const coverage = evaluateWorkOrderCoverage(ledger);
+    return { ok: coverage.ok, blockers: coverage.blockers };
+}
 async function staleReflectionReasons(root, state = {}, gate = {}) {
     const created = Date.parse(gate.created_at || gate.updated_at || '');
     if (!Number.isFinite(created))
@@ -233,9 +255,16 @@ export async function evaluateStop(root, state, payload, opts = {}) {
             };
         }
         if (gate.ok) {
+            const coverage = await workOrderCoverageGateStatus(root, state);
+            if (!coverage.ok)
+                return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} route has unresolved work-order-ledger items (neither verified nor honestly blocked): ${coverage.blockers.join(', ')}.`, { gate: 'work-order-ledger', missing: coverage.blockers });
             const reflection = await reflectionGateStatus(root, state, jsonCache);
-            if (!reflection.ok)
+            if (!reflection.ok) {
+                const coverageRequiredRoute = routeById(routeFromState(state))?.coverage_required === true;
+                if (coverageRequiredRoute)
+                    return complianceBlock(root, state, reflectionStopReason(state, reflection), { gate: 'reflection', missing: reflection.missing });
                 await appendHonestModeNote(root, state, `reflection stale: ${(reflection.missing || []).join(', ')}`);
+            }
             return { continue: true };
         }
         const missing = gate.missing?.length ? ` Missing gate fields: ${gate.missing.join(', ')}.` : '';
@@ -255,8 +284,12 @@ export async function evaluateStop(root, state, payload, opts = {}) {
                 allowLatestFallback: opts.allowLatestFallback !== true ? false : true,
             });
             if (stopCheck.action === 'allow_stop') {
-                if (narutoFamily)
+                if (narutoFamily) {
+                    const coverage = await workOrderCoverageGateStatus(root, state);
+                    if (!coverage.ok)
+                        return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} route has unresolved work-order-ledger items (neither verified nor honestly blocked): ${coverage.blockers.join(', ')}.`, { gate: 'work-order-ledger', missing: coverage.blockers });
                     return { continue: true, systemMessage: `SKS: canonical stop-gate passed at ${stopCheck.gate_path}` };
+                }
             }
             else if (stopCheck.action === 'hard_blocked') {
                 return { continue: true, systemMessage: stopCheck.feedback, action: 'hard_blocked', gate: stopCheck.gate_path };
@@ -290,6 +323,9 @@ export async function evaluateStop(root, state, payload, opts = {}) {
     const reflection = await reflectionGateStatus(root, state, jsonCache);
     if (!reflection.ok)
         return complianceBlock(root, state, reflectionStopReason(state, reflection), { gate: 'reflection', missing: reflection.missing });
+    const coverage = await workOrderCoverageGateStatus(root, state);
+    if (!coverage.ok)
+        return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} route has unresolved work-order-ledger items (neither verified nor honestly blocked): ${coverage.blockers.join(', ')}.`, { gate: 'work-order-ledger', missing: coverage.blockers });
     fireAndForgetProjectMemory(root, state);
     return null;
 }

package/dist/core/proof/selftest-proof-fixtures.js

@@ -26,6 +26,14 @@ export async function writeSelftestRouteProof(root, { missionId, route = '$Team'
     return writeRouteCompletionProof(root, {
         missionId,
         route,
+        // This fixture writes into a scratch temp directory (see selftestCommand's
+        // `tmpdir('sks-selftest-')`) that is discarded after the call returns, so trust
+        // artifacts and post-route retention are pointless here. Worse than pointless:
+        // writeRouteCompletionProof's default path runs runPostRouteRetention() with
+        // `max_tmp_age_hours: 0`, which swept the just-written completion-proof.json
+        // before the caller could read it back, making `sks selftest --mock` fail with
+        // "completion proof fixture missing" even though the proof was written correctly.
+        lightweightEvidence: true,
         status: 'mock_only',
         executionClass: 'mock_fixture',
         gate: {

package/dist/core/providers/glm/naruto/glm-naruto-requirement-coverage.js

@@ -35,7 +35,7 @@ export function inferCandidateRequirementCoverage(input) {
             assumptions.push(`manual_preservation_evidence_required:${requirement.id}`);
             continue;
         }
-        if (input.envelope.patch.trim()) {
+        if (input.envelope.patch.trim() && hasKeywordOverlap(requirement.text, input.envelope.patch, input.envelope.target_paths)) {
             satisfied.push(requirement.id);
         }
         else {
@@ -89,4 +89,21 @@ export function buildGlmNarutoRequirementCoverageSummary(input) {
 function extractPaths(text) {
     return [...new Set(text.match(/[A-Za-z0-9_.-]+\/[A-Za-z0-9_./-]+\.[A-Za-z0-9]+/g) ?? [])];
 }
+const REQUIREMENT_STOPWORDS = new Set([
+    'the', 'a', 'an', 'and', 'or', 'to', 'of', 'in', 'on', 'for', 'with', 'is', 'are', 'be',
+    'this', 'that', 'it', 'as', 'by', 'at', 'from', 'should', 'must', 'will', 'not', 'no',
+    '이', '가', '을', '를', '은', '는', '에', '의', '으로', '로', '만', '및', '그리고'
+]);
+function extractKeywords(text) {
+    const tokens = text.toLowerCase().match(/[a-z0-9_]{3,}|[가-힣]{2,}/g) ?? [];
+    return [...new Set(tokens.filter((token) => !REQUIREMENT_STOPWORDS.has(token)))];
+}
+function hasKeywordOverlap(requirementText, patch, targetPaths) {
+    const keywords = extractKeywords(requirementText);
+    if (keywords.length === 0)
+        return false;
+    const patchLower = patch.toLowerCase();
+    const pathsLower = targetPaths.map((file) => file.toLowerCase());
+    return keywords.some((keyword) => patchLower.includes(keyword) || pathsLower.some((file) => file.includes(keyword)));
+}
 //# sourceMappingURL=glm-naruto-requirement-coverage.js.map

package/dist/core/providers/glm/naruto/glm-naruto-requirement-ledger.js

@@ -1,7 +1,8 @@
+const CONSTRAINT_CLAUSE_PATTERN = /\b(must|without|do not|don't|preserve|only|never|no fallback|no fake|금지|필수|보존|없이|만)\b/;
 export function buildGlmNarutoRequirementLedger(input) {
     const requirements = [];
     const seen = new Set();
-    const add = (text, source, required = true) => {
+    const add = (text, source, required = true, kind = 'task') => {
         const clean = text.replace(/\s+/g, ' ').trim();
         if (!clean || seen.has(`${source}:${clean.toLowerCase()}`))
             return;
@@ -10,23 +11,22 @@ export function buildGlmNarutoRequirementLedger(input) {
             id: `REQ-${String(requirements.length + 1).padStart(3, '0')}`,
             text: clean,
             source,
-            required
+            required,
+            kind
         });
     };
     for (const clause of splitRequirementClauses(input.task)) {
-        const lower = clause.toLowerCase();
-        if (/\b(must|without|do not|don't|preserve|only|never|no fallback|no fake|금지|필수|보존|없이|만)\b/.test(lower)) {
-            add(clause, 'user_task', true);
-        }
+        const kind = CONSTRAINT_CLAUSE_PATTERN.test(clause.toLowerCase()) ? 'constraint' : 'task';
+        add(clause, 'user_task', true, kind);
     }
     for (const file of input.mentionedPaths ?? []) {
-        add(`Touch or preserve mentioned path: ${file}`, 'user_task', true);
+        add(`Touch or preserve mentioned path: ${file}`, 'user_task', true, 'constraint');
     }
     if (input.gitStatus && input.gitStatus.trim()) {
-        add('Preserve pre-existing dirty worktree changes unless explicitly selected.', 'git_status', true);
+        add('Preserve pre-existing dirty worktree changes unless explicitly selected.', 'git_status', true, 'constraint');
     }
     if (requirements.length === 0)
-        add(input.task, 'user_task', true);
+        add(input.task, 'user_task', true, 'task');
     return {
         schema: 'sks.glm-naruto-requirement-ledger.v1',
         mission_id: input.missionId,
@@ -34,9 +34,25 @@ export function buildGlmNarutoRequirementLedger(input) {
     };
 }
 function splitRequirementClauses(task) {
-    return task
-        .split(/\r?\n|[.;]|(?:\s+-\s+)/g)
-        .map((part) => part.replace(/^[-*\d.)\s]+/, '').trim())
+    const byLine = task
+        .split(/\r?\n/g)
+        .map((line) => line.trim())
         .filter(Boolean);
+    const clauses = [];
+    for (const line of byLine) {
+        const byMarker = line
+            .split(/(?:\s+-\s+)|(?=(?:^|\s)(?:\d+[.)]|[-*•])\s)/g)
+            .map((part) => part.replace(/^[-*•\d.)\s]+/, '').trim())
+            .filter(Boolean);
+        const segments = byMarker.length > 1 ? byMarker : [line];
+        for (const segment of segments) {
+            const bySentence = segment
+                .split(/(?<=[.;!?])\s+(?=[A-Z0-9가-힣])|[;]/g)
+                .map((part) => part.replace(/^[-*•\d.)\s]+/, '').trim())
+                .filter(Boolean);
+            clauses.push(...(bySentence.length > 0 ? bySentence : [segment]));
+        }
+    }
+    return clauses.filter(Boolean);
 }
 //# sourceMappingURL=glm-naruto-requirement-ledger.js.map

package/dist/core/questions.js

@@ -392,7 +392,7 @@ export function buildRequestIntake(prompt, explicitAnswers = {}, opts = {}) {
     const answers = { ...(inferred.answers || {}), ...(explicitAnswers || {}) };
     const ambiguity = buildAmbiguityAssessment(originalPrompt, explicitAnswers);
     const wikiContext = summarizeWikiContext(opts.wikiContext);
-    const promptRequirements = promptRequirementItems(originalPrompt);
+    const { items: promptRequirements } = promptRequirementItems(originalPrompt);
     const semanticRequirements = semanticRequirementItems(originalPrompt);
     const acceptance = toStringList(answers.ACCEPTANCE_CRITERIA);
     const constraints = toStringList(answers.RISK_BOUNDARY);
@@ -464,20 +464,22 @@ function summarizeWikiContext(wikiContext = null) {
         }))
     };
 }
-function promptRequirementItems(prompt) {
-    const cleaned = prompt
-        .replace(/(?:^|\s)\$[A-Za-z0-9_-]+(?:\s|$)/g, ' ')
-        .replace(/\s+/g, ' ')
-        .trim();
+const PROMPT_REQUIREMENT_ITEM_CEILING = 128;
+export function promptRequirementItems(prompt) {
+    const stripped = String(prompt || '').replace(/(?:^|\s)\$[A-Za-z0-9_-]+(?:\s|$)/g, ' ');
+    const cleaned = stripped.replace(/[ \t]+/g, ' ').trim();
     if (!cleaned)
-        return [];
+        return { items: [], truncated: false, truncated_count: 0 };
     const sourceChunks = cleaned
-        .split(/\n+|(?:^|\s)[-*]\s+/)
+        .split(/\n+|(?:^|\s)[-*]\s+|(?:^|\n)\s*\d+[.)]\s+|(?:^|\n)\s*[①-⑳]\s*|(?:^|\n)\s*[A-Z]-\d+[.)]?\s+|(?:^|\n)\s*#{1,4}\s+/m)
         .flatMap((chunk) => splitLooseClauses(chunk))
-        .map((chunk) => chunk.trim())
+        .map((chunk) => chunk.replace(/\s+/g, ' ').trim())
         .filter(Boolean);
     const chunks = sourceChunks.length ? sourceChunks : [cleaned];
-    return chunks.slice(0, 12).map((text, index) => requirementItem('prompt', index + 1, text, 'source_prompt_order'));
+    const truncated = chunks.length > PROMPT_REQUIREMENT_ITEM_CEILING;
+    const kept = truncated ? chunks.slice(0, PROMPT_REQUIREMENT_ITEM_CEILING) : chunks;
+    const items = kept.map((text, index) => requirementItem('prompt', index + 1, text, 'source_prompt_order'));
+    return { items, truncated, truncated_count: truncated ? chunks.length - PROMPT_REQUIREMENT_ITEM_CEILING : 0 };
 }
 function splitLooseClauses(text) {
     const compact = String(text || '').trim();