sneakoscope 3.1.4 → 3.1.6

package/dist/core/qa-loop.js

@@ -2,6 +2,8 @@ import path from 'node:path';
 import { exists, nowIso, readJson, readText, writeJsonAtomic, writeTextAtomic, PACKAGE_VERSION } from './fsx.js';
 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';
@@ -320,6 +322,11 @@ export function defaultQaGate(contract = {}, opts = {}) {
         image_artifact_path_contract_present: false,
         image_artifact_path_contract_artifact: null,
         image_artifact_path_contract_blockers: [],
+        codex_app_execution_profile: opts.executionProfile ? compactExecutionProfile(opts.executionProfile) : null,
+        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,
@@ -338,16 +345,25 @@ export async function writeQaLoopArtifacts(dir, mission, contract) {
     const a = contract.answers || {};
     const checklist = qaChecklist(a);
     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 }));
+    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 };
 }
@@ -432,6 +448,11 @@ export async function writeMockQaResult(dir, mission, contract) {
         image_artifact_path_contract_present: previousGate.image_artifact_path_contract_present === true,
         image_artifact_path_contract_artifact: previousGate.image_artifact_path_contract_artifact || null,
         image_artifact_path_contract_blockers: previousGate.image_artifact_path_contract_blockers || [],
+        codex_app_execution_profile: previousGate.codex_app_execution_profile || null,
+        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,
@@ -453,7 +474,23 @@ export async function writeMockQaResult(dir, mission, contract) {
     });
     return evaluateQaGate(dir);
 }
