sneakoscope 6.4.0 → 6.7.0

package/dist/core/codex-runtime/resolve-codex-runtime.js

@@ -4,6 +4,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { exists, packageRoot, runProcess, which } from '../fsx.js';
 import { parseCodexVersionText } from '../codex-compat/codex-version-policy.js';
+const OFFICIAL_CODEX_PACKAGE = '@openai/codex';
+const OFFICIAL_CODEX_SDK_PACKAGE = '@openai/codex-sdk';
 export async function resolveCodexRuntime(input = {}) {
     const requestedBy = input.requestedBy || 'codex-runtime-resolver';
     const candidates = await codexRuntimeCandidates(input.explicitPath || null, Boolean(input.includeGlobalDiagnostics));
@@ -25,6 +27,125 @@ export async function resolveCodexRuntime(input = {}) {
         candidates
     };
 }
+export async function resolveOfficialCodexPackageRuntime(input = {}) {
+    const requestedBy = input.requestedBy || 'official-codex-package-runtime-resolver';
+    const root = packageRoot();
+    const nodeModulesRoot = path.join(root, 'node_modules');
+    const basePackageRoot = path.join(nodeModulesRoot, '@openai', 'codex');
+    const basePackageJsonPath = path.join(basePackageRoot, 'package.json');
+    const platformRuntime = officialCodexPlatformRuntime();
+    if (!platformRuntime) {
+        return officialRuntimeBlocked(basePackageRoot, 'codex_sdk_official_runtime_platform_unsupported');
+    }
+    const nativePackageRoot = path.join(nodeModulesRoot, ...platformRuntime.packageName.split('/'));
+    const nativeBinaryPath = path.join(nativePackageRoot, 'vendor', platformRuntime.targetTriple, 'bin', platformRuntime.binaryName);
+    const basePackageManifest = await readPackageManifest(basePackageJsonPath);
+    if (!basePackageManifest) {
+        return officialRuntimeBlocked(nativeBinaryPath, await exists(basePackageJsonPath)
+            ? 'codex_sdk_official_runtime_package_manifest_invalid'
+            : 'codex_sdk_official_runtime_package_not_found');
+    }
+    if (basePackageManifest.name !== OFFICIAL_CODEX_PACKAGE || typeof basePackageManifest.version !== 'string') {
+        return officialRuntimeBlocked(nativeBinaryPath, 'codex_sdk_official_runtime_package_identity_mismatch');
+    }
+    const sdkPackageRoot = path.join(nodeModulesRoot, '@openai', 'codex-sdk');
+    const sdkPackageJsonPath = path.join(sdkPackageRoot, 'package.json');
+    const sdkManifest = await readPackageManifest(sdkPackageJsonPath);
+    if (!sdkManifest || sdkManifest.name !== OFFICIAL_CODEX_SDK_PACKAGE) {
+        return officialRuntimeBlocked(nativeBinaryPath, 'codex_sdk_official_runtime_sdk_package_identity_mismatch');
+    }
+    const sdkDependencies = recordValue(sdkManifest.dependencies);
+    if (sdkDependencies?.[OFFICIAL_CODEX_PACKAGE] !== basePackageManifest.version) {
+        return officialRuntimeBlocked(nativeBinaryPath, 'codex_sdk_official_runtime_version_mismatch');
+    }
+    const optionalDependencies = recordValue(basePackageManifest.optionalDependencies);
+    const expectedNativeVersion = `${basePackageManifest.version}-${platformRuntime.versionSuffix}`;
+    const expectedNativeAlias = `npm:${OFFICIAL_CODEX_PACKAGE}@${expectedNativeVersion}`;
+    if (optionalDependencies?.[platformRuntime.packageName] !== expectedNativeAlias) {
+        return officialRuntimeBlocked(nativeBinaryPath, 'codex_sdk_official_runtime_platform_package_mismatch');
+    }
+    const nativePackageJsonPath = path.join(nativePackageRoot, 'package.json');
+    const nativePackageManifest = await readPackageManifest(nativePackageJsonPath);
+    if (!nativePackageManifest
+        || nativePackageManifest.name !== OFFICIAL_CODEX_PACKAGE
+        || nativePackageManifest.version !== expectedNativeVersion) {
+        return officialRuntimeBlocked(nativeBinaryPath, 'codex_sdk_official_runtime_platform_package_mismatch');
+    }
+    const runtimeMetadataPath = path.join(nativePackageRoot, 'vendor', platformRuntime.targetTriple, 'codex-package.json');
+    const runtimeMetadata = await readPackageManifest(runtimeMetadataPath);
+    if (runtimeMetadata?.version !== basePackageManifest.version
+        || runtimeMetadata.target !== platformRuntime.targetTriple
+        || runtimeMetadata.variant !== 'codex'
+        || runtimeMetadata.entrypoint !== `bin/${platformRuntime.binaryName}`) {
+        return officialRuntimeBlocked(nativeBinaryPath, 'codex_sdk_official_runtime_metadata_mismatch');
+    }
+    const candidateExists = await exists(nativeBinaryPath);
+    if (!candidateExists) {
+        return officialRuntimeBlocked(nativeBinaryPath, 'codex_sdk_official_runtime_binary_missing');
+    }
+    let canonicalNodeModulesRoot;
+    let canonicalBasePackageRoot;
+    let canonicalSdkPackageRoot;
+    let canonicalNativePackageRoot;
+    let canonicalBinaryPath;
+    try {
+        [
+            canonicalNodeModulesRoot,
+            canonicalBasePackageRoot,
+            canonicalSdkPackageRoot,
+            canonicalNativePackageRoot,
+            canonicalBinaryPath
+        ] = await Promise.all([
+            fsp.realpath(nodeModulesRoot),
+            fsp.realpath(basePackageRoot),
+            fsp.realpath(sdkPackageRoot),
+            fsp.realpath(nativePackageRoot),
+            fsp.realpath(nativeBinaryPath)
+        ]);
+    }
+    catch {
+        return officialRuntimeBlocked(nativeBinaryPath, 'codex_sdk_official_runtime_binary_missing', candidateExists);
+    }
+    if (!pathIsWithin(canonicalNodeModulesRoot, canonicalBasePackageRoot)
+        || !pathIsWithin(canonicalNodeModulesRoot, canonicalSdkPackageRoot)
+        || !pathIsWithin(canonicalNodeModulesRoot, canonicalNativePackageRoot)) {
+        return officialRuntimeBlocked(nativeBinaryPath, 'codex_sdk_official_runtime_package_path_mismatch', candidateExists);
+    }
+    if (!pathIsWithin(canonicalNativePackageRoot, canonicalBinaryPath)) {
+        return officialRuntimeBlocked(nativeBinaryPath, 'codex_sdk_official_runtime_binary_path_mismatch', candidateExists);
+    }
+    const binaryStat = await fsp.stat(canonicalBinaryPath).catch(() => null);
+    if (!binaryStat?.isFile()) {
+        return officialRuntimeBlocked(nativeBinaryPath, 'codex_sdk_official_runtime_binary_path_mismatch', candidateExists);
+    }
+    const trust = await verifyOfficialCodexRuntimeTrust(canonicalBinaryPath);
+    if (!trust.ok) {
+        return officialRuntimeBlocked(nativeBinaryPath, trust.blocker, candidateExists);
+    }
+    let identity;
+    try {
+        identity = {
+            ...await codexRuntimeIdentity(nativeBinaryPath, 'project', requestedBy),
+            trusted: true,
+            trust_basis: trust.trustBasis
+        };
+    }
+    catch {
+        return officialRuntimeBlocked(nativeBinaryPath, 'codex_sdk_official_runtime_binary_unusable', candidateExists);
+    }
+    if (identity.realpath !== canonicalBinaryPath
+        || identity.packageRoot !== canonicalNativePackageRoot
+        || identity.packageVersion !== expectedNativeVersion
+        || identity.version !== basePackageManifest.version) {
+        return officialRuntimeBlocked(nativeBinaryPath, 'codex_sdk_official_runtime_package_identity_mismatch', candidateExists);
+    }
+    return {
+        ok: true,
+        identity,
+        blockers: [],
+        candidates: [{ source: 'project', path: nativeBinaryPath, exists: candidateExists }]
+    };
+}
 export async function codexRuntimeCandidates(explicitPath, includeGlobalDiagnostics = false) {
     const rows = [];
     const add = async (source, value) => {
@@ -99,3 +220,81 @@ async function readPackageVersion(root) {
         return null;
     }
 }
+async function readPackageManifest(file) {
+    try {
+        return recordValue(JSON.parse(await fsp.readFile(file, 'utf8')));
+    }
+    catch {
+        return null;
+    }
+}
+function recordValue(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function officialCodexPlatformRuntime() {
+    const binaryName = process.platform === 'win32' ? 'codex.exe' : 'codex';
+    if (process.platform === 'darwin' && process.arch === 'arm64') {
+        return { packageName: '@openai/codex-darwin-arm64', targetTriple: 'aarch64-apple-darwin', versionSuffix: 'darwin-arm64', binaryName };
+    }
+    if (process.platform === 'darwin' && process.arch === 'x64') {
+        return { packageName: '@openai/codex-darwin-x64', targetTriple: 'x86_64-apple-darwin', versionSuffix: 'darwin-x64', binaryName };
+    }
+    if (process.platform === 'linux' && process.arch === 'arm64') {
+        return { packageName: '@openai/codex-linux-arm64', targetTriple: 'aarch64-unknown-linux-musl', versionSuffix: 'linux-arm64', binaryName };
+    }
+    if (process.platform === 'linux' && process.arch === 'x64') {
+        return { packageName: '@openai/codex-linux-x64', targetTriple: 'x86_64-unknown-linux-musl', versionSuffix: 'linux-x64', binaryName };
+    }
+    if (process.platform === 'win32' && process.arch === 'arm64') {
+        return { packageName: '@openai/codex-win32-arm64', targetTriple: 'aarch64-pc-windows-msvc', versionSuffix: 'win32-arm64', binaryName };
+    }
+    if (process.platform === 'win32' && process.arch === 'x64') {
+        return { packageName: '@openai/codex-win32-x64', targetTriple: 'x86_64-pc-windows-msvc', versionSuffix: 'win32-x64', binaryName };
+    }
+    return null;
+}
+function pathIsWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+async function verifyOfficialCodexRuntimeTrust(binaryPath) {
+    if (process.platform !== 'darwin') {
+        return { ok: true, trustBasis: 'official_package_pin' };
+    }
+    const codesign = '/usr/bin/codesign';
+    if (!await exists(codesign)) {
+        return { ok: false, blocker: 'codex_sdk_official_runtime_codesign_tool_unavailable' };
+    }
+    const verified = await runProcess(codesign, ['--verify', '--deep', '--strict', binaryPath], {
+        timeoutMs: 15_000,
+        maxOutputBytes: 64 * 1024
+    }).catch(() => null);
+    if (!verified || verified.code !== 0 || verified.timedOut) {
+        return { ok: false, blocker: 'codex_sdk_official_runtime_codesign_verify_failed' };
+    }
+    const described = await runProcess(codesign, ['-dv', '--verbose=4', binaryPath], {
+        timeoutMs: 15_000,
+        maxOutputBytes: 64 * 1024
+    }).catch(() => null);
+    if (!described || described.code !== 0 || described.timedOut) {
+        return { ok: false, blocker: 'codex_sdk_official_runtime_codesign_identity_unavailable' };
+    }
+    const details = `${described.stdout || ''}\n${described.stderr || ''}`;
+    const identityMatches = /^Identifier=codex$/m.test(details)
+        && /^TeamIdentifier=2DC432GLL2$/m.test(details)
+        && /^Authority=.*OpenAI.*\(2DC432GLL2\)$/m.test(details);
+    if (!identityMatches) {
+        return { ok: false, blocker: 'codex_sdk_official_runtime_codesign_identity_mismatch' };
+    }
+    return { ok: true, trustBasis: 'macos_codesign_openai_team_2DC432GLL2' };
+}
+function officialRuntimeBlocked(binaryPath, blocker, candidateExists = false) {
+    return {
+        ok: false,
+        identity: null,
+        blockers: [blocker],
+        candidates: [{ source: 'project', path: binaryPath, exists: candidateExists }]
+    };
+}

package/dist/core/commands/agent-bridge-command.js

@@ -10,8 +10,8 @@ async function resolveSksEntrypoint() {
     const sourceBin = fileURLToPath(new URL('../../../bin/sks.js', import.meta.url));
     return (await exists(packedBin)) ? packedBin : sourceBin;
 }
-async function runNonInteractiveSmoke(entrypoint) {
-    const result = await runProcess(process.execPath, [entrypoint, 'status', '--json'], {
+async function runJsonSmoke(entrypoint, args, validate, run) {
+    const result = await run(process.execPath, [entrypoint, ...args], {
         env: { SKS_AGENT_MODE: '1' },
         timeoutMs: 15_000,
         // Status is intentionally bounded but can exceed 32 KiB when several
@@ -19,23 +19,50 @@ async function runNonInteractiveSmoke(entrypoint) {
         // bridge report a false non-interactive failure.
         maxOutputBytes: 512 * 1024
     }).catch((err) => ({ code: 1, stdout: '', stderr: err instanceof Error ? err.message : String(err) }));
-    let stdoutIsCleanJson = false;
+    let parsed = null;
     try {
-        JSON.parse(result.stdout);
-        stdoutIsCleanJson = true;
+        const value = JSON.parse(result.stdout);
+        parsed = value && typeof value === 'object' && !Array.isArray(value) ? value : null;
     }
     catch {
-        stdoutIsCleanJson = false;
+        parsed = null;
     }
+    const issues = parsed ? validate(parsed) : ['stdout_not_clean_json_object'];
+    if (result.code !== 0)
+        issues.push(`exit_code:${String(result.code)}`);
     return {
-        ok: result.code === 0 && stdoutIsCleanJson,
-        command: `SKS_AGENT_MODE=1 ${entrypoint} status --json`,
+        ok: result.code === 0 && issues.length === 0,
+        command: `SKS_AGENT_MODE=1 ${entrypoint} ${args.join(' ')}`,
         exit_code: result.code,
-        note: stdoutIsCleanJson
-            ? 'stdout parsed as clean JSON with SKS_AGENT_MODE=1 set — non-interactive contract verified end-to-end for this one command.'
-            : 'stdout did not parse as clean JSON; a real agent host would fail to consume this — see exit_code/stderr in the report.'
+        note: issues.length === 0
+            ? 'stdout parsed as one clean JSON object with SKS_AGENT_MODE=1 set.'
+            : `non-interactive JSON contract failed: ${issues.join(', ')}`,
+        issues,
+        starts_mission: false
     };
 }
+export async function runAgentBridgeContractSmokes(entrypoint, manifest, run = runProcess) {
+    const naruto = manifest.tools.find((tool) => tool.name === 'naruto');
+    const manifestActions = naruto?.input_schema?.properties?.action?.enum;
+    const [status, narutoHelp] = await Promise.all([
+        runJsonSmoke(entrypoint, ['status', '--json'], () => [], run),
+        runJsonSmoke(entrypoint, ['naruto', 'help', '--json'], (value) => {
+            const issues = [];
+            if (value.schema !== 'sks.naruto-subagent-workflow.v1')
+                issues.push('naruto_help_schema');
+            if (value.action !== 'help')
+                issues.push('naruto_help_action');
+            if (value.workflow !== 'official_codex_subagent')
+                issues.push('naruto_help_workflow');
+            if (value.max_depth !== 1)
+                issues.push('naruto_help_max_depth');
+            if (JSON.stringify(value.commands) !== JSON.stringify(manifestActions))
+                issues.push('naruto_help_manifest_actions');
+            return issues;
+        }, run)
+    ]);
+    return { status, naruto_help: narutoHelp };
+}
 function registrationSnippets() {
     return {
         generic_mcp_host: { command: 'sks', args: ['mcp-server'] },
@@ -80,17 +107,20 @@ export async function agentBridgeCommand(subcommand, args = []) {
     await ensureDir(path.dirname(manifestPath));
     await writeJsonAtomic(manifestPath, manifest);
     const entrypoint = await resolveSksEntrypoint();
-    const smoke = await runNonInteractiveSmoke(entrypoint);
+    const smokes = await runAgentBridgeContractSmokes(entrypoint, manifest);
     const result = {
         schema: 'sks.agent-bridge-setup.v1',
         generated_at: nowIso(),
-        ok: smoke.ok,
+        ok: smokes.status.ok && smokes.naruto_help.ok,
         manifest_path: manifestPath,
         tool_count: manifest.tools.length,
         manifest_validation: manifestValidation,
         registration_snippets: registrationSnippets(),
-        non_interactive_smoke: smoke
+        non_interactive_smoke: smokes.status,
+        naruto_help_smoke: smokes.naruto_help
     };
+    if (!result.ok)
+        process.exitCode = 1;
     if (flag(args, '--json')) {
         console.log(JSON.stringify(result, null, 2));
     }
@@ -100,7 +130,8 @@ export async function agentBridgeCommand(subcommand, args = []) {
         console.log(`  ${JSON.stringify(registrationSnippets().generic_mcp_host)}`);
         console.log('Register with Codex CLI:');
         console.log(`  ${registrationSnippets().codex_cli}`);
-        console.log(`Non-interactive smoke test: ${smoke.ok ? 'ok' : 'FAILED'} (${smoke.note})`);
+        console.log(`Non-interactive status smoke: ${smokes.status.ok ? 'ok' : 'FAILED'} (${smokes.status.note})`);
+        console.log(`Naruto help contract smoke: ${smokes.naruto_help.ok ? 'ok' : 'FAILED'} (${smokes.naruto_help.note})`);
     }
     return result;
 }

package/dist/core/commands/basic-cli.js

@@ -17,7 +17,7 @@ import { createMission } from '../mission.js';
 import { formatSksUpdateStatusText, runSksUpdateNow, runSksUpdateReview, runSksUpdateRollback, runSksUpdateStatus } from '../update-check.js';
 import { persistSksUpdateNoticeFromVersions } from '../update/update-notice.js';
 import { withSecretPreservationGuard } from '../config/config-migration-journal.js';
-const REMOVED_USAGE_TOPICS = new Set(['db']);
+const REMOVED_USAGE_TOPICS = new Set(['db', 'ui']);
 export async function helpCommand(args = []) {
     const topic = args[0];
     if (topic)

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

@@ -84,10 +84,10 @@ export function ambientGoalContinuation() {
     return {
         schema_version: 1,
         enabled: true,
-        mode: 'ambient_codex_native_goal_overlay',
+        mode: 'codex_native_goal_only',
         native_slash_command: '/goal',
         non_disruptive: true,
-        rule: 'Use Codex native goal persistence to keep long work resumable when available, but never replace Naruto, TriWiki, verification, or Honest Mode route gates.'
+        rule: 'Use Codex native Goal as the only persisted goal owner. Never create SKS Goal missions, bridge artifacts, compatibility loops, or fallback goal state.'
     };
 }
 export function knownGeneratedSkillNames() {

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

@@ -47,11 +47,28 @@ async function saveEvalReport(root, args, report, prefix) {
 function pct(x) {
     return `${(100 * x).toFixed(1)}%`;
 }
+function printSizeAndTokens(report, comparison) {
+    const baselineSize = report.baseline.serialized_size_bytes;
+    const candidateSize = report.candidate.serialized_size_bytes;
+    if (baselineSize !== undefined && candidateSize !== undefined) {
+        const delta = comparison.serialized_size_savings_pct;
+        const suffix = delta === null || delta === undefined
+            ? ''
+            : delta >= 0 ? ` (${pct(delta)} smaller)` : ` (${pct(-delta)} larger)`;
+        console.log(`JSON size: ${baselineSize} B -> ${candidateSize} B${suffix} (non-token proxy)`);
+    }
+    if (comparison.token_measurement?.available) {
+        console.log(`Tokens:    ${report.baseline.token_count} -> ${report.candidate.token_count} (${pct(comparison.token_savings_pct)} saved)`);
+    }
+    else {
+        console.log('Tokens:    not measured (actual token counts with evidence required)');
+    }
+}
 function printEvalRun(report, saved) {
     const c = report.comparison;
     console.log('Sneakoscope Eval');
     console.log(`Scenario:  ${report.scenario.id}`);
-    console.log(`Tokens:    ${report.baseline.estimated_tokens} -> ${report.candidate.estimated_tokens} (${pct(c.token_savings_pct)} saved)`);
+    printSizeAndTokens(report, c);
     console.log(`Accuracy:  ${report.baseline.quality.accuracy_proxy} -> ${report.candidate.quality.accuracy_proxy} (${c.accuracy_delta >= 0 ? '+' : ''}${c.accuracy_delta})`);
     console.log(`Meaningful improvement: ${c.meaningful_improvement ? 'yes' : 'no'}`);
     if (saved)
@@ -62,7 +79,7 @@ function printEvalCompare(report, saved) {
     console.log('Sneakoscope Eval Compare');
     console.log(`Baseline:  ${report.baseline_label}`);
     console.log(`Candidate: ${report.candidate_label}`);
-    console.log(`Tokens:    ${report.baseline.estimated_tokens} -> ${report.candidate.estimated_tokens} (${pct(c.token_savings_pct)} saved)`);
+    printSizeAndTokens(report, c);
     console.log(`Accuracy:  ${report.baseline.quality.accuracy_proxy} -> ${report.candidate.quality.accuracy_proxy} (${c.accuracy_delta >= 0 ? '+' : ''}${c.accuracy_delta})`);
     console.log(`Meaningful improvement: ${c.meaningful_improvement ? 'yes' : 'no'}`);
     if (saved)

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

@@ -1,92 +1,43 @@
-import path from 'node:path';
-import { exists, readJson, sksRoot } from '../fsx.js';
-import { initProject } from '../init.js';
-import { createMission, loadMission, setCurrent, stateFile } from '../mission.js';
-import { createAndWriteWorkOrderLedgerForPrompt, closeWorkOrderLedgerForRouteResult } from '../work-order-ledger.js';
-import { GOAL_BRIDGE_ARTIFACT, GOAL_WORKFLOW_ARTIFACT, updateGoalWorkflow, writeGoalWorkflow } from '../goal-workflow.js';
-import { flag, promptOf, resolveMissionId } from './command-utils.js';
-import { compileGoalToLoopPlan } from '../loops/goal-to-loop-compat.js';
-import { runLoopPlan } from '../loops/loop-runtime.js';
-import { evaluateLocalGate } from './route-success-helpers.js';
+import { buildNativeGoalRequest } from '../goal-workflow.js';
+import { flag, promptOf } from './command-utils.js';
+const ACTIONS = new Set(['create', 'edit', 'pause', 'resume', 'clear', 'status']);
 export async function goalCommand(sub, args = []) {
-    const known = new Set(['create', 'pause', 'resume', 'clear', 'status', 'help', '--help', '-h']);
-    const action = known.has(sub) ? sub : 'create';
-    const actionArgs = action === 'create' && sub && !known.has(sub) ? [sub, ...args] : args;
-    if (action === 'create')
-        return goalCreate(actionArgs);
-    if (action === 'pause' || action === 'resume' || action === 'clear')
-        return goalControl(action, actionArgs);
-    if (action === 'status')
-        return goalStatus(actionArgs);
-    console.log(`SKS Goal
+    if (sub === 'help' || sub === '--help' || sub === '-h')
+        return printHelp();
+    if (flag(args, '--legacy-goal-runtime') || process.env.SKS_LEGACY_GOAL_RUNTIME === '1') {
+        throw new Error('The SKS Goal runtime was removed. Use Codex native /goal only.');
+    }
+    const action = ACTIONS.has(sub) ? sub : 'create';
+    const actionArgs = action === 'create' && sub && !ACTIONS.has(sub) ? [sub, ...args] : args;
+    const prompt = action === 'create' || action === 'edit' ? promptOf(actionArgs) : '';
+    const request = buildNativeGoalRequest(action, prompt);
+    if (flag(args, '--json')) {
+        console.log(JSON.stringify(request, null, 2));
+        return;
+    }
+    console.log([
+        'Codex native Goal only; SKS did not create or modify goal state.',
+        'Run this in Codex:',
+        '',
+        request.slash_command
+    ].join('\n'));
+}
+function printHelp() {
+    console.log(`SKS Goal compatibility helper (stateless)
+
+Codex native /goal is the only goal owner. This command writes no SKS mission,
+artifact, loop, fallback state, or current-route state.
 
 Usage:
   sks goal create "task"
-  sks goal pause <mission-id|latest>
-  sks goal resume <mission-id|latest>
-  sks goal clear <mission-id|latest>
-  sks goal status <mission-id|latest>
+  sks goal edit "revised task"
+  sks goal pause
+  sks goal resume
+  sks goal clear
+  sks goal status
+
+The create/edit helper expands the task into Outcome, Scope, Constraints,
+Verification, Done when, Stop conditions, and Non-goals before printing the
+native Codex command. Prefer using /goal directly in Codex.
 `);
 }
-async function goalCreate(args) {
-    const root = await sksRoot();
-    if (!(await exists(path.join(root, '.sneakoscope'))))
-        await initProject(root, {});
-    const prompt = promptOf(args);
-    if (!prompt)
-        throw new Error('Missing goal task prompt.');
-    if (flag(args, '--legacy-goal-runtime') || process.env.SKS_LEGACY_GOAL_RUNTIME === '1')
-        return legacyGoalCreate(root, prompt, args);
-    const { id, dir, mission } = await createMission(root, { mode: 'goal', prompt });
-    await createAndWriteWorkOrderLedgerForPrompt(dir, { missionId: id, route: 'Goal', prompt });
-    const workflow = await writeGoalWorkflow(dir, mission, { action: 'create', prompt });
-    const plan = await compileGoalToLoopPlan({ root, missionId: id, goalText: prompt, legacyGoalOptions: { native_goal: workflow.native_goal } });
-    const result = await runLoopPlan({ root, plan, parallelism: 'balanced' });
-    const gate = await evaluateLocalGate({ root, missionId: id, gateFile: 'loop-graph-proof.json' });
-    const ok = result.ok === true && gate.ok === true;
-    await closeWorkOrderLedgerForRouteResult(dir, { ok, blockers: gate.blockers || [] });
-    await setCurrent(root, { mission_id: id, mode: 'GOAL', route: 'Goal', route_command: '$Goal', phase: ok ? 'GOAL_LOOP_COMPLETED' : 'GOAL_LOOP_BLOCKED', questions_allowed: true, implementation_allowed: true, native_goal: workflow.native_goal, stop_gate: 'loop-graph-proof.json', stop_gate_blockers: gate.blockers }, { replace: true });
-    if (!ok)
-        process.exitCode = 1;
-    if (flag(args, '--json'))
-        return console.log(JSON.stringify({ schema: 'sks.goal-create.v1', ok, mission_id: id, workflow, loop_plan: plan, loop_result: result, gate }, null, 2));
-    console.log(`Goal compiled to Loop Graph: ${id}`);
-    if (!ok)
-        console.log(`Gate blocked: ${gate.blockers.join(', ') || 'loop_result_not_ok'}`);
-    console.log('Use `sks loop status latest` to inspect.');
-    console.log(`Artifact: ${path.relative(root, path.join(dir, GOAL_WORKFLOW_ARTIFACT))}`);
-    console.log(`Bridge: ${path.relative(root, path.join(dir, GOAL_BRIDGE_ARTIFACT))}`);
-    console.log(`Native Codex control: ${workflow.native_goal.slash_command}`);
-}
-async function legacyGoalCreate(root, prompt, args) {
-    const { id, dir, mission } = await createMission(root, { mode: 'goal', prompt });
-    const workflow = await writeGoalWorkflow(dir, mission, { action: 'create', prompt });
-    await setCurrent(root, { mission_id: id, mode: 'GOAL', route: 'Goal', route_command: '$Goal', phase: 'GOAL_READY', questions_allowed: true, implementation_allowed: true, native_goal: workflow.native_goal, stop_gate: 'none' }, { replace: true });
-    if (flag(args, '--json'))
-        return console.log(JSON.stringify({ schema: 'sks.goal-create.v1', ok: true, mission_id: id, workflow, runtime: 'legacy-goal' }, null, 2));
-    console.log(`Goal mission created: ${id}`);
-    console.log(`Artifact: ${path.relative(root, path.join(dir, GOAL_WORKFLOW_ARTIFACT))}`);
-    console.log(`Bridge: ${path.relative(root, path.join(dir, GOAL_BRIDGE_ARTIFACT))}`);
-    console.log(`Native Codex control: ${workflow.native_goal.slash_command}`);
-}
-async function goalControl(action, args) {
-    const root = await sksRoot();
-    const id = await resolveMissionId(root, args[0]);
-    if (!id)
-        throw new Error(`Usage: sks goal ${action} <mission-id|latest>`);
-    const { dir } = await loadMission(root, id);
-    const workflow = await updateGoalWorkflow(dir, action);
-    await setCurrent(root, { mission_id: id, mode: 'GOAL', route: 'Goal', route_command: '$Goal', phase: `GOAL_${String(action).toUpperCase()}`, native_goal: workflow.native_goal, questions_allowed: true, implementation_allowed: action !== 'pause' && action !== 'clear', stop_gate: 'none' }, { replace: true });
-    console.log(`Goal ${action}: ${id}`);
-    console.log(`Native Codex control: ${workflow.native_goal.slash_command}`);
-}
-async function goalStatus(args) {
-    const root = await sksRoot();
-    const id = await resolveMissionId(root, args[0]);
-    if (!id)
-        throw new Error('Usage: sks goal status <mission-id|latest>');
-    const { dir, mission } = await loadMission(root, id);
-    const state = await readJson(stateFile(root), {});
-    const workflow = await readJson(path.join(dir, GOAL_WORKFLOW_ARTIFACT), null);
-    console.log(JSON.stringify({ mission, state, goal_workflow: workflow }, null, 2));
-}

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

@@ -374,7 +374,6 @@ export async function madHighCommand(args = [], deps = {}) {
             session_name: launch.session_name || null,
             live_panes: !headlessZellij,
             initial_panes: 'orchestrator-monitor-viewports',
-            dashboard_created: true,
             worker_panes_created: 0,
             viewport_panes_created: Number(madSksEnv.SKS_ZELLIJ_VIEWPORTS),
             ui_architecture: 'monitor_plus_viewports',
@@ -720,7 +719,6 @@ function baseMadLaunchOnlyFlags() {
         '--install-homebrew',
         '--headless',
         '--zellij-compact-slots',
-        '--zellij-dashboard',
         '--zellij-full-debug',
         '--allow-system',
         '--allow-db-write',