sneakoscope 2.0.16 → 2.0.18

package/dist/core/image-ux-review/imagegen-adapter.js

@@ -7,6 +7,7 @@ import { detectImagegenCapability } from '../imagegen/imagegen-capability.js';
 import { validateGptImage2Request } from '../imagegen/gpt-image-2-request-validator.js';
 import { withResponsesRetry } from '../responses-retry-policy.js';
 import { discoverCodexAppGeneratedImage } from './codex-app-generated-image-discovery.js';
+import { writeImageArtifactPathContract } from '../image/image-artifact-path-contract.js';
 const DEFAULT_OPENAI_IMAGE_EDITS_ENDPOINT = 'https://api.openai.com/v1/images/edits';
 export function buildCalloutPrompt(sourceScreenId, context = {}) {
     return [
@@ -124,6 +125,7 @@ export function createCodexAppImagegenAdapter(opts = {}) {
                     real_generated: true
                 });
                 const outputSource = manualOutput ? 'manual_attach' : 'auto_discovered_generated_images';
+                const imageContract = await writeGeneratedImagePathContract(input, dest, 'codex_app_imagegen').catch(() => null);
                 await writeJsonAtomic(responseArtifact, {
                     schema: 'sks.image-ux-gpt-image-2-response.v1',
                     created_at: nowIso(),
@@ -135,6 +137,7 @@ export function createCodexAppImagegenAdapter(opts = {}) {
                     output_image_sha256: meta.sha256,
                     output_id: meta.output_id,
                     output_source: outputSource,
+                    image_artifact_path_contract: imageContract?.artifact_path || null,
                     discovered_from: discovery?.selected?.path || null,
                     discovery: discovery ? { candidates_considered: discovery.candidates_considered, since_ms: discovery.since_ms, max_age_ms: discovery.max_age_ms } : null,
                     local_only: true
@@ -149,6 +152,7 @@ export function createCodexAppImagegenAdapter(opts = {}) {
                     output_source: outputSource,
                     request_artifact: requestArtifact,
                     response_artifact: responseArtifact,
+                    image_artifact_path_contract: imageContract?.artifact_path || null,
                     latency_ms: null
                 };
             }
@@ -241,6 +245,7 @@ export function createFakeImagegenAdapter(opts = {}) {
                 real_generated: false,
                 mock: true
             });
+            const imageContract = await writeGeneratedImagePathContract(input, out, 'fake_imagegen_adapter').catch(() => null);
             await writeJsonAtomic(responseArtifact, {
                 schema: 'sks.image-ux-gpt-image-2-response.v1',
                 created_at: nowIso(),
@@ -251,6 +256,7 @@ export function createFakeImagegenAdapter(opts = {}) {
                 output_image_path: out,
                 output_image_sha256: meta.sha256,
                 output_id: meta.output_id,
+                image_artifact_path_contract: imageContract?.artifact_path || null,
                 dimensions: { width: meta.width, height: meta.height, format: meta.format },
                 latency_ms: Date.now() - started,
                 fake_adapter: true,
@@ -259,7 +265,7 @@ export function createFakeImagegenAdapter(opts = {}) {
                 mock: true,
                 local_only: true
             });
-            return { ok: true, status: 'generated', generated_image_path: out, output_id: meta.output_id, blocker: null, provider: 'fake_imagegen_adapter', request_artifact: requestArtifact, response_artifact: responseArtifact, latency_ms: Date.now() - started };
+            return { ok: true, status: 'generated', generated_image_path: out, output_id: meta.output_id, blocker: null, provider: 'fake_imagegen_adapter', request_artifact: requestArtifact, response_artifact: responseArtifact, image_artifact_path_contract: imageContract?.artifact_path || null, latency_ms: Date.now() - started };
         }
     };
 }
@@ -385,6 +391,7 @@ export function createOpenAIImagesApiAdapter(opts = {}) {
                         output_id: generated.id || payload?.id || null,
                         real_generated: true
                     });
+                    const imageContract = await writeGeneratedImagePathContract(input, out, 'openai_responses_image_generation').catch(() => null);
                     await writeJsonAtomic(responseArtifact, {
                         schema: 'sks.image-ux-gpt-image-2-response.v1',
                         created_at: nowIso(),
@@ -397,12 +404,13 @@ export function createOpenAIImagesApiAdapter(opts = {}) {
                         output_image_path: out,
                         output_image_sha256: meta.sha256,
                         output_id: meta.output_id,
+                        image_artifact_path_contract: imageContract?.artifact_path || null,
                         dimensions: { width: meta.width, height: meta.height, format: meta.format },
                         latency_ms: Date.now() - started,
                         token_cost_metadata: payload?.usage || null,
                         local_only: true
                     });
-                    return { ok: true, status: 'generated', generated_image_path: out, output_id: meta.output_id, blocker: null, provider: 'openai_responses_image_generation', request_artifact: requestArtifact, response_artifact: responseArtifact, latency_ms: Date.now() - started };
+                    return { ok: true, status: 'generated', generated_image_path: out, output_id: meta.output_id, blocker: null, provider: 'openai_responses_image_generation', request_artifact: requestArtifact, response_artifact: responseArtifact, image_artifact_path_contract: imageContract?.artifact_path || null, latency_ms: Date.now() - started };
                 }
                 const sourceBytes = await fsp.readFile(sourcePath);
                 const qualityParam = imagegenQualityParam(opts);