-export function buildQaLoopPrompt({ id, mission, contract, cycle, previous, reportFile, imagePathContract, appHandoff }) {
+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
         ? `\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`
@@ -461,6 +498,9 @@ export function buildQaLoopPrompt({ id, mission, contract, cycle, previous, repo
     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`
         : '';
+    const executionProfileText = executionProfile
+        ? `\nCODEX APP EXECUTION PROFILE:\n${JSON.stringify(compactExecutionProfile(executionProfile), null, 2)}\nUse this routing profile for agent role strategy and app/headless assumptions.\n`
+        : '';
     return `SKS QA-LOOP
 MISSION: ${id}
 TASK: ${mission.prompt}
@@ -473,7 +513,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}
+${imageContractText}${appHandoffText}${executionProfileText}
 Previous tail:
 ${String(previous || '').slice(-2500)}
 `;
@@ -486,7 +526,8 @@ export async function qaStatus(dir) {
     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()), desktop_app_handoff: appHandoff, desktop_app_confirmation: appConfirmation, desktop_review_complete: appConfirmation?.verdict === 'pass', image_path_contract: imagePathContract };
+    const executionProfile = await readJson(path.join(dir, 'qa-loop', 'execution-profile.json'), null);
+    return { gate, checklist_count: ledger?.checklist?.length ?? null, report_file: reportFile, report_written: Boolean(report.trim()), desktop_app_handoff: appHandoff, desktop_app_confirmation: appConfirmation, desktop_review_complete: appConfirmation?.verdict === 'pass', image_path_contract: imagePathContract, codex_app_execution_profile: executionProfile };
 }
 function qaChecklist(a) {
     const cases = [
@@ -504,6 +545,23 @@ function qaChecklist(a) {
     cases.push(['report.evidence', 'Record pass/fail/blocked/skipped with evidence.'], ['report.corrective_loop', 'Record fixes, rechecks, unresolved findings, deferred blockers.'], ['report.honest', 'Run Honest Mode.']);
     return cases.map(([id, title]) => ({ id, title, status: 'pending', evidence: [] }));
 }
+function missionRootFromDir(dir) {
+    const normalized = path.resolve(String(dir || ''));
+    const marker = `${path.sep}.sneakoscope${path.sep}missions${path.sep}`;
+    const idx = normalized.indexOf(marker);
+    return idx > 0 ? normalized.slice(0, idx) : null;
+}
+function compactExecutionProfile(profile) {
+    return profile ? {
+        mode: profile.mode || 'unknown',
+        agent_role_strategy: profile.agent_role_strategy || 'message-role',
+        hooks_approval_required: profile.hooks_approval_required === true,
+        hook_approval_state: profile.hook_approval_state || 'unknown',
+        app_handoff_ready: profile.app_handoff_ready === true,
+        plugin_mcp_inventory_ready: profile.plugin_mcp_inventory_ready === true,
+        artifact_path: profile.artifact_path || '.sneakoscope/reports/codex-app-execution-profile.json'
+    } : null;
+}
 function qaReportTemplate(mission, contract, checklist) {
     const a = contract.answers || {};
     return `# QA-LOOP Report\n\nMission: ${mission.id}\nTarget: ${a.TARGET_BASE_URL || 'unset'}\nScope: ${a.QA_SCOPE || 'unset'}\nEnvironment: ${a.TARGET_ENVIRONMENT || 'unset'}\n\n## Safety\n\n- Deployed destructive tests: never\n- Credentials: temp-only, never saved\n- UI evidence: ${CODEX_WEB_VERIFICATION_POLICY}\n\n## Checklist\n\n${checklist.map((item) => `- [ ] ${item.id}: ${item.title}`).join('\n')}\n\n## Findings\n\nTBD\n\n## Corrections And Rechecks\n\nTBD\n\n## Honest Mode\n\nTBD\n`;

package/dist/core/research/research-cycle-runner.js

@@ -63,6 +63,7 @@ export async function runResearchCycle(inputOrDir, legacyGraph = null, legacyOpt
         blockers: [...new Set(blockers)],
         stages: stageResults.map((stage) => stage.stage_id),
         stage_results: stageResults,
+        codex_app_execution_profile: input.plan?.codex_app_execution_profile || null,
         parallelism: {
             max_parallel_stages: maxParallel,
             max_observed_parallel: maxObservedParallel,

package/dist/core/research/research-stage-runner.js

@@ -91,7 +91,7 @@ async function runSourceShardStage(input, startedAt) {
         const validation = validateResearchSourceShardOutput(output);
         await writeJsonAtomic(path.join(input.dir, artifact), output);
         await writeTextAtomic(path.join(input.dir, 'research', `cycle-${input.cycle}`, 'source-notes', `${layer.id}.md`), `# Source shard: ${layer.label}\n\n${output.sources.map((source) => `- ${source.id}: ${source.title}`).join('\n')}\n`);
-        return baseResult(input, startedAt, 'source_shard', validation.ok ? 'passed' : 'blocked', [artifact, `research/cycle-${input.cycle}/source-notes/${layer.id}.md`], validation.blockers, { layer_id: layer.id, source_count: output.sources.length });
+        return baseResult(input, startedAt, 'source_shard', validation.ok ? 'passed' : 'blocked', [artifact, `research/cycle-${input.cycle}/source-notes/${layer.id}.md`], validation.blockers, { layer_id: layer.id, source_count: output.sources.length, source_tool_route: researchSourceToolRoute(input.plan) });
     }
     const codex = await runResearchCodexStage({
         root: input.root,
@@ -333,9 +333,16 @@ function baseResult(input, startedAt, stageKind, status, outputArtifacts, blocke
         backend: input.backend,
         worker_result_path: typeof metrics.worker_result_path === 'string' ? metrics.worker_result_path : null,
         blockers: [...new Set(blockers.map(String).filter(Boolean))],
-        metrics
+        metrics: {
+            ...metrics,
+            codex_app_execution_profile: input.plan?.codex_app_execution_profile || null,
+            source_tool_route: metrics.source_tool_route || researchSourceToolRoute(input.plan)
+        }
     };
 }
+function researchSourceToolRoute(plan) {
+    return plan?.web_research_policy?.source_tool_routing?.mode || (plan?.codex_app_execution_profile?.plugin_mcp_inventory_ready ? 'plugin-mcp-inventory-first' : 'codex-cli-or-web-fallback');
+}
 async function buildResearchGateSeed(dir, plan) {
     const sourceLedger = await readJson(path.join(dir, 'source-ledger.json'), null);
     const claimMatrix = await readJson(path.join(dir, 'claim-evidence-matrix.json'), null);

package/dist/core/research.js

@@ -17,6 +17,8 @@ import { writeResearchHandoffArtifacts } from './research/research-handoff.js';
 import { RESEARCH_WORK_GRAPH_ARTIFACT, writeResearchWorkGraph } from './research/research-work-graph.js';
 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';
@@ -252,6 +254,15 @@ export function createResearchPlan(prompt, opts = {}) {
     const createdAt = nowIso();
     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,
@@ -262,6 +273,8 @@ export function createResearchPlan(prompt, opts = {}) {
         paper_artifact: paperArtifact,
         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,
@@ -318,6 +331,13 @@ export function createResearchPlan(prompt, opts = {}) {
         web_research_policy: {
             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: sourceStrategy,
+                plugin_mcp_inventory_ready: executionProfile?.plugin_mcp_inventory_ready === true,
+                execution_profile_artifact: executionProfile?.artifact_path || '.sneakoscope/reports/codex-app-execution-profile.json',
+                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',
                 'plain-language explanations and empirical examples',
@@ -417,6 +437,9 @@ export function researchPlanMarkdown(plan) {
     lines.push(`Depth: ${plan.depth}`);
     lines.push(`Methodology: ${plan.methodology}`);
     lines.push(`Research paper: ${researchPaperArtifactForPlan(plan)}`);
+    if (plan.codex_app_execution_profile) {
+        lines.push(`Execution profile: ${plan.codex_app_execution_profile.mode}; agent role strategy ${plan.codex_app_execution_profile.agent_role_strategy}`);
+    }
     if (plan.execution_policy) {
         lines.push(`Execution: ${plan.execution_policy.normal_run}; default cycle timeout ${plan.execution_policy.default_cycle_timeout_minutes} minutes`);
         if (plan.execution_policy.default_max_cycles)
@@ -468,6 +491,8 @@ export function researchPlanMarkdown(plan) {
         lines.push('## Web Research Policy');
         lines.push(`Mode: ${plan.web_research_policy.mode}`);
         lines.push(`Requirement: ${plan.web_research_policy.requirement}`);
+        if (plan.web_research_policy.source_tool_routing)
+            lines.push(`Source tool routing: ${plan.web_research_policy.source_tool_routing.mode}`);
         for (const querySet of plan.web_research_policy.query_sets || [])
             lines.push(`- query set: ${querySet}`);
         if (plan.web_research_policy.skill_creator?.artifact)
@@ -537,7 +562,11 @@ export function countGeniusOpinionSummaries(text = '') {
     }).length;
 }
 export async function writeResearchPlan(dir, prompt, opts = {}) {
-    const plan = createResearchPlan(prompt, opts);
+    const root = opts.root || missionRootFromDir(String(dir || ''));
+    const executionProfile = opts.executionProfile || (root ? await resolveCodexAppExecutionProfile({ root }).catch(() => null) : null);
+    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: [],
@@ -553,6 +582,10 @@ export async function writeResearchPlan(dir, prompt, opts = {}) {
     const experimentPlan = defaultExperimentPlan(plan);
     const replicationPack = defaultReplicationPack(plan);
     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);
@@ -575,6 +608,40 @@ 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}`;
+    const idx = normalized.indexOf(marker);
+    return idx > 0 ? normalized.slice(0, idx) : null;
+}
+function compactExecutionProfile(profile) {
+    return profile ? {
+        mode: profile.mode || 'unknown',
+        agent_role_strategy: profile.agent_role_strategy || 'message-role',
+        hooks_approval_required: profile.hooks_approval_required === true,
+        hook_approval_state: profile.hook_approval_state || 'unknown',
+        plugin_mcp_inventory_ready: profile.plugin_mcp_inventory_ready === true,
+        artifact_path: profile.artifact_path || '.sneakoscope/reports/codex-app-execution-profile.json'
+    } : null;
+}
 export async function writeResearchNativeAgentLedger(dir, plan, opts = {}) {
     const missionId = opts.missionId || plan?.mission_id;
     if (!missionId)

package/dist/core/routes.js

@@ -30,7 +30,7 @@ export const FROM_CHAT_IMG_CHECKLIST_ARTIFACT = 'from-chat-img-checklist.md';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT = 'from-chat-img-temp-triwiki.json';
 export const FROM_CHAT_IMG_QA_LOOP_ARTIFACT = 'from-chat-img-qa-loop.json';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS = 5;
-export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|zellij|tmux|auto-review|team|qa-loop|ppt|image-ux-review|goal|fast-mode|research|db|git|codex|codex-app|hooks|features|all-features|openclaw|hermes|dfix|commit|commit-and-push|design|imagegen|dollar|context7|xai|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|wrongness|code-structure|proof-field|skill-dream|rust';
+export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|zellij|tmux|auto-review|team|qa-loop|ppt|image-ux-review|goal|fast-mode|research|db|git|codex|codex-app|codex-native|hooks|features|all-features|dfix|commit|commit-and-push|design|imagegen|dollar|context7|xai|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|wrongness|code-structure|proof-field|skill-dream|rust';
 export const CODEX_COMPUTER_USE_EVIDENCE_SOURCE = 'codex_computer_use';
 export const CODEX_WEB_VERIFICATION_EVIDENCE_SOURCE = 'codex_chrome_extension';
 export const CODEX_IMAGEGEN_EVIDENCE_SOURCE = 'codex_app_imagegen_gpt_image_2';
@@ -633,11 +633,10 @@ export const COMMAND_CATALOG = [
     { name: 'deps', usage: 'sks deps check [--json] [--yes]', description: 'Check Node/npm, Codex CLI, and Zellij readiness; pass --yes to repair missing Codex CLI/Zellij tooling when supported.' },
     { name: 'codex', usage: 'sks codex compatibility|version|doctor|schema [--json]', description: 'Check Codex CLI rust-v0.136.0 compatibility, installed version, 0.136 capabilities, inherited 0.135/0.134/0.133 behavior, and vendored hook schema snapshot freshness.' },
     { name: 'codex-app', usage: 'sks codex-app [check|product-design|product-design --check-only|ensure-product-design|chrome-extension|pat status|remote-control]', description: 'Check Codex App install, Product Design plugin auto-install readiness, Codex Chrome Extension web verification readiness, PAT-safe status, first-party MCP/plugin readiness, and Codex CLI 0.130.0+ remote-control availability.' },
+    { name: 'codex-native', usage: 'sks codex-native status|feature-broker|invocation-plan|init-deep [--json]', description: 'Inspect Codex Native feature broker readiness, invocation routing, pattern evidence, and managed memory setup.' },
     { name: 'hooks', usage: 'sks hooks explain|status|trust-report|replay|codex-validate|warning-check ... [--json]', description: 'Explain Codex hook events, validate vendored latest 10-event output schemas, replay fixtures, and enforce warning-zero SKS hook policies under the 0.134 compatibility matrix.' },
     { name: 'codex-lb', usage: 'sks codex-lb status|health|metrics|doctor|circuit|repair|setup ...', description: 'Configure, health-check, repair, and record circuit evidence for codex-lb provider auth without confusing ChatGPT OAuth and proxy keys.' },
     { name: 'auth', usage: 'sks auth status|health|repair|setup --host <domain> --api-key <key>', description: 'Shortcut for codex-lb provider auth status, health, repair, and setup commands.' },
-    { name: 'openclaw', usage: 'sks openclaw install|path|print [--dir path] [--force] [--json]', description: 'Generate an OpenClaw skill package so OpenClaw agents can discover and use local SKS workflows.' },
-    { name: 'hermes', usage: 'sks hermes install|status|path|print [--dir path] [--force] [--json]', description: 'Generate a Hermes Agent skill package so Hermes agents can discover and use local SKS workflows.' },
     { name: 'zellij', usage: 'sks zellij status|repair [--json] | sks naruto dashboard latest | sks --mad', description: 'Inspect Zellij runtime status, explain repair (no auto-install), and open the SKS Zellij runtime used by MAD and Naruto lane UI.' },
     { name: 'tmux', usage: 'sks tmux [--json]', description: 'Show the removed-runtime migration notice and point operators to Zellij.' },
     { name: 'mad', usage: 'sks --mad [--high]', description: 'Open a one-shot Zellij Codex CLI workspace with the SKS MAD full-access auto-review profile.' },

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '3.1.4';
+export const PACKAGE_VERSION = '3.1.6';
 //# sourceMappingURL=version.js.map

package/dist/core/zellij/homebrew-policy.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import readline from 'node:readline';
 export const HOMEBREW_INSTALL_COMMAND = '/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"';
 export function resolveHomebrewInstallPolicy(input = {}) {

package/dist/core/zellij/zellij-self-heal-types.js

@@ -0,0 +1,45 @@
+import { nowIso } from '../fsx.js';
+export function isZellijSelfHealResult(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const row = value;
+    return row.schema === 'sks.zellij-self-heal.v1'
+        && typeof row.ok === 'boolean'
+        && typeof row.requested_by === 'string'
+        && typeof row.strategy === 'string'
+        && row.before !== null
+        && typeof row.before === 'object'
+        && row.after !== null
+        && typeof row.after === 'object'
+        && Array.isArray(row.blockers)
+        && Array.isArray(row.warnings);
+}
+export function normalizeZellijSelfHealResult(value) {
+    if (isZellijSelfHealResult(value)) {
+        return {
+            ...value,
+            dry_run: value.dry_run === true,
+            planned_mutations: Array.isArray(value.planned_mutations) ? value.planned_mutations : []
+        };
+    }
+    return {
+        schema: 'sks.zellij-self-heal.v1',
+        ok: false,
+        requested_by: 'setup',
+        fix_requested: false,
+        auto_approved: false,
+        install_homebrew_allowed: false,
+        dry_run: false,
+        planned_mutations: [],
+        before: { status: 'unknown', version: null, bin: null },
+        latest_version: null,
+        strategy: 'failed',
+        command: null,
+        after: { status: 'unknown', version: null, bin: null },
+        mutation_guard_artifact: null,
+        homebrew: { present: false, bin: null, install_attempted: false, install_allowed: false },
+        blockers: ['invalid_zellij_self_heal_result'],
+        warnings: [`normalized_at:${nowIso()}`]
+    };
+}
+//# sourceMappingURL=zellij-self-heal-types.js.map

package/dist/core/zellij/zellij-self-heal.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { ensureDir, nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
@@ -12,6 +11,7 @@ export async function repairZellijForSks(input) {
     const root = path.resolve(input.root || process.cwd());
     const env = input.env || process.env;
     const autoApproved = input.autoApprove === true;
+    const dryRun = input.dryRun === true;
     const beforeReport = await capabilitySnapshot(root, env, 'before');
     const before = compactCapability(beforeReport);
     const latest = await latestZellijVersion(env);
@@ -41,6 +41,9 @@ export async function repairZellijForSks(input) {
     if (input.fixRequested !== true) {
         return manualResult(root, input, env, before, latest, brew, 'fix_not_requested');
     }
+    if (dryRun) {
+        return dryRunResult(root, input, env, before, latest, brew, mutationArtifact);
+    }
     if (!autoApproved && input.interactive !== true) {
         return input.allowHeadlessFallback === true
             ? headlessResult(root, input, before, latest, brew, 'noninteractive_without_auto_approval')
@@ -183,10 +186,10 @@ async function capabilitySnapshot(root, env, phase, fallbackVersion) {
         require_zellij: false,
         min_version: ZELLIJ_MIN_VERSION,
         version: null,
-        bin: null,
+        bin: 'zellij',
         command: ['zellij', '--version'],
         docs_evidence: [],
-        blockers: [`zellij_capability_check_failed:${tail(err?.message || String(err))}`],
+        blockers: [`zellij_capability_check_failed:${tail(errorMessage(err))}`],
         warnings: [],
         operator_actions: ['Resolve the Zellij capability check failure, then rerun `sks doctor --fix --yes`.']
     }));
@@ -261,7 +264,7 @@ async function runZellijBrew(root, env, brewBin, args, command) {
         env,
         timeoutMs: 180000,
         maxOutputBytes: 256 * 1024
-    }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
+    }).catch((err) => ({ code: 1, stdout: '', stderr: errorMessage(err) }));
 }
 async function runHomebrewInstall(root, env) {
     if (env.SKS_ZELLIJ_SELF_HEAL_FAKE_RUN === '1') {
@@ -281,7 +284,7 @@ async function runHomebrewInstall(root, env) {
         env,
         timeoutMs: 600000,
         maxOutputBytes: 256 * 1024
-    }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
+    }).catch((err) => ({ code: 1, stdout: '', stderr: errorMessage(err) }));
 }
 async function appendFakeBrewLog(env, args) {
     if (!env.SKS_FAKE_BREW_LOG)
@@ -289,6 +292,56 @@ async function appendFakeBrewLog(env, args) {
     await ensureDir(path.dirname(env.SKS_FAKE_BREW_LOG));
     await fs.appendFile(env.SKS_FAKE_BREW_LOG, `${args.join(' ')}\n`, 'utf8');
 }
+async function dryRunResult(root, input, env, before, latest, brew, mutationArtifact) {
+    const policy = !brew.present
+        ? resolveHomebrewInstallPolicy({
+            env,
+            installHomebrew: input.installHomebrew === true,
+            autoApprove: input.autoApprove === true,
+            interactiveAccepted: false
+        })
+        : null;
+    if (!brew.present && policy?.allowed !== true) {
+        return input.allowHeadlessFallback === true
+            ? headlessResult(root, input, before, latest, brew, policy?.blockers[0] || 'homebrew_missing')
+            : manualResult(root, input, env, before, latest, brew, policy?.blockers[0] || 'homebrew_missing');
+    }
+    const planned = [];
+    if (!brew.present) {
+        planned.push({
+            command: HOMEBREW_INSTALL_COMMAND,
+            reason: 'homebrew_missing_for_zellij_repair'
+        });
+    }
+    const install = before.status === 'missing';
+    const zellijCommand = install ? 'brew install zellij' : 'brew upgrade zellij';
+    planned.push({
+        command: zellijCommand,
+        reason: install ? 'zellij_missing' : 'zellij_too_old_or_stale'
+    });
+    const strategy = !brew.present ? 'brew-install-homebrew-then-zellij'
+        : install ? 'brew-install-zellij'
+            : 'brew-upgrade-zellij';
+    return persistSelfHeal(root, input.missionDir, {
+        schema: 'sks.zellij-self-heal.v1',
+        ok: true,
+        requested_by: input.requestedBy,
+        fix_requested: true,
+        auto_approved: input.autoApprove === true,
+        install_homebrew_allowed: policy?.allowed === true,
+        dry_run: true,
+        planned_mutations: planned,
+        before,
+        latest_version: latest,
+        strategy,
+        command: planned.map((row) => row.command).join(' && '),
+        after: before,
+        mutation_guard_artifact: `${mutationArtifact}#planned`,
+        homebrew: { present: brew.present, bin: brew.bin, install_attempted: false, install_allowed: policy?.allowed === true },
+        blockers: [],
+        warnings: ['dry_run_no_mutation_performed']
+    });
+}
 async function manualResult(root, input, env, before, latest, brew, reason) {
     const command = brew.present ? 'sks doctor --fix --yes' : 'sks doctor --fix --install-homebrew --yes';
     return persistSelfHeal(root, input.missionDir, {
@@ -329,10 +382,15 @@ async function headlessResult(root, input, before, latest, brew, reason) {
     });
 }
 async function persistSelfHeal(root, missionDir, result) {
-    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'zellij-self-heal.json'), result).catch(() => undefined);
+    const normalized = {
+        ...result,
+        dry_run: result.dry_run === true,
+        planned_mutations: result.planned_mutations || []
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'zellij-self-heal.json'), normalized).catch(() => undefined);
     if (missionDir)
-        await writeJsonAtomic(path.join(missionDir, 'zellij-self-heal.json'), result).catch(() => undefined);
-    return result;
+        await writeJsonAtomic(path.join(missionDir, 'zellij-self-heal.json'), normalized).catch(() => undefined);
+    return normalized;
 }
 async function askZellijRepairAllowed(question) {
     if (!(process.stdin.isTTY && process.stdout.isTTY))
@@ -347,6 +405,9 @@ async function askZellijRepairAllowed(question) {
         rl.close();
     }
 }
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
 function tail(value, limit = 1000) {
     return String(value || '').replace(/\s+/g, ' ').trim().slice(-limit);
 }

package/dist/core/zellij/zellij-update.js

@@ -232,17 +232,25 @@ export async function maybePromptZellijUpdateForLaunch(args = [], opts = {}) {
                 interactive: mode === 'interactive-prompt',
                 installHomebrew: opts.installHomebrew === true || list.includes('--install-homebrew'),
                 allowHeadlessFallback: opts.allowHeadlessFallback === true,
+                dryRun: opts.dryRun === true || list.includes('--dry-run'),
                 missionDir: opts.missionDir || null,
                 env
             });
             if (repaired.strategy === 'headless-fallback')
                 console.log('Zellij repair: headless fallback selected (live_panes=false).');
+            else if (repaired.dry_run)
+                console.log(`Zellij repair: dry_run planned ${repaired.command || 'none'}`);
             else if (repaired.ok && repaired.command)
                 console.log(`Zellij repair: ${repaired.strategy} via ${repaired.command}`);
             else if (!repaired.ok)
                 console.log(`Zellij repair required. Run: ${repaired.command || notice.upgrade_command}`);
+            const repairedStatus = repaired.strategy === 'headless-fallback' ? 'headless_fallback'
+                : !repaired.ok || repaired.strategy === 'manual-required' ? 'repair_required'
+                    : repaired.strategy === 'brew-upgrade-zellij' ? 'upgraded'
+                        : repaired.strategy === 'none-current' ? 'noop'
+                            : 'installed';
             return {
-                status: repaired.ok ? (repaired.strategy === 'headless-fallback' ? 'missing' : 'installed') : 'manual_required',
+                status: repairedStatus,
                 current: repaired.after.version || repaired.before.version,
                 latest: repaired.latest_version,
                 command: repaired.command,

package/dist/scripts/sks-3-1-4-directive-check-lib.js

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
-// @ts-nocheck
 import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { spawnSync } from 'node:child_process';
 import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
 export async function runDirective314Gate(id) {
     if (id.startsWith('zellij:'))
@@ -13,14 +11,10 @@ export async function runDirective314Gate(id) {
         return doctorZellijGate(id);
     if (id.startsWith('mad:zellij'))
         return madZellijGate(id);
-    if (id === 'lazycodex:analysis')
-        return lazycodexAnalysisGate(id);
     if (id.startsWith('codex-app:') || id === 'doctor:codex-app-harness')
         return codexAppGate(id);
     if (id.startsWith('loop:'))
         return loopGate(id);
-    if (id === 'lazycodex:interop-policy' || id === 'lazycodex:pattern-adoption-blackbox')
-        return lazycodexInteropGate(id);
     throw new Error(`unknown_gate:${id}`);
 }
 async function zellijGate(id) {
@@ -97,14 +91,6 @@ async function madZellijGate(id) {
     }
     emitGate(id, { source_checked: true });
 }
-async function lazycodexAnalysisGate(id) {
-    const mod = await importDist('core/codex-app/lazycodex-analysis.js');
-    const report = await mod.writeLazyCodexPatternAnalysis(root);
-    assertGate(report.patterns.length >= 14, 'LazyCodex analysis must include required patterns', report);
-    const docs = mod.renderLazyCodexAnalysisMarkdown(report);
-    await fsp.writeFile(path.join(root, 'docs', 'lazycodex-analysis.md'), `${docs}\n`, 'utf8');
-    emitGate(id, { patterns: report.patterns.length });
-}
 async function codexAppGate(id) {
     const rootDir = await tempRoot(`sks-${id.replace(/[:/]/g, '-')}-`);
     const previous = swapEnv({
@@ -131,7 +117,7 @@ async function codexAppGate(id) {
             const skillsRoot = path.join(rootDir, 'skills');
             await fsp.mkdir(path.join(skillsRoot, 'ulw-loop'), { recursive: true });
             const report = await mod.syncCodexSksSkills({ root: rootDir, skillsRoot, apply: true });
-            assertGate(report.interop.clobbered_lazycodex === false && report.lazycodex_reserved_present.includes('ulw-loop'), 'skill sync must preserve LazyCodex skills', report);
+            assertGate(report.interop.clobbered_external_routes === false && report.external_route_names_preserved.includes('ulw-loop'), 'skill sync must preserve existing external route skills', report);
             return emitGate(id, { desired: report.desired_skills.length });
         }
         if (id === 'codex-app:agent-role-sync') {
@@ -185,21 +171,6 @@ async function loopGate(id) {
     assertGate(report.should_continue === true, 'loop continuation should request resume when proof missing', report);
     emitGate(id, { should_continue: report.should_continue });
 }
-async function lazycodexInteropGate(id) {
-    const rootDir = await tempRoot(`sks-${id.replace(/[:/]/g, '-')}-`);
-    const previous = swapEnv({ SKS_CODEX_PLUGIN_JSON_FAKE: '1' });
-    try {
-        const mod = await importDist('core/codex-app/lazycodex-interop-policy.js');
-        const skillsRoot = path.join(rootDir, '.codex', 'skills');
-        await fsp.mkdir(path.join(skillsRoot, 'start-work'), { recursive: true });
-        const report = await mod.buildLazyCodexInteropPolicy({ root: rootDir, codexHome: path.join(rootDir, '.codex') });
-        assertGate(report.policy.clobber_lazycodex_skills === false, 'interop policy must not clobber LazyCodex skills', report);
-        emitGate(id, { detected: report.lazycodex_detected, collisions: report.detection.collisions.length });
-    }
-    finally {
-        restoreEnv(previous);
-    }
-}
 function fakeZellijEnv(status, opts = {}) {
     return {
         ...process.env,