sneakoscope 3.1.5 → 3.1.7

package/dist/core/codex-native/codex-native-repair-transaction.js

@@ -0,0 +1,150 @@
+import path from 'node:path';
+import { buildCodexHookLifecycle } from '../codex-app/codex-hook-lifecycle.js';
+import { runCodexInitDeep } from '../codex-app/codex-init-deep.js';
+import { syncCodexAgentRoles } from '../codex-app/codex-agent-role-sync.js';
+import { syncCodexSksSkills } from '../codex-app/codex-skill-sync.js';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { createRequestedScopeContract } from '../safety/requested-scope-contract.js';
+import { evaluateMutation, mutationLedgerPath, recordMutation } from '../safety/mutation-ledger.js';
+export async function repairCodexNativeManagedAssets(input) {
+    const root = path.resolve(input.root);
+    const requested = {
+        skills: input.repairSkills !== false,
+        agent_roles: input.repairAgentRoles !== false,
+        hooks: input.repairHooks !== false,
+        project_memory: input.repairProjectMemory !== false
+    };
+    const requestedAssets = Object.entries(requested)
+        .filter(([, enabled]) => enabled)
+        .map(([asset]) => asset);
+    if (input.yes !== true) {
+        const report = {
+            schema: 'sks.codex-native-repair-transaction.v1',
+            ok: false,
+            generated_at: nowIso(),
+            requested_by: input.requestedBy,
+            repaired: requestedAssets.map((asset) => ({
+                asset,
+                ok: false,
+                changed: false,
+                artifact_path: artifactPathFor(asset),
+                blockers: ['repair_transaction_requires_yes']
+            })),
+            confirmed: false,
+            mutation_ledger_path: null,
+            blockers: ['repair_transaction_requires_yes'],
+            warnings: []
+        };
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-native-repair-transaction.json'), report).catch(() => undefined);
+        return report;
+    }
+    const rows = [];
+    if (requested.skills) {
+        const report = await syncCodexSksSkills({ root, apply: true }).catch((err) => ({ ok: false, blockers: [messageOf(err)] }));
+        rows.push({
+            asset: 'skills',
+            ok: recordOk(report) !== false,
+            changed: listLength(report, 'created') > 0,
+            artifact_path: '.sneakoscope/reports/codex-skill-sync.json',
+            blockers: blockersOf(report)
+        });
+    }
+    if (requested.agent_roles) {
+        const report = await syncCodexAgentRoles({ root, apply: true }).catch((err) => ({ ok: false, blockers: [messageOf(err)] }));
+        rows.push({
+            asset: 'agent_roles',
+            ok: recordOk(report) !== false,
+            changed: listLength(report, 'created') > 0,
+            artifact_path: '.sneakoscope/reports/codex-agent-role-sync.json',
+            blockers: blockersOf(report)
+        });
+    }
+    if (requested.hooks) {
+        const report = await buildCodexHookLifecycle({ root, apply: true }).catch((err) => ({ ok: false, blockers: [messageOf(err)] }));
+        rows.push({
+            asset: 'hooks',
+            ok: recordOk(report) !== false,
+            changed: recordOk(report) !== false,
+            artifact_path: '.sneakoscope/reports/codex-hook-lifecycle.json',
+            blockers: blockersOf(report)
+        });
+    }
+    if (requested.project_memory) {
+        const report = await runCodexInitDeep({ root, apply: true, directoryLocal: true }).catch((err) => ({ ok: false, blockers: [messageOf(err)] }));
+        rows.push({
+            asset: 'project_memory',
+            ok: recordOk(report) !== false,
+            changed: listLength(report, 'directory_local_agents.created') + listLength(report, 'directory_local_agents.updated') > 0,
+            artifact_path: '.sneakoscope/reports/codex-init-deep.json',
+            blockers: blockersOf(report)
+        });
+    }
+    const blockers = rows.flatMap((row) => row.blockers);
+    const mutationWarnings = await recordRepairMutations(root, rows);
+    const report = {
+        schema: 'sks.codex-native-repair-transaction.v1',
+        ok: rows.every((row) => row.ok) && blockers.length === 0,
+        generated_at: nowIso(),
+        requested_by: input.requestedBy,
+        repaired: rows,
+        confirmed: true,
+        mutation_ledger_path: path.relative(root, mutationLedgerPath(root)).split(path.sep).join('/'),
+        blockers: [...new Set(blockers)],
+        warnings: mutationWarnings
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-native-repair-transaction.json'), report).catch(() => undefined);
+    return report;
+}
+async function recordRepairMutations(root, rows) {
+    const contract = createRequestedScopeContract({
+        route: 'codex-native-repair-transaction',
+        userRequest: 'Repair SKS-managed Codex Native assets after explicit --yes confirmation.',
+        projectRoot: root,
+        overrides: { global_codex_config: true }
+    });
+    const warnings = [];
+    for (const row of rows) {
+        const kind = row.asset === 'project_memory' ? 'file_write' : 'global_config_write';
+        const entry = evaluateMutation(contract, kind, {
+            target: row.asset,
+            confirmed: true,
+            applied: row.changed,
+            noOpReason: row.changed ? 'sks_managed_asset_transaction_recorded' : 'repair_noop'
+        });
+        await recordMutation(root, entry).catch((err) => warnings.push(`mutation_ledger_write_failed:${messageOf(err)}`));
+    }
+    return warnings;
+}
+function artifactPathFor(asset) {
+    return asset === 'skills'
+        ? '.sneakoscope/reports/codex-skill-sync.json'
+        : asset === 'agent_roles'
+            ? '.sneakoscope/reports/codex-agent-role-sync.json'
+            : asset === 'hooks'
+                ? '.sneakoscope/reports/codex-hook-lifecycle.json'
+                : '.sneakoscope/reports/codex-init-deep.json';
+}
+function recordOk(value) {
+    return Boolean(value) && typeof value === 'object' && typeof value.ok === 'boolean'
+        ? value.ok
+        : undefined;
+}
+function blockersOf(value) {
+    return Boolean(value) && typeof value === 'object' && Array.isArray(value.blockers)
+        ? value.blockers.map((item) => String(item)).filter(Boolean)
+        : [];
+}
+function listLength(value, key) {
+    const parts = key.split('.');
+    let current = value;
+    for (const part of parts) {
+        if (!current || typeof current !== 'object')
+            return 0;
+        current = current[part];
+    }
+    return Array.isArray(current) ? current.length : 0;
+}
+function messageOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+//# sourceMappingURL=codex-native-repair-transaction.js.map

package/dist/core/codex-plugins/codex-plugin-json.js

@@ -33,7 +33,8 @@ export async function buildCodexPluginInventory() {
     });
     const blockers = [
         ...(capability.supports_plugin_json ? [] : ['codex_0_138_plugin_json_unavailable']),
-        ...normalizeList(listJson?.blockers)
+        ...normalizeList(listJson?.blockers),
+        ...(process.env.SKS_CODEX_PLUGIN_JSON_FAKE_NO_MCP === '1' ? ['fixture_mcp_candidates_disabled'] : [])
     ];
     return {
         schema: 'sks.codex-plugin-inventory.v1',
@@ -169,7 +170,9 @@ function fakePluginDetail(pluginId) {
         installed: true,
         enabled: true,
         default_prompts: ['Use the fixture plugin safely.'],
-        remote_mcp_servers: [{ name: 'fixture-db-docs', url: 'https://mcp.example.test', auth_type: 'oauth' }],
+        remote_mcp_servers: process.env.SKS_CODEX_PLUGIN_JSON_FAKE_NO_MCP === '1'
+            ? []
+            : [{ name: 'fixture-db-docs', url: 'https://mcp.example.test', auth_type: 'oauth' }],
         unavailable_app_templates: ['fixture-desktop-template']
     };
 }

