sneakoscope 7.0.2 → 7.0.3

package/dist/core/commands/naruto-command.js

@@ -11,6 +11,7 @@ import { codexAppSessionKey, detectCodexAppSession, runOfficialSubagentWorkflow
 import { NARUTO_GATE_FILENAME, NARUTO_RESULT_SCHEMA, NARUTO_SUMMARY_FILENAME, SUBAGENT_PLAN_FILENAME, buildNarutoGateResult, buildNarutoSummary, officialSubagentPreparationInProgress, prepareOfficialSubagentMission, withOfficialSubagentLifecycleLock, withNarutoMissionRunAdmission, writeNarutoGate } from '../subagents/official-subagent-preparation.js';
 import { recordOfficialSubagentParentOutcomesTelemetry } from '../zellij/zellij-official-subagent-telemetry.js';
 import { effectiveSubagentTarget, refreshSubagentWaveLifecycle } from '../subagents/wave-lifecycle.js';
+import { HOST_CAPABILITY_HOOK_RUNTIME_FILENAME, bindParentSummaryToHostCapabilityEvidence, createHostCapabilityHookRuntimeBinding, resolveHostCapabilityHookRuntimeBinding } from '../agent-bridge/host-capability-runtime.js';
 export { buildNarutoGateResult } from '../subagents/official-subagent-preparation.js';
 let nextNarutoPreparationFailureInjectionForTest = null;
 export function injectNextNarutoPreparationFailureForTest(value) {
@@ -138,11 +139,14 @@ async function narutoRunTransaction(parsed, root, appSession, sessionKey, resolv
     const { plan, evidence: preparationEvidence, budget, verification, delegationPrompt, workflowRunId, configBlockers } = preparation;
     const run = await runOfficialSubagentWorkflow({
         root,
+        goal: parsed.prompt,
         prompt: delegationPrompt,
         requestedSubagents: budget.requestedSubagents,
         maxThreads: budget.maxThreads,
         appSession,
+        projectTrusted: parsed.trustedProject,
         missionId: id,
+        workflowRunId,
         sessionKey,
         ...(missionLease ? { onChildSpawn: missionLease.protectChildPid } : {})
     });
@@ -160,7 +164,21 @@ async function narutoRunTransaction(parsed, root, appSession, sessionKey, resolv
             waveCount: Number(completedPlan?.wave_count ?? budget.waveCount),
             capacity: completedPlan?.capacity_controller || budget.capacity
         };
-        const runBoundParentSummary = bindTrustworthySubagentParentSummaryToRun(run.parent_summary, workflowRunId);
+        const hostCapabilityHookBinding = appSession && sessionKey && run.host_capability_runtime
+            ? createHostCapabilityHookRuntimeBinding({
+                missionId: id,
+                workflowRunId,
+                sessionScope: sessionKey,
+                runtime: run.host_capability_runtime
+            })
+            : null;
+        if (hostCapabilityHookBinding) {
+            await writeJsonAtomic(path.join(dir, HOST_CAPABILITY_HOOK_RUNTIME_FILENAME), hostCapabilityHookBinding);
+        }
+        const hostCapabilityBinding = run.host_capability_evidence
+            ? bindParentSummaryToHostCapabilityEvidence(run.parent_summary, run.host_capability_evidence)
+            : { value: run.parent_summary, blockers: [] };
+        const runBoundParentSummary = bindTrustworthySubagentParentSummaryToRun(hostCapabilityBinding.value, workflowRunId);
         const effectiveParentSummary = await persistOrReuseTrustworthySubagentParentSummary(dir, runBoundParentSummary, {
             workflowStatus: run.status,
             runId: workflowRunId
@@ -177,7 +195,8 @@ async function narutoRunTransaction(parsed, root, appSession, sessionKey, resolv
             workflowStatus: run.status,
             preparationOnly: appSession,
             runId: workflowRunId,
-            additionalBlockers: configBlockers
+            additionalBlockers: [...configBlockers, ...hostCapabilityBinding.blockers],
+            ...(run.host_capability_evidence ? { hostCapabilityEvidence: run.host_capability_evidence } : {})
         });
         if (!appSession) {
             const parentTelemetry = await recordOfficialSubagentParentOutcomesTelemetry({
@@ -207,8 +226,11 @@ async function narutoRunTransaction(parsed, root, appSession, sessionKey, resolv
         const blockers = uniqueStrings([
             ...(Array.isArray(evidence.blockers) ? evidence.blockers : []),
             ...configBlockers,
+            ...hostCapabilityBinding.blockers,
             ...(Array.isArray(run.blockers) ? run.blockers : []),
-            ...(appSession ? ['official_subagent_execution_pending_in_current_parent'] : [])
+            ...(appSession && run.status === 'delegation_context_ready'
+                ? ['official_subagent_execution_pending_in_current_parent']
+                : [])
         ]);
         const gate = await writeNarutoGate(dir, {
             missionId: id,
@@ -220,7 +242,7 @@ async function narutoRunTransaction(parsed, root, appSession, sessionKey, resolv
         const passed = gate.passed === true;
         const status = passed
             ? 'completed'
-            : appSession
+            : appSession && run.status === 'delegation_context_ready'
                 ? 'delegation_context_ready'
                 : run.ok === true
                     ? 'incomplete'
@@ -245,7 +267,11 @@ async function narutoRunTransaction(parsed, root, appSession, sessionKey, resolv
             mission_id: id,
             official_subagent_run_id: workflowRunId,
             session_scope: sessionKey,
-            phase: passed ? 'NARUTO_COMPLETE' : appSession ? 'NARUTO_DELEGATION_CONTEXT_READY' : 'NARUTO_BLOCKED',
+            phase: passed
+                ? 'NARUTO_COMPLETE'
+                : appSession && run.status === 'delegation_context_ready'
+                    ? 'NARUTO_DELEGATION_CONTEXT_READY'
+                    : 'NARUTO_BLOCKED',
             subagents_verified: evidence.ok === true,
             requested_subagents: finalBudget.requestedSubagents,
             target_subagents: evidence.target_subagents,
@@ -262,7 +288,7 @@ async function narutoRunTransaction(parsed, root, appSession, sessionKey, resolv
             ...summary,
             mission_id: id,
             attached_to_pending_run: false,
-            additionalContext: appSession ? run.additionalContext : undefined,
+            additionalContext: appSession && run.status === 'delegation_context_ready' ? run.additionalContext : undefined,
             artifacts: narutoArtifactLinks(evidence)
         };
     });
@@ -286,15 +312,21 @@ async function narutoRunTransaction(parsed, root, appSession, sessionKey, resolv
 async function readPendingAppNarutoRun(root, mission, sessionKey, prompt) {
     if (await officialSubagentPreparationInProgress(mission.dir))
         return null;
-    const [plan, evidence, summary, gate, state] = await Promise.all([
+    const [plan, evidence, summary, gate, state, rawHostCapabilityBinding] = await Promise.all([
         readJson(path.join(mission.dir, SUBAGENT_PLAN_FILENAME), null),
         readJson(path.join(mission.dir, 'subagent-evidence.json'), null),
         readJson(path.join(mission.dir, NARUTO_SUMMARY_FILENAME), null),
         readJson(path.join(mission.dir, NARUTO_GATE_FILENAME), null),
-        loadStateForSession(root, sessionKey).catch(() => null)
+        loadStateForSession(root, sessionKey).catch(() => null),
+        readJson(path.join(mission.dir, HOST_CAPABILITY_HOOK_RUNTIME_FILENAME), null).catch(() => null)
     ]);
     const workflowRunId = String(plan?.workflow_run_id || '').trim();
     const sessionMatches = state?._session_key === sessionStateKey(sessionKey);
+    const hostCapabilityScopeMatches = Boolean(resolveHostCapabilityHookRuntimeBinding(rawHostCapabilityBinding, {
+        missionId: mission.id,
+        workflowRunId,
+        sessionScope: sessionKey
+    }).binding);
     const pending = Boolean(workflowRunId
         && plan?.schema === 'sks.subagent-plan.v1'
         && plan?.workflow === 'official_codex_subagent'
@@ -319,7 +351,8 @@ async function readPendingAppNarutoRun(root, mission, sessionKey, prompt) {
         && state?.official_subagent_run_id === workflowRunId
         && state?.session_scope === sessionKey
         && state?.route_closed !== true
-        && state?.phase === 'NARUTO_DELEGATION_CONTEXT_READY');
+        && state?.phase === 'NARUTO_DELEGATION_CONTEXT_READY'
+        && hostCapabilityScopeMatches);
     if (!pending)
         return null;
     return {
@@ -567,6 +600,7 @@ export function parseNarutoArgs(args) {
         missionId: String(missionFlag || positionalMission || 'latest'),
         json: normalized.includes('--json'),
         readOnly: normalized.includes('--readonly') || normalized.includes('--read-only'),
+        trustedProject: optionArgs.includes('--trusted-project'),
         argumentErrors: uniqueStrings(argumentErrors)
     };
 }
@@ -575,7 +609,7 @@ function positionalValues(args) {
         '--agents', '--max-threads', '--mission', '--mission-id'
     ]);
     const booleanFlags = new Set([
-        '--json', '--readonly', '--read-only'
+        '--json', '--readonly', '--read-only', '--trusted-project'
     ]);
     const result = [];
     for (let index = 0; index < args.length; index += 1) {
@@ -638,7 +672,7 @@ function optionErrors(name, option, numeric) {
 function unknownOptionErrors(args) {
     const canonical = new Set([
         '--agents', '--max-threads', '--mission', '--mission-id',
-        '--json', '--readonly', '--read-only', '--help', '-h', '--'
+        '--json', '--readonly', '--read-only', '--trusted-project', '--help', '-h', '--'
     ]);
     const errors = [];
     const optionArgs = args.includes('--') ? args.slice(0, args.indexOf('--')) : args;
@@ -652,7 +686,7 @@ function unknownOptionErrors(args) {
     return errors;
 }
 function booleanOptionErrors(args) {
-    const booleanNames = new Set(['--json', '--readonly', '--read-only', '--help', '-h']);
+    const booleanNames = new Set(['--json', '--readonly', '--read-only', '--trusted-project', '--help', '-h']);
     const optionArgs = args.includes('--') ? args.slice(0, args.indexOf('--')) : args;
     const errors = [];
     for (const arg of optionArgs) {

package/dist/core/commands/ppt-command.js

@@ -20,9 +20,6 @@ export async function pptCommand(command, args = []) {
     if (action === 'explain')
         return pptExplain(root, args.slice(1));
     const missionArg = args[1] && !String(args[1]).startsWith('--') ? args[1] : 'latest';
-    // build/status act on ppt-gate.json (written by build, not the imagegen-review gate),
-    // so scope by mode only here - requiring the imagegen-review gate would wrongly exclude
-    // a fresh ppt mission that hasn't gone through review yet.
     const missionId = missionArg === 'latest' ? await findLatestMission(root, { mode: 'ppt' }) : missionArg;
     if (!missionId)
         return missingMission(args);
@@ -340,12 +337,6 @@ function mockPptFixtureGate(gate = {}) {
         blockers: ['ppt_fixture_mode_cannot_claim_real']
     };
 }
-// The image-asset-ledger's `assets` array (see buildPptImageAssetLedger in ../ppt.ts) is the
-// authoritative list of raster/bitmap image assets planned or generated for the deck; every
-// entry in it is a raster PNG produced (or pending) via Codex App $imagegen/gpt-image-2. When the
-// ledger omits `imagegen_evidence` outright, we must NOT assume the imagegen-required policy was
-// satisfied. Instead derive a safe default from that asset list: any raster asset present forces
-// the derived evidence to fail-closed (required + not passed) rather than silently pass.
 function deriveImagegenEvidenceDefault(imageAssetLedger) {
     if (imageAssetLedger?.imagegen_evidence)
         return imageAssetLedger.imagegen_evidence;

package/dist/core/commands/run-command.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { exists, projectRoot, runProcess, writeJsonAtomic } from '../fsx.js';
 import { createMission, missionDir, setCurrent } from '../mission.js';
 import { createAndWriteWorkOrderLedgerForPrompt, closeWorkOrderLedgerForRouteResult } from '../work-order-ledger.js';
@@ -392,8 +393,7 @@ async function executePreparedRoute(root, route, prompt, { prepare, run, trustSt
     });
 }
 async function runSks(root, commandArgs, { parentMissionId = null } = {}) {
-    const packedBin = new URL('../../bin/sks.js', import.meta.url).pathname;
-    const sourceBin = new URL('../../../bin/sks.js', import.meta.url).pathname;
+    const { packedBin, sourceBin } = runSksEntrypointCandidates();
     const entrypoint = (await exists(packedBin)) ? packedBin : sourceBin;
     return runProcess(process.execPath, [entrypoint, ...commandArgs], {
         cwd: root,
@@ -407,6 +407,12 @@ async function runSks(root, commandArgs, { parentMissionId = null } = {}) {
         },
     });
 }
+export function runSksEntrypointCandidates(moduleUrl = import.meta.url) {
+    return {
+        packedBin: fileURLToPath(new URL('../../bin/sks.js', moduleUrl)),
+        sourceBin: fileURLToPath(new URL('../../../bin/sks.js', moduleUrl)),
+    };
+}
 function routeExecutionResult(route, command, result, options = {}) {
     const nestedMissionId = parseMissionId(result.stdout);
     const ok = result.code === 0;

package/dist/core/commands/seo-command.js

@@ -23,8 +23,6 @@ export async function runSearchVisibilityCommand(mode, args = [], displayCommand
         if (!mission)
             blockers.push('mission_required_for_apply');
         else {
-            // explicit_apply_only precondition: a mutation plan must already exist on disk,
-            // proving a prior `plan` step was run and reviewed before this apply can mutate anything.
             const planGate = await evaluateLocalGate({ root: mission.root, dir: mission.dir, gateFile: mode === 'seo' ? 'seo-gate.json' : 'geo-gate.json', requiredArtifacts: ['search-visibility/mutation-plan.json'] });
             if (planGate.blockers.includes('missing_artifact:search-visibility/mutation-plan.json'))
                 blockers.push('seo_apply_missing_mutation_plan');
@@ -103,15 +101,11 @@ async function applySearchVisibilityGateResult(mode, action, result, options) {
     });
     const blockers = [...new Set([...(result.blockers || []), ...evaluated.blockers])];
     if (action === 'apply') {
-        // explicit_apply_only postcondition: apply must not report success unless both the mutation
-        // plan and the rollback manifest it produces are actually present on disk after execution.
         if (blockers.includes('missing_artifact:search-visibility/mutation-plan.json') && !blockers.includes('seo_apply_missing_mutation_plan'))
             blockers.push('seo_apply_missing_mutation_plan');
         if (blockers.includes('missing_artifact:search-visibility/rollback-manifest.json') && !blockers.includes('seo_apply_missing_rollback_manifest'))
             blockers.push('seo_apply_missing_rollback_manifest');
     }
-    // Re-evaluate against the authoritative on-disk gate (catches mock/fixture-only gates,
-    // not just the presence checks `evaluateLocalGate` performs) before reporting final success.
     const authoritative = await evaluateGate(mission.root, mission.id, gateFile);
     if (!authoritative.pass) {
         for (const reason of authoritative.reasons) {

package/dist/core/commands/wiki-command.js

@@ -240,9 +240,6 @@ async function wikiRefreshCode(args = []) {
         written: written ? written.path : null
     };
     process.exitCode = validation.ok ? 0 : 2;
-    // Always note the counts/issues on stderr (even in --json mode, where stdout must
-    // stay pure JSON) so a blocked run is diagnosable from stderr_tail alone without
-    // needing to reproduce it separately in an isolated environment.
     process.stderr.write(`wiki-refresh-code: root=${root} modules=${index.modules.length} entries=${pack.entries.length} token_cost=${pack.total_token_cost}/${pack.token_budget} issues=${JSON.stringify(validation.issues)}\n`);
     if (flag(args, '--json'))
         return console.log(JSON.stringify(result, null, 2));
@@ -251,13 +248,6 @@ async function wikiRefreshCode(args = []) {
     for (const issue of validation.issues)
         console.log(`- ${issue}`);
 }
-/** Cheap freshness check: compares the code pack's recorded git HEAD sha (at
- * generation time) against the current HEAD. A commit containing only the two
- * tracked code-pack metadata files is equivalent to the generating HEAD, which
- * avoids an impossible self-referential commit hash. Any other uncertainty
- * resolves to 'stale' rather than 'fresh', never overclaiming. */
-/** Active-wrongness counts per TriWiki module id (from wrongness records' module_ids),
- * so attention can hydrate frequently-wrong modules' code entries first. */
 async function buildWrongnessByModule(root) {
     const records = await readCombinedWrongnessRecords(root, null).catch(() => []);
     const counts = {};
@@ -425,10 +415,6 @@ export async function writeWikiContextPack(root, args = [], opts = {}) {
         wrongnessByModule
     });
     const wrongnessContext = await wrongnessContextForRoute(root, { route: '$Wiki', limit: 12 });
-    // buildTriWikiAttention's use_first/hydrate_first can reference code: ids that were
-    // never routed through selectClaims (no fabricated RGBA coordinate for them — see
-    // codePackAttentionRows), so append their real summary text here or a recallpulse
-    // consumer resolving pack.claims by id would only see the bare id string.
     const attentionCodeIds = new Set([
         ...(pack.attention?.use_first || []),
         ...(pack.attention?.hydrate_first || [])

package/dist/core/computer-use-live-evidence.js

@@ -5,11 +5,6 @@ import { ensureDir, exists, nowIso, packageRoot, readJson, rel, sha256, writeJso
 import { addVisualAnchor, ingestImage, missionImageLedgerPath } from './wiki-image/image-voxel-ledger.js';
 const officialScreenshotAdapters = new WeakSet();
 const officialCaptureAttestations = new WeakMap();
-/**
- * Production trust boundary for a Codex App Computer Use host bridge.
- * Object-literal adapters and fixture callbacks cannot mint the in-process
- * attestation required for live_capture_success.
- */
 export function createOfficialCodexComputerUseScreenshotAdapter(captureScreenshot) {
     if (typeof captureScreenshot !== 'function')
         throw new TypeError('official_computer_use_capture_function_required');

package/dist/core/config/secret-preservation.js

@@ -118,15 +118,6 @@ export function changedOrMissingProtectedSecrets(before, after) {
     })
         .filter((item) => Boolean(item));
 }
-// A repair that intentionally deactivates a config block (e.g. commenting out
-// a colliding stdio MCP server) makes the secret disappear from the *live*
-// scan even though its value is still sitting right there in a comment, fully
-// recoverable. Without this check the guard treats that as an accidental loss,
-// rolls the whole file back (undoing the repair), and still throws — so the
-// repair can never stick. Only 'missing' entries are reconsidered here: a
-// 'changed' entry means a live value actually differs and must still trip the
-// guard. Never reads the pre-image value itself — only re-hashes whatever text
-// is currently on disk, so raw_values_recorded stays false throughout.
 async function withoutSecretsPreservedInComments(entries) {
     const textBySource = new Map();
     const kept = [];
@@ -146,8 +137,6 @@ async function withoutSecretsPreservedInComments(entries) {
     }
     return kept;
 }
-/** Like readAssignment, but also matches the same key commented out (`# KEY = ...`)
- * and returns every candidate value found, not just the first. */
 function readAllAssignmentValues(text, key) {
     const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\\\./g, '\\s*\\.\\s*');
     const re = new RegExp(`^\\s*#?\\s*(?:export\\s+)?${escaped}\\s*=\\s*(.+?)\\s*$`, 'gm');

package/dist/core/daemon/sksd-hook-daemon-entrypoint.js

@@ -1,6 +1,4 @@
 #!/usr/bin/env node
-// Entrypoint for the detached sksd hook daemon process (spawned by
-// spawnSksdHookDaemonDetached). Not invoked directly by users.
 import { startSksdHookDaemon } from './sksd-hook-daemon.js';
 import { evaluateHookPayloadOnce } from '../hooks-runtime.js';
 const root = process.argv[2];

package/dist/core/daemon/sksd-hook-daemon.js

@@ -6,24 +6,9 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { sha256 } from '../fsx.js';
-// 20차 P2-1: hook round-trip daemon. `.codex/hooks.json` fires PreToolUse/
-// PostToolUse for every tool call, each spawning a fresh `sks hook <event>`
-// process that cold-imports the CLI and re-does all hook setup work — the
-// audited raw cost was ~171ms/call. This daemon keeps that work warm in a
-// long-lived process reachable over a Unix domain socket, so a hook call
-// only pays for a short-lived client process's own boot plus a small
-// socket round-trip.
-//
-// Opt-in only for now via SKS_HOOK_DAEMON=1 (see sks-dispatch.ts) — the
-// default `sks hook <event>` path is unchanged until this has been proven
-// safe and .codex/hooks.json is deliberately updated to depend on it.
 const IDLE_SHUTDOWN_MS = 30 * 60 * 1000;
 const CONNECT_TIMEOUT_MS = 150;
 const REQUEST_TIMEOUT_MS = 5_000;
-// Unix domain socket paths have a ~100 byte limit on macOS/Linux. TMPDIR can
-// itself be a deeply nested hermetic test root, so sockets use a short,
-// per-user SKS-owned runtime directory under the platform's real /tmp. The
-// project hash keeps independent repositories collision-free.
 export function sksdSocketPath(root) {
     return path.join(sksdRuntimeDir(), `sksd-${projectKey(root)}.sock`);
 }
@@ -138,20 +123,15 @@ async function removeStaleSocketPath(socketPath) {
         return;
     if (stat.isDirectory() && !stat.isSymbolicLink())
         throw new Error('unsafe_sksd_socket_path_directory');
-    // rm() unlinks a symlink itself; it never follows it to the target.
     await fsp.rm(socketPath, { force: true });
 }
-// Called by the daemon entrypoint (registers real process signal handlers
-// and exits the process on shutdown) and directly by tests (which own the
-// returned handle's close() instead and must not have this call
-// process.exit — that would kill the test runner).
 export async function startSksdHookDaemon(root, handleHook) {
     const socketPath = sksdSocketPath(root);
     const pidFilePath = sksdPidFilePath(root);
     const runtimeDir = path.dirname(socketPath);
     await ensureSafeRuntimeDir(runtimeDir);
     if (!(await claimPidFile(pidFilePath, root))) {
-        return null; // Another daemon for this root owns the live PID claim.
+        return null;
     }
     try {
         await removeStaleSocketPath(socketPath);
@@ -258,11 +238,6 @@ export async function startSksdHookDaemon(root, handleHook) {
     resetIdleTimer();
     return { close };
 }
-// Spawns the daemon as a detached background process running this same
-// module's entrypoint, then returns immediately — the caller (a hook
-// client that couldn't connect) does not wait for it to finish warming up;
-// it falls back to handling the current call itself and lets the daemon
-// serve the *next* call.
 export function spawnSksdHookDaemonDetached(root) {
     const entrypoint = fileURLToPath(new URL('./sksd-hook-daemon-entrypoint.js', import.meta.url));
     const child = spawn(process.execPath, [entrypoint, root], {
@@ -271,9 +246,6 @@ export function spawnSksdHookDaemonDetached(root) {
     });
     child.unref();
 }
-// Thin client used by `sks hook <event>`: attempt a fast socket round-trip;
-// return null (never throws) if the daemon isn't reachable so the caller
-// can fail open to the direct in-process path.
 export async function callSksdHookDaemon(root, name, payload) {
     const socketPath = sksdSocketPath(root);
     if (!safeRuntimeDirPresent(path.dirname(socketPath)))

package/dist/core/daemon/sksd-hook-dispatch.js

@@ -1,21 +1,4 @@
-// Opt-in fast path for `sks hook <event>` (SKS_HOOK_DAEMON=1 only — see
-// sks-dispatch.ts). Tries the sksd hook daemon first; on any failure to
-// reach it, spawns the daemon in the background for next time and falls
-// back to running the exact same evaluateHookPayload()/normalizeHookResult()
-// logic the default path uses, so behavior is identical either way — only
-// the latency differs (20차 P2-1).
-//
-// Lives under core/daemon rather than bin/ deliberately: dist/bin/ is
-// force-loaded as CommonJS by build-dist.ts's writeCommonJsBinScope() via a
-// hand-maintained per-file rewrite list, which this file isn't on — as a
-// plain ESM module under core/, sks-dispatch.ts's dynamic import() of it
-// works regardless of dist/bin/'s module-type override.
 import { callSksdHookDaemon, spawnSksdHookDaemonDetached } from './sksd-hook-daemon.js';
-// loadHookPayload/normalizeHookResult come from the lightweight hook-io
-// module, not hooks-runtime.js directly — hooks-runtime.js pulls in ~20
-// domain modules (pipeline, mission, db-safety, harness-guard, ...) that a
-// daemon-hit call has no reason to load. evaluateHookPayload (the heavy
-// one) is dynamically imported below, only on the fallback path.
 import { loadHookPayload, normalizeHookResult } from '../hooks-runtime/hook-io.js';
 import { projectRoot } from '../fsx.js';
 export async function hookDaemonInline(name) {

package/dist/core/db-safety.js

@@ -646,13 +646,6 @@ async function scanSupabaseMcpConfigs(root) {
 }
 function extractSupabaseMcpUrls(text) {
     const out = new Set();
-    // Config files (TOML/JSON) always quote URL values, so a closing quote or
-    // whitespace is the only reliable terminator. A comma is a legitimate query-string
-    // character (e.g. "...&features=database,docs") - excluding it here silently
-    // truncated multi-value features lists, which happened to be benign only because
-    // the truncated remainder still contained an allowed feature. Stopping at ')'/'>' is
-    // unnecessary for structured config scanning and risks the same truncation for any
-    // URL whose query string legitimately contains those characters (URL-encoded or not).
     const re = /https:\/\/mcp\.supabase\.com\/mcp[^"'\s]*/gi;
     let m;
     while ((m = re.exec(text)))

package/dist/core/doctor/browser-use-repair.js

@@ -124,8 +124,6 @@ export async function repairBrowserUse(input) {
     const optionalFeatureEnablementBlockers = optionalFeatureSteps
         .filter((step) => step.attempted && !step.ok)
         .map((step) => `${step.id}:codex_feature_enable_unsupported_or_failed`);
-    // This repair can establish configuration/plugin capability only. A live Browser or
-    // Chrome action in a fresh Codex task is required before any route may claim use proof.
     const realBrowserInteractionVerified = false;
     const refreshActions = pluginRepair?.changed ? pluginRepair.next_actions || [] : [];
     const nextActions = recovered ? refreshActions : [

package/dist/core/doctor/doctor-codex-startup-repair.js

@@ -7,9 +7,6 @@ export const DOCTOR_CODEX_STARTUP_REPAIR_SCHEMA = 'sks.doctor-codex-startup-repa
 export async function runDoctorCodexStartupRepair(input) {
     const root = path.resolve(input.root || process.cwd());
     const codexHome = input.codexHome || process.env.CODEX_HOME || path.join(process.env.HOME || os.homedir(), '.codex');
-    // Project-scoped official custom-agent installation is owned by repairAgentRoleConfigs.
-    // This startup repair remains structural/MCP-only and never touches legacy
-    // or user agent TOMLs in project or global directories.
     const roleFiles = { sanitized: [], created: [], blockers: [] };
     const configs = [];
     for (const candidate of [

package/dist/core/doctor/doctor-readiness-matrix.js

@@ -97,6 +97,17 @@ export function buildDoctorReadinessMatrix(input = {}) {
         blockers.add('agent_role_config_repair_failed');
     if (Array.isArray(agentRoleConfig.missing) && agentRoleConfig.missing.length && agentRoleConfig.apply !== true)
         warnings.add('agent_role_config_missing_repair_available');
+    const skills = input.skills || null;
+    for (const scope of ['global', 'project']) {
+        const report = skills?.[scope];
+        if (!report || report.skipped === true)
+            continue;
+        if (report.ok === false || report.core_skill_integrity?.ok === false) {
+            blockers.add(`${scope}_skills_reconcile_failed`);
+            for (const warning of normalizeList(report.warnings))
+                warnings.add(`${scope}_skills:${warning}`);
+        }
+    }
     const repairReadiness = buildRepairReadiness(input);
     for (const blocker of repairReadiness.blockers)
         blockers.add(blocker);
@@ -188,6 +199,7 @@ export function buildDoctorReadinessMatrix(input = {}) {
             blockers: normalizeList(localModel.blockers)
         },
         agent_role_config: agentRoleConfig,
+        skills,
         ready: coreReady,
         primary_blocker: [...blockers][0] || null,
         blockers: [...blockers],

package/dist/core/doctor/doctor-skill-reconcile.js

@@ -0,0 +1,32 @@
+import os from 'node:os';
+import path from 'node:path';
+import { sameFilesystemPath } from '../fsx.js';
+export async function reconcileDoctorSkills(root, doctorFix) {
+    if (!doctorFix)
+        return { skipped: true, reason: 'doctor_without_fix' };
+    const { reconcileSkills } = await import('../init/skills.js');
+    const home = path.resolve(process.env.HOME || os.homedir());
+    const globalTarget = path.resolve(home, '.agents', 'skills');
+    const projectTarget = path.resolve(root, '.agents', 'skills');
+    const global = await reconcileSkills({
+        targetDir: globalTarget,
+        scope: 'global',
+        fix: true
+    }).catch((err) => ({ ok: false, error: err?.message || String(err) }));
+    const project = await sameFilesystemPath(projectTarget, globalTarget)
+        ? {
+            schema: 'sks.skill-reconcile.v1',
+            ok: true,
+            scope: 'project',
+            target_dir: projectTarget,
+            fix: true,
+            skipped: true,
+            reason: 'same_as_authoritative_global_skill_root'
+        }
+        : await reconcileSkills({
+            targetDir: projectTarget,
+            scope: 'project',
+            fix: true
+        }).catch((err) => ({ ok: false, error: err?.message || String(err) }));
+    return { global, project };
+}

package/dist/core/doctor/imagegen-repair.js

@@ -118,8 +118,6 @@ export async function repairCodexImagegen(input) {
     const realGenerationVerified = capabilityReady
         && after?.real_generation_available === true
         && after?.real_output_verified_by_capability_check === true;
-    // No real generation round-trip primitive exists in imagegen-capability.ts today.
-    // Keep configuration detection separate from route/output proof.
     const communicationTest = {
         level: realGenerationVerified ? 'real_output' : 'flag_level',
         ok: realGenerationVerified,

package/dist/core/doctor/mcp-transport-collision-repair.js

@@ -98,7 +98,6 @@ export async function detectAndRepairMcpTransportCollisions(input) {
     }
     return report;
 }
-/** Scans only the top-level project config text for `[mcp_servers.<name>]` headers (not nested child tables like `.env`). */
 function listMcpServerNames(text) {
     const source = String(text || '');
     const pattern = /^\s*\[mcp_servers\.([^.\]]+)\]\s*(?:#.*)?$/gm;
@@ -126,8 +125,6 @@ async function readGlobalCodexConfigText() {
     const text = await fs.readFile(file, 'utf8').catch(() => '');
     return { path: file, text };
 }
-/** Comments every line of the colliding project MCP block (header + child tables like .env) so Codex stops merging
- * two transports for the same server name, while keeping the original text — including secrets — recoverable in place. */
 function commentOutMcpServerBlock(block, server, projectTransport, globalTransport) {
     const note = `# [sks doctor] MCP server "${server}" project block disabled: project transport (${projectTransport}) collided with the global config's transport (${globalTransport}) for the same server name (Codex refuses the merged config, e.g. "url is not supported for stdio"). Re-add a block with a matching transport if this project needs its own "${server}" MCP server.\n`;
     const commented = String(block || '')

package/dist/core/doctor/retired-managed-residue-private.js

@@ -1,6 +1,5 @@
 import path from 'node:path';
 import { inspectConfinedPath, moveConfinedPath, removeEmptyTreeVerified, uniqueConfinedPath, walkConfinedEntries } from '../managed-path-safety.js';
-/** Cleanup-only inventory. These names are never registered, listed, or redirected. */
 export const REMOVED_PUBLIC_COMMANDS = ['team', 'mad-db', 'tmux', 'xai', 'swarm', 'agent', 'ralph', 'ui'];
 const RETIRED_COMMAND_TOMBSTONES = new Set(REMOVED_PUBLIC_COMMANDS);
 const RETIRED_MISSION_MODES = new Set([

package/dist/core/doctor/supabase-mcp-repair.js

@@ -46,12 +46,6 @@ export async function repairSupabaseMcp(input) {
     }
     const readOnlyBefore = /read[_-]?only\s*=\s*true|access_mode\s*=\s*"read-only"|--read-only/.test(block);
     const unsafeWriteAccessBefore = configured && !disabled && !readOnlyBefore && /write|service_role|SUPABASE_ACCESS_TOKEN/.test(block);
-    // Codex merges the global (~/.codex) and project (.codex) config per key. When
-    // the project defines a stdio supabase server (command=...) while the global
-    // one uses a streamable-http url, the merged table has both `command` and
-    // `url`, and Codex refuses to load with "url is not supported for stdio",
-    // blocking every chat/task in that project. Detect and disable the project's
-    // stdio block so it inherits the safe global read-only url form.
     const globalConfig = await readGlobalCodexConfigText();
     const distinctConfigs = path.resolve(globalConfig.path) !== path.resolve(config.path);
     const projectTransport = blockTransport(block);
@@ -88,8 +82,6 @@ export async function repairSupabaseMcp(input) {
                 mutate: () => afterText
             });
     }
-    // A resolved collision comments the whole stdio block out, so the project no
-    // longer contributes an active supabase server at all.
     const effectivelyConfigured = configured && !transportCollisionResolved;
     const afterBlock = transportCollisionResolved ? '' : readOnlyMigrated ? mcpServerBlock(afterText, 'supabase') || '' : block;
     const readOnlyAfter = /read[_-]?only\s*=\s*true|access_mode\s*=\s*"read-only"|--read-only/.test(afterBlock);
@@ -171,9 +163,6 @@ function blockTransport(block) {
         return 'url';
     return null;
 }
-/** Comment every line of a supabase MCP block (header + child .env table) so
- * Codex stops loading it as a stdio server, while keeping the original text —
- * including the access token — recoverable in place. */
 function commentOutStdioSupabaseBlock(block) {
     const note = '# [sks doctor] Supabase MCP stdio block disabled: it collided with the global read-only URL Supabase entry (Codex: "url is not supported for stdio"). Re-add a read-only URL form (url = "https://mcp.supabase.com/mcp?project_ref=<ref>&read_only=true&features=database,docs") if this project needs its own Supabase MCP.\n';
     const commented = String(block || '')