@@ -440,6 +448,7 @@ export function createOpenAIImagesApiAdapter(opts = {}) {
                     output_id: image?.id || payload?.id || null,
                     real_generated: true
                 });
+                const imageContract = await writeGeneratedImagePathContract(input, out, 'openai_images_api').catch(() => null);
                 await writeJsonAtomic(responseArtifact, {
                     schema: 'sks.image-ux-gpt-image-2-response.v1',
                     created_at: nowIso(),
@@ -451,12 +460,13 @@ export function createOpenAIImagesApiAdapter(opts = {}) {
                     output_image_path: out,
                     output_image_sha256: meta.sha256,
                     output_id: meta.output_id,
+                    image_artifact_path_contract: imageContract?.artifact_path || null,
                     dimensions: { width: meta.width, height: meta.height, format: meta.format },
                     latency_ms: Date.now() - started,
                     token_cost_metadata: payload?.usage || null,
                     local_only: true
                 });
-                return { ok: true, status: 'generated', generated_image_path: out, output_id: meta.output_id, blocker: null, provider: 'openai_images_api', request_artifact: requestArtifact, response_artifact: responseArtifact, latency_ms: Date.now() - started };
+                return { ok: true, status: 'generated', generated_image_path: out, output_id: meta.output_id, blocker: null, provider: 'openai_images_api', request_artifact: requestArtifact, response_artifact: responseArtifact, image_artifact_path_contract: imageContract?.artifact_path || null, latency_ms: Date.now() - started };
             }
             catch (err) {
                 const provider = useResponsesImageTool ? 'openai_responses_image_generation' : 'openai_images_api';
@@ -468,6 +478,17 @@ export function createOpenAIImagesApiAdapter(opts = {}) {
         }
     };
 }
