sneakoscope 3.1.3 → 3.1.5

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
     };
 }

package/dist/core/qa-loop.js

@@ -2,6 +2,7 @@ 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';
 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 +321,10 @@ 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,
         api_e2e_required: apiRequired,
         unsafe_external_side_effects: false,
         corrective_loop_enabled: corrective,
@@ -338,16 +343,21 @@ 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;
+    if (executionProfile)
+        await writeJsonAtomic(path.join(dir, 'qa-loop', 'execution-profile.json'), executionProfile).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,
         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 }));
     await writeTextAtomic(path.join(dir, reportFile), qaReportTemplate(mission, contract, checklist));
     return { checklist_count: checklist.length, report_file: reportFile };
 }
@@ -432,6 +442,10 @@ 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,
         blockers: previousGate.blockers || [],
         passed: !uiRequired,
         qa_report_written: true,
@@ -453,7 +467,7 @@ export async function writeMockQaResult(dir, mission, contract) {
     });
     return evaluateQaGate(dir);
 }
-export function buildQaLoopPrompt({ id, mission, contract, cycle, previous, reportFile, imagePathContract, appHandoff }) {
+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 +475,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 +490,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 +503,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 +522,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,7 @@ 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';
 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 +253,7 @@ 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;
     return {
         schema_version: 1,
         mission_id: opts.missionId || null,
@@ -262,6 +264,7 @@ 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,
         agent_sessions: nativeAgentPlan.personas,
         agent_batches: nativeAgentPlan.batches,
         autoresearch_cycle_policy: nativeAgentPlan.autoresearch_cycle_policy,
@@ -318,6 +321,12 @@ 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: executionProfile?.plugin_mcp_inventory_ready ? 'plugin-mcp-inventory-first' : 'codex-cli-or-web-fallback',
+                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.'
+            },
             query_sets: [
                 'first-principles and theory sources',
                 'plain-language explanations and empirical examples',
@@ -417,6 +426,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 +480,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 +551,9 @@ 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 plan = createResearchPlan(prompt, { ...opts, executionProfile });
     const noveltyLedger = {
         schema_version: 1,
         entries: [],
@@ -553,6 +569,8 @@ 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);
     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 +593,22 @@ 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;
 }
+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/version.js

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

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

@@ -0,0 +1,44 @@
+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 = {}) {
+    const args = (input.args || []).map(String);
+    const env = input.env || process.env;
+    const hasFlag = input.installHomebrew === true || args.includes('--install-homebrew');
+    const hasYes = input.autoApprove === true || args.includes('--yes') || args.includes('-y');
+    const envAllowed = env.SKS_ALLOW_HOMEBREW_INSTALL === '1';
+    const interactiveAccepted = input.interactiveAccepted === true;
+    const allowed = envAllowed || interactiveAccepted || (hasFlag && hasYes);
+    const source = envAllowed ? 'env'
+        : interactiveAccepted ? 'interactive_confirmed'
+            : hasFlag && hasYes ? 'yes_install_homebrew'
+                : hasFlag ? 'flag'
+                    : 'not_allowed';
+    return {
+        schema: 'sks.homebrew-policy.v1',
+        allowed,
+        source,
+        install_command: HOMEBREW_INSTALL_COMMAND,
+        blockers: allowed ? [] : ['homebrew_install_requires_explicit_approval']
+    };
+}
+export function homebrewMissingDoctorMessage() {
+    return [
+        'Zellij repair: Homebrew missing. Run:',
+        '  sks doctor --fix --install-homebrew --yes',
+        'or install Homebrew manually, then:',
+        '  sks doctor --fix --yes'
+    ].join('\n');
+}
+export async function askHomebrewInstallAllowed(question = 'Homebrew is missing. Install Homebrew now? [y/N] ') {
+    if (!(process.stdin.isTTY && process.stdout.isTTY))
+        return false;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await new Promise((resolve) => rl.question(question, resolve));
+        return /^(y|yes|예|네|응)$/i.test(String(answer || '').trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+//# sourceMappingURL=homebrew-policy.js.map

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

@@ -30,7 +30,10 @@ export function resolveZellijStackedPaneCapability(input = {}) {
     };
 }
 export async function checkZellijStackedPaneCapability(opts = {}) {
-    const versionRun = await runZellij(['--version'], { optional: true, timeoutMs: 5000 });
+    const runOpts = { optional: true, timeoutMs: 5000 };
+    if (opts.env !== undefined)
+        runOpts.env = opts.env;
+    const versionRun = await runZellij(['--version'], runOpts);
     const versionText = `${versionRun.stdout_tail}\n${versionRun.stderr_tail}`.trim();
     const report = resolveZellijStackedPaneCapability({
         ok: versionRun.ok,
@@ -45,8 +48,34 @@ export async function checkZellijStackedPaneCapability(opts = {}) {
     return report;
 }
 export async function checkZellijCapability(opts = {}) {
-    const requireZellij = opts.require === true || process.env.SKS_REQUIRE_ZELLIJ === '1';
-    const versionRun = await runZellij(['--version'], { optional: !requireZellij, timeoutMs: 5000 });
+    const env = opts.env || process.env;
+    const requireZellij = opts.require === true || env.SKS_REQUIRE_ZELLIJ === '1';
+    if (env.SKS_ZELLIJ_CAPABILITY_FAKE_STATUS) {
+        const fakeStatus = String(env.SKS_ZELLIJ_CAPABILITY_FAKE_STATUS);
+        const status = fakeStatus === 'ok' || fakeStatus === 'missing' || fakeStatus === 'too_old' || fakeStatus === 'blocked' ? fakeStatus : 'blocked';
+        const report = {
+            schema: ZELLIJ_CAPABILITY_SCHEMA,
+            generated_at: nowIso(),
+            ok: status === 'ok',
+            status,
+            integration_optional: !requireZellij,
+            require_zellij: requireZellij,
+            min_version: ZELLIJ_MIN_VERSION,
+            version: status === 'missing' ? null : String(env.SKS_ZELLIJ_CAPABILITY_FAKE_VERSION || '0.40.0'),
+            bin: 'zellij',
+            command: ['zellij', '--version'],
+            docs_evidence: [],
+            blockers: requireZellij && status !== 'ok' ? [`zellij_${status}_required`] : [],
+            warnings: !requireZellij && status !== 'ok' ? [`zellij_${status}_optional_integration`] : [],
+            operator_actions: status === 'ok' ? [] : ['Install Zellij. On macOS: `brew install zellij`.']
+        };
+        if (opts.writeReport !== false) {
+            const root = opts.root || process.cwd();
+            await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'zellij-capability.json'), report);
+        }
+        return report;
+    }
+    const versionRun = await runZellij(['--version'], { optional: !requireZellij, timeoutMs: 5000, env });
     const versionText = `${versionRun.stdout_tail}\n${versionRun.stderr_tail}`.trim();
     const version = parseZellijVersionText(versionText);
     const missing = !versionRun.ok && versionRun.blockers.includes('zellij_missing');

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