sneakoscope 3.1.6 → 3.1.8

package/README.md

@@ -35,7 +35,14 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **3.1.6** removes external reference branding from user-visible release surfaces and routes Codex-native feature decisions through one broker for Loop, QA, Research, Image, MAD, and Doctor.
+SKS **3.1.8** hardens update/setup/doctor safety around four operator-facing failure modes: immutable core skills, duplicate project skills, real native capability repair status, and Supabase/secret preservation.
+
+What changed in 3.1.8:
+
+- **Core SKS skills are content-addressed and immutable.** The eight built-in route skills now have a manifest and no-drift gates; setup/update/doctor may install missing managed copies or restore corrupted managed copies, but they do not overwrite user-authored collisions.
+- **Duplicate skills are detected and repaired safely.** Canonical skill names collapse variants such as `Loop`, `loop`, and `loop/SKILL.md`; SKS-managed duplicates can be quarantined automatically, while user-authored duplicates require explicit confirmation.
+- **`sks doctor --fix` reports native capability truthfully.** Image generation, image follow-up edit paths, Computer Use, Chrome/web review, app screenshots, app handoff, and image path exposure now run through a repair matrix and postcheck instead of capability assumptions.
+- **Supabase keys survive setup/update/doctor.** Protected secret surfaces are fingerprinted before and after guarded operations; reports store only redacted previews and hashes, never raw values.
 
 SKS 3.0.0 was the parallel-runtime stabilization release. The whole live-swarm experience — what you actually *see* while 5, 20, or 100 workers run — was rebuilt and proven end-to-end.
 
@@ -79,7 +86,7 @@ npm run runtime:ts-python-boundary
 npm run codex-control:all-pipelines
 ```
 
-Broader release checks still live behind `npm run release:check`. Detailed release history is in [CHANGELOG.md](CHANGELOG.md), and release readiness is tracked in [docs/release-readiness.md](docs/release-readiness.md).
+Change-aware release checks live behind `npm run release:check`; publish-authorizing full DAG checks use `npm run release:check:full`. Detailed release history is in [CHANGELOG.md](CHANGELOG.md), and release readiness is tracked in [docs/release-readiness.md](docs/release-readiness.md).
 
 ## 🍥 Parallelism, UX, And Integrations
 
@@ -622,7 +629,7 @@ TriWiki is intentionally sparse: `sks wiki sweep` records demote, soft-forget, a
 
 ```sh
 sks codex-native status --json