+async function writeGeneratedImagePathContract(input, outputPath, provider) {
+    return writeImageArtifactPathContract(process.cwd(), {
+        missionId: input.mission_id || 'unassigned',
+        images: [{
+                id: `${provider}-${input.source_screen_id || 'screen'}`,
+                kind: 'generated_image',
+                filePath: outputPath
+            }],
+        artifactPath: path.join(input.output_dir, 'image-artifact-path-contract.json')
+    });
+}
 export async function generateGptImage2CalloutReview(input, opts = {}) {
     if (opts.fake === true || process.env.SKS_TEST_FAKE_IMAGEGEN === '1') {
         return createFakeImagegenAdapter(opts.fakeAdapter || {}).generateCalloutReview(input);

package/dist/core/init.js

@@ -1043,6 +1043,7 @@ export async function installSkills(root) {
         'research': `---\nname: research\ndescription: Dollar-command route for $Research or $research frontier discovery workflows.\n---\n\nUse when the user invokes $Research/$research or asks for research, hypotheses, new mechanisms, falsification, or testable predictions. Prefer sks research prepare and sks research run. Research is not an implementation route: do not edit repository source, docs, package metadata, generated skills, or harness files; write only route-local mission artifacts under .sneakoscope/missions/<mission-id>/. Run the genius-lens agent council with named persona-inspired cognitive roles: Einstein Agent, Feynman Agent, Turing Agent, von Neumann Agent, and Skeptic Agent. These are lenses only; do not impersonate the historical people. Every Research agent ledger row must include display_name, persona, persona_boundary, effort=xhigh, reasoning_effort=xhigh, service_tier when available, one literal "Eureka!" idea, falsifiers, cheap_probes, and challenge_or_response before synthesis. This is not a fixed three-cycle route: repeat source gathering, Eureka ideas, evidence-bound debate, falsification, and synthesis pressure until every agent records final agreement, or until the explicit max-cycle safety cap pauses with an unpassed gate. Create research-source-skill.md as a route-local Skill Creator artifact, then maximize layered public web/source search across latest papers, official/government or leading-institution data, standards/primary docs, current news, public discourse, developer/practitioner sources, traditional background sources, and counterevidence before synthesis. Record research-source-skill.md, source-ledger.json, agent-ledger.json, debate-ledger.json, novelty-ledger.json, falsification-ledger.json, research-report.md, research-paper.md, genius-opinion-summary.md, and research-gate.json. debate-ledger.json must include consensus_iterations, unanimous_consensus, and per-agent agreements; research-gate.json cannot pass until unanimous_consensus=true with every agent agreement recorded. Context7 is optional and only needed when the research topic depends on external package/API/framework docs; do not use it as the default research evidence layer. Normal Research may take one or two hours when needed; favor real source collection, cross-layer comparison, falsification, and a concise paper manuscript over speed. Do not use --mock except for selftests or dry harness checks; if live source execution is unavailable, record a blocker and keep the gate unpassed. Do not use for ordinary code edits.\n`,
         'autoresearch': `---\nname: autoresearch\ndescription: Dollar-command route for $AutoResearch or $autoresearch iterative experiment loops.\n---\n\nUse for $AutoResearch, iterative improvement, SEO/GEO, ranking, workflow, benchmark, or experiments. Define program, hypothesis, experiment, metric, keep/discard, falsification, next step, and Honest Mode. Load seo-geo-optimizer for README/npm/GitHub/schema/AI-search work.\n`,
         'db': `---\nname: db\ndescription: Dollar-command route for $DB or $db database and Supabase safety checks.\n---\n\nUse when the user invokes $DB/$db or the task touches SQL, Supabase, Postgres, migrations, Prisma, Drizzle, Knex, MCP database tools, or production data. Run or follow sks db policy, sks db scan, sks db classify, and sks db check. Destructive database operations remain forbidden.\n`,
+        'mad-db': `---\nname: mad-db\ndescription: One-cycle Mad-DB break-glass route alias for $MAD-DB and $mad-db database safety work.\n---\n\nUse only when the user explicitly invokes $MAD-DB/$mad-db or asks for Mad-DB visibility. Treat it as a DB safety route with one-cycle break-glass controls, not as a general permanent DB unlock. Prefer \`sks mad-db status --json\` for inspection, \`sks mad-db enable --ack "I AUTHORIZE ONE-CYCLE DB BREAK-GLASS" [--mission latest|new|M-...] --json\` only after explicit user authorization, and \`sks mad-db revoke --mission <id|latest> --json\` to close the cycle. Keep catastrophic safeguards active: whole database/schema/table removal, truncate, all-row delete/update, reset, dangerous project/branch management, credential exfiltration, persistent security weakening, and unrequested fallback implementation remain blocked. Pair with db-safety-guard, Context7 evidence when external DB/API docs are involved, route-local reflection, and Honest Mode.\n`,
         'mad-sks': `---\nname: mad-sks\ndescription: Explicit high-risk authorization modifier for $MAD-SKS scoped permission widening across approved target-project surfaces.\n---\n\nUse only when the user explicitly invokes $MAD-SKS or top-level sks --mad. It can be combined with another route, such as $MAD-SKS $Team or $DB ... $MAD-SKS; in that case the other command remains the primary workflow and MAD-SKS is only the temporary permission grant. The widened permission applies only while the active mission gate is open, must be deactivated when the task ends, and can open approved scopes such as target-project file writes, shell commands, package installs, local service control, network operations, browser/Computer Use workflows, generated assets, file permissions, migrations, Supabase MCP database writes, column/schema cleanup, direct execute SQL, and normal targeted DB writes. Keep catastrophic safeguards active: whole database/schema/table removal, truncate, all-row delete/update, reset, dangerous project/branch management, credential exfiltration, persistent security weakening, destructive delete without explicit confirmation, and unrequested fallback implementation remain blocked. Do not carry MAD-SKS permission into later prompts or routes. The permission profile source is centralized in src/core/permission-gates.ts and emitted as dist/core/permission-gates.js so skill/hook/MCP-style gates share one decision function.\n`,
         'gx': `---\nname: gx\ndescription: Dollar-command route for $GX or $gx deterministic GX visual context cartridges.\n---\n\nUse when the user invokes $GX/$gx or asks for architecture/context visualization through SKS. Prefer sks gx init, render, validate, drift, and snapshot. vgraph.json remains the source of truth.\n`,
         'help': `---\nname: help\ndescription: Dollar-command route for $Help or $help explaining installed SKS commands and workflows.\n---\n\nUse when the user invokes $Help/$help or asks what commands exist. Prefer concise output from sks commands, sks usage <topic>, sks quickstart, sks aliases, and sks codex-app.\n`,

package/dist/core/mad-db/mad-db-capability.js

@@ -89,7 +89,7 @@ export async function recordMadDbOperation(root, missionId, input = {}) {
 }
 export async function consumeMadDbCapability(root, missionId, input = {}) {
     const capability = await readMadDbCapability(root, missionId);
-    if (!isMadDbCapabilityActive(capability))
+    if (!capability || capability.consumed === true)
         return capability;
     const consumed = {
         ...capability,
@@ -103,6 +103,14 @@ export async function consumeMadDbCapability(root, missionId, input = {}) {
     await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), { ts: nowIso(), type: 'capability.consumed', mission_id: missionId, cycle_id: consumed.cycle_id, consumed_by: consumed.consumed_by });
     return consumed;
 }
+export async function closeMadDbCycle(root, missionId, cycleId) {
+    const capability = await readMadDbCapability(root, missionId);
+    if (!capability || capability.cycle_id !== cycleId)
+        return capability;
+    if (capability.consumed === true)
+        return capability;
+    return consumeMadDbCapability(root, missionId, { consumedBy: 'mad-db-cycle-close', reason: 'mad_db_cycle_closed' });
+}
 export async function revokeMadDbCapability(root, missionId, reason = 'operator_revoked') {
     const capability = await readMadDbCapability(root, missionId);
     if (!capability)

package/dist/core/mad-db/mad-db-result-lifecycle.js

@@ -0,0 +1,207 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { appendJsonlBounded, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
+import { missionDir } from '../mission.js';
+import { appendMadDbOperationLifecycle } from './mad-db-ledger.js';
+const PENDING_FILE = 'mad-db-lifecycle-pending.jsonl';
+const PENDING_LATEST_FILE = 'mad-db-lifecycle-pending.latest.json';
+export async function recordPendingMadDbLifecycleHook(root, missionId, hook) {
+    const dir = missionDir(root, missionId);
+    const row = {
+        schema: 'sks.mad-db-lifecycle-pending.v1',
+        ts: nowIso(),
+        mission_id: missionId,
+        hook
+    };
+    await appendJsonlBounded(path.join(dir, PENDING_FILE), row);
+    await writeJsonAtomic(path.join(dir, PENDING_LATEST_FILE), row).catch(() => undefined);
+    return row;
+}
+export async function readLatestPendingMadDbLifecycleHook(root, missionId, payload = {}) {
+    const dir = missionDir(root, missionId);
+    const embedded = lifecycleHookFromUnknown(payload);
+    if (embedded)
+        return embedded;
+    const latest = await readJson(path.join(dir, PENDING_LATEST_FILE), null).catch(() => null);
+    const latestHook = lifecycleHookFromUnknown(latest?.hook);
+    if (latestHook && hookMatchesPayload(latestHook, payload))
+        return latestHook;
+    const text = await readText(path.join(dir, PENDING_FILE), '').catch(() => '');
+    const rows = String(text).split(/\r?\n/).map((line) => line.trim()).filter(Boolean).reverse();
+    for (const line of rows.slice(0, 50)) {
+        try {
+            const row = JSON.parse(line);
+            const hook = lifecycleHookFromUnknown(row?.hook);
+            if (hook && hookMatchesPayload(hook, payload))
+                return hook;
+        }
+        catch {
+            // Ignore malformed pending rows.
+        }
+    }
+    return null;
+}
+export async function recordMadDbToolResult(input) {
+    const terminalType = input.ok ? 'db_operation.succeeded' : 'db_operation.failed';
+    if (await hasTerminalLifecycleEvent(input.root, input.missionId, input.hook.operation_id)) {
+        return {
+            schema: 'sks.mad-db-tool-result-lifecycle.v1',
+            ok: true,
+            skipped: true,
+            reason: 'mad_db_operation_terminal_event_already_recorded',
+            operation_id: input.hook.operation_id
+        };
+    }
+    const event = await appendMadDbOperationLifecycle(input.root, input.missionId, {
+        type: terminalType,
+        operationId: input.hook.operation_id,
+        cycleId: input.hook.cycle_id || null,
+        mcpServer: input.hook.mcp_server || null,
+        toolName: input.hook.tool_name || null,
+        sqlHash: input.hook.sql_hash || null,
+        destructive: input.hook.destructive === true,
+        resultStatus: input.ok ? 'succeeded' : 'failed',
+        rowCount: input.rowCount ?? null,
+        error: input.error || null
+    });
+    await markPendingHookResolved(input.root, input.missionId, input.hook, input.ok);
+    return {
+        schema: 'sks.mad-db-tool-result-lifecycle.v1',
+        ok: true,
+        skipped: false,
+        operation_id: input.hook.operation_id,
+        result_status: input.ok ? 'succeeded' : 'failed',
+        event
+    };
+}
+export async function maybeRecordMadDbToolResultFromToolUse(input) {
+    const payload = input.toolResult ?? input.toolCallPayload ?? {};
+    const hook = lifecycleHookFromUnknown(input.decision)
+        || lifecycleHookFromUnknown(input.toolCallPayload)
+        || lifecycleHookFromUnknown(input.toolResult)
+        || await readLatestPendingMadDbLifecycleHook(input.root, input.missionId, input.toolCallPayload || payload);
+    if (!hook)
+        return null;
+    const ok = !madDbToolUseFailed(payload);
+    return recordMadDbToolResult({
+        root: input.root,
+        missionId: input.missionId,
+        hook,
+        ok,
+        rowCount: extractRowCount(payload),
+        error: ok ? null : extractToolError(payload)
+    });
+}
+export function lifecycleHookFromUnknown(value) {
+    const candidate = value?.ledger_result_hook || value?.mad_db?.ledger_result_hook || value;
+    const missionId = stringOrNull(candidate?.mission_id || candidate?.missionId);
+    const operationId = stringOrNull(candidate?.operation_id || candidate?.operationId);
+    if (!missionId || !operationId)
+        return null;
+    return {
+        mission_id: missionId,
+        operation_id: operationId,
+        cycle_id: stringOrNull(candidate?.cycle_id || candidate?.cycleId),
+        tool_name: stringOrNull(candidate?.tool_name || candidate?.toolName),
+        sql_hash: stringOrNull(candidate?.sql_hash || candidate?.sqlHash),
+        mcp_server: stringOrNull(candidate?.mcp_server || candidate?.mcpServer),
+        destructive: candidate?.destructive === true
+    };
+}
+function hookMatchesPayload(hook, payload) {
+    if (!hook.tool_name)
+        return true;
+    const toolText = [
+        payload.tool_name,
+        payload.toolName,
+        payload.name,
+        payload.tool?.name,
+        payload.server,
+        payload.mcp_tool,
+        payload.tool,
+        payload.type
+    ].filter(Boolean).join(' ').toLowerCase();
+    if (!toolText)
+        return true;
+    return toolText.includes(String(hook.tool_name).toLowerCase()) || String(hook.tool_name).toLowerCase().includes(toolText);
+}
+function madDbToolUseFailed(payload = {}) {
+    if (payload?.isError === true || payload?.tool_response?.isError === true || payload?.toolResponse?.isError === true || payload?.result?.isError === true)
+        return true;
+    const candidates = [
+        payload.exit_code,
+        payload.exitCode,
+        payload.tool_response?.exit_code,
+        payload.toolResponse?.exitCode,
+        payload.result?.exit_code,
+        payload.result?.exitCode
+    ];
+    for (const candidate of candidates) {
+        if (candidate === undefined || candidate === null || candidate === '')
+            continue;
+        const n = Number(candidate);
+        if (Number.isFinite(n))
+            return n !== 0;
+    }
+    if (payload.success === false || payload.tool_response?.success === false || payload.toolResponse?.success === false || payload.result?.success === false)
+        return true;
+    if (payload.executed === false)
+        return true;
+    return false;
+}
+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 = {}) {
+    if (payload?.result?.isError === true && Array.isArray(payload.result.content)) {
+        const text = payload.result.content.map((entry) => entry?.text || entry?.message || '').filter(Boolean).join('\n');
+        if (text.trim())
+            return text.trim();
+    }
+    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 hasTerminalLifecycleEvent(root, missionId, operationId) {
+    const ledger = path.join(missionDir(root, missionId), 'mad-db-ledger.jsonl');
+    const text = await readText(ledger, '').catch(() => '');
+    return String(text).split(/\r?\n/).some((line) => {
+        if (!line.includes(operationId))
+            return false;
+        return line.includes('db_operation.succeeded') || line.includes('db_operation.failed');
+    });
+}
+async function markPendingHookResolved(root, missionId, hook, ok) {
+    const dir = missionDir(root, missionId);
+    const row = {
+        schema: 'sks.mad-db-lifecycle-pending-resolution.v1',
+        ts: nowIso(),
+        mission_id: missionId,
+        operation_id: hook.operation_id,
+        cycle_id: hook.cycle_id || null,
+        result_status: ok ? 'succeeded' : 'failed'
+    };
+    await appendJsonlBounded(path.join(dir, 'mad-db-lifecycle-resolved.jsonl'), row).catch(() => undefined);
+    await fs.rm(path.join(dir, PENDING_LATEST_FILE), { force: true }).catch(() => undefined);
+}
+function stringOrNull(value) {
+    const text = String(value || '').trim();
+    return text ? text : null;
+}
+//# sourceMappingURL=mad-db-result-lifecycle.js.map

package/dist/core/mcp/mcp-plugin-inventory.js

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import { buildCodexPluginInventory } from '../codex-plugins/codex-plugin-json.js';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { policyForPluginMcpServer } from './mcp-server-policy.js';
+export function buildMcpPluginServerCandidates(inventory) {
+    const candidates = inventory.plugins.flatMap((plugin) => plugin.remote_mcp_servers.map((server) => policyForPluginMcpServer({
+        pluginId: plugin.id,
+        name: server.name,
+        url: server.url,
+        authType: server.auth_type
+    })));
+    return {
+        schema: 'sks.mcp-plugin-server-candidates.v1',
+        generated_at: nowIso(),
+        candidates,
+        candidate_only: true,
+        blockers: []
+    };
+}
+export async function writeMcpPluginInventoryArtifacts(root, input = {}) {
+    const inventory = input.inventory || await buildCodexPluginInventory();
+    const candidates = buildMcpPluginServerCandidates(inventory);
+    const pluginArtifact = path.join(root, '.sneakoscope', 'codex-plugin-inventory.json');
+    const candidateArtifact = path.join(root, '.sneakoscope', 'mcp-plugin-server-candidates.json');
+    await writeJsonAtomic(pluginArtifact, inventory);
+    await writeJsonAtomic(candidateArtifact, candidates);
+    return { inventory, candidates, plugin_artifact: pluginArtifact, candidate_artifact: candidateArtifact };
+}
+//# sourceMappingURL=mcp-plugin-inventory.js.map

package/dist/core/mcp/mcp-server-policy.js

@@ -0,0 +1,24 @@
+export function policyForPluginMcpServer(input) {
+    const haystack = `${input.name} ${input.url || ''}`.toLowerCase();
+    const dbRelated = /supabase|postgres|database|sql|db\b/.test(haystack);
+    const oauth = /oauth/i.test(String(input.authType || ''));
+    return {
+        name: input.name,
+        plugin_id: input.pluginId,
+        url: input.url || null,
+        auth_type: input.authType || null,
+        candidate_only: true,
+        auto_enable: false,
+        destructive_tools_auto_enabled: false,
+        db_safety_required: dbRelated,
+        mad_db_required_for_destructive: dbRelated,
+        oauth_prerefresh_recommended: oauth,
+        policy_notes: [
+            'Remote MCP servers from plugin detail are candidate only.',
+            'Do not auto-enable destructive MCP tools.',
+            dbRelated ? 'DB MCP servers require DB safety and Mad-DB for destructive operations.' : 'Non-DB MCP candidate still requires explicit operator enablement.',
+            oauth ? 'OAuth-backed MCP should trigger pre-refresh doctor check.' : ''
+        ].filter(Boolean)
+    };
+}
+//# sourceMappingURL=mcp-server-policy.js.map

package/dist/core/qa-loop/qa-loop-budget-policy.js

@@ -0,0 +1,37 @@
+import { defaultModelCallBudget } from '../codex-control/model-call-concurrency.js';
+import { codexModelEffortCapability, nextAdvertisedEffort } from '../codex-control/codex-model-capabilities.js';
+export function buildQaLoopBudgetPolicy(input = {}) {
+    const usage = input.usage || null;
+    const available = Boolean(usage?.token_usage);
+    const limit = Number(usage?.usage_limit_tokens || 0);
+    const total = Number(usage?.token_usage?.total_tokens || 0);
+    const nearLimit = Boolean(limit > 0 && total / limit >= 0.9);
+    const baseBudget = defaultModelCallBudget(String(input.provider || 'codex-sdk'));
+    return {
+        schema: 'sks.qa-loop-budget-policy.v1',
+        ok: true,
+        account_usage_source: usage?.source || 'unavailable',
+        token_usage_available: available,
+        near_limit: nearLimit,
+        remote_model_call_concurrency: nearLimit ? Math.max(1, Math.min(2, baseBudget)) : baseBudget,
+        local_llm_draft_preferred: nearLimit,
+        final_reviewer_gpt_backed: true,
+        warnings: available ? [] : ['codex_account_usage_unavailable_no_hard_block']
+    };
+}
+export function selectQaLoopEscalatedEffort(input = {}) {
+    const capability = input.capability || codexModelEffortCapability();
+    const current = input.currentEffort || capability.default_effort;
+    const failureCount = Number(input.failureCount || 0);
+    return {
+        schema: 'sks.qa-loop-effort-escalation.v1',
+        model: capability.model,
+        advertised_efforts: capability.advertised_efforts,
+        order_source: capability.order_source,
+        failure_count: failureCount,
+        current_effort: current,
+        next_effort: failureCount >= 2 ? nextAdvertisedEffort(current, capability) : current,
+        escalated: failureCount >= 2 && nextAdvertisedEffort(current, capability) !== current
+    };
+}
+//# sourceMappingURL=qa-loop-budget-policy.js.map

package/dist/core/qa-loop.js

@@ -309,6 +309,14 @@ export function defaultQaGate(contract = {}, opts = {}) {
         ui_chrome_extension_evidence: !uiRequired,
         ui_computer_use_evidence: false,
         ui_evidence_source: uiRequired ? null : 'not_required',
+        desktop_app_handoff_required: false,
+        desktop_app_handoff_status: 'not_requested',
+        desktop_app_handoff_artifact: null,
+        desktop_app_handoff_supported: false,
+        desktop_app_handoff_is_web_ui_evidence: false,
+        image_artifact_path_contract_present: false,
+        image_artifact_path_contract_artifact: null,
+        image_artifact_path_contract_blockers: [],
         api_e2e_required: apiRequired,
         unsafe_external_side_effects: false,
         corrective_loop_enabled: corrective,
@@ -374,6 +382,15 @@ export async function evaluateQaGate(dir) {
         if (evidenceMentionsForbiddenWebComputerUseEvidence({ evidence: gate.evidence, ui_evidence_source: gate.ui_evidence_source }))
             reasons.push('computer_use_web_evidence_forbidden');
     }
+    if (gate.desktop_app_handoff_required === true) {
+        if (gate.desktop_app_handoff_status !== 'pending' && gate.desktop_app_handoff_status !== 'completed')
+            reasons.push('desktop_app_handoff_missing');
+        if (gate.desktop_app_handoff_is_web_ui_evidence === true)
+            reasons.push('desktop_app_handoff_misused_as_web_evidence');
+    }
+    const imageBlockers = Array.isArray(gate.image_artifact_path_contract_blockers) ? gate.image_artifact_path_contract_blockers : [];
+    if (imageBlockers.includes('image_generated_file_path_missing'))
+        reasons.push('image_generated_file_path_missing');
     if (!reportFile)
         reasons.push('qa_report_file_missing');
     else if (!isQaReportFilename(reportFile))
@@ -396,8 +413,14 @@ export async function writeMockQaResult(dir, mission, contract) {
     await writeJsonAtomic(path.join(dir, 'qa-gate.json'), { ...defaultQaGate(contract, { reportFile }), passed: !uiRequired, qa_report_written: true, qa_ledger_complete: true, checklist_completed: true, safety_reviewed: true, credentials_not_persisted: true, chrome_extension_preflight_passed: !uiRequired, ui_chrome_extension_evidence: !uiRequired, ui_computer_use_evidence: false, ui_evidence_source: uiRequired ? null : 'not_required', unresolved_findings: 0, unresolved_fixable_findings: 0, unsafe_or_deferred_findings: 0, post_fix_verification_complete: true, honest_mode_complete: true, evidence: ['mock QA-LOOP smoke completed'], notes: ['No live UI/API verification was claimed.'] });
     return evaluateQaGate(dir);
 }
-export function buildQaLoopPrompt({ id, mission, contract, cycle, previous, reportFile }) {
+export function buildQaLoopPrompt({ id, mission, contract, cycle, previous, reportFile, imagePathContract, appHandoff }) {
     const report = reportFile && isQaReportFilename(reportFile) ? reportFile : 'the date/version-prefixed report named by qa-gate.json.qa_report_file';
+    const imageContractText = imagePathContract
+        ? `\nIMAGE PATH CONTRACT:\n${JSON.stringify(imagePathContract, null, 2)}\nUse model_visible_path values for follow-up image edits; do not invent generated image paths.\n`
+        : '';
+    const appHandoffText = appHandoff
+        ? `\nCODEX DESKTOP /app HANDOFF:\n${JSON.stringify(appHandoff, null, 2)}\nThis is desktop-app review status only and is not web UI evidence.\n`
+        : '';
     return `SKS QA-LOOP
 MISSION: ${id}
 TASK: ${mission.prompt}
@@ -410,6 +433,7 @@ GATE: passed=false while unresolved_findings or unresolved_fixable_findings > 0,
 ARTIFACTS: update qa-ledger.json, ${report}, qa-gate.json, and qa-loop/cycle-${cycle}/.
 CONTRACT:
 ${JSON.stringify(contract, null, 2)}
+${imageContractText}${appHandoffText}
 Previous tail:
 ${String(previous || '').slice(-2500)}
 `;
@@ -417,9 +441,11 @@ ${String(previous || '').slice(-2500)}
 export async function qaStatus(dir) {
     const gate = await readJson(path.join(dir, 'qa-gate.evaluated.json'), await readJson(path.join(dir, 'qa-gate.json'), null));
     const ledger = await readJson(path.join(dir, 'qa-ledger.json'), null);
+    const appHandoff = await readJson(path.join(dir, 'qa-loop', 'app-handoff.json'), null);
+    const imagePathContract = await readJson(path.join(dir, 'qa-loop', 'image-artifact-path-contract.json'), null);
     const reportFile = qaReportFileFromGate(gate?.gate || gate || {}) || ledger?.qa_report_file || null;
     const report = reportFile && isQaReportFilename(reportFile) ? await readText(path.join(dir, reportFile), '') : '';
-    return { gate, checklist_count: ledger?.checklist?.length ?? null, report_file: reportFile, report_written: Boolean(report.trim()) };
+    return { gate, checklist_count: ledger?.checklist?.length ?? null, report_file: reportFile, report_written: Boolean(report.trim()), desktop_app_handoff: appHandoff, image_path_contract: imagePathContract };
 }
 function qaChecklist(a) {
     const cases = [

package/dist/core/release/release-gate-affected-selector.js

@@ -10,7 +10,7 @@ export function selectAffectedReleaseGates(root, manifest, gates, input = {}) {
     if (input.full) {
         return selectionResult(gates, gates, [], 'full', {}, []);
     }
-    const changedFiles = resolveChangedFiles(root, input.changedSince || 'auto');
+    const changedFiles = input.changedFiles ? [...new Set(input.changedFiles)].sort() : resolveChangedFiles(root, input.changedSince || 'auto');
     const selected = [];
     const reasons = {};
     for (const gate of gates) {
@@ -28,7 +28,9 @@ export function selectAffectedReleaseGates(root, manifest, gates, input = {}) {
             reasons[gate.id] = 'always_keep_core_release_safety';
         }
     }
-    const expanded = expandWithDependencies(selected, manifest);
+    const expanded = input.preset === 'affected' || input.preset === 'fast'
+        ? selected
+        : expandWithDependencies(selected, manifest);
     const ordered = manifest.gates.filter((gate) => expanded.some((row) => row.id === gate.id));
     return selectionResult(gates, ordered, changedFiles, 'affected', reasons, gates.filter((gate) => !ordered.some((row) => row.id === gate.id)).map((gate) => gate.id));
 }
@@ -53,19 +55,32 @@ function gateSelectionReason(gate, changedFiles, preset) {
         return 'always_keep_core_release_safety';
     if (!changedFiles.length)
         return preset === 'fast' ? 'fast_no_diff_core_only_skip' : 'no_changed_files';
+    const releaseGate = /^(release:|publish:|prepublish)/.test(gate.id);
     if (changedFiles.some((file) => file === 'package.json' || file === 'package-lock.json')) {
         if (/^(release:|publish:|prepublish|runtime:|typecheck|schema:check)/.test(gate.id))
             return 'package_metadata_changed';
     }
-    if (changedFiles.some((file) => file === 'release-gates.v2.json' || file.startsWith('src/core/release/') || file.startsWith('src/scripts/release-')))
-        return 'release_gate_system_changed';
+    if (changedFiles.some((file) => file === 'release-gates.v2.json' || file.startsWith('src/core/release/'))) {
+        if (releaseGate)
+            return 'release_gate_system_changed';
+    }
+    const matchingReleaseScript = changedFiles.some((file) => releaseScriptGateCandidates(file).includes(gate.id));
+    if (matchingReleaseScript)
+        return 'release_script_changed';
+    if (changedFiles.some((file) => file.startsWith('src/scripts/prepublish-') || file.startsWith('src/scripts/publish-'))) {
+        if (releaseGate && gate.id === 'release:version-truth')
+            return 'publish_or_prepublish_script_changed';
+    }
+    if (changedFiles.some((file) => file.startsWith('src/scripts/scheduler-') || file.startsWith('src/core/scheduler/'))) {
+        return gate.id.startsWith('scheduler:') ? 'scheduler_source_changed' : null;
+    }
     if (changedFiles.some((file) => file.startsWith('src/core/research/')))
         return gate.id.startsWith('research:') ? 'research_source_changed' : null;
     if (changedFiles.some((file) => file.startsWith('src/core/zellij/') || file.startsWith('src/commands/zellij')))
         return gate.id.startsWith('zellij:') || gate.id.startsWith('agent:zellij') || gate.id.startsWith('naruto:zellij') ? 'zellij_source_changed' : null;
     if (changedFiles.some((file) => file.includes('/db') || file.includes('mad-db') || file.includes('mcp')))
         return /db|mcp|mad-db|mad-sks/.test(gate.id) ? 'db_mcp_or_mad_db_changed' : null;
-    const inputs = gate.cache?.inputs || [];
+    const inputs = (gate.cache?.inputs || []).filter((pattern) => !isBroadAffectedInput(pattern));
     if (inputs.some((pattern) => changedFiles.some((file) => matchesGlobish(file, pattern))))
         return 'cache_input_changed';
     return null;
@@ -110,4 +125,31 @@ function matchesGlobish(file, pattern) {
         return file.startsWith(normalized.slice(0, -1));
     return false;
 }
+function isBroadAffectedInput(pattern) {
+    const normalized = pattern.replace(/\\/g, '/');
+    return new Set([
+        '**',
+        '**/*',
+        'src/**',
+        'src/**/*',
+        'schemas/**',
+        'schemas/**/*',
+        'package.json',
+        'package-lock.json',
+        'release-gates.v2.json'
+    ]).has(normalized);
+}
+function releaseScriptGateCandidates(file) {
+    const normalized = file.replace(/\\/g, '/');
+    const base = normalized.split('/').pop()?.replace(/\.(ts|js|mjs|cjs)$/, '') || '';
+    if (!base.startsWith('release-'))
+        return [];
+    const rest = base.slice('release-'.length);
+    const withoutCheck = rest.replace(/-check$/, '');
+    return [
+        `release:${rest}`,
+        `release:${withoutCheck}`,
+        `release:${withoutCheck}:check`
+    ];
+}
 //# sourceMappingURL=release-gate-affected-selector.js.map

package/dist/core/release/release-gate-dag.js

@@ -26,6 +26,10 @@ export async function runReleaseGateDag(input) {
         ? selectAffectedReleaseGates(root, manifest, presetGates, { changedSince: input.changedSince || 'auto', preset })
         : selectAffectedReleaseGates(root, manifest, presetGates, { full: true, preset });
     const selected = affected.gates;
+    const selectedIds = new Set(selected.map((gate) => gate.id));
+    const affectedExternalSatisfiedDeps = affected.selection.mode === 'affected'
+        ? new Set(selected.flatMap((gate) => gate.deps || []).filter((dep) => !selectedIds.has(dep)))
+        : new Set();
     const runId = `rg-${new Date().toISOString().replace(/[:.]/g, '-')}-${process.pid}`;
     const reportDir = path.join(root, '.sneakoscope', 'reports', 'release-gates', runId);
     fs.mkdirSync(reportDir, { recursive: true });
@@ -88,7 +92,7 @@ export async function runReleaseGateDag(input) {
         writeReleaseGateJson(path.join(reportDir, 'explain.json'), { schema: RELEASE_GATE_NODE_SCHEMA, preset, budget, gates: selected.map((gate) => ({ id: gate.id, deps: gate.deps, resource: gate.resource, command: gate.command })) });
     }
     while (pending.size || running.size) {
-        const ready = findReadyReleaseGateNodes({ pending, completed, failed });
+        const ready = findReadyReleaseGateNodes({ pending, completed, failed, satisfiedDeps: affectedExternalSatisfiedDeps });
         const launchable = pickReadyLaunchableReleaseGates({ ready, running: [...running.values()].map((row) => row.gate) });
         let progressed = false;
         for (const gate of launchable) {

package/dist/core/release/release-gate-scheduler.js

@@ -1,6 +1,7 @@
 import { defaultReleaseGateBudget, pickLaunchableReleaseGates } from './release-gate-resource-governor.js';
 export function findReadyReleaseGateNodes(input) {
-    return [...input.pending.values()].filter((gate) => gate.deps.every((dep) => input.completed.has(dep)) && !gate.deps.some((dep) => input.failed.has(dep)));
+    const satisfiedDeps = input.satisfiedDeps || new Set();
+    return [...input.pending.values()].filter((gate) => gate.deps.every((dep) => input.completed.has(dep) || satisfiedDeps.has(dep)) && !gate.deps.some((dep) => input.failed.has(dep)));
 }
 export function findReleaseGatesBlockedByFailedDeps(input) {
     return [...input.pending.values()].filter((gate) => gate.deps.some((dep) => input.failed.has(dep)));