sneakoscope 2.0.16 → 2.0.18

package/dist/core/commands/team-legacy-observe-command.js

@@ -0,0 +1,182 @@
+import path from 'node:path';
+import { ARTIFACT_FILES } from '../artifact-schemas.js';
+import { readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
+import { loadMission } from '../mission.js';
+import { MIN_TEAM_REVIEWER_LANES } from '../team-review-policy.js';
+import { renderTeamDashboardState, writeTeamDashboardState } from '../team-dashboard-renderer.js';
+import { appendTeamEvent, formatRoleCounts, isTerminalTeamAgentStatus, readTeamControl, readTeamDashboard, readTeamLive, readTeamTranscriptTail, renderTeamAgentLane, renderTeamCleanupSummary, renderTeamWatch, requestTeamSessionCleanup, teamCleanupRequested } from '../team-live.js';
+import { attachZellijSessionInteractive, launchTeamZellijView } from '../zellij/zellij-launcher.js';
+import { flag, readFlagValue } from './command-utils.js';
+export const teamLegacySubcommands = new Set([
+    'log',
+    'tail',
+    'watch',
+    'lane',
+    'status',
+    'dashboard',
+    'event',
+    'message',
+    'open-zellij',
+    'attach-zellij',
+    'cleanup-zellij',
+    'open-tmux',
+    'attach-tmux',
+    'cleanup-tmux'
+]);
+export async function teamLegacyObserveCommand(sub, args = []) {
+    const root = await sksRoot();
+    const missionArg = args[0] && !String(args[0]).startsWith('--') ? args[0] : 'latest';
+    const { resolveMissionId } = await import('./command-utils.js');
+    const id = await resolveMissionId(root, missionArg);
+    if (!id) {
+        console.error(`Usage: sks team ${sub} [mission-id|latest]`);
+        process.exitCode = 1;
+        return;
+    }
+    const { dir } = await loadMission(root, id);
+    if (sub === 'open-tmux' || sub === 'attach-tmux' || sub === 'cleanup-tmux') {
+        const result = { ok: false, status: 'removed_runtime', runtime: 'tmux', replacement: 'zellij', operator_actions: ['Use `sks team open-zellij`, `attach-zellij`, or `cleanup-zellij`.'] };
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify(result, null, 2));
+        console.error('tmux runtime has been removed from SKS Team. Use Zellij commands instead.');
+        process.exitCode = 2;
+        return;
+    }
+    if (sub === 'open-zellij' || sub === 'attach-zellij') {
+        const plan = await readJson(path.join(dir, 'team-plan.json'), null);
+        if (!plan) {
+            console.error(`Team plan missing for ${id}; cannot open Zellij Team view.`);
+            process.exitCode = 2;
+            return;
+        }
+        const slotCount = await inferTeamZellijSlotCount(dir, plan);
+        const zellij = await launchTeamZellijView({ root, missionId: id, ledgerRoot: path.join(dir, 'agents'), slotCount, dryRun: flag(args, '--json'), attach: false });
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify(zellij, null, 2));
+        if (!zellij.ok) {
+            console.error(`Zellij Team view blocked for ${id}: ${(zellij.blockers || []).join('; ') || 'Zellij launch failed'}`);
+            process.exitCode = 2;
+            return;
+        }
+        if (zellij.capability?.status === 'ok')
+            console.log(`Zellij: prepared Team lane(s) in ${zellij.session_name}`);
+        else
+            console.log(`Zellij: optional live panes unavailable (${(zellij.warnings || []).join('; ') || zellij.capability?.status || 'unknown'})`);
+        if (zellij.capability?.status === 'ok' && (sub === 'attach-zellij' || shouldAutoAttachTeamZellij(args))) {
+            attachZellijSessionInteractive(zellij.session_name, { cwd: root, configPath: zellij.clipboard_config_path });
+        }
+        return;
+    }
+    if (sub === 'event') {
+        const message = readFlagValue(args, '--message', '');
+        if (!message) {
+            console.error('Usage: sks team event [mission-id|latest] --agent <name> --phase <phase> --message "..."');
+            process.exitCode = 1;
+            return;
+        }
+        const phase = readFlagValue(args, '--phase', 'general');
+        const record = await appendTeamEvent(dir, { agent: readFlagValue(args, '--agent', 'parent_orchestrator'), phase, type: readFlagValue(args, '--type', 'status'), artifact: readFlagValue(args, '--artifact', ''), message });
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify(record, null, 2));
+        console.log(`${record.ts} [${record.phase}] ${record.agent}: ${record.message}`);
+        return;
+    }
+    if (sub === 'message') {
+        const message = readFlagValue(args, '--message', '');
+        if (!message) {
+            console.error('Usage: sks team message [mission-id|latest] --from <agent> --to <agent|all> --message "..."');
+            process.exitCode = 1;
+            return;
+        }
+        const record = await appendTeamEvent(dir, { agent: readFlagValue(args, '--from', readFlagValue(args, '--agent', 'parent_orchestrator')), to: readFlagValue(args, '--to', 'all'), phase: readFlagValue(args, '--phase', 'communication'), type: 'message', message });
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify(record, null, 2));
+        console.log(`${record.ts} [${record.phase}] ${record.agent} -> ${record.to}: ${record.message}`);
+        return;
+    }
+    if (sub === 'cleanup-zellij') {
+        const control = await requestTeamSessionCleanup(dir, { missionId: id, agent: readFlagValue(args, '--agent', 'parent_orchestrator'), reason: readFlagValue(args, '--reason', 'Team session ended; clean up live follow panes.'), finalMessage: 'Team session ended.' });
+        await appendTeamEvent(dir, { agent: readFlagValue(args, '--agent', 'parent_orchestrator'), phase: 'session_cleanup', type: 'cleanup', message: control.cleanup_reason || 'Team session cleanup requested.' });
+        const cleanup = { ok: true, runtime: 'zellij', mission_id: id, control, close_requested: flag(args, '--close-session') || flag(args, '--close') };
+        await writeJsonAtomic(path.join(dir, 'zellij-session-cleanup.json'), cleanup);
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify(cleanup, null, 2));
+        console.log('Zellij cleanup: marked complete.');
+        console.log(renderTeamCleanupSummary(control));
+        return;
+    }
+    if (sub === 'status') {
+        const dashboard = await readTeamDashboard(dir);
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify(dashboard || {}, null, 2));
+        if (!dashboard) {
+            console.error(`Team dashboard missing for ${id}.`);
+            process.exitCode = 2;
+            return;
+        }
+        console.log(`Team mission: ${id}`);
+        console.log(`Updated: ${dashboard.updated_at || 'unknown'}`);
+        console.log(`Agent sessions: ${dashboard.agent_session_count || MIN_TEAM_REVIEWER_LANES}`);
+        if (dashboard.role_counts)
+            console.log(`Role counts: ${formatRoleCounts(dashboard.role_counts)}`);
+        return;
+    }
+    if (sub === 'dashboard') {
+        await writeTeamDashboardState(dir, { missionId: id });
+        const state = await readJson(path.join(dir, ARTIFACT_FILES.team_dashboard_state), {});
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify(state, null, 2));
+        console.log(renderTeamDashboardState(state));
+        return;
+    }
+    if (sub === 'log')
+        return console.log(await readTeamLive(dir));
+    if (sub === 'lane') {
+        const agent = readFlagValue(args, '--agent', 'parent_orchestrator');
+        const phase = readFlagValue(args, '--phase', '');
+        const lines = Number(readFlagValue(args, '--lines', '12'));
+        const text = await renderTeamAgentLane(dir, { missionId: id, agent, phase, lines });
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify({ mission_id: id, agent, phase, lane: text }, null, 2));
+        console.log(text);
+        if (flag(args, '--follow') && !teamCleanupRequested(await readTeamControl(dir)) && !isTerminalTeamAgentStatus((await readTeamDashboard(dir).catch(() => null))?.agents?.[agent]?.status || '')) {
+            // Follow mode intentionally falls through only for interactive terminals in the full Zellij lane.
+        }
+        return;
+    }
+    if (sub === 'tail' || sub === 'watch') {
+        const lines = readFlagValue(args, '--lines', '20');
+        if (sub === 'watch' && !flag(args, '--raw'))
+            console.log(await renderTeamWatch(dir, { missionId: id, lines: Number(lines) }));
+        else
+            for (const line of await readTeamTranscriptTail(dir, Number(lines)))
+                console.log(line);
+    }
+}
+async function inferTeamZellijSlotCount(dir, plan = {}) {
+    const scheduler = await readJson(path.join(dir, 'agents', 'agent-scheduler-state.json'), null);
+    const lanes = await readJson(path.join(dir, 'agents', 'agent-zellij-lanes.json'), null);
+    const candidates = [
+        plan?.bundle_size,
+        plan?.agent_session_count,
+        lanes?.lane_count,
+        plan?.target_active_slots,
+        scheduler?.target_active_slots
+    ].map((value) => Number(value)).filter((value) => Number.isFinite(value) && value > 0);
+    return Math.max(1, Math.min(100, Math.floor(candidates[0] || 5)));
+}
+function shouldAutoAttachTeamZellij(args = []) {
+    const list = (args || []).map((arg) => String(arg));
+    if (list.includes('--no-attach'))
+        return false;
+    if (list.includes('--json'))
+        return false;
+    if (process.env.SKS_NO_ZELLIJ_ATTACH === '1')
+        return false;
+    if (process.env.ZELLIJ)
+        return false;
+    if (list.includes('--attach'))
+        return true;
+    return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+//# sourceMappingURL=team-legacy-observe-command.js.map

package/dist/core/db-safety.js

@@ -5,6 +5,7 @@ import { evaluateMadSksPermissionGate, isMadSksRouteState } from './permission-g
 import { resolveMadDbMutationPolicy } from './mad-db/mad-db-policy-resolver.js';
 import { recordMadDbOperation } from './mad-db/mad-db-capability.js';
 import { appendMadDbLedgerEvent, appendMadDbOperationLifecycle } from './mad-db/mad-db-ledger.js';
+import { lifecycleHookFromUnknown, recordPendingMadDbLifecycleHook } from './mad-db/mad-db-result-lifecycle.js';
 export const DEFAULT_DB_SAFETY_POLICY = Object.freeze({
     schema_version: 1,
     mode: 'read_only_default',
@@ -520,6 +521,14 @@ export async function checkDbOperation(root, state, payload, { duringNoQuestion
             sqlHash,
             destructive: classification.level === 'destructive'
         });
+        const lifecycleHook = {
+            mission_id: String(state.mission_id),
+            operation_id: operationId,
+            cycle_id: madDbDecision.cycle_id || null,
+            tool_name: classification.toolName || null,
+            sql_hash: sqlHash,
+            destructive: classification.level === 'destructive'
+        };
         const decision = {
             allowed: true,
             action: 'allow',
@@ -534,6 +543,8 @@ export async function checkDbOperation(root, state, payload, { duringNoQuestion
                 capability_file: 'mad-db-capability.json',
                 consumed: false,
                 operation_id: operationId,
+                lifecycle_result_pending: true,
+                ledger_result_hook: lifecycleHook,
                 operation_count: Number(madDbDecision.operation_count || 0) + 1,
                 max_operations: madDbDecision.max_operations || 20
             }
@@ -555,6 +566,7 @@ export async function checkDbOperation(root, state, payload, { duringNoQuestion
         });
         decision.mad_db.consumed = updatedCapability?.consumed === true;
         decision.mad_db.operation_count = updatedCapability?.operation_count ?? decision.mad_db.operation_count;
+        await recordPendingMadDbLifecycleHook(root, state.mission_id, lifecycleHook);
         await appendJsonlBounded(path.join(missionDir(root, state.mission_id), 'db-safety.jsonl'), { ts: nowIso(), decision });
         return decision;
     }
@@ -567,6 +579,9 @@ export async function checkDbOperation(root, state, payload, { duringNoQuestion
     }
     return decision;
 }
+export function madDbLifecycleHookFromDecision(decision) {
+    return lifecycleHookFromUnknown(decision);
+}
 export async function checkSqlFile(file) {
     const sql = await readText(file);
     return classifySql(sql);

package/dist/core/doctor/codex-0138-doctor.js

@@ -0,0 +1,104 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { detectCodex0138Capability } from '../codex-control/codex-0138-capability.js';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+export async function runCodex0138Doctor(root, input = {}) {
+    const capability = await detectCodex0138Capability();
+    const fixed = [];
+    const checks = {
+        bash_fallback: await bashFallbackCheck(),
+        linux_proxy_socket_path: linuxProxySocketCheck(root),
+        oauth_mcp_prerefresh: oauthMcpPrerefreshCheck(capability),
+        agents_logical_path: await agentsLogicalPathCheck(root),
+        plugin_discovery_cache: await pluginDiscoveryCacheCheck(root, input.fix === true, fixed)
+    };
+    const warnings = [
+        ...(capability.ok ? [] : ['codex_0_138_not_detected']),
+        ...Object.values(checks).flatMap((check) => Array.isArray(check.warnings) ? check.warnings : [])
+    ];
+    const blockers = Object.values(checks).flatMap((check) => Array.isArray(check.blockers) ? check.blockers : []);
+    const report = {
+        schema: 'sks.codex-0138-doctor.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        codex_0138_capability: capability,
+        checks,
+        fixed,
+        warnings,
+        blockers
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'codex-0138-doctor.json'), report);
+    return report;
+}
+async function bashFallbackCheck() {
+    const candidates = ['/bin/bash', '/usr/bin/bash'];
+    const existing = [];
+    for (const candidate of candidates) {
+        try {
+            await fs.access(candidate);
+            existing.push(candidate);
+        }
+        catch { }
+    }
+    return {
+        ok: existing.length > 0,
+        candidates,
+        existing,
+        blockers: existing.length ? [] : ['bash_fallback_missing'],
+        warnings: []
+    };
+}
+function linuxProxySocketCheck(root) {
+    if (process.platform !== 'linux')
+        return { ok: true, status: 'not_linux', warnings: [], blockers: [] };
+    const candidate = path.join(os.tmpdir(), 'sks-proxy', path.basename(root), 'proxy.sock');
+    return {
+        ok: candidate.length < 100,
+        candidate,
+        length: candidate.length,
+        warnings: candidate.length < 100 ? [] : ['linux_proxy_socket_path_long'],
+        blockers: []
+    };
+}
+function oauthMcpPrerefreshCheck(capability) {
+    return {
+        ok: true,
+        supported: capability.supports_oauth_mcp_prerefresh === true,
+        warnings: capability.supports_oauth_mcp_prerefresh ? [] : ['oauth_mcp_prerefresh_requires_codex_0_138'],
+        blockers: []
+    };
+}
+async function agentsLogicalPathCheck(root) {
+    const agents = path.join(root, 'AGENTS.md');
+    const realRoot = await fs.realpath(root).catch(() => root);
+    const exists = await fs.stat(agents).then((st) => st.isFile()).catch(() => false);
+    return {
+        ok: exists,
+        logical_path: agents,
+        real_root: realRoot,
+        warnings: exists ? [] : ['agents_md_missing_or_unreadable'],
+        blockers: []
+    };
+}
+async function pluginDiscoveryCacheCheck(root, fix, fixed) {
+    const cacheDir = path.join(root, '.sneakoscope', 'cache', 'codex-plugin-discovery');
+    const exists = await fs.stat(cacheDir).then((st) => st.isDirectory()).catch(() => false);
+    if (!exists && fix) {
+        await fs.mkdir(cacheDir, { recursive: true });
+        await writeJsonAtomic(path.join(cacheDir, 'README.json'), {
+            schema: 'sks.codex-plugin-discovery-cache.v1',
+            repaired_at: nowIso(),
+            purpose: 'Codex 0.138 plugin discovery cache placeholder; safe to refresh from codex plugin list --json.'
+        });
+        fixed.push('plugin_discovery_cache');
+    }
+    const after = exists || fix;
+    return {
+        ok: after,
+        path: cacheDir,
+        warnings: after ? [] : ['plugin_discovery_cache_missing_repair_available'],
+        blockers: []
+    };
+}
+//# sourceMappingURL=codex-0138-doctor.js.map

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

@@ -52,6 +52,14 @@ export function buildDoctorReadinessMatrix(input = {}) {
         blockers.add('codex_app_fast_ui_repair_requires_confirmation');
     if (input.codex_app_ui?.fast_selector === 'repaired')
         warnings.add('codex_app_fast_selector_repaired_restart_app_if_needed');
+    const codex0138Doctor = input.codex_0138_doctor || null;
+    if (codex0138Doctor?.ok === false)
+        for (const blocker of normalizeList(codex0138Doctor.blockers))
+            warnings.add(blocker);
+    for (const warning of normalizeList(codex0138Doctor?.warnings))
+        warnings.add(warning);
+    for (const warning of normalizeList(input.codex_plugin_app_template_policy?.doctor_warnings))
+        warnings.add(warning);
     if (input.codex_lb?.ok === false)
         warnings.add(`codex_lb_${input.codex_lb?.circuit?.state || 'blocked'}`);
     const localModel = input.local_model || {};
@@ -107,6 +115,9 @@ export function buildDoctorReadinessMatrix(input = {}) {
             replacement: 'zellij'
         },
         codex_doctor: codexDoctor || null,
+        codex_0138_doctor: codex0138Doctor,
+        codex_plugin_inventory: input.codex_plugin_inventory || null,
+        codex_plugin_app_template_policy: input.codex_plugin_app_template_policy || null,
         fast_mode_ready: input.fast_mode_ready !== false,
         codex_app_ui: input.codex_app_ui || null,
         hooks_ready: input.hooks_ready !== false,

package/dist/core/effort-orchestrator.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { nowIso, writeJsonAtomic } from './fsx.js';
 import { ARTIFACT_FILES } from './artifact-schemas.js';
+import { codexModelEffortCapability, modelEffortAtLeast } from './codex-control/codex-model-capabilities.js';
 export const EFFORT_POLICY_VERSION = 1;
 export function selectEffort(task = {}) {
     const route = String(task.route || task.command || '').toLowerCase();
@@ -39,11 +40,19 @@ export function selectEffort(task = {}) {
         selected = 'medium';
         reasonCodes.push('default_medium');
     }
+    const modelCapability = codexModelEffortCapability({
+        model: task.model || task.model_id,
+        advertisedEfforts: task.advertised_efforts || task.model_advertised_efforts,
+        defaultEffort: task.model_reasoning_effort || task.default_effort
+    });
+    const modelReasoningEffort = modelEffortAtLeast(selected, modelCapability);
     return {
         schema_version: EFFORT_POLICY_VERSION,
         mission_id: task.mission_id || 'unassigned',
         task_id: task.task_id || 'TASK-001',
         selected_effort: selected,
+        model_reasoning_effort: modelReasoningEffort,
+        model_effort_capability: modelCapability,
         reason_codes: reasonCodes,
         risk_scores: risks,
         demotion_allowed_after: demotionPolicy(selected),

package/dist/core/feature-registry.js

@@ -830,7 +830,7 @@ function commandMaturity(name) {
 function routeMaturity(command) {
     if (['$Answer', '$DFix', '$SKS', '$Fast-Mode', '$Wiki', '$Help'].includes(command))
         return 'stable';
-    if (['$Team', '$Goal', '$DB', '$Computer-Use', '$CU', '$QA-LOOP', '$MAD-SKS'].includes(command))
+    if (['$Team', '$Goal', '$DB', '$Computer-Use', '$CU', '$QA-LOOP', '$MAD-SKS', '$MAD-DB'].includes(command))
         return 'beta';
     return 'labs';
 }
@@ -858,7 +858,7 @@ function knownGapsForCommand(name) {
 function routeVoxelContract(command) {
     if (['$Image-UX-Review', '$UX-Review', '$PPT', '$From-Chat-IMG', '$GX'].includes(command))
         return 'image/source/bbox voxel required';
-    if (command === '$DB' || command === '$MAD-SKS')
+    if (command === '$DB' || command === '$MAD-SKS' || command === '$MAD-DB')
         return 'DB policy voxel required';
     return 'TriWiki anchors required';
 }
@@ -867,6 +867,8 @@ function routeKnownGaps(command) {
         return ['live imagegen/CU evidence required'];
     if (command === '$MAD-SKS')
         return ['permission closed by owning gate'];
+    if (command === '$MAD-DB')
+        return ['one-cycle capability must be explicitly enabled, consumed, or revoked'];
     return [];
 }
 function checkRow(id, ok, blockers = []) {

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 = '2.0.16';
+export const PACKAGE_VERSION = '2.0.18';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/hooks-runtime.js

@@ -3,6 +3,7 @@ import { projectRoot, readJson, readText, writeJsonAtomic, appendJsonl, readStdi
 import { looksInteractiveCommand, interactiveCommandReason } from './no-question-guard.js';
 import { missionDir, setCurrent, stateFile } from './mission.js';
 import { checkDbOperation, dbBlockReason, handleMadSksUserConfirmation } from './db-safety.js';
+import { maybeRecordMadDbToolResultFromToolUse } from './mad-db/mad-db-result-lifecycle.js';
 import { checkHarnessModification, harnessGuardBlockReason, isHarnessSourceProject } from './harness-guard.js';
 import { isMadSksRouteState } from './permission-gates.js';
 import { classifyMadSksShellCommand } from './mad-sks/write-guard.js';
@@ -162,6 +163,8 @@ function toolFailed(payload = {}) {
         if (Number.isFinite(n))
             return n !== 0;
     }
+    if (payload.isError === true || payload.tool_response?.isError === true || payload.toolResponse?.isError === true || payload.result?.isError === true)
+        return true;
     if (payload.success === false || payload.tool_response?.success === false || payload.toolResponse?.success === false || payload.result?.success === false)
         return true;
     if (payload.executed === false)
@@ -422,10 +425,7 @@ function agentWorkerHookContext(state = {}, payload = {}) {
         || payload.agentWorker === true);
 }
 async function hookPostTool(root, state, payload, noQuestion) {
-    const dbDecision = await checkDbOperation(root, state, payload, { duringNoQuestion: noQuestion });
-    if (dbDecision.action === 'block' || dbDecision.action === 'confirm') {
-        return { decision: 'block', reason: dbBlockReason(dbDecision) };
-    }
+    await recordMadDbPostToolLifecycle(root, state, payload).catch(() => null);
     await recordContext7Evidence(root, state, payload).catch(() => null);
     await recordSubagentEvidence(root, state, payload).catch(() => null);
     if (toolFailed(payload))
@@ -449,6 +449,40 @@ async function hookPostTool(root, state, payload, noQuestion) {
         ? { continue: true, additionalContext: teamDigest.context, systemMessage: joinSystemMessages(visibleHookMessage('post-tool'), teamDigest.system) }
         : { continue: true };
 }
+async function recordMadDbPostToolLifecycle(root, state = {}, payload = {}) {
+    if (!state?.mission_id)
+        return null;
+    return maybeRecordMadDbToolResultFromToolUse({
+        root,
+        missionId: String(state.mission_id),
+        toolCallPayload: payload,
+        toolResult: payload
+    });
+}
+function extractRowCount(payload = {}) {
+    const candidates = [
+        payload.row_count,
+        payload.rowCount,
+        payload.tool_response?.row_count,
+        payload.tool_response?.rowCount,
+        payload.toolResponse?.rowCount,
+        payload.result?.row_count,
+        payload.result?.rowCount,
+        payload.result?.rows_affected,
+        payload.tool_response?.rows_affected
+    ];
+    for (const candidate of candidates) {
+        if (candidate === undefined || candidate === null || candidate === '')
+            continue;
+        const parsed = Number(candidate);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return null;
+}
+function extractToolError(payload = {}) {
+    return String(payload.error || payload.message || payload.stderr || payload.tool_response?.stderr || payload.toolResponse?.stderr || payload.result?.stderr || payload.result?.error || 'tool_failed');
+}
 async function recordToolErrorTaxonomy(root, state = {}, payload = {}) {
     if (!state?.mission_id)
         return null;

package/dist/core/image/image-artifact-path-contract.js

@@ -0,0 +1,99 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { imageDimensions } from '../wiki-image/image-hash.js';
+export async function buildImageArtifactPathContract(root, input) {
+    const images = [];
+    const blockers = [];
+    for (const [index, image] of input.images.entries()) {
+        const filePath = path.resolve(root, image.filePath || '');
+        const exists = await fileExists(filePath);
+        if (!exists)
+            blockers.push(`${image.kind}_file_path_missing:${image.id || index + 1}`);
+        const dims = exists ? await imageDimensions(filePath).catch(() => null) : null;
+        images.push({
+            id: image.id || `image-${index + 1}`,
+            kind: image.kind,
+            file_path: filePath,
+            relative_path: path.relative(root, filePath),
+            exists,
+            mime_type: mimeForPath(filePath),
+            width: dims?.width ?? null,
+            height: dims?.height ?? null,
+            model_visible_path: filePath,
+            followup_edit_hint: exists
+                ? `Use this saved local path for follow-up image edits: ${filePath}`
+                : 'Image file path missing; do not run visual QA until a real saved file path exists.'
+        });
+    }
+    if (images.some((image) => image.kind === 'generated_image' && !image.exists))
+        blockers.push('image_generated_file_path_missing');
+    return {
+        schema: 'sks.image-artifact-path-contract.v1',
+        mission_id: input.missionId,
+        generated_at: nowIso(),
+        images,
+        blockers: [...new Set(blockers)]
+    };
+}
+export async function writeImageArtifactPathContract(root, input) {
+    const contract = await buildImageArtifactPathContract(root, input);
+    const artifactPath = input.artifactPath || path.join(root, '.sneakoscope', 'missions', input.missionId, 'image-artifact-path-contract.json');
+    await writeJsonAtomic(artifactPath, contract);
+    return { contract, artifact_path: artifactPath };
+}
+export async function discoverImageArtifactsInDir(dir) {
+    const out = [];
+    await walk(dir, async (file) => {
+        if (!/\.(png|jpe?g|webp|gif)$/i.test(file))
+            return;
+        out.push({
+            id: path.basename(file).replace(/[^0-9A-Za-z._-]/g, '_'),
+            kind: /generated|gpt-image|callout/i.test(file) ? 'generated_image' : 'visual_qa_snapshot',
+            filePath: file
+        });
+    });
+    return out;
+}
+function mimeForPath(file) {
+    const ext = path.extname(file).toLowerCase();
+    if (ext === '.png')
+        return 'image/png';
+    if (ext === '.jpg' || ext === '.jpeg')
+        return 'image/jpeg';
+    if (ext === '.webp')
+        return 'image/webp';
+    if (ext === '.gif')
+        return 'image/gif';
+    return null;
+}
+async function fileExists(file) {
+    try {
+        const st = await fs.stat(file);
+        return st.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function walk(dir, visit) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (['node_modules', '.git', 'dist'].includes(entry.name))
+                continue;
+            await walk(full, visit);
+        }
+        else {
+            await visit(full);
+        }
+    }
+}
+//# sourceMappingURL=image-artifact-path-contract.js.map