package/dist/core/commands/mad-sks-command.js

@@ -22,6 +22,7 @@ import { checkSksUpdateNotice } from '../update/update-notice.js';
 import { createMadDbCapability, MAD_DB_ACK } from '../mad-db/mad-db-capability.js';
 import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-capability.js';
 import { writeCodex0139CapabilityArtifacts } from '../codex-control/codex-0139-capability.js';
+import { resolveCodexNativeInvocationPlan } from '../codex-native/codex-native-invocation-router.js';
 import { repairZellijForSks } from '../zellij/zellij-self-heal.js';
 export async function madHighCommand(args = [], deps = {}) {
     const subcommand = firstSubcommand(args);
@@ -478,6 +479,14 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
     const { id, dir } = await createMission(root, { mode: 'mad-sks', prompt: 'sks --mad Zellij scoped high-power maintenance session' });
     await writeCodex0138CapabilityArtifacts(root, { missionId: id }).catch(() => null);
     await writeCodex0139CapabilityArtifacts(root, { missionId: id }).catch(() => null);
+    const codexNativeInvocation = await resolveCodexNativeInvocationPlan({
+        root,
+        missionId: id,
+        route: '$MAD',
+        desiredCapability: 'hook-evidence'
+    }).catch(() => null);
+    if (codexNativeInvocation)
+        await writeJsonAtomic(path.join(dir, 'mad-codex-native-invocation.json'), codexNativeInvocation).catch(() => undefined);
     const protectedCore = resolveProtectedCore({ packageRoot: packageRoot(), targetRoot: cwd });
     // The interactive launch 'before' snapshot is only persisted (env + policy json)
     // and is never compared against an 'after' snapshot during the session, so the
@@ -521,6 +530,13 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
         protected_core_policy: protectedCorePolicyPath,
         protected_core_before: protectedCoreBeforePath,
         protected_core_digest: protectedCoreBefore.digest,
+        codex_native_invocation_plan: codexNativeInvocation ? {
+            selected_strategy: codexNativeInvocation.selected_strategy,
+            hook_evidence_policy: codexNativeInvocation.env.SKS_CODEX_NATIVE_HOOK_EVIDENCE_POLICY,
+            blockers: codexNativeInvocation.blockers,
+            warnings: codexNativeInvocation.warnings,
+            artifact_path: 'mad-codex-native-invocation.json'
+        } : null,
         activated_by: 'sks --mad',
         cwd: path.resolve(cwd || process.cwd())
     };

