sneakoscope 6.4.0 → 6.7.0

package/dist/core/codex-control/codex-task-runner.js

@@ -19,6 +19,7 @@ import { runLocalLlmTask } from '../local-llm/local-llm-control-adapter.js';
 import { detectPythonCodexSdkCapability, runPythonCodexSdkTask } from './python-codex-sdk-adapter.js';
 import { defaultModelCallBudget, withModelCallSlot } from './model-call-concurrency.js';
 import { inspectCodexLbSdkLaunchRecovery } from './codex-lb-launch-recovery.js';
+import { prepareNativeCodexAuthBridge } from './codex-sdk-env-policy.js';
 export async function runCodexTask(input) {
     const root = path.resolve(input.mutationLedgerRoot);
     await ensureDir(root);
@@ -41,6 +42,12 @@ export async function runCodexTask(input) {
         await ensureDir(runtime.env.env.HOME);
     if (runtime.env.env.CODEX_HOME)
         await ensureDir(runtime.env.env.CODEX_HOME);
+    const fakeAllowed = fakeCodexSdkAllowed();
+    const nativeCodexAuthBridge = await prepareNativeCodexAuthBridge(runtime.env.env, { required: !fakeAllowed });
+    if (nativeCodexAuthBridge.ok) {
+        runtime.env.proof.home = runtime.env.env.HOME;
+        runtime.env.proof.codex_home = runtime.env.env.CODEX_HOME;
+    }
     const codexLbToolOutputRecovery = await inspectCodexLbSdkLaunchRecovery({
         config: runtime.config,
         env: runtime.env.env,
@@ -48,44 +55,50 @@ export async function runCodexTask(input) {
     });
     if (codexLbToolOutputRecovery.ok)
         await ensurePythonCodexLbConfig(runtime.env.env, runtime.config);
-    const fakeAllowed = fakeCodexSdkAllowed();
     const blockers = [
         ...(capability.ok || fakeAllowed ? [] : capability.blockers),
         ...(sandbox.ok ? [] : sandbox.blockers),
+        ...(nativeCodexAuthBridge.ok ? [] : nativeCodexAuthBridge.blockers),
         ...(codexLbToolOutputRecovery.ok ? [] : codexLbToolOutputRecovery.blockers)
     ];
     let adapterResult = null;
-    if (!blockers.length) {
-        adapterResult = await withModelCallSlot({
-            root,
-            missionId: task.missionId,
-            provider: 'codex-sdk',
-            budget: defaultModelCallBudget('codex-sdk'),
-            slotId: task.slotId || null,
-            generationIndex: task.generationIndex ?? null,
-            sessionId: task.sessionId || null,
-            backend: 'codex-sdk'
-        }, () => runWithCodexReliabilityShield(task, async (_attempt, controls) => {
-            try {
-                const attemptTask = controls?.noMcp
-                    ? { ...task, requestedScopeContract: { ...task.requestedScopeContract, no_mcp: true } }
-                    : task;
-                return fakeAllowed
-                    ? await runFakeCodexSdkTask(attemptTask)
-                    : await runRealCodexSdkTask(attemptTask, { sandboxMode: sandbox.sandboxMode, env: runtime.env.env, config: { ...runtime.config, mcp_servers: {} } });
-            }
-            catch (err) {
-                return {
-                    ok: false,
-                    sdkThreadId: '',
-                    sdkRunId: null,
-                    events: [],
-                    finalResponse: '',
-                    structuredOutput: null,
-                    blockers: ['codex_sdk_run_failed:' + String(err?.message || err)]
-                };
-            }
-        }));
+    let nativeAuthCleanupBlockers = [];
+    try {
+        if (!blockers.length) {
+            adapterResult = await withModelCallSlot({
+                root,
+                missionId: task.missionId,
+                provider: 'codex-sdk',
+                budget: defaultModelCallBudget('codex-sdk'),
+                slotId: task.slotId || null,
+                generationIndex: task.generationIndex ?? null,
+                sessionId: task.sessionId || null,
+                backend: 'codex-sdk'
+            }, () => runWithCodexReliabilityShield(task, async (_attempt, controls) => {
+                try {
+                    const attemptTask = controls?.noMcp
+                        ? { ...task, requestedScopeContract: { ...task.requestedScopeContract, no_mcp: true } }
+                        : task;
+                    return fakeAllowed
+                        ? await runFakeCodexSdkTask(attemptTask)
+                        : await runRealCodexSdkTask(attemptTask, { sandboxMode: sandbox.sandboxMode, env: runtime.env.env, config: { ...runtime.config, mcp_servers: {} } });
+                }
+                catch (err) {
+                    return {
+                        ok: false,
+                        sdkThreadId: '',
+                        sdkRunId: null,
+                        events: [],
+                        finalResponse: '',
+                        structuredOutput: null,
+                        blockers: ['codex_sdk_run_failed:' + String(err?.message || err)]
+                    };
+                }
+            }));
+        }
+    }
+    finally {
+        nativeAuthCleanupBlockers = await cleanupNativeCodexAuthBridge(nativeCodexAuthBridge);
     }
     const events = Array.isArray(adapterResult?.events) ? adapterResult.events : [];
     const translatedEvents = translateCodexSdkEvents(events);
@@ -99,6 +112,7 @@ export async function runCodexTask(input) {
     const validation = structuredOutput ? validateJsonSchemaRecursive(structuredOutput, schema) : { ok: false, issues: ['structured_output_missing'] };
     const primaryBlockers = [
         ...blockers,
+        ...nativeAuthCleanupBlockers,
         ...(adapterResult?.blockers || []),
         ...codexControlAdapterFailureBlockers(adapterResult, 'codex-sdk')
     ];
@@ -133,6 +147,7 @@ export async function runCodexTask(input) {
         backend_family: fakeAllowed ? 'fake' : 'remote-gpt',
         sdkThreadId: String(adapterResult?.sdkThreadId || ''),
         sdkRunId: adapterResult?.sdkRunId ? String(adapterResult.sdkRunId) : null,
+        runtimeIdentity: adapterResult?.runtimeIdentity || null,
         streamEventCount: events.length,
         structuredOutputValid: validation.ok,
         workerResultPath,
@@ -174,6 +189,7 @@ export async function runCodexTask(input) {
             ...runtime.env.proof,
             capacity_fallback_selected: result.capacityFallback === true,
             model_capacity_retry_count: result.modelCapacityRetryCount,
+            native_codex_auth_bridge: nativeCodexAuthBridge.proof,
             codex_lb_tool_output_recovery: codexLbToolOutputRecovery
         },
         config: runtime.config,
@@ -190,36 +206,49 @@ async function runPythonControlTask(root, task, schema, routerDecision) {
         await ensureDir(runtime.env.env.HOME);
     if (runtime.env.env.CODEX_HOME)
         await ensureDir(runtime.env.env.CODEX_HOME);
+    const fakeAllowed = process.env.SKS_PYTHON_CODEX_SDK_FAKE === '1';
+    const nativeCodexAuthBridge = await prepareNativeCodexAuthBridge(runtime.env.env, { required: !fakeAllowed });
+    if (nativeCodexAuthBridge.ok) {
+        runtime.env.proof.home = runtime.env.env.HOME;
+        runtime.env.proof.codex_home = runtime.env.env.CODEX_HOME;
+    }
     const codexLbToolOutputRecovery = await inspectCodexLbSdkLaunchRecovery({
         config: runtime.config,
         env: runtime.env.env,
         overrideEnv: process.env
     });
-    const fakeAllowed = process.env.SKS_PYTHON_CODEX_SDK_FAKE === '1';
-    const adapterResult = codexLbToolOutputRecovery.ok && (capability.ok || fakeAllowed)
-        ? await withModelCallSlot({
-            root,
-            missionId: task.missionId,
-            provider: 'python-codex-sdk',
-            budget: defaultModelCallBudget('python-codex-sdk'),
-            slotId: task.slotId || null,
-            generationIndex: task.generationIndex ?? null,
-            sessionId: task.sessionId || null,
-            backend: 'python-codex-sdk'
-        }, () => runPythonCodexSdkTask(task, { env: runtime.env.env, config: runtime.config }))
-        : {
-            ok: false,
-            events: [],
-            translatedEvents: [],
-            finalResponse: '',
-            threadId: '',
-            turnId: '',
-            blockers: [
-                ...(codexLbToolOutputRecovery.ok ? [] : codexLbToolOutputRecovery.blockers),
-                ...(capability.ok || fakeAllowed ? [] : capability.blockers)
-            ],
-            capability
-        };
+    let adapterResult;
+    let nativeAuthCleanupBlockers = [];
+    try {
+        adapterResult = codexLbToolOutputRecovery.ok && nativeCodexAuthBridge.ok && (capability.ok || fakeAllowed)
+            ? await withModelCallSlot({
+                root,
+                missionId: task.missionId,
+                provider: 'python-codex-sdk',
+                budget: defaultModelCallBudget('python-codex-sdk'),
+                slotId: task.slotId || null,
+                generationIndex: task.generationIndex ?? null,
+                sessionId: task.sessionId || null,
+                backend: 'python-codex-sdk'
+            }, () => runPythonCodexSdkTask(task, { env: runtime.env.env, config: runtime.config }))
+            : {
+                ok: false,
+                events: [],
+                translatedEvents: [],
+                finalResponse: '',
+                threadId: '',
+                turnId: '',
+                blockers: [
+                    ...(codexLbToolOutputRecovery.ok ? [] : codexLbToolOutputRecovery.blockers),
+                    ...(nativeCodexAuthBridge.ok ? [] : nativeCodexAuthBridge.blockers),
+                    ...(capability.ok || fakeAllowed ? [] : capability.blockers)
+                ],
+                capability
+            };
+    }
+    finally {
+        nativeAuthCleanupBlockers = await cleanupNativeCodexAuthBridge(nativeCodexAuthBridge);
+    }
     const events = Array.isArray(adapterResult.events) ? adapterResult.events : [];
     const translatedEvents = Array.isArray(adapterResult.translatedEvents) ? adapterResult.translatedEvents : [];
     for (const event of translatedEvents)
@@ -227,6 +256,7 @@ async function runPythonControlTask(root, task, schema, routerDecision) {
     const structuredOutput = parseStructuredOutput(adapterResult.finalResponse || '');
     const validation = structuredOutput ? validateJsonSchemaRecursive(structuredOutput, schema) : { ok: false, issues: ['structured_output_missing'] };
     const primaryBlockers = [
+        ...nativeAuthCleanupBlockers,
         ...(adapterResult.blockers || []),
         ...codexControlAdapterFailureBlockers(adapterResult, 'python-codex-sdk')
     ];
@@ -268,6 +298,7 @@ async function runPythonControlTask(root, task, schema, routerDecision) {
         stream_event_count: events.length,
         structured_output_valid: validation.ok,
         worker_result_path: workerResultPath,
+        native_codex_auth_bridge: nativeCodexAuthBridge.proof,
         codex_lb_tool_output_recovery: codexLbToolOutputRecovery,
         blockers: finalBlockers
     });
@@ -317,6 +348,7 @@ async function runPythonControlTask(root, task, schema, routerDecision) {
             ...runtime.env.proof,
             python_bin: capability.python_bin,
             python_version: capability.python_version,
+            native_codex_auth_bridge: nativeCodexAuthBridge.proof,
             codex_lb_tool_output_recovery: codexLbToolOutputRecovery
         },
         config: { ...runtime.config, backend: 'python-codex-sdk', package_name: capability.package_name, import_name: capability.import_name },
@@ -326,6 +358,27 @@ async function runPythonControlTask(root, task, schema, routerDecision) {
     });
     return result;
 }
+async function cleanupNativeCodexAuthBridge(bridge) {
+    const proof = bridge.proof;
+    try {
+        const cleanup = await bridge.cleanup();
+        proof.cleanup_required = cleanup.cleanup_required;
+        proof.cleanup_status = cleanup.status;
+        proof.cleanup_outcome = cleanup.outcome;
+        if (!cleanup.ok) {
+            proof.cleanup_blockers = cleanup.blockers;
+            return cleanup.blockers;
+        }
+        return [];
+    }
+    catch (error) {
+        const blocker = `native_codex_auth_cleanup_failed:${String(error?.message || error)}`;
+        proof.cleanup_required = true;
+        proof.cleanup_status = 'failed';
+        proof.cleanup_blockers = [blocker];
+        return [blocker];
+    }
+}
 async function runLocalControlTask(root, task, schema, routerDecision) {
     const config = await readLocalModelConfig();
     const adapterResult = await withModelCallSlot({
@@ -489,6 +542,8 @@ function isRunFailureBlocker(blockers) {
             || text.startsWith('python_codex_sdk_run_failed')
             || text.startsWith('python_codex_sdk_timeout')
             || text.startsWith('python_codex_sdk_error')
+            || text.startsWith('native_codex_auth_bridge_failed')
+            || text.startsWith('native_codex_auth_cleanup_failed')
             || text.startsWith('local_llm_generate_failed')
             || text.startsWith('local_llm_eligibility_blocked')
             || text.startsWith('codex_lb_tool_output_recovery_')

package/dist/core/codex-control/gpt-final-arbiter.js

@@ -147,8 +147,7 @@ function buildArbiterPrompt(input, compressed) {
         'You are the GPT Final Arbiter for an SKS local collaboration run.',
         'Local model outputs are drafts only. Review the proof pack, candidate diff, patch envelopes, verification results, side effects, mutation ledger, and rollback plan.',
         leanEngineeringCompactText(),
-        'Lean review: check for reused helpers before reimplementation, unjustified dependencies, one-implementation factories/interfaces, hidden mock or provider fallbacks, duplicated caller guards instead of root-cause fixes, forwarding-only files, missing runnable checks for non-trivial logic, and safety/validation removal disguised as simplification.',
-        'Approve or modify only when the candidate is safe, supported, and no more complex than the request requires. Reject unsafe local patches. Return only the requested structured JSON schema.',
+        'Judge the candidate against that directive and the recorded evidence. Reject fabricated substitutes, unsupported complexity, or unsafe changes. Return only the requested structured JSON schema.',
         JSON.stringify({
             route: input.route,
             mission_id: input.mission_id,

package/dist/core/codex-control/python-codex-sdk-adapter.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 import path from 'node:path';
-import { packageRoot, randomId, runProcess, which } from '../fsx.js';
+import { packageRoot, randomId, registerDetachedProcessGroup, runProcess, which } from '../fsx.js';
 import { translatePythonCodexSdkEvents } from './python-codex-sdk-event-translator.js';
 export async function detectPythonCodexSdkCapability() {
     const python = await resolvePythonCodexSdkPython();
@@ -88,10 +88,13 @@ export async function runPythonCodexSdkTask(input, opts = {}) {
 }
 function pythonRunnerEnv(envOverride, moduleParentPath) {
     const env = {};
-    for (const [key, value] of Object.entries(envOverride || process.env)) {
+    for (const [key, value] of Object.entries(envOverride || {})) {
         if (value !== undefined)
             env[key] = String(value);
     }
+    if (process.env.SKS_PYTHON_CODEX_SDK_FAKE === '1' && env.SKS_PYTHON_CODEX_SDK_FAKE === undefined) {
+        env.SKS_PYTHON_CODEX_SDK_FAKE = '1';
+    }
     const parent = String(moduleParentPath || '').trim();
     if (!parent)
         return env;
@@ -102,21 +105,29 @@ function prependPath(value, entry) {
     const parts = String(value || '').split(path.delimiter).filter(Boolean);
     return [entry, ...parts.filter((part) => part !== entry)].join(path.delimiter);
 }
-function runPythonRunner(python, request, envOverride, timeoutMs) {
+export function runPythonRunner(python, request, envOverride, timeoutMs, forceKillDelayMs = 5000) {
     const runner = path.join(packageRoot(), 'pytools', 'codex_sdk_runner.py');
     return new Promise((resolve, reject) => {
         const child = spawn(python, [runner], {
             stdio: ['pipe', 'pipe', 'pipe'],
-            env: envOverride ? { ...process.env, ...envOverride } : process.env,
+            env: envOverride || {},
             detached: process.platform !== 'win32'
         });
+        const unregisterDetachedProcessGroup = registerDetachedProcessGroup(child);
         const events = [];
         let stderr = '';
         let timedOut = false;
+        let settled = false;
+        let cancelForceKill = () => { };
+        const cleanupLifecycle = () => {
+            clearTimeout(timer);
+            cancelForceKill();
+            unregisterDetachedProcessGroup();
+        };
         const timer = setTimeout(() => {
             timedOut = true;
             events.push({ event: 'error', retryable: true, message: `python_codex_sdk_timeout:${timeoutMs}` });
-            terminatePythonRunner(child);
+            cancelForceKill = terminatePythonRunner(child, forceKillDelayMs);
         }, timeoutMs);
         timer.unref?.();
         child.stdout.setEncoding('utf8');
@@ -132,9 +143,18 @@ function runPythonRunner(python, request, envOverride, timeoutMs) {
             }
         });
         child.stderr.on('data', (chunk) => { stderr += String(chunk); });
-        child.on('error', reject);
-        child.on('close', () => {
-            clearTimeout(timer);
+        child.once('error', (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanupLifecycle();
+            reject(error);
+        });
+        child.once('close', () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanupLifecycle();
             if (stderr.trim())
                 events.push({ event: 'stderr', message: stderr.slice(-1000) });
             if (timedOut && !events.some((event) => String(event?.message || '').startsWith('python_codex_sdk_timeout:'))) {
@@ -159,12 +179,13 @@ function positiveFinite(value) {
     const parsed = Number(value);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
 }
-function terminatePythonRunner(child) {
-    if (!child.pid)
-        return;
+function terminatePythonRunner(child, forceKillDelayMs) {
+    const pid = child.pid;
+    if (!pid)
+        return () => { };
     try {
         if (process.platform !== 'win32')
-            process.kill(-child.pid, 'SIGTERM');
+            process.kill(-pid, 'SIGTERM');
         else
             child.kill('SIGTERM');
     }
@@ -174,15 +195,17 @@ function terminatePythonRunner(child) {
         }
         catch { }
     }
-    setTimeout(() => {
+    const forceKillTimer = setTimeout(() => {
         try {
             if (process.platform !== 'win32')
-                process.kill(-child.pid, 'SIGKILL');
+                process.kill(-pid, 'SIGKILL');
             else
                 child.kill('SIGKILL');
         }
         catch { }
-    }, 5000).unref?.();
+    }, forceKillDelayMs);
+    forceKillTimer.unref?.();
+    return () => clearTimeout(forceKillTimer);
 }
 function mapSandbox(value) {
     if (value === 'workspace-write')

package/dist/core/codex-lb/codex-lb-tool-catalog.js

@@ -26,7 +26,7 @@ const REQUIRED_CODEX_0144_MODEL_FIELDS = {
     supports_parallel_tool_calls: ['boolean'],
     experimental_supported_tools: ['array']
 };
-// Exact union observed in Codex CLI 0.144.1's native cache and codex-lb catalog.
+// Exact union observed in Codex CLI 0.144.5's native cache and codex-lb catalog.
 // Unknown response fields are deliberately not persisted into a Codex-owned file.
 const CODEX_0144_MODEL_FIELD_TYPES = {
     ...REQUIRED_CODEX_0144_MODEL_FIELDS,
@@ -94,7 +94,7 @@ export function normalizeCodexLbToolCatalog(payload, opts = {}) {
             return sanitized;
         if (row.use_responses_lite !== false)
             patchedModels.push(model);
-        // Codex 0.144.1 omits the request's `tools` field for Responses Lite.
+        // Codex 0.144.5 omits the request's `tools` field for Responses Lite.
         // Preserve the provider's tool_mode contract, but force full Responses.
         return { ...sanitized, use_responses_lite: false };
     });
@@ -393,7 +393,7 @@ function catalogIdentity(baseUrl, apiKey) {
         origin: new URL(baseUrl).origin,
         base_url_sha256: sha256(baseUrl),
         api_key_sha256: sha256(apiKey),
-        contract: 'codex-cli-0.144.1-model-catalog'
+        contract: 'codex-cli-0.144.5-model-catalog'
     };
 }
 function sameCatalogIdentity(actual, expected) {

package/dist/core/codex-native/core-skill-manifest.js

@@ -1,5 +1,5 @@
 import { PACKAGE_VERSION, nowIso, sha256 } from '../fsx.js';
-import { leanPolicyReference } from '../lean-engineering-policy.js';
+import { coreEngineeringDirectiveReference } from '../lean-engineering-policy.js';
 import { normalizeDollarSkillName, prefixKnownSksDollarReferences, sksPrefixedDollarCommand, sksPrefixedSkillName } from '../routes/dollar-prefix.js';
 import { canonicalSkillName } from './skill-name-canonicalizer.js';
 export const CORE_SKILL_TEMPLATE_VERSION = 'sks-core-skill-template.v1';
@@ -23,7 +23,7 @@ const CORE_SKILL_DEFINITIONS = [
         route: '$Naruto',
         purpose: 'run a Codex official subagent workflow with official agent threads while parent integration remains owner.',
         when: 'Use when the user explicitly invokes $Naruto or the selected route requires bounded parallel delegation.',
-        workflow: 'Use sks naruto run "<task>" [--agents N] [--max-threads N] [--json]. Naruto is the default execution route for non-trivial change requests; Answer and truly tiny DFix work stay lightweight. Automatic fan-out starts at two for bounded work, four for explicit parallel work, and six for large-scale work, then may expand to ten only after decomposition proves useful independent slices. Before every wave compute C_t as the minimum of ready DAG width, disjoint ownership, verifier capacity, tool concurrency, available slots after parent/reviewer reservations, and workers with positive marginal usefulness; max_threads is a cap, never a target. An explicit operator --agents N remains authoritative. The GPT-5.6 Sol Max parent selects the narrow project-scoped custom role matching each slice. Luna Max is only for tiny short-context mechanical work; Sol High handles ordinary implementation; Sol Max handles review, debugging, planning, architecture, security, DB, research, release, ambiguity, and judgment; Terra Medium handles long-context analysis plus direct Computer Use, Browser/Chrome, and image-generation execution. Split mixed execution and judgment where safe; otherwise Sol Max wins. Reject duplicate slice fingerprints and overlapping or unassigned parallel writes. Reviewer-only fan-out is capped at two ordinarily and three for critical multi-domain review; protected security/DB/release/irreversible gates cannot be offset by aggregate gains. Keep max_depth=1, wait for every requested subagent, reuse only four ordinary or six complex query-aware TriWiki trust/hydration anchors, treat SubagentStart/SubagentStop as lifecycle-only evidence, require subagent-parent-summary.json with one structured outcome per thread, and let the parent own integration and final judgment.',
+        workflow: 'Run sks naruto run "<task>" [--agents N] [--max-threads N] [--json] with Codex official subagent threads only. The parent owns decomposition, per-wave capacity, later root-owned waves, integration, and final verification. Automatic targets begin at 2/4/6 by task size and may expand to 10 only for independent useful slices; max_threads is a cap, never a target, and max_depth=1 blocks nested delegation. Route each slice to the narrowest matching Codex role and wait for every planned thread before final.',
         safety: 'Preserve user-authored content, inherit the parent permission mode, do not spawn nested subagents, do not inject the full pack or the full TriWiki context into every child, and do not fall back to another model, process runtime, custom scheduler, or worker pool. The historical Naruto process runtime is removed; stop with explicit blocker evidence when the official path is unavailable.',
         cli: 'sks naruto run "<task>" [--agents N] [--max-threads N] [--json]; sks naruto status|subagents|proof [--mission <id>] [--json]',
         evidence: 'subagent-plan.json, subagent-events.jsonl, subagent-parent-summary.json, subagent-evidence.json, naruto-summary.json, and naruto-gate.json.',
@@ -157,7 +157,7 @@ export function renderCoreSkillTemplate(name) {
     if (!legacy)
         throw new Error(`Unknown SKS core skill: ${name}`);
     const skill = currentCoreSkillDefinition(legacy);
-    const lean = leanPolicyReference();
+    const directive = coreEngineeringDirectiveReference();
     return [
         '---',
         `name: ${skill.display_name}`,
@@ -180,13 +180,10 @@ export function renderCoreSkillTemplate(name) {
         `Use when: ${skill.when}`,
         `Workflow: ${skill.workflow || 'Run the selected route lifecycle, read source evidence before mutation planning, keep changes scoped, verify with the cheapest sufficient check, and record blockers honestly.'}`,
         `CLI entrypoint: ${skill.cli || skill.route}`,
-        `Lean policy: ${lean.policy_id}/${lean.policy_hash}`,
+        `Core directive: ${directive.directive_id}/${directive.directive_hash}`,
         `Safety: ${skill.safety || 'Preserve user-authored content, keep route state bounded, avoid unsupported guarantees, and stop on hard blockers instead of fabricating fallback behavior.'}`,
         `Evidence/artifacts: ${skill.evidence}`,
-        `Proof paths: ${skill.evidence}`,
-        'Safety rules: preserve user-authored skills, keep route state bounded, and stop on hard blockers instead of fabricating fallback behavior.',
         `Failure/recovery: ${skill.fallback}`,
-        `Failure recovery: ${skill.fallback}`,
         ''
     ].join('\n');
 }