-sks codex-native invocation-plan --route '$Loop' --capability agent-role --json
+sks codex-native invocation-plan --route Loop --capability agent-role --json
 sks codex-native init-deep --apply --directory-local --json
 ```
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "3.1.6"
+version = "3.1.8"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "3.1.6"
+version = "3.1.8"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 3.1.6"),
+        Some("--version") => println!("sks-rs 3.1.8"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "3.1.6",
-  "source_digest": "98f9f4c6a64ddd6b1d43f757e16358768f24b27cd9c3285eab0bdacce7cbf5d6",
-  "source_file_count": 2543,
-  "built_at_source_time": 1781450666248
+  "package_version": "3.1.8",
+  "source_digest": "94742dc3eb63f280df98aa286ac2a94a14fd140f27c89db85880e4f92c630454",
+  "source_file_count": 2602,
+  "built_at_source_time": 1781513577024
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '3.1.6';
+const FAST_PACKAGE_VERSION = '3.1.8';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/commands/codex-app.js

@@ -9,12 +9,15 @@ import { syncCodexAgentRoles } from '../core/codex-app/codex-agent-role-sync.js'
 import { runCodexInitDeep } from '../core/codex-app/codex-init-deep.js';
 import { buildCodexHookLifecycle } from '../core/codex-app/codex-hook-lifecycle.js';
 import { resolveCodexAppExecutionProfile } from '../core/codex-app/codex-app-execution-profile.js';
+import { repairCodexNativeManagedAssets } from '../core/codex-native/codex-native-repair-transaction.js';
 export async function run(_command, args = []) {
     const action = args[0] || 'check';
     if (action === 'remote-control' || action === 'remote')
         return codexAppRemoteControlCommand(args.slice(1));
-    if (action === 'harness-matrix')
-        return printCodexAppResult(args, await buildCodexAppHarnessMatrix({ root: await sksRoot(), applyRepairs: flag(args, '--fix') || flag(args, '--apply') }));
+    if (action === 'harness-matrix') {
+        const root = await sksRoot();
+        return printCodexAppResult(args, await maybeRepairThenReadOnlyHarness(args, root));
+    }
     if (action === 'skill-sync')
         return printCodexAppResult(args, await syncCodexSksSkills({ root: await sksRoot(), apply: flag(args, '--apply') || flag(args, '--fix') }));
     if (action === 'agent-role-sync')
@@ -103,4 +106,19 @@ function printCodexAppResult(args = [], result) {
     if (result?.ok === false)
         process.exitCode = 1;
 }
+async function maybeRepairThenReadOnlyHarness(args = [], root) {
+    const wantsRepair = flag(args, '--fix') || flag(args, '--apply') || flag(args, '--repair-codex-native');
+    if (!wantsRepair)
+        return buildCodexAppHarnessMatrix({ root, mode: 'read-only' });
+    const repair = await repairCodexNativeManagedAssets({ root, requestedBy: 'manual', yes: flag(args, '--yes') });
+    const matrix = await buildCodexAppHarnessMatrix({ root, mode: 'read-only' });
+    return {
+        schema: 'sks.codex-app-harness-read-repair-split.v1',
+        ok: repair.ok && matrix?.ok !== false,
+        repair,
+        matrix,
+        blockers: [...(repair.blockers || []), ...(matrix?.blockers || [])],
+        warnings: [...(repair.warnings || []), 'harness_probe_after_explicit_repair_transaction']
+    };
+}
 //# sourceMappingURL=codex-app.js.map

package/dist/commands/codex-native.js

@@ -12,14 +12,15 @@ import { resolveCodexNativeInvocationPlan } from '../core/codex-native/codex-nat
 import { buildCodexNativeInteropPolicy } from '../core/codex-native/codex-native-interop-policy.js';
 import { analyzeCodexNativeReferenceSource } from '../core/codex-native/codex-native-reference-evidence.js';
 import { writeCodexNativePatternAnalysis } from '../core/codex-native/codex-native-pattern-analysis.js';
+import { repairCodexNativeManagedAssets } from '../core/codex-native/codex-native-repair-transaction.js';
 export async function run(_command, args = []) {
     const root = await sksRoot();
     const action = String(args[0] || 'status');
     if (action === 'status' || action === 'check' || action === 'feature-broker' || action === 'feature-matrix') {
-        return printCodexNativeResult(args, await buildCodexNativeFeatureMatrix({ root, applyRepairs: flag(args, '--fix') || flag(args, '--apply') }));
+        return printCodexNativeResult(args, await maybeRepairThenReadOnlyMatrix(args, root, () => buildCodexNativeFeatureMatrix({ root, mode: 'read-only' })));
     }
     if (action === 'harness-matrix' || action === 'harness-compat') {
-        return printCodexNativeResult(args, await buildCodexAppHarnessMatrix({ root, applyRepairs: flag(args, '--fix') || flag(args, '--apply') }));
+        return printCodexNativeResult(args, await maybeRepairThenReadOnlyMatrix(args, root, () => buildCodexAppHarnessMatrix({ root, mode: 'read-only' })));
     }
     if (action === 'skill-sync')
         return printCodexNativeResult(args, await syncCodexSksSkills({ root, apply: flag(args, '--apply') || flag(args, '--fix') }));
@@ -46,6 +47,21 @@ export async function run(_command, args = []) {
     console.error('Usage: sks codex-native status|feature-broker|harness-compat|skill-sync|agent-role-sync|init-deep|hook-lifecycle|execution-profile|interop-policy|reference-evidence|pattern-analysis|invocation-plan [--json]');
     process.exitCode = 1;
 }
+async function maybeRepairThenReadOnlyMatrix(args = [], root, matrixFn) {
+    const wantsRepair = flag(args, '--fix') || flag(args, '--apply') || flag(args, '--repair-codex-native');
+    if (!wantsRepair)
+        return matrixFn();
+    const repair = await repairCodexNativeManagedAssets({ root, requestedBy: 'manual', yes: flag(args, '--yes') });
+    const matrix = await matrixFn();
+    return {
+        schema: 'sks.codex-native-read-repair-split.v1',
+        ok: repair.ok && matrix?.ok !== false,
+        repair,
+        matrix,
+        blockers: [...(repair.blockers || []), ...(matrix?.blockers || [])],
+        warnings: [...(repair.warnings || []), 'matrix_probe_after_explicit_repair_transaction']
+    };
+}
 function printCodexNativeResult(args = [], result) {
     if (flag(args, '--json')) {
         printJson(result);

package/dist/commands/doctor.js

@@ -26,6 +26,8 @@ import { writeMcpPluginInventoryArtifacts } from '../core/mcp/mcp-plugin-invento
 import { runDoctorZellijRepair, doctorZellijRepairConsoleLine } from '../core/doctor/doctor-zellij-repair.js';
 import { buildCodexAppHarnessMatrix } from '../core/codex-app/codex-app-harness-matrix.js';
 import { buildCodexNativeFeatureMatrix } from '../core/codex-native/codex-native-feature-broker.js';
+import { repairCodexNativeManagedAssets } from '../core/codex-native/codex-native-repair-transaction.js';
+import { runDoctorNativeCapabilityRepair } from '../core/doctor/doctor-native-capability-repair.js';
 export async function run(_command, args = []) {
     const doctorFix = flag(args, '--fix');
     let setupRepair = null;
@@ -68,6 +70,23 @@ export async function run(_command, args = []) {
         };
     }
     const root = await projectRoot();
+    const doctorNativeCapabilityRepair = await runDoctorNativeCapabilityRepair({
+        root,
+        fix: doctorFix || flag(args, '--repair-native-capabilities'),
+        yes: flag(args, '--yes') || flag(args, '-y'),
+        flags: args.map((arg) => String(arg))
+    }).catch((err) => ({
+        schema: 'sks.doctor-native-capability-repair.v1',
+        ok: false,
+        root,
+        fix: doctorFix,
+        yes: flag(args, '--yes') || flag(args, '-y'),
+        core_skills: null,
+        skill_dedupe: null,
+        native_capabilities: null,
+        secret_preservation_guard: '.sneakoscope/reports/secret-preservation-guard.json',
+        blockers: [err?.message || String(err)]
+    }));
     const codexBin = readOption(args, '--codex-bin', process.env.SKS_DOCTOR_CODEX_BIN || '');
     const configProbeOpts = {
         codexProbe: flag(args, '--fix') || flag(args, '--actual-codex') || Boolean(codexBin),
@@ -198,7 +217,23 @@ export async function run(_command, args = []) {
     const mcpPluginInventory = pluginInventory?.report
         ? await writeMcpPluginInventoryArtifacts(root, { inventory: pluginInventory.report }).catch((err) => ({ error: err?.message || String(err), candidates: null }))
         : null;
-    const codexAppHarnessMatrix = await buildCodexAppHarnessMatrix({ root, applyRepairs: doctorFix }).catch((err) => ({
+    const repairCodexNative = doctorFix && flag(args, '--repair-codex-native');
+    const codexNativeRepair = repairCodexNative
+        ? await repairCodexNativeManagedAssets({
+            root,
+            requestedBy: 'doctor --fix',
+            yes: flag(args, '--yes') || flag(args, '-y')
+        }).catch((err) => ({
+            schema: 'sks.codex-native-repair-transaction.v1',
+            ok: false,
+            generated_at: new Date().toISOString(),
+            requested_by: 'doctor --fix',
+            repaired: [],
+            blockers: [err?.message || String(err)],
+            warnings: []
+        }))
+        : null;
+    const codexAppHarnessMatrix = await buildCodexAppHarnessMatrix({ root, mode: 'read-only' }).catch((err) => ({
         schema: 'sks.codex-app-harness-matrix.v1',
         ok: false,
         codex_cli: { available: false, version: null },
@@ -207,7 +242,7 @@ export async function run(_command, args = []) {
         blockers: [err?.message || String(err)],
         warnings: []
     }));
-    const codexNativeFeatureMatrix = await buildCodexNativeFeatureMatrix({ root, applyRepairs: doctorFix }).catch((err) => ({
+    const codexNativeFeatureMatrix = await buildCodexNativeFeatureMatrix({ root, mode: 'read-only' }).catch((err) => ({
         schema: 'sks.codex-native-feature-matrix.v1',
         ok: false,
         codex_cli: { available: Boolean(codex.bin), version: codex.version || null, bin: codex.bin || null },
@@ -288,7 +323,7 @@ export async function run(_command, args = []) {
         ready,
         sneakoscope: { ok: await exists(`${root}/.sneakoscope`) },
         package: { bytes: pkgBytes, human: formatBytes(pkgBytes) },
-        repair: { sks_update: sksUpdate, setup: setupRepair, codex_config: configRepair, migration_journal: migrationJournal, global_sks_installs: globalSksInstallCleanup, agent_role_config: agentRoleConfigRepair, zellij: zellijRepair }
+        repair: { sks_update: sksUpdate, setup: setupRepair, codex_config: configRepair, migration_journal: migrationJournal, global_sks_installs: globalSksInstallCleanup, agent_role_config: agentRoleConfigRepair, zellij: zellijRepair, codex_native: codexNativeRepair, doctor_native_capability: doctorNativeCapabilityRepair }
     };
     if (flag(args, '--json')) {
         printJson(result);
@@ -324,8 +359,32 @@ export async function run(_command, args = []) {
     console.log(`  Loop Mesh: ${runtimeReadiness.loop_mesh}`);
     console.log(`  QA Visual: ${runtimeReadiness.qa_visual}`);
     console.log(`  Research Sources: ${runtimeReadiness.research_sources}`);
-    for (const action of runtimeReadiness.repair_actions)
-        console.log(`  Repair: ${action}`);
+    console.log(`  Image Follow-up: ${runtimeReadiness.image_followup}`);
+    for (const note of runtimeReadiness.notes)
+        console.log(`  ${note}`);
+    if (runtimeReadiness.repair_actions.length) {
+        console.log('Repair actions:');
+        for (const action of runtimeReadiness.repair_actions)
+            console.log(`  - ${action}`);
+    }
+    const nativeCapabilityRows = Array.isArray(doctorNativeCapabilityRepair?.native_capabilities?.capabilities)
+        ? doctorNativeCapabilityRepair.native_capabilities.capabilities
+        : [];
+    console.log('SKS Native Capabilities:');
+    console.log(`  image generation: ${nativeCapabilityStatus(nativeCapabilityRows, 'image_generation', 'repair_required')}`);
+    console.log(`  image follow-up edit: ${nativeCapabilityStatus(nativeCapabilityRows, 'image_followup_edit', 'degraded')}`);
+    console.log(`  computer use: ${nativeCapabilityStatus(nativeCapabilityRows, 'computer_use', 'manual_required')}`);
+    console.log(`  Chrome/web review: ${nativeCapabilityStatus(nativeCapabilityRows, 'chrome_web_review', 'manual_required')}`);
+    console.log(`  app screenshot: ${nativeCapabilityStatus(nativeCapabilityRows, 'codex_app_screenshot', 'degraded')}`);
+    console.log(`  app handoff: ${nativeCapabilityStatus(nativeCapabilityRows, 'app_handoff', 'unavailable')}`);
+    console.log(`  image path exposure: ${nativeCapabilityStatus(nativeCapabilityRows, 'image_path_exposure', 'fallback')}`);
+    console.log('SKS Skills:');
+    console.log(`  core skills: ${doctorSkillStatus(doctorNativeCapabilityRepair?.core_skills)}`);
+    console.log(`  duplicate project skills: ${doctorDedupeStatus(doctorNativeCapabilityRepair?.skill_dedupe)}`);
+    console.log('Secret preservation:');
+    console.log(`  Supabase keys: ${doctorNativeCapabilityRepair?.ok === false && String((doctorNativeCapabilityRepair?.blockers || []).join(' ')).includes('secret_preservation_failed') ? 'blocked' : 'preserved'}`);
+    console.log('  secret values: redacted');
+    console.log(`  migration journal: ${doctorNativeCapabilityRepair?.secret_preservation_guard || '.sneakoscope/reports/secret-preservation-guard.json'}`);
     console.log('Codex App Harness:');
     console.log(`  plugins: ${codexAppHarnessMatrix.app_features?.plugin_json ? 'ok' : 'degraded'}`);
     console.log(`  hook approval: ${codexAppHarnessMatrix.app_features?.hook_approval_state_detectable ? 'ok' : 'unknown'}`);
@@ -424,14 +483,14 @@ function buildRuntimeReadiness(zellijReadiness, matrix) {
         ? 'ok'
         : matrix?.codex_cli?.available ? 'degraded' : 'blocked';
     const repairActions = [];
-    if (zellijStatus === 'repair_required')
-        repairActions.push('sks doctor --fix --yes');
+    if (zellijStatus !== 'ok') {
+        repairActions.push('Zellij: sks doctor --fix --yes');
+        repairActions.push('Homebrew + Zellij: sks doctor --fix --install-homebrew --yes');
+    }
     if (codexNative !== 'ok')
-        repairActions.push('sks doctor --fix --repair-codex-native --yes');
+        repairActions.push('Codex Native managed assets: sks doctor --fix --repair-codex-native --yes');
     if (matrix?.features?.project_memory?.ok !== true)
-        repairActions.push('sks codex-native init-deep --apply --directory-local');
-    if (hookPolicy !== 'approved-only')
-        repairActions.push('hook-derived evidence will not count until Codex hook approval is approved');
+        repairActions.push('Project memory: sks codex-native init-deep --apply --directory-local');
     return {
         schema: 'sks.runtime-readiness-story.v1',
         zellij: zellijStatus,
@@ -439,6 +498,7 @@ function buildRuntimeReadiness(zellijReadiness, matrix) {
         loop_mesh: agentStrategy === 'agent_type' ? 'ok' : 'fallback',
         qa_visual: defaults.qa_visual_review_strategy || 'blocked',
         research_sources: defaults.research_source_strategy || 'local-files',
+        image_followup: defaults.image_followup_strategy || 'blocked',
         hook_evidence_policy: hookPolicy,
         agent_role_strategy: agentStrategy,
         notes: [
@@ -446,9 +506,43 @@ function buildRuntimeReadiness(zellijReadiness, matrix) {
             ...(hookPolicy !== 'approved-only' ? ['hook-derived evidence will not count'] : []),
             ...(agentStrategy !== 'agent_type' ? ['message-role fallback active'] : [])
         ],
-        repair_actions: repairActions
+        repair_actions: [...new Set(repairActions)]
     };
 }
+function nativeCapabilityStatus(rows, id, fallback) {
+    const row = rows.find((entry) => entry?.id === id);
+    if (!row)
+        return fallback;
+    if (row.after === 'verified' || row.before === 'verified')
+        return 'verified';
+    if (row.repairability === 'manual-required')
+        return 'manual_required';
+    if (row.before === 'degraded' || row.after === 'degraded')
+        return 'degraded';
+    if (row.repairability === 'doctor-fix')
+        return row.after === 'blocked' ? 'blocked' : 'repair_required';
+    if (row.repairability === 'unavailable')
+        return 'unavailable';
+    return fallback;
+}
+function doctorSkillStatus(coreSkills) {
+    if (!coreSkills)
+        return 'drift_detected';
+    if (Array.isArray(coreSkills.restored) && coreSkills.restored.length)
+        return 'repaired';
+    if (Array.isArray(coreSkills.blockers) && coreSkills.blockers.length)
+        return 'drift_detected';
+    return 'current';
+}
+function doctorDedupeStatus(skillDedupe) {
+    if (!skillDedupe)
+        return 'manual_required';
+    if (Array.isArray(skillDedupe.actions) && skillDedupe.actions.some((action) => action.action === 'quarantined'))
+        return 'repaired';
+    if (Array.isArray(skillDedupe.blockers) && skillDedupe.blockers.length)
+        return 'manual_required';
+    return 'none';
+}
 // Assemble the explicit Zellij readiness block for `doctor --json` from the
 // capability probe + readiness matrix. Proof statuses are availability-derived:
 // `verified` is reserved for a real environment run (SKS_REQUIRE_ZELLIJ=1 gates);

package/dist/core/codex-app/codex-agent-role-sync.js

@@ -56,7 +56,7 @@ export async function syncCodexAgentRoles(input) {
         for (const role of DIRECTIVE_ROLES) {
             const file = path.join(targetDir, `${role}.toml`);
             const current = await fs.readFile(file, 'utf8').catch(() => '');
-            if (current && !current.includes('SKS managed 3.1.4 directive role') && !current.includes('SKS managed 3.1.5 directive role') && !current.includes('SKS managed 3.1.6 directive role') && !current.includes('SKS managed 3.1.6 bounded role'))
+            if (current && !current.includes('SKS managed 3.1.4 directive role') && !current.includes('SKS managed 3.1.5 directive role') && !current.includes('SKS managed 3.1.6 directive role') && !current.includes('SKS managed 3.1.6 bounded role') && !current.includes('SKS managed 3.1.7 directive role'))
                 continue;
             await writeTextAtomic(file, roleToml(role, rolePayloads[role]));
             created.push(file);
@@ -69,6 +69,9 @@ export async function syncCodexAgentRoles(input) {
         apply: input.apply === true,
         agent_type_supported: agentTypeProbe.supported,
         fallback: agentTypeProbe.supported ? 'agent_type' : 'message-role',
+        strategy: agentTypeProbe.supported ? 'agent_type' : 'message-role',
+        probe_artifact_path: '.sneakoscope/reports/codex-agent-type-probe.json',
+        clobbered_user_roles: false,
         codex_home: codexHome,
         directive_roles: DIRECTIVE_ROLES,
         role_payloads: rolePayloads,
@@ -86,21 +89,22 @@ function roleToml(role, payload) {
         : `message_role_prefix = "${escapeToml(payload?.message_role_prefix || `Role: ${role}.`)}"`;
     return [
         `name = "${role}"`,
-        `description = "SKS managed 3.1.6 directive role: ${role}"`,
+        `description = "SKS managed 3.1.7 directive role: ${role}"`,
         strategyLine,
         'model_reasoning_effort = "medium"',
         role.includes('implementer') ? 'sandbox_mode = "workspace-write"' : 'sandbox_mode = "read-only"',
         'approval_policy = "never"',
         'developer_instructions = """',
-        `You are ${role}. SKS managed 3.1.6 directive role with bounded ownership.`,
+        `You are ${role}. SKS managed 3.1.7 directive role with bounded ownership.`,
         'Bounded ownership: use only the assigned owner files/directories and treat memory as guidance, not permission.',
         role.includes('implementer') ? 'Maker/checker separation: implementer may patch only owner scope and cannot self-approve.' : 'Maker/checker separation: checker is read-only and must reject missing gates or missing proof artifacts.',
+        role.includes('implementer') ? 'Allowed sandbox: workspace-write only within assigned owner scope.' : 'Allowed sandbox: read-only; checker roles cannot mutate.',
         role.includes('release') ? 'Release verifier: verify version truth, release DAG coverage, package scripts, packlist, and changelog evidence.' : '',
         role.includes('zellij') ? 'UI/Zellij verifier: inspect readiness status, headless fallback, repair_required, pane proof, and slot telemetry without mutating unrelated UI state.' : '',
         role.includes('codex') ? 'Codex native verifier: inspect hook approval, agent_type, skill sync, plugin inventory, MCP candidates, and invocation plan artifacts.' : '',
-        'Side effects: no destructive shell, package publish, global config mutation, database mutation, or external service write unless the sealed route contract explicitly allows it.',
+        'Side-effect restrictions: no destructive shell, package publish, global config mutation, database mutation, or external service write unless the sealed route contract explicitly allows it.',
         'Required proof artifacts: cite concrete repo paths, command outputs, and route-local JSON proof before claiming completion.',
-        'Final arbiter: parent integration owns final acceptance; this role supplies evidence and cannot override missing gates.',
+        'Final arbiter constraints: parent integration owns final acceptance; this role supplies evidence and cannot override missing gates.',
         `Execution role strategy: ${payload?.strategy || 'message-role'}. Probe: ${payload?.probe_artifact_path || '.sneakoscope/reports/codex-agent-type-probe.json'}.`,
         '"""',
         ''

package/dist/core/codex-app/codex-init-deep.js

@@ -28,7 +28,7 @@ export async function runCodexInitDeep(input = {}) {
                     }
                     if (existing.trim()) {
                         const beforeHash = hashText(existing);
-                        const backup = `${agentsPath}.sks-backup-${beforeHash.slice(0, 12)}-${Date.now()}`;
+                        const backup = `${agentsPath}.sks-backup-${Date.now()}-${beforeHash.slice(0, 12)}`;
                         await fs.copyFile(agentsPath, backup);
                         directoryLocalAgents.backup_paths.push(path.relative(root, backup));
                         directoryLocalAgents.backups_created += 1;
@@ -83,9 +83,10 @@ async function pruneBackups(root, agentsPath, keep) {
         return [];
     const dir = path.dirname(agentsPath);
     const base = path.basename(agentsPath);
+    const backupPattern = new RegExp(`^${escapeRegExp(base)}\\.sks-backup-\\d{13}-[0-9a-f]{8,12}$`);
     const rows = await fs.readdir(dir).catch(() => []);
     const backups = rows
-        .filter((name) => name.startsWith(`${base}.sks-backup-`))
+        .filter((name) => backupPattern.test(name))
         .map((name) => path.join(dir, name))
         .sort();
     const remove = backups.slice(0, Math.max(0, backups.length - keep));
@@ -99,6 +100,9 @@ async function pruneBackups(root, agentsPath, keep) {
         await guardedRm(guard, file, { force: true }).catch(() => undefined);
     return remove;
 }
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 function hashText(text) {
     let hash = 2166136261;
     for (let index = 0; index < text.length; index += 1) {