package/dist/core/feature-fixtures.js

@@ -64,8 +64,7 @@ const FIXTURES = Object.freeze({
     'cli-bootstrap': fixture('mock', 'sks bootstrap --dry-run', [], 'pass'),
     'cli-deps': fixture('mock', 'sks deps check --json', [], 'pass'),
     'cli-auth': fixture('mock', 'sks auth status --json', [], 'pass'),
-    'cli-openclaw': fixture('mock', 'sks openclaw status --json', [], 'pass'),
-    'cli-hermes': fixture('mock', 'sks hermes status --json', [], 'pass'),
+    'cli-codex-native': fixture('mock', 'sks codex-native status --json', [], 'pass'),
     'cli-zellij': fixture('mock', 'npm run zellij:capability --silent', [], 'pass'),
     'cli-tmux': fixture('mock', 'removed runtime migration notice: sks tmux --json', [], 'pass'),
     'cli-mad': fixture('mock', 'sks mad --help', [], 'pass'),
@@ -129,8 +128,7 @@ const STATIC_CONTRACT_FEATURES = new Set([
     'cli-bootstrap',
     'cli-deps',
     'cli-auth',
-    'cli-openclaw',
-    'cli-hermes',
+    'cli-codex-native',
     'cli-zellij',
     'cli-tmux',
     'cli-mad',

package/dist/core/feature-registry.js

@@ -813,7 +813,7 @@ function commandCategory(name) {
         return 'proof-route';
     if (['qa-loop', 'research', 'recallpulse', 'skill-dream', 'eval', 'perf'].includes(name))
         return 'loop';
-    if (['codex', 'codex-app', 'codex-lb', 'auth', 'hooks', 'context7', 'openclaw', 'hermes'].includes(name))
+    if (['codex', 'codex-app', 'codex-native', 'codex-lb', 'auth', 'hooks', 'context7'].includes(name))
         return 'integration';
     if (['db', 'guard', 'conflicts', 'harness', 'versioning'].includes(name))
         return 'safety';

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

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

@@ -2,9 +2,17 @@ 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';
+import { resolveCodexNativeInvocationPlan } from '../codex-native/codex-native-invocation-router.js';
 export async function buildImageArtifactPathContract(root, input) {
     const images = [];
     const blockers = [];
+    const invocationPlan = await resolveCodexNativeInvocationPlan({
+        root,
+        missionId: input.missionId,
+        route: '$Image',
+        desiredCapability: 'image-followup'
+    }).catch(() => null);
+    const followupStrategy = invocationPlan?.selected_strategy === 'codex-app-native' ? 'model-visible-path' : 'artifact-path';
     for (const [index, image] of input.images.entries()) {
         const filePath = path.resolve(root, image.filePath || '');
         const exists = await fileExists(filePath);
@@ -23,8 +31,11 @@ export async function buildImageArtifactPathContract(root, input) {
             width: dims?.width ?? null,
             height: dims?.height ?? null,
             model_visible_path: filePath,
+            codex_native_followup_strategy: followupStrategy,
             followup_edit_hint: exists
-                ? `Use this saved local path for follow-up image edits: ${filePath}`
+                ? followupStrategy === 'model-visible-path'
+                    ? `Use this model-visible saved local path for follow-up image edits: ${filePath}`
+                    : `Use this saved artifact path for follow-up image edits: ${filePath}`
                 : 'Image file path missing; do not run visual QA until a real saved file path exists.'
         });
     }
@@ -35,6 +46,12 @@ export async function buildImageArtifactPathContract(root, input) {
         mission_id: input.missionId,
         generated_at: nowIso(),
         images,
+        codex_native_invocation_plan: invocationPlan ? {
+            selected_strategy: invocationPlan.selected_strategy,
+            proof_policy: invocationPlan.proof_policy,
+            blockers: invocationPlan.blockers,
+            warnings: invocationPlan.warnings
+        } : null,
         blockers: [...new Set(blockers)]
     };
 }

package/dist/core/loops/loop-owner-inference.js

@@ -39,6 +39,9 @@ export function detectOwnerScopeCollisions(scopes) {
     }
     return blockers;
 }
+export function memoryHintMayExpandOwnerScope() {
+    return false;
+}
 function inferPackageScripts(domainId) {
     if (domainId === 'docs')
         return ['docs:loop-runtime'];

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

@@ -56,7 +56,12 @@ export async function planLoopsFromRequest(input) {
     const memoryHints = await readInitDeepMemoryHints(input.root, scopePathsForNodes(nodes)).catch(() => []);
     const nodesWithMemory = nodes.map((node) => {
         const hints = memoryHints.filter((hint) => hintAppliesToNode(hint, node)).slice(0, 5);
-        return hints.length ? { ...node, memory_hints: hints } : node;
+        return {
+            ...node,
+            ...(hints.length ? { memory_hints: hints } : {}),
+            memory_hints_used: hints,
+            memory_did_not_expand_scope: true
+        };
     });
     const plan = {
         schema: 'sks.loop-plan.v1',
@@ -94,7 +99,8 @@ export async function planLoopsFromRequest(input) {
         plan.project_memory = {
             source: projectMemory.path,
             injected: true,
-            summary: projectMemory.text.split(/\r?\n/).filter((line) => /^##\s+/.test(line)).slice(0, 8)
+            summary: projectMemory.text.split(/\r?\n/).filter((line) => /^##\s+/.test(line)).slice(0, 8),
+            memory_did_not_expand_scope: true
         };
     }
     const validation = validateLoopPlan(plan);

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

@@ -10,6 +10,7 @@ export function buildLoopMakerPrompt(input) {
         `Owner directories: ${node.owner_scope.directories.join(', ') || '-'}`,
         `Allowed mutation scope: ${ownerScopeText(node)}`,
         'Do not mutate outside the owner scope.',
+        'Memory hints are guidance only; memory never grants write permission or expands owner scope.',
         `Selected local gates: ${allGateIds(node.gates).join(', ') || '-'}`,
         `Budget: ${JSON.stringify(node.budget)}`,
         `Worktree path: ${input.worktreePath || '-'}`,
@@ -30,6 +31,7 @@ export function buildLoopCheckerPrompt(input) {
         `Selected gates: ${allGateIds(node.gates).join(', ') || '-'}`,
         `Risk: ${node.risk.level} (${node.risk.reasons.join(', ') || '-'})`,
         'Reject unrequested side effects and owner-scope violations.',
+        'Memory hints are guidance only; memory never grants write permission or expands owner scope.',
         'Write checker-findings.json with fresh_session, reviewed_maker_artifacts, side_effects_detected, and approved.',
         'No synthetic pass is allowed for production proof.'
     ].join('\n');

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

@@ -7,6 +7,7 @@ import { computeLoopConcurrencyBudget, loopWorkerBudgetFor } from './loop-concur
 import { decideLoopFixturePolicy, writeLoopFixturePolicyDecision } from './loop-fixture-policy.js';
 import { buildLoopCheckerPrompt, buildLoopMakerPrompt } from './loop-worker-prompts.js';
 import { resolveCodexAppExecutionProfile } from '../codex-app/codex-app-execution-profile.js';
+import { resolveCodexNativeInvocationPlan } from '../codex-native/codex-native-invocation-router.js';
 export async function runLoopMakerWorkers(input) {
     return runLoopWorkers({ ...input, phase: 'maker' });
 }
@@ -44,7 +45,13 @@ async function runLoopWorkerNative(input) {
         : buildLoopCheckerPrompt({ plan: input.plan, node: input.node, makerArtifacts: input.makerArtifacts || [] });
     const workerCount = effectiveLoopWorkerCount(input);
     const executionProfile = await resolveCodexAppExecutionProfile({ root: input.root }).catch(() => null);
-    const workGraph = buildLoopNarutoWorkGraph(input, workerCount, executionProfile);
+    const invocationPlan = await resolveCodexNativeInvocationPlan({
+        root: input.root,
+        missionId: input.plan.mission_id,
+        route: '$Loop',
+        desiredCapability: 'agent-role'
+    }).catch(() => null);
+    const workGraph = buildLoopNarutoWorkGraph(input, workerCount, executionProfile, invocationPlan);
     // Root-cause-1 fix: keep the ORCHESTRATOR root on the MAIN repo (input.root), not the
     // loop worktree. All zellij/right-column/slot-telemetry state derives from the orchestrator
     // root, so anchoring it on input.root makes the SLOTS snapshot land under
@@ -81,7 +88,10 @@ async function runLoopWorkerNative(input) {
             SKS_LOOP_MAIN_ROOT: input.root,
             SKS_LOOP_WORKER_BUDGET: String(workerCount),
             SKS_CODEX_APP_EXECUTION_PROFILE: executionProfile?.mode || 'unknown',
-            SKS_CODEX_AGENT_ROLE_STRATEGY: executionProfile?.agent_role_strategy || 'message-role'
+            SKS_CODEX_AGENT_ROLE_STRATEGY: executionProfile?.agent_role_strategy || 'message-role',
+            SKS_CODEX_NATIVE_STRATEGY: invocationPlan?.selected_strategy || 'message-role-fallback',
+            SKS_CODEX_NATIVE_AGENT_ROLE_STRATEGY: invocationPlan?.env.SKS_CODEX_NATIVE_AGENT_ROLE_STRATEGY || executionProfile?.agent_role_strategy || 'message-role',
+            SKS_CODEX_NATIVE_FEATURE_MATRIX: invocationPlan?.feature_matrix_artifact || '.sneakoscope/reports/codex-native-feature-matrix.json'
         },
         ...(input.worktree?.path ? {
             worktree: {
@@ -99,9 +109,9 @@ async function runLoopWorkerNative(input) {
             fallback_reason: null
         } : null
     });
-    return normalizeNativeResult(input, orchestrator, executionProfile);
+    return normalizeNativeResult(input, orchestrator, executionProfile, invocationPlan);
 }
-async function normalizeNativeResult(input, result, executionProfile) {
+async function normalizeNativeResult(input, result, executionProfile, invocationPlan) {
     const artifacts = collectArtifactPaths(result);
     const changedFiles = stringArray(result?.changed_files || result?.proof?.changed_files || result?.results?.flatMap?.((row) => row?.changed_files || []));
     const blockers = [
@@ -132,6 +142,9 @@ async function normalizeNativeResult(input, result, executionProfile) {
                 artifact_path: executionProfile.artifact_path,
                 agent_type_probe_artifact_path: executionProfile.agent_type_probe_artifact_path
             }
+        } : {}),
+        ...(invocationPlan ? {
+            codex_native_invocation_plan: compactInvocationPlan(invocationPlan)
         } : {})
     };
     await writeJsonAtomic(proofPath, { ...normalized, native_result_summary: summarizeNativeResult(result), generated_at: nowIso() });
@@ -146,6 +159,12 @@ async function runLoopWorkerFixture(input) {
     });
     const dir = path.join(loopNodeRoot(input.root, input.plan.mission_id, input.node.loop_id), input.phase);
     await ensureDir(dir);
+    const invocationPlan = await resolveCodexNativeInvocationPlan({
+        root: input.root,
+        missionId: input.plan.mission_id,
+        route: '$Loop',
+        desiredCapability: 'agent-role'
+    }).catch(() => null);
     const resultPath = path.join(dir, 'worker-runtime-result.json');
     const childInputPath = path.join(dir, 'worker-fixture-intake.json');
     await writeJsonAtomic(childInputPath, {
@@ -157,7 +176,8 @@ async function runLoopWorkerFixture(input) {
         worker_count: input.phase === 'maker' ? input.node.maker.worker_count : input.node.checker.worker_count,
         result_path: resultPath,
         owner_scope: input.node.owner_scope,
-        maker_artifacts: input.makerArtifacts || []
+        maker_artifacts: input.makerArtifacts || [],
+        codex_native_invocation_plan: invocationPlan ? compactInvocationPlan(invocationPlan) : null
     });
     const child = await runProcess(process.execPath, [fixtureChildEntrypoint(), childInputPath], {
         cwd: input.root,
@@ -197,13 +217,14 @@ async function runLoopWorkerFixture(input) {
         fixture_allowed_reason: fixturePolicy.allowed ? fixturePolicy.reason : null
     };
 }
-function buildLoopNarutoWorkGraph(input, workerCount, executionProfile) {
+function buildLoopNarutoWorkGraph(input, workerCount, executionProfile, invocationPlan) {
     const profilePayload = executionProfile ? {
         mode: executionProfile.mode,
         agent_role_strategy: executionProfile.agent_role_strategy,
         artifact_path: executionProfile.artifact_path,
         agent_type_probe_artifact_path: executionProfile.agent_type_probe_artifact_path
     } : undefined;
+    const invocationPayload = invocationPlan ? compactInvocationPlan(invocationPlan) : undefined;
     const workItems = Array.from({ length: Math.max(1, workerCount) }, (_, index) => {
         const id = `${input.node.loop_id}-${input.phase}-${index + 1}`;
         const writeAllowed = input.phase === 'maker';
@@ -233,7 +254,8 @@ function buildLoopNarutoWorkGraph(input, workerCount, executionProfile) {
                 required: input.node.worktree.required,
                 allocation_required: false
             },
-            ...(profilePayload ? { codex_app_execution_profile: profilePayload } : {})
+            ...(profilePayload ? { codex_app_execution_profile: profilePayload } : {}),
+            ...(invocationPayload ? { codex_native_invocation_plan: invocationPayload } : {})
         };
     });
     return {
@@ -255,10 +277,23 @@ function buildLoopNarutoWorkGraph(input, workerCount, executionProfile) {
             fallback_reason: input.worktree?.path ? 'loop_worktree_already_allocated' : null
         },
         ...(profilePayload ? { codex_app_execution_profile: profilePayload } : {}),
+        ...(invocationPayload ? { codex_native_invocation_plan: invocationPayload } : {}),
         blockers: [],
         ok: true
     };
 }
+function compactInvocationPlan(plan) {
+    return {
+        route: plan.route,
+        desired_capability: plan.desired_capability,
+        selected_strategy: plan.selected_strategy,
+        required_artifacts: plan.required_artifacts,
+        proof_policy: plan.proof_policy,
+        env: plan.env,
+        blockers: plan.blockers,
+        warnings: plan.warnings
+    };
+}
 function collectArtifactPaths(result) {
     return stringArray([
         result?.ledger_root,

package/dist/core/qa-loop.js

@@ -3,6 +3,7 @@ import { exists, nowIso, readJson, readText, writeJsonAtomic, writeTextAtomic, P
 import { CODEX_WEB_VERIFICATION_EVIDENCE_SOURCE, CODEX_WEB_VERIFICATION_POLICY, evidenceMentionsForbiddenBrowserAutomation, evidenceMentionsForbiddenWebComputerUseEvidence } from './routes.js';
 import { appendAgentLedgerEvent, initializeAgentCentralLedger } from './agents/agent-central-ledger.js';
 import { resolveCodexAppExecutionProfile } from './codex-app/codex-app-execution-profile.js';
+import { resolveCodexNativeInvocationPlan } from './codex-native/codex-native-invocation-router.js';
 export const QA_LOOP_ROUTE = 'QALoop';
 const QA_REPORT_SUFFIX = 'qa-report.md';
 const UI_CHROME_EXTENSION_FIRST_ACK = 'use_codex_chrome_extension_first_no_computer_use_for_web_ui_or_mark_unverified';
@@ -325,6 +326,7 @@ export function defaultQaGate(contract = {}, opts = {}) {
         codex_app_execution_profile_artifact: opts.executionProfile ? 'qa-loop/execution-profile.json' : null,
         codex_app_hooks_approval_required: opts.executionProfile?.hooks_approval_required === true,
         codex_app_agent_role_strategy: opts.executionProfile?.agent_role_strategy || null,
+        codex_native_invocation: opts.codexNativeInvocation || null,
         api_e2e_required: apiRequired,
         unsafe_external_side_effects: false,
         corrective_loop_enabled: corrective,
@@ -345,19 +347,23 @@ export async function writeQaLoopArtifacts(dir, mission, contract) {
     const reportFile = qaReportFilename();
     const root = missionRootFromDir(dir);
     const executionProfile = root ? await resolveCodexAppExecutionProfile({ root }).catch(() => null) : null;
+    const codexNativeInvocation = root ? await resolveQaCodexNativeInvocation(root, mission.id).catch(() => null) : null;
     if (executionProfile)
         await writeJsonAtomic(path.join(dir, 'qa-loop', 'execution-profile.json'), executionProfile).catch(() => undefined);
+    if (codexNativeInvocation)
+        await writeJsonAtomic(path.join(dir, 'qa-loop', 'codex-native-invocation.json'), codexNativeInvocation).catch(() => undefined);
     await writeJsonAtomic(path.join(dir, 'qa-ledger.json'), {
         schema_version: 1,
         generated_at: nowIso(),
         mission_id: mission.id,
         qa_report_file: reportFile,
         codex_app_execution_profile: executionProfile ? compactExecutionProfile(executionProfile) : null,
+        codex_native_invocation: codexNativeInvocation,
         target: { scope: a.QA_SCOPE, environment: a.TARGET_ENVIRONMENT, base_url: a.TARGET_BASE_URL, api_base_url: a.API_BASE_URL },
         safety: { mutation_policy: a.QA_MUTATION_POLICY, deployed_destructive_tests_allowed: 'never', credentials: 'temp_only_never_saved', ui_evidence: 'codex_chrome_extension_first_required_for_web_ui_e2e' },
         checklist
     });
-    await writeJsonAtomic(path.join(dir, 'qa-gate.json'), defaultQaGate(contract, { reportFile, executionProfile }));
+    await writeJsonAtomic(path.join(dir, 'qa-gate.json'), defaultQaGate(contract, { reportFile, executionProfile, codexNativeInvocation }));
     await writeTextAtomic(path.join(dir, reportFile), qaReportTemplate(mission, contract, checklist));
     return { checklist_count: checklist.length, report_file: reportFile };
 }
@@ -446,6 +452,7 @@ export async function writeMockQaResult(dir, mission, contract) {
         codex_app_execution_profile_artifact: previousGate.codex_app_execution_profile_artifact || null,
         codex_app_hooks_approval_required: previousGate.codex_app_hooks_approval_required === true,
         codex_app_agent_role_strategy: previousGate.codex_app_agent_role_strategy || null,
+        codex_native_invocation: previousGate.codex_native_invocation || null,
         blockers: previousGate.blockers || [],
         passed: !uiRequired,
         qa_report_written: true,
@@ -467,6 +474,22 @@ export async function writeMockQaResult(dir, mission, contract) {
     });
     return evaluateQaGate(dir);
 }
+async function resolveQaCodexNativeInvocation(root, missionId) {
+    const [visualReview, hookEvidence, imageFollowup] = await Promise.all([
+        resolveCodexNativeInvocationPlan({ root, missionId, route: '$QA-LOOP', desiredCapability: 'visual-review' }),
+        resolveCodexNativeInvocationPlan({ root, missionId, route: '$QA-LOOP', desiredCapability: 'hook-evidence' }),
+        resolveCodexNativeInvocationPlan({ root, missionId, route: '$Image', desiredCapability: 'image-followup' })
+    ]);
+    return {
+        visual_review: visualReview.selected_strategy,
+        visual_review_plan: visualReview,
+        hook_evidence_policy: hookEvidence.env.SKS_CODEX_NATIVE_HOOK_EVIDENCE_POLICY,
+        hook_evidence_plan: hookEvidence,
+        image_path_strategy: imageFollowup.selected_strategy === 'codex-app-native' ? 'model-visible-path' : 'artifact-path',
+        image_followup_plan: imageFollowup,
+        hook_derived_evidence_counted: hookEvidence.selected_strategy !== 'blocked'
+    };
+}
 export function buildQaLoopPrompt({ id, mission, contract, cycle, previous, reportFile, imagePathContract, appHandoff, executionProfile }) {
     const report = reportFile && isQaReportFilename(reportFile) ? reportFile : 'the date/version-prefixed report named by qa-gate.json.qa_report_file';
     const imageContractText = imagePathContract

package/dist/core/research.js

@@ -18,6 +18,7 @@ import { RESEARCH_WORK_GRAPH_ARTIFACT, writeResearchWorkGraph } from './research
 import { researchPromptContractText, validateResearchPromptContract } from './research/research-prompt-contract.js';
 import { buildRealisticResearchPaper, buildRealisticResearchReport } from './research/research-realistic-report.js';
 import { resolveCodexAppExecutionProfile } from './codex-app/codex-app-execution-profile.js';
+import { resolveCodexNativeInvocationPlan } from './codex-native/codex-native-invocation-router.js';
 export const RESEARCH_PAPER_ARTIFACT = 'research-paper.md';
 export const RESEARCH_SOURCE_SKILL_ARTIFACT = 'research-source-skill.md';
 export const RESEARCH_GENIUS_SUMMARY_ARTIFACT = 'genius-opinion-summary.md';
@@ -254,6 +255,14 @@ export function createResearchPlan(prompt, opts = {}) {
     const paperArtifact = researchPaperArtifactName(prompt, createdAt, opts);
     const nativeAgentPlan = researchNativeAgentPlan(prompt, { paperArtifact, missionId: opts.missionId });
     const executionProfile = opts.executionProfile || null;
+    const codexNativeInvocation = opts.codexNativeInvocation || null;
+    const sourceStrategy = codexNativeInvocation?.mcp_source?.selected_strategy === 'codex-app-native'
+        ? 'mcp-plugin-candidates'
+        : codexNativeInvocation?.web_search?.selected_strategy === 'codex-cli-headless'
+            ? 'web-sources'
+            : executionProfile?.plugin_mcp_inventory_ready
+                ? 'mcp-plugin-candidates'
+                : 'local-files';
     return {
         schema_version: 1,
         mission_id: opts.missionId || null,
@@ -265,6 +274,7 @@ export function createResearchPlan(prompt, opts = {}) {
         quality_contract: DEFAULT_RESEARCH_QUALITY_CONTRACT,
         native_agent_plan: nativeAgentPlan,
         codex_app_execution_profile: executionProfile ? compactExecutionProfile(executionProfile) : null,
+        codex_native_invocation: codexNativeInvocation,
         agent_sessions: nativeAgentPlan.personas,
         agent_batches: nativeAgentPlan.batches,
         autoresearch_cycle_policy: nativeAgentPlan.autoresearch_cycle_policy,
@@ -322,10 +332,11 @@ export function createResearchPlan(prompt, opts = {}) {
             mode: 'layered_source_retrieval_and_triangulation',
             requirement: 'Use every safely available public web/source route before synthesis, separated into source layers so the final claim is not dominated by one corpus or platform.',
             source_tool_routing: {
-                mode: executionProfile?.plugin_mcp_inventory_ready ? 'plugin-mcp-inventory-first' : 'codex-cli-or-web-fallback',
+                mode: sourceStrategy,
                 plugin_mcp_inventory_ready: executionProfile?.plugin_mcp_inventory_ready === true,
                 execution_profile_artifact: executionProfile?.artifact_path || '.sneakoscope/reports/codex-app-execution-profile.json',
-                rule: 'Prefer verified plugin/MCP inventory when available; otherwise record source-tool blockers instead of assuming live search coverage.'
+                codex_native_invocation_artifact: codexNativeInvocation ? 'research/codex-native-invocation.json' : null,
+                rule: 'Prefer verified plugin/MCP candidates when available; otherwise record source-tool blockers instead of assuming live search coverage.'
             },
             query_sets: [
                 'first-principles and theory sources',
@@ -553,7 +564,9 @@ export function countGeniusOpinionSummaries(text = '') {
 export async function writeResearchPlan(dir, prompt, opts = {}) {
     const root = opts.root || missionRootFromDir(String(dir || ''));
     const executionProfile = opts.executionProfile || (root ? await resolveCodexAppExecutionProfile({ root }).catch(() => null) : null);
-    const plan = createResearchPlan(prompt, { ...opts, executionProfile });
+    const missionId = opts.missionId || path.basename(String(dir || ''));
+    const codexNativeInvocation = root ? await resolveResearchCodexNativeInvocation(root, missionId).catch(() => null) : null;
+    const plan = createResearchPlan(prompt, { ...opts, executionProfile, codexNativeInvocation });
     const noveltyLedger = {
         schema_version: 1,
         entries: [],
@@ -571,6 +584,8 @@ export async function writeResearchPlan(dir, prompt, opts = {}) {
     await writeJsonAtomic(path.join(dir, 'research-plan.json'), plan);
     if (executionProfile)
         await writeJsonAtomic(path.join(dir, 'research', 'execution-profile.json'), executionProfile).catch(() => undefined);
+    if (codexNativeInvocation)
+        await writeJsonAtomic(path.join(dir, 'research', 'codex-native-invocation.json'), codexNativeInvocation).catch(() => undefined);
     await writeTextAtomic(path.join(dir, 'research-plan.md'), researchPlanMarkdown(plan));
     await writeTextAtomic(path.join(dir, RESEARCH_SOURCE_SKILL_ARTIFACT), researchSourceSkillMarkdown(plan));
     await writeResearchQualityContract(dir, plan.quality_contract);
@@ -593,6 +608,24 @@ export async function writeResearchPlan(dir, prompt, opts = {}) {
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.plan.created', depth: plan.depth });
     return plan;
 }
+async function resolveResearchCodexNativeInvocation(root, missionId) {
+    const [pluginSource, mcpSource, webSearch] = await Promise.all([
+        resolveCodexNativeInvocationPlan({ root, missionId, route: '$Research', desiredCapability: 'plugin-source' }),
+        resolveCodexNativeInvocationPlan({ root, missionId, route: '$Research', desiredCapability: 'mcp-source' }),
+        resolveCodexNativeInvocationPlan({ root, missionId, route: '$Research', desiredCapability: 'web-search' })
+    ]);
+    return {
+        plugin_source: pluginSource,
+        mcp_source: mcpSource,
+        web_search: webSearch,
+        selected_source_strategy: mcpSource.selected_strategy === 'codex-app-native'
+            ? 'mcp-plugin-candidates'
+            : webSearch.selected_strategy === 'codex-cli-headless'
+                ? 'web-sources'
+                : 'local-files',
+        hook_derived_source_evidence_allowed: false
+    };
+}
 function missionRootFromDir(dir) {
     const normalized = path.resolve(String(dir || ''));
     const marker = `${path.sep}.sneakoscope${path.sep}missions${path.sep}`;