sneakoscope 3.1.4 → 3.1.6

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

@@ -28,17 +28,52 @@ export async function madHighCommand(args = [], deps = {}) {
     if (subcommand)
         return madSksSubcommand(subcommand, args.filter((arg) => String(arg) !== subcommand));
     const cleanArgs = stripMadLaunchOnlyArgs(args);
-    if (args.includes('--json')) {
+    const rawArgs = (args || []).map((arg) => String(arg));
+    const dryRun = rawArgs.includes('--dry-run');
+    if (args.includes('--json') && !dryRun) {
         const profile = buildMadHighLaunchProfileNoWrite();
         return console.log(JSON.stringify(profile, null, 2));
     }
     const update = { status: 'notice_only', non_blocking: true };
-    const rawArgs = (args || []).map((arg) => String(arg));
     const headlessZellij = rawArgs.includes('--headless') || process.env.SKS_MAD_ALLOW_HEADLESS === '1';
     const skipZellijRepair = rawArgs.includes('--skip-zellij-repair') || rawArgs.includes('--no-auto-install-zellij');
     const launchRoot = process.cwd();
     if (!(await exists(path.join(launchRoot, '.sneakoscope'))))
         await initProject(launchRoot, {});
+    if (dryRun) {
+        const zellijPlan = skipZellijRepair
+            ? { schema: 'sks.zellij-self-heal.v1', ok: true, status: 'skipped', dry_run: true, planned_mutations: [], command: null, blockers: [], warnings: ['zellij_repair_skipped'] }
+            : await repairZellijForSks({
+                root: launchRoot,
+                requestedBy: 'sks --mad',
+                fixRequested: true,
+                autoApprove: rawArgs.includes('--yes') || rawArgs.includes('-y'),
+                interactive: false,
+                installHomebrew: rawArgs.includes('--install-homebrew'),
+                allowHeadlessFallback: headlessZellij,
+                dryRun: true
+            });
+        const report = {
+            schema: 'sks.mad-sks-zellij-dry-run.v1',
+            ok: zellijPlan.ok === true,
+            status: zellijPlan.ok === true ? 'dry_run' : 'repair_required',
+            generated_at: nowIso(),
+            launch_skipped: true,
+            zellij_repair: zellijPlan
+        };
+        await writeJsonAtomic(path.join(launchRoot, '.sneakoscope', 'reports', 'mad-sks-zellij-dry-run.json'), report);
+        if (rawArgs.includes('--json'))
+            console.log(JSON.stringify(report, null, 2));
+        else {
+            console.log(`SKS MAD dry-run: launch_skipped=true status=${report.status}`);
+            const planned = Array.isArray(zellijPlan.planned_mutations) ? zellijPlan.planned_mutations : [];
+            for (const row of planned)
+                console.log(`- plan: ${row.command}`);
+            if (zellijPlan.command && planned.length === 0)
+                console.log(`- run: ${zellijPlan.command}`);
+        }
+        return report;
+    }
     const codexUpdate = deps.maybePromptCodexUpdateForLaunch ? await deps.maybePromptCodexUpdateForLaunch(args, { label: 'MAD launch' }) : { status: 'skipped' };
     if (codexUpdate.status === 'failed' || codexUpdate.status === 'updated_not_reflected') {
         console.error(`Codex CLI update failed: ${codexUpdate.error || 'updated version was not visible on PATH'}`);

package/dist/core/commands/qa-loop-command.js

@@ -146,6 +146,7 @@ async function qaLoopRun(args) {
     const mock = flag(args, '--mock');
     const qaGate = await readJson(path.join(dir, 'qa-gate.json'), {});
     const reportFile = qaGate.qa_report_file;
+    const executionProfile = await readJson(path.join(dir, 'qa-loop', 'execution-profile.json'), null);
     const uiRequired = qaUiRequired(contract.answers || {});
     const capabilityArtifact = await writeCodex0138CapabilityArtifacts(root, { missionId: id }).catch((err) => ({ error: err?.message || String(err), report: null }));
     const usageArtifact = await writeCodexAccountUsageArtifacts(root, { missionId: id }).catch((err) => ({ error: err?.message || String(err), snapshot: null }));
@@ -273,7 +274,7 @@ async function qaLoopRun(args) {
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'qaloop.run.started', maxCycles, mock });
     const nativeAgentPlan = await readJson(path.join(dir, 'qa-agent-plan.json'), null);
     const nativeRoster = requestedAgents === 3 ? nativeAgentPlan : null;
-    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: '$QA-LOOP', prompt: mission.prompt || 'QA-LOOP run', backend: mock ? 'fake' : 'codex-sdk', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency: Math.min(requestedAgents, 5), readonly: !(applyPatches && writeMode !== 'off'), profile, writeMode: writeMode, applyPatches, dryRunPatches, maxWriteAgents, roster: nativeRoster, routeCommand: 'sks qa-loop run', routeBlackboxKind: 'actual_qa_command' });
+    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: '$QA-LOOP', prompt: mission.prompt || 'QA-LOOP run', backend: mock ? 'fake' : 'codex-sdk', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency: Math.min(requestedAgents, 5), readonly: !(applyPatches && writeMode !== 'off'), profile, writeMode: writeMode, applyPatches, dryRunPatches, maxWriteAgents, roster: nativeRoster, routeCommand: 'sks qa-loop run', routeBlackboxKind: 'actual_qa_command', env: { SKS_CODEX_APP_EXECUTION_PROFILE: executionProfile?.mode || 'unknown', SKS_CODEX_AGENT_ROLE_STRATEGY: executionProfile?.agent_role_strategy || 'message-role' } });
     await writeJsonAtomic(path.join(dir, 'qa-native-agent-run.json'), nativeAgentRun);
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'qaloop.native_agents.completed', backend: nativeAgentRun.backend, ok: nativeAgentRun.ok, proof: nativeAgentRun.proof?.status });
     if (mock) {
@@ -343,7 +344,7 @@ async function qaLoopRun(args) {
     for (let cycle = 1; cycle <= maxCycles; cycle += 1) {
         const cycleDir = path.join(dir, 'qa-loop', `cycle-${cycle}`);
         const outputFile = path.join(cycleDir, 'final.md');
-        const prompt = buildQaLoopPrompt({ id, mission, contract, cycle, previous: last, reportFile, imagePathContract: imagePathContract?.contract || null, appHandoff });
+        const prompt = buildQaLoopPrompt({ id, mission, contract, cycle, previous: last, reportFile, imagePathContract: imagePathContract?.contract || null, appHandoff, executionProfile });
         await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'qaloop.cycle.start', cycle });
         const result = await runCodexExec({ root, prompt, outputFile, json: true, profile, logDir: cycleDir });
         await writeJsonAtomic(path.join(cycleDir, 'process.json'), { code: result.code, stdout_tail: result.stdout, stderr_tail: result.stderr, stdout_bytes: result.stdoutBytes, stderr_bytes: result.stderrBytes, truncated: result.truncated, timed_out: result.timedOut });

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

@@ -52,7 +52,7 @@ async function researchPrepare(args) {
     const context7Required = routeNeedsContext7(route, prompt);
     const reasoning = routeReasoning(route, prompt);
     const autoresearch = flag(args, '--autoresearch');
-    const plan = await writeResearchPlan(dir, prompt, { depth: readFlagValue(args, '--depth', 'frontier'), missionId: id, autoresearch });
+    const plan = await writeResearchPlan(dir, prompt, { root, depth: readFlagValue(args, '--depth', 'frontier'), missionId: id, autoresearch });
     const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task: prompt, required: context7Required, ambiguity: { required: false, status: 'direct_research_cli' } });
     await writeJsonAtomic(path.join(dir, 'route-context.json'), {
         route: route.id,
@@ -114,7 +114,7 @@ async function researchRun(args) {
     const { dir, mission } = await loadMission(root, id);
     const planPath = path.join(dir, 'research-plan.json');
     if (!(await exists(planPath)))
-        await writeResearchPlan(dir, mission.prompt || '', { missionId: id, autoresearch: flag(args, '--autoresearch') });
+        await writeResearchPlan(dir, mission.prompt || '', { root, missionId: id, autoresearch: flag(args, '--autoresearch') });
     const plan = await readJson(planPath);
     const dbScan = await scanDbSafety(root);
     if (!dbScan.ok) {

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

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import { repairZellijForSks } from '../zellij/zellij-self-heal.js';
 export async function runDoctorZellijRepair(input) {
     const args = (input.args || []).map(String);
@@ -10,6 +9,7 @@ export async function runDoctorZellijRepair(input) {
         fixRequested: true,
         autoApprove: args.includes('--yes') || args.includes('-y'),
         installHomebrew: args.includes('--install-homebrew') || process.env.SKS_ALLOW_HOMEBREW_INSTALL === '1',
+        dryRun: args.includes('--dry-run'),
         interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY && process.env.SKS_NO_QUESTION !== '1'),
         allowHeadlessFallback: false,
         env: process.env
@@ -18,6 +18,10 @@ export async function runDoctorZellijRepair(input) {
 export function doctorZellijRepairConsoleLine(result) {
     if (!result)
         return null;
+    if (result.dry_run) {
+        const planned = result.planned_mutations.map((row) => row.command).join(' && ') || result.command || 'none';
+        return `Zellij repair: dry_run planned ${planned}`;
+    }
     if (result.strategy === 'none-current')
         return `Zellij repair: current ${result.after.version || ''}`.trim();
     if (result.ok && (result.strategy === 'brew-install-zellij' || result.strategy === 'brew-install-homebrew-then-zellij')) {

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'),
@@ -107,6 +106,7 @@ const FIXTURES = Object.freeze({
     'route-from-chat-img': fixture('mock', '$From-Chat-IMG visual work order route', ['from-chat-img-work-order.md', 'image-voxel-ledger.json', 'completion-proof.json'], 'pass'),
     'route-ux-review': fixture('mock', '$UX-Review image UX alias route', ['image-ux-generated-review-ledger.json', 'image-voxel-ledger.json'], 'pass'),
     'route-db': fixture('execute_and_validate_artifacts', 'sks db check --sql "SELECT 1" --json', ['completion-proof.json', 'db-operation-report.json'], 'pass'),
+    'route-mad-db': fixture('mock', '$MAD-DB one-cycle DB break-glass route contract', ['mad-db-capability.json', 'mad-db-ledger.jsonl', 'completion-proof.json'], 'pass'),
     'route-wiki': fixture('execute_and_validate_artifacts', 'sks wiki image-ingest test/fixtures/images/one-by-one.png --json', [{ path: 'completion-proof.json', schema: 'sks.completion-proof.v1' }, { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }], 'pass'),
     'route-gx': fixture('execute_and_validate_artifacts', 'sks gx validate fixture --mock --json', ['completion-proof.json', { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }, 'gx-validation.json'], 'pass'),
     'route-sks': fixture('mock', '$SKS control-surface route', ['completion-proof.json'], 'pass'),
@@ -128,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

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { COMMAND_CATALOG, DOLLAR_COMMAND_ALIASES, DOLLAR_COMMANDS } from './routes.js';
+import { COMMAND_CATALOG, DOLLAR_COMMAND_ALIASES, DOLLAR_COMMANDS, ROUTES } from './routes.js';
 import { FEATURE_QUALITY_LEVELS, fixtureForFeature, fixtureSummary, validateFeatureFixtures } from './feature-fixtures.js';
 import { runFeatureFixture, writeFeatureFixtureReports } from './feature-fixture-runner.js';
 import { PACKAGE_VERSION, exists, nowIso, packageRoot, readJson, readText, runProcess, writeJsonAtomic, writeTextAtomic } from './fsx.js';
@@ -46,6 +46,9 @@ export async function buildFeatureRegistry({ root = packageRoot(), generatedAt =
     }
     for (const route of DOLLAR_COMMANDS)
         features.push(routeFeature(route));
+    for (const route of ROUTES.filter((entry) => entry.hidden === true)) {
+        features.push(routeFeature(route));
+    }
     features.push(nativeAgentIntakeFeature());
     features.push(agentProofEvidenceFeature());
     for (const skillName of skillNames) {
@@ -810,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.4';
+export const PACKAGE_VERSION = '3.1.6';
 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/init.js

@@ -639,7 +639,10 @@ export async function initProject(root, opts = {}) {
         const baseUrl = globalConfig.match(/(^|\n)\[model_providers\.codex-lb\][\s\S]*?\n\s*base_url\s*=\s*"([^"]+)"/)?.[2] || parseCodexLbEnvBaseUrl(envText);
         if (!parseCodexLbEnvKey(envText) || !baseUrl)
             return next;
-        next = upsertTopLevelTomlString(next, 'model_provider', 'codex-lb');
+        const shouldSelectCodexLb = selectedRe.test(next) || selectedRe.test(globalConfig);
+        next = shouldSelectCodexLb
+            ? upsertTopLevelTomlString(next, 'model_provider', 'codex-lb')
+            : removeTopLevelTomlKeyIfValue(next, 'model_provider', 'codex-lb');
         next = upsertTomlTable(next, 'model_providers.codex-lb', `[model_providers.codex-lb]\nname = "OpenAI"\nbase_url = "${baseUrl}"\nwire_api = "responses"\nenv_key = "CODEX_LB_API_KEY"\nsupports_websockets = true\nrequires_openai_auth = false`);
         return `${next.trim()}\n`;
     }

package/dist/core/loops/loop-continuation-enforcer.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import path from 'node:path';
 import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { loopPlanPath } from './loop-artifacts.js';
@@ -8,9 +7,9 @@ export async function evaluateLoopContinuation(input) {
     const blockers = [];
     if (!plan)
         blockers.push('loop_plan_missing');
-    const nodes = plan?.graph?.nodes || [];
+    const nodes = loopNodes(plan);
     const proofs = await Promise.all(nodes.map((node) => readJson(path.join(root, '.sneakoscope', 'missions', input.missionId, 'loops', node.loop_id, 'loop-proof.json'), null)));
-    const completed = proofs.filter((proof) => proof?.status === 'completed').length;
+    const completed = proofs.filter((proof) => isRecord(proof) && proof.status === 'completed').length;
     const incomplete = Math.max(0, nodes.length - completed);
     const shouldContinue = Boolean(plan && incomplete > 0 && blockers.length === 0);
     const report = {
@@ -29,4 +28,13 @@ export async function evaluateLoopContinuation(input) {
     await writeJsonAtomic(path.join(root, '.sneakoscope', 'missions', input.missionId, 'loop-continuation-enforcer.json'), report).catch(() => undefined);
     return report;
 }
+function loopNodes(value) {
+    if (!isRecord(value) || !isRecord(value.graph) || !Array.isArray(value.graph.nodes))
+        return [];
+    return value.graph.nodes
+        .filter((node) => isRecord(node) && typeof node.loop_id === 'string');
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
 //# sourceMappingURL=loop-continuation-enforcer.js.map

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

@@ -5,7 +5,7 @@ import { selectLoopGates } from './loop-gate-selector.js';
 import { inferLoopOwnerScope } from './loop-owner-inference.js';
 import { classifyLoopRisk } from './loop-risk-classifier.js';
 import { defaultLoopBudget, validateLoopPlan } from './loop-schema.js';
-import { readInitDeepMemory } from '../codex-app/codex-init-deep.js';
+import { readInitDeepMemory, readInitDeepMemoryHints } from '../codex-app/codex-init-deep.js';
 export async function planLoopsFromRequest(input) {
     const parallelism = input.parallelism || 'balanced';
     const maxLoops = Math.max(1, Math.min(32, input.maxLoops || 8));
@@ -53,6 +53,16 @@ export async function planLoopsFromRequest(input) {
         })
     };
     const nodes = [...actionNodes, integrationNode];
+    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 {
+            ...node,
+            ...(hints.length ? { memory_hints: hints } : {}),
+            memory_hints_used: hints.length,
+            memory_did_not_expand_scope: true
+        };
+    });
     const plan = {
         schema: 'sks.loop-plan.v1',
         mission_id: input.missionId,
@@ -64,12 +74,12 @@ export async function planLoopsFromRequest(input) {
             confidence: actionNodes.length ? 'high' : 'medium'
         },
         graph: {
-            nodes,
+            nodes: nodesWithMemory,
             edges: actionNodes.map((node) => ({ from: node.loop_id, to: integrationNode.loop_id, reason: 'integration_after_loop_proof' }))
         },
         global_budget: defaultLoopBudget({
-            max_iterations: Math.max(...nodes.map((node) => node.budget.max_iterations)),
-            max_subagents: nodes.reduce((sum, node) => sum + node.budget.max_subagents, 0)
+            max_iterations: Math.max(...nodesWithMemory.map((node) => node.budget.max_iterations)),
+            max_subagents: nodesWithMemory.reduce((sum, node) => sum + node.budget.max_subagents, 0)
         }),
         safety: {
             no_unrequested_fallback_code: true,
@@ -89,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);
@@ -176,4 +187,16 @@ function dynamicCheckerWorkerCount(input) {
 function titleFromDomain(domainId) {
     return domainId === 'loop-general-coding' ? 'General coding loop' : `${domainId} loop`;
 }
+function scopePathsForNodes(nodes) {
+    return nodes.flatMap((node) => [
+        ...node.owner_scope.files,
+        ...node.owner_scope.directories
+    ]).filter(Boolean);
+}
+function hintAppliesToNode(hint, node) {
+    if (hint.scope === '.')
+        return true;
+    const scopes = [...node.owner_scope.files, ...node.owner_scope.directories].map((value) => value.replace(/^\.?\//, ''));
+    return scopes.some((scope) => scope === hint.scope || scope.startsWith(`${hint.scope}/`) || hint.scope.startsWith(`${scope}/`));
+}
 //# sourceMappingURL=loop-planner.js.map

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' });
 }
@@ -43,7 +44,14 @@ async function runLoopWorkerNative(input) {
         ? buildLoopMakerPrompt({ plan: input.plan, node: input.node, worktreePath: input.worktree?.path || null })
         : buildLoopCheckerPrompt({ plan: input.plan, node: input.node, makerArtifacts: input.makerArtifacts || [] });
     const workerCount = effectiveLoopWorkerCount(input);
-    const workGraph = buildLoopNarutoWorkGraph(input, workerCount);
+    const executionProfile = await resolveCodexAppExecutionProfile({ root: input.root }).catch(() => null);
+    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
@@ -52,7 +60,6 @@ async function runLoopWorkerNative(input) {
     // The loop worktree is still where workers cwd + write: it is threaded through the per-worker
     // `worktree` opt below, which launchWorker reads as ctx.opts.worktree -> workerCwd.
     const insideZellij = Boolean(process.env.SKS_ZELLIJ_SESSION_NAME || process.env.ZELLIJ);
-    const executionProfile = await resolveCodexAppExecutionProfile({ root: input.root }).catch(() => null);
     const visiblePaneCap = Math.min(resolveLoopVisiblePaneCap(workerCount), Math.max(1, workerCount));
     const zellijPlacementOpts = insideZellij ? {
         workerPlacement: 'zellij-pane',
@@ -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);
+    return normalizeNativeResult(input, orchestrator, executionProfile, invocationPlan);
 }
-async function normalizeNativeResult(input, result) {
+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 = [
@@ -124,7 +134,18 @@ async function normalizeNativeResult(input, result) {
         blockers: [...new Set(blockers)],
         runtime_proof_path: proofPath,
         worker_ids: stringArray(result?.results?.map?.((row) => row?.agent_id || row?.id)),
-        session_ids: stringArray(result?.results?.map?.((row) => row?.session_id))
+        session_ids: stringArray(result?.results?.map?.((row) => row?.session_id)),
+        ...(executionProfile ? {
+            codex_app_execution_profile: {
+                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
+            }
+        } : {}),
+        ...(invocationPlan ? {
+            codex_native_invocation_plan: compactInvocationPlan(invocationPlan)
+        } : {})
     };
     await writeJsonAtomic(proofPath, { ...normalized, native_result_summary: summarizeNativeResult(result), generated_at: nowIso() });
     return normalized;
@@ -189,7 +210,14 @@ async function runLoopWorkerFixture(input) {
         fixture_allowed_reason: fixturePolicy.allowed ? fixturePolicy.reason : null
     };
 }
-function buildLoopNarutoWorkGraph(input, workerCount) {
+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';
@@ -218,7 +246,9 @@ function buildLoopNarutoWorkGraph(input, workerCount) {
                 mode: input.worktree?.path ? 'patch-envelope-only' : 'git-worktree',
                 required: input.node.worktree.required,
                 allocation_required: false
-            }
+            },
+            ...(profilePayload ? { codex_app_execution_profile: profilePayload } : {}),
+            ...(invocationPayload ? { codex_native_invocation_plan: invocationPayload } : {})
         };
     });
     return {
@@ -239,10 +269,24 @@ function buildLoopNarutoWorkGraph(input, workerCount) {
             worktree_root: null,
             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/naruto/naruto-loop-worker-router.js

@@ -1,7 +1,9 @@
-export function routeNarutoLoopWorker(node, role) {
+export function routeNarutoLoopWorker(node, role, profile) {
     const domain = node.loop_id.replace(/^loop-/, '');
     const roles = roleLabels(domain);
     const gates = [...node.gates.triage, ...node.gates.local, ...node.gates.checker, ...node.gates.integration, ...node.gates.final];
+    const roleName = role === 'maker' ? roles.maker : roles.checker;
+    const strategy = profile?.agent_role_strategy || 'message-role';
     return {
         schema: 'sks.naruto-loop-worker-route.v1',
         loop_id: node.loop_id,
@@ -9,7 +11,10 @@ export function routeNarutoLoopWorker(node, role) {
         checker_role: roles.checker,
         prompt: [
             `loop purpose: ${node.purpose}`,
-            `role: ${role === 'maker' ? roles.maker : roles.checker}`,
+            `role: ${roleName}`,
+            `agent role strategy: ${strategy}`,
+            `agent_type: ${strategy === 'agent_type' ? roleName.replace(/\s+/g, '-') : '-'}`,
+            `message role prefix: ${strategy === 'message-role' ? `Role: ${roleName}.` : '-'}`,
             `owner files: ${node.owner_scope.files.join(', ') || '-'}`,
             `owner directories: ${node.owner_scope.directories.join(', ') || '-'}`,
             `gates: ${gates.join(', ') || '-'}`,
@@ -21,6 +26,10 @@ export function routeNarutoLoopWorker(node, role) {
         allowed_files: node.owner_scope.files,
         allowed_directories: node.owner_scope.directories,
         gates,
+        agent_role_strategy: strategy,
+        agent_type: strategy === 'agent_type' ? roleName.replace(/\s+/g, '-') : null,
+        message_role_prefix: strategy === 'message-role' ? `Role: ${roleName}.` : null,
+        execution_profile_artifact: profile?.artifact_path || null,
         mutation_outside_owner_scope_allowed: false
     };
 }