sneakoscope 7.1.0 → 7.3.0

package/dist/core/codex-app.js

@@ -7,11 +7,13 @@ import { CODEX_CHROME_EXTENSION_DOC_URL, DEFAULT_CODEX_APP_PLUGINS as DEFAULT_CO
 import { PRODUCT_DESIGN_PLUGIN, normalizeProductDesignPluginEvidence } from './product-design-plugin.js';
 import { PRODUCT_DESIGN_AUTO_INSTALL_ENV, ensureProductDesignPluginInstalled, productDesignAutoInstallRequested } from './product-design-app-server.js';
 import { GLM_CODEX_CONFIG_PROVIDER_ID, GLM_52_OPENROUTER_MODEL, RETIRED_GLM_DESKTOP_CONFIG_PROFILE_IDS } from './codex-app/openrouter-provider.js';
+import { sksOpenRouterCatalogPath } from './codex-app/codex-model-catalog.js';
 import { resolveOpenRouterApiKey } from './providers/openrouter/openrouter-secret-store.js';
 import { codexLbEnvPath, loadCodexLbEnv, parseShellEnvValue, readCodexLbModelCatalog } from './codex-lb/codex-lb-env.js';
 import { codexLbToolCatalogPath, inspectCodexLbToolCatalog } from './codex-lb/codex-lb-tool-catalog.js';
 import { isSksOwnedGlobalUiLock } from './codex-app/codex-app-ui-state-snapshot.js';
 import { redactString } from './secret-redaction.js';
+import { escapeRegExp } from './text/regex.js';
 export const CODEX_APP_DOCS_URL = 'https://developers.openai.com/codex/app/features';
 export const CODEX_CHANGELOG_URL = 'https://developers.openai.com/codex/changelog';
 export const CODEX_ACCESS_TOKENS_DOCS_URL = 'https://developers.openai.com/codex/enterprise/access-tokens';
@@ -944,6 +946,8 @@ export async function codexProviderModelUiStatus(opts = {}) {
         && hasTomlBoolean(codexLbProvider, 'supports_websockets', true)
         && hasTomlBoolean(codexLbProvider, 'requires_openai_auth', true);
     const codexLbSelectedDefault = /(?:^|\n)\s*model_provider\s*=\s*"codex-lb"\s*(?:#.*)?(?=\n|$)/.test(topLevelToml(globalConfig));
+    const selectedProviderValue = topLevelToml(globalConfig)
+        .match(/(?:^|\n)\s*model_provider\s*=\s*"([^"]+)"\s*(?:#.*)?(?=\n|$)/)?.[1] || null;
     const managedCatalogPath = codexLbToolCatalogPath(path.join(home || '', '.codex'));
     const configuredCatalogPath = topLevelToml(globalConfig).match(/(?:^|\n)\s*model_catalog_json\s*=\s*"([^"]+)"\s*(?:#.*)?(?=\n|$)/)?.[1] || '';
     const managedCatalogConfigured = Boolean(configuredCatalogPath)
@@ -995,10 +999,30 @@ export async function codexProviderModelUiStatus(opts = {}) {
             ? ['codex_lb_gpt_5_6_catalog_unverified']
             : [])
     ];
-    const selectedProviderBlockers = codexLbSelectedDefault ? codexLbBlockers : [];
+    const openRouterSelectedDefault = selectedProviderValue === GLM_CODEX_CONFIG_PROVIDER_ID;
+    const openRouterManagedCatalogPath = sksOpenRouterCatalogPath({ home });
+    const openRouterCatalogBound = Boolean(configuredCatalogPath)
+        && path.resolve(configuredCatalogPath) === path.resolve(openRouterManagedCatalogPath);
+    const openRouterCatalogDangling = openRouterCatalogBound && !openRouterSelectedDefault;
+    const openRouterSelectedBlockers = openRouterSelectedDefault
+        ? [
+            ...glmBlockers,
+            ...(openRouterCatalogBound ? [] : ['openrouter_model_catalog_json_unselected'])
+        ]
+        : [];
+    const selectedProviderBlockers = [
+        ...(codexLbSelectedDefault
+            ? codexLbBlockers
+            : openRouterSelectedDefault
+                ? openRouterSelectedBlockers
+                : []),
+        ...(openRouterCatalogDangling ? ['openrouter_model_catalog_json_dangling'] : [])
+    ];
     const optionalProviderBlockers = codexLbSelectedDefault
         ? glmBlockers
-        : [...glmBlockers, ...codexLbBlockers];
+        : openRouterSelectedDefault
+            ? codexLbBlockers
+            : [...glmBlockers, ...codexLbBlockers];
     const keyCommand = 'sks codex-app set-openrouter-key --api-key-stdin';
     const installCommand = 'sks codex-app use-openrouter --model z-ai/glm-5.2';
     const setupCommand = 'sks codex-lb setup --host <domain> --api-key-stdin --yes';
@@ -1007,7 +1031,7 @@ export async function codexProviderModelUiStatus(opts = {}) {
         schema: 'sks.codex-app-provider-model-ui.v1',
         ok: selectedProviderBlockers.length === 0,
         selected_provider_ok: selectedProviderBlockers.length === 0,
-        selected_provider: codexLbSelectedDefault ? 'codex-lb' : 'oauth',
+        selected_provider: codexLbSelectedDefault ? 'codex-lb' : (selectedProviderValue || 'oauth'),
         selected_provider_blockers: selectedProviderBlockers,
         optional_provider_blockers: optionalProviderBlockers,
         checked: true,
@@ -1030,6 +1054,9 @@ export async function codexProviderModelUiStatus(opts = {}) {
             openrouter_key_present: Boolean(openRouterKey.key),
             openrouter_key_source: openRouterKey.source || null,
             openrouter_key_preview: openRouterKey.key_preview || null,
+            openrouter_selected: openRouterSelectedDefault,
+            model_catalog_json_configured: openRouterCatalogBound,
+            model_catalog_json_path: openRouterManagedCatalogPath,
             key_command: keyCommand,
             install_command: installCommand,
             doctor_command: 'sks codex-app openrouter-status',
@@ -1197,9 +1224,6 @@ function hasTomlBoolean(text = '', key = '', value) {
     const re = new RegExp(`(?:^|\\n)\\s*${escapeRegExp(key)}\\s*=\\s*${expected}\\s*(?:#.*)?(?=\\n|$)`);
     return re.test(String(text || ''));
 }
-function escapeRegExp(text = '') {
-    return String(text).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 function remoteControlGuidance(status = {}) {
     if (!status.codex_cli?.ok)
         return 'Codex remote-control requires Codex CLI 0.130.0+. Install with: npm i -g @openai/codex@latest';

package/dist/core/codex-compat/codex-hook-semantic-validator.js

@@ -1,5 +1,6 @@
 import { codexHookEventName } from './codex-schema-snapshot.js';
 import { codexHookIssuesByCategory, dedupeCodexHookIssues, makeCodexHookIssue } from './codex-hook-issues.js';
+import { asRecordOrNull as asRecord } from '../json/records.js';
 const LEGACY_TOP_LEVEL_KEYS = new Set([
     'permissionDecision',
     'permissionDecisionReason',
@@ -215,9 +216,6 @@ function result(event, issues) {
         reason: uniqueFatal[0] || null
     };
 }
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
-}
 function nonEmpty(value) {
     return typeof value === 'string' && value.trim().length > 0;
 }

package/dist/core/codex-control/codex-app-server-v2-client.js

@@ -88,8 +88,33 @@ export class CodexAppServerV2Client {
         });
     }
     async waitForTurnCompletion(threadId, turnId, timeoutMs = this.timeoutMs) {
-        const expected = turnId ? ['turn/completed', 'thread/closed', 'thread/status/changed'] : ['turn/completed', 'thread/closed'];
-        return await this.waitForNotification(expected, timeoutMs);
+        const buffered = this.notifications.find((event) => isTurnCompletionEvent(event, threadId, turnId));
+        if (buffered)
+            return buffered;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                dispose();
+                reject(new Error(`Timed out waiting for app-server turn completion: ${threadId}:${turnId ?? '*'}`));
+            }, timeoutMs);
+            timer.unref?.();
+            const dispose = this.onEvent((event) => {
+                const method = String(event.method || '');
+                const params = event.params && typeof event.params === 'object'
+                    ? event.params
+                    : {};
+                if (method === 'thread/closed' && String(params.threadId || '') === threadId) {
+                    clearTimeout(timer);
+                    dispose();
+                    reject(new Error(`Codex thread closed before turn completion: ${threadId}`));
+                    return;
+                }
+                if (!isTurnCompletionEvent(event, threadId, turnId))
+                    return;
+                clearTimeout(timer);
+                dispose();
+                resolve(event);
+            });
+        });
     }
     start() {
         if (this.child)
@@ -292,3 +317,15 @@ function jsonRpcErrorMessage(method, error) {
         return `${method}: ${String(error.message)}`;
     return `${method}: ${JSON.stringify(error)}`;
 }
+function isTurnCompletionEvent(event, threadId, turnId) {
+    if (String(event.method || '') !== 'turn/completed')
+        return false;
+    const params = event.params && typeof event.params === 'object'
+        ? event.params
+        : {};
+    const completedTurn = params.turn && typeof params.turn === 'object'
+        ? params.turn
+        : {};
+    return String(params.threadId || '') === threadId
+        && (!turnId || String(completedTurn.id || params.turnId || '') === turnId);
+}

package/dist/core/codex-lb/codex-lb-env.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import os from 'node:os';
 import { exists, readJson, readText, runProcess, which } from '../fsx.js';
+import { escapeRegExp } from '../text/regex.js';
 const KEYCHAIN_WRITER_SWIFT = `import Foundation
 import Security
 let a=CommandLine.arguments[1],s=CommandLine.arguments[2]
@@ -389,6 +390,3 @@ async function sha256Full(value) {
 function redactSecret(text, secret) {
     return String(text || '').split(String(secret || '')).join('[redacted]');
 }
-function escapeRegExp(value) {
-    return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

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

@@ -20,14 +20,16 @@ const REQUIRED_CODEX_0144_MODEL_FIELDS = {
     supported_in_api: ['boolean'],
     priority: ['number'],
     base_instructions: ['string'],
-    supports_reasoning_summaries: ['boolean'],
     support_verbosity: ['boolean'],
     truncation_policy: ['object'],
     supports_parallel_tool_calls: ['boolean'],
     experimental_supported_tools: ['array']
 };
+const REASONING_SUMMARY_FIELD_NAMES = ['supports_reasoning_summaries', 'supports_reasoning_summary_parameter'];
 const CODEX_0144_MODEL_FIELD_TYPES = {
     ...REQUIRED_CODEX_0144_MODEL_FIELDS,
+    supports_reasoning_summaries: ['boolean'],
+    supports_reasoning_summary_parameter: ['boolean'],
     description: ['string'],
     default_reasoning_level: ['string'],
     additional_speed_tiers: ['array'],
@@ -357,6 +359,9 @@ function validateCodex0144Model(row, index) {
         if (!allowedTypes.includes(valueType(row[field])))
             issues.push(`codex_lb_model_catalog_field_type_invalid:${index}:${field}`);
     }
+    if (!REASONING_SUMMARY_FIELD_NAMES.some((field) => Object.prototype.hasOwnProperty.call(row, field))) {
+        issues.push(`codex_lb_model_catalog_required_field_missing:${index}:supports_reasoning_summaries`);
+    }
     for (const [field, value] of Object.entries(row)) {
         if (!(CODEX_0144_MODEL_FIELD_TYPES[field] || []).includes(valueType(value)))
             issues.push(`codex_lb_model_catalog_field_type_invalid:${index}:${field}`);

package/dist/core/codex-native/codex-native-feature-broker.js

@@ -16,6 +16,8 @@ import { MANAGED_OFFICIAL_SUBAGENT_ROLES, MANAGED_SKILLS, managedOfficialSubagen
 import { buildMcpPluginServerCandidates } from '../mcp/mcp-plugin-inventory.js';
 import { codexNativeFeatureState, computeCodexNativeInvocationDefaults } from './codex-native-feature-matrix.js';
 import { currentCodexSkillRoots, currentSksSkillName, resolveAuthoritativeSksSkillSources } from './sks-skill-paths.js';
+import { messageOf } from '../errors/message.js';
+import { isRecord } from '../json/records.js';
 const REPORT_PATH = '.sneakoscope/reports/codex-native-feature-matrix.json';
 const REQUIRED_SKILL_NAMES = MANAGED_SKILLS.map((skill) => currentSksSkillName(skill.id));
 const REQUIRED_AGENT_ROLES = MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => role.id);
@@ -396,9 +398,3 @@ function codex0144State(capability, key) {
         input.unavailableStatus = 'fallback';
     return codexNativeFeatureState(input);
 }
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
-}

package/dist/core/codex-native/codex-native-interop-policy.js

@@ -6,6 +6,7 @@ import { buildCodexPluginInventory } from '../codex-plugins/codex-plugin-json.js
 import { inspectConfinedPath, isLexicallyConfined } from '../managed-path-safety.js';
 import { currentCodexSkillRoots } from './sks-skill-paths.js';
 import { writeRootConfinedJsonReport } from './confined-report-writer.js';
+import { messageOf } from '../errors/message.js';
 const RESERVED_EXTERNAL_ROUTE_SKILLS = ['ulw-loop', 'ulw-plan', 'start-work'];
 export async function buildCodexNativeInteropPolicy(input) {
     const root = path.resolve(input.root);
@@ -64,9 +65,6 @@ function normalizeInventory(value) {
         blockers: Array.isArray(record.blockers) ? record.blockers.map(String) : []
     };
 }
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
-}
 async function discoverSkillNames(roots) {
     const names = new Set();
     const blockers = new Set();

package/dist/core/codex-native/codex-native-reference-cache.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { exists, nowIso, runProcess, sha256, writeJsonAtomic } from '../fsx.js';
+import { messageOf } from '../errors/message.js';
 export async function ensureCodexNativeReferenceSnapshot(input) {
     const root = path.resolve(input.root);
     const cacheDir = path.join(root, '.sneakoscope', 'cache', 'codex-native-reference');
@@ -92,6 +93,3 @@ async function gitSha(sourceDir) {
     const sha = run?.code === 0 ? `${run.stdout || ''}`.trim() : '';
     return /^[0-9a-f]{40}$/i.test(sha) ? sha : null;
 }
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
-}

package/dist/core/codex-native/codex-native-reference-source.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { ensureCodexNativeReferenceSnapshot } from './codex-native-reference-cache.js';
+import { messageOf } from '../errors/message.js';
 const PATTERNS = [
     { id: 'no-global-optional-tooling', claim: 'optional tooling avoids mandatory global install', re: /\bnpx\b|no[- ]global|global install/i },
     { id: 'plugin-lifecycle-state-separation', claim: 'plugin install state is separated from approval/readiness', re: /\bplugin\b.+\b(install|enable|marketplace|lifecycle)\b/i },
@@ -143,6 +144,3 @@ async function gitSha(sourceDir) {
         return (await fs.readFile(path.join(sourceDir, '.git', ref), 'utf8').catch(() => '')).trim() || null;
     return /^[0-9a-f]{40}$/i.test(head.trim()) ? head.trim() : null;
 }
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
-}

package/dist/core/codex-native/codex-native-repair-transaction.js

@@ -6,6 +6,7 @@ import { syncCodexSksSkills } from '../codex-app/codex-skill-sync.js';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
 import { createRequestedScopeContract } from '../safety/requested-scope-contract.js';
 import { evaluateMutation, mutationLedgerPath, recordMutation } from '../safety/mutation-ledger.js';
+import { messageOf } from '../errors/message.js';
 export async function repairCodexNativeManagedAssets(input) {
     const root = path.resolve(input.root);
     const requested = {
@@ -144,6 +145,3 @@ function listLength(value, key) {
     }
     return Array.isArray(current) ? current.length : 0;
 }
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
-}

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

@@ -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: '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.',
+        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 4/6/8 by task size and may expand to 12 when independent useful slices and healthy host capacity remain positive; 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.',
@@ -47,7 +47,8 @@ const CORE_SKILL_DEFINITIONS = [
         route: '$Research',
         purpose: 'run evidence-bound discovery, source ledgers, and synthesis cycles.',
         when: 'Use for discovery, evaluation, external-source claims, or frontier-style research.',
-        workflow: 'Run layered Super Search first and accept only source rows correlated to verified proof, source-ledger, and hydrated-content artifacts. Then run exactly three independent official research_reviewer threads on GPT-5.6 Sol Max using Einstein, von Neumann, and Skeptic composite lenses. Any objection triggers a mission-local research_synthesizer revision and a fresh three-thread review cycle. agent-ledger.json and debate-ledger.json are compatibility projections only; do not launch a removed legacy scheduler or a custom debate pool.',
+        workflow: 'Frame the research criteria and map assumptions before retrieval. Run layered Super Search first and accept only source rows correlated to verified proof, source-ledger, and hydrated-content artifacts. Then run exactly three independent official research_reviewer threads on GPT-5.6 Sol Max using Einstein, von Neumann, and Skeptic composite lenses. Each reviewer must return one literal "Eureka!" idea, source ids, falsifiers, cheap probes, and zero unresolved objections before approval. Any objection triggers a mission-local research_synthesizer revision and a fresh three-thread review cycle. agent-ledger.json and debate-ledger.json are compatibility projections only; do not launch a removed legacy scheduler or a custom debate pool.',
+        safety: 'Preserve user-authored content, keep research route state bounded, and do not edit repository source. Do not overclaim genius, novelty, breakthrough, publication acceptance, or experimental support beyond recorded evidence.',
         evidence: 'research plan, source ledger, cycle record, synthesis, and final review.',
         fallback: 'State source/tool unavailability and avoid unsupported live-accuracy claims.'
     },

package/dist/core/codex-native/native-capability-repair-matrix.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { ensureDir, nowIso, writeJsonAtomic } from '../fsx.js';
 import { detectImagegenCapability } from '../imagegen/imagegen-capability.js';
 import { buildCodexNativeFeatureMatrix } from './codex-native-feature-broker.js';
+import { messageOf } from '../errors/message.js';
 export const NATIVE_CAPABILITY_IDS = [
     'image_generation',
     'image_followup_edit',
@@ -317,6 +318,3 @@ function fixtureNativeFeatureMatrix(mode) {
         blockers: ok ? [] : ['fixture_manual_required']
     };
 }
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
-}

package/dist/core/codex-plugins/codex-plugin-repair.js

@@ -2,6 +2,7 @@ import { findCodexBinary } from '../codex-adapter.js';
 import { nowIso, runProcess } from '../fsx.js';
 import { redactSecrets, redactString } from '../secret-redaction.js';
 import { buildCodexPluginInventory } from './codex-plugin-json.js';
+import { messageOf } from '../errors/message.js';
 export const CODEX_PLUGIN_REPAIR_SCHEMA = 'sks.codex-plugin-repair.v1';
 export async function ensureCodexPlugins(input) {
     const pluginIds = [...new Set((input.pluginIds || []).map(String))];
@@ -112,6 +113,3 @@ function tail(value, max = 2000) {
     const text = redactString(String(value || ''));
     return text.length > max ? text.slice(-max) : text;
 }
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
-}

package/dist/core/codex-runtime/codex-desktop-config-policy.js

@@ -4,6 +4,7 @@ import { DEFAULT_CODEX_APP_PLUGINS } from '../routes.js';
 import { ensureDir, PACKAGE_VERSION, readText, writeTextAtomic } from '../fsx.js';
 import { removeLegacyTopLevelCodexModeLocks, writeCodexConfigGuarded } from '../codex/codex-config-guard.js';
 import { cleanupCodexConfigBackups, validateCodexConfigRoundTrip } from '../codex/codex-config-toml.js';
+import { escapeRegExp } from '../text/regex.js';
 export async function ensureGlobalCodexFastModeDuringInstall(opts = {}) {
     if (process.env.SKS_SKIP_CODEX_FAST_MODE_REPAIR === '1')
         return { status: 'skipped', reason: 'SKS_SKIP_CODEX_FAST_MODE_REPAIR=1' };
@@ -61,6 +62,7 @@ function normalizeCodexFastModeUiConfigOnce(text = '', opts = {}) {
     for (const legacyFlag of ['codex_hooks', 'remote_control', 'fast_mode_ui', 'codex_git_commit']) {
         next = removeTomlTableKey(next, 'features', legacyFlag, 'true');
     }
+    next = removeTomlTableKey(next, 'features', 'multi_agent');
     if (opts.forceFastMode === true) {
         next = upsertTopLevelTomlString(next, 'service_tier', 'fast');
     }
@@ -70,7 +72,6 @@ function normalizeCodexFastModeUiConfigOnce(text = '', opts = {}) {
     next = upsertTopLevelTomlBooleanIfAbsent(next, 'suppress_unstable_features_warning', true);
     for (const featureLine of [
         'hooks = true',
-        'multi_agent = true',
         'fast_mode = true',
         'apps = true',
         'computer_use = true',
@@ -239,6 +240,8 @@ export async function safeWriteCodexConfigToml(configPath, current, next, tag =
         cause: tag,
         removeTopLevelModeLocks: true,
         ...(opts.preserveFastUiKeys === undefined ? {} : { preserveFastUiKeys: opts.preserveFastUiKeys }),
+        ...(opts.verifyUnchangedBeforeWrite === undefined ? {} : { verifyUnchangedBeforeWrite: opts.verifyUnchangedBeforeWrite }),
+        ...(opts.expectedBeforeExists === undefined ? {} : { expectedBeforeExists: opts.expectedBeforeExists }),
         mutate: () => String(next || '')
     });
 }
@@ -299,6 +302,3 @@ export function upsertTomlTable(text, table, block) {
     lines.splice(start, end - start, ...blockLines);
     return lines.join('\n').replace(/\n{3,}/g, '\n\n');
 }
-function escapeRegExp(value) {
-    return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

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

@@ -3,7 +3,8 @@ import { fileURLToPath } from 'node:url';
 import { ensureDir, exists, nowIso, projectRoot, runProcess, writeJsonAtomic } from '../fsx.js';
 import { agentManifestDigest, buildAgentManifest, validateAgentManifest } from '../agent-bridge/agent-manifest.js';
 import { inspectHostCapabilityRuntime } from '../agent-bridge/host-capability-runtime.js';
-import { flag } from './command-utils.js';
+import { renderHostCapabilityBlockedLines } from '../agent-bridge/host-capability-policy.js';
+const flag = (args = [], name) => args.includes(name);
 async function resolveSksEntrypoint() {
     const packedBin = fileURLToPath(new URL('../../bin/sks.js', import.meta.url));
     const sourceBin = fileURLToPath(new URL('../../../bin/sks.js', import.meta.url));
@@ -93,7 +94,8 @@ export async function agentBridgeCommand(subcommand, args = []) {
         if (flag(args, '--json'))
             console.log(JSON.stringify(result, null, 2));
         else
-            console.log(`Unknown agent-bridge subcommand "${sub}". Supported: setup`);
+            for (const line of renderAgentBridgeBlockedLines([result.error]))
+                console.error(line);
         return result;
     }
     const root = await projectRoot();
@@ -115,7 +117,8 @@ export async function agentBridgeCommand(subcommand, args = []) {
         if (flag(args, '--json'))
             console.log(JSON.stringify(result, null, 2));
         else
-            console.error(`Agent bridge manifest validation failed: ${manifestValidation.issues.join(', ')}`);
+            for (const line of renderAgentBridgeBlockedLines([result.status, ...manifestValidation.issues]))
+                console.error(line);
         return result;
     }
     await ensureDir(path.dirname(manifestPath));
@@ -144,6 +147,11 @@ export async function agentBridgeCommand(subcommand, args = []) {
         console.log(JSON.stringify(result, null, 2));
     }
     else {
+        if (!result.ok) {
+            for (const line of renderAgentBridgeBlockedLines(agentBridgeBlockers(result)))
+                console.error(line);
+            return result;
+        }
         console.log(`Agent bridge manifest written: ${manifestPath} (${manifest.tools.length} tools)`);
         console.log('Register with a generic MCP host:');
         console.log(`  ${JSON.stringify(registrationSnippets().generic_mcp_host)}`);
@@ -155,3 +163,16 @@ export async function agentBridgeCommand(subcommand, args = []) {
     }
     return result;
 }
+export function renderAgentBridgeBlockedLines(blockers) {
+    return renderHostCapabilityBlockedLines(blockers, {
+        reason: 'Agent Bridge 설정이 완료 조건을 충족하지 못했습니다.',
+        action: '세부 코드를 확인해 가장 먼저 표시된 원인을 해결한 뒤 다시 실행하세요.'
+    });
+}
+function agentBridgeBlockers(result) {
+    return [
+        ...(!result.non_interactive_smoke?.ok ? ['agent_bridge_status_smoke_failed', ...(result.non_interactive_smoke?.issues || [])] : []),
+        ...(!result.naruto_help_smoke?.ok ? ['agent_bridge_naruto_help_smoke_failed', ...(result.naruto_help_smoke?.issues || [])] : []),
+        ...(result.host_capability_inventory?.blockers || [])
+    ];
+}

package/dist/core/commands/image-ux-review-command.js

@@ -13,6 +13,7 @@ import { sha256File, imageDimensions } from '../wiki-image/image-hash.js';
 import { writeRouteCollaborationArtifacts } from '../agents/route-collaboration-ledger.js';
 import { codexChromeExtensionStatus } from '../codex-app.js';
 import { requireCodexImagegen } from '../imagegen/require-imagegen.js';
+import { imagegenEvidenceClassBlockers, isFullImagegenEvidenceClass, isFullImagegenOutputSource } from '../imagegen/imagegen-evidence.js';
 import { evaluateGate } from '../stop-gate/gate-evaluator.js';
 const ONE_BY_ONE_PNG_BASE64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMB/axX7V8AAAAASUVORK5CYII=';
 const IMAGE_UX_REVIEW_ARTIFACT_PATHS = {
@@ -160,7 +161,7 @@ async function runImageUxReview(root, command, args = []) {
             const response = await readImagegenResponse(dir);
             const evidenceClass = String(response?.evidence_class || '');
             const fakeGenerated = evidenceClass === 'mock_fixture' || result.provider === 'fake_imagegen_adapter';
-            const realGenerated = evidenceClass === 'codex_app_imagegen';
+            const realGenerated = isFullImagegenEvidenceClass(evidenceClass);
             await attachGeneratedReviewImage(root, dir, contract, result.generated_image_path, {
                 realGenerated,
                 mock: fakeGenerated,
@@ -509,7 +510,7 @@ async function attachGeneratedReviewImage(root, dir, contract, imagePath, opts =
         evidence_class: evidenceClass,
         output_source: outputSource,
         output_sha256: outputSha256 || undefined,
-        real_generated: opts.realGenerated === true && evidenceClass === 'codex_app_imagegen',
+        real_generated: opts.realGenerated === true && isFullImagegenEvidenceClass(evidenceClass),
         mock: opts.mock === true
     });
     if (!response && opts.realGenerated === true) {
@@ -631,16 +632,9 @@ async function validateImagegenResponseEvidence(response = null, dir = process.c
     if (response.ok !== true || response.status !== 'generated')
         blockers.push(response.blocker || 'imagegen_response_not_generated');
     const evidenceClass = String(response.evidence_class || '');
-    if (!evidenceClass)
-        blockers.push('imagegen_response_evidence_class_missing');
-    if (evidenceClass === 'mock_fixture')
-        blockers.push('imagegen_response_mock_fixture_not_full_evidence');
-    if (evidenceClass === 'non_codex_api_fallback')
-        blockers.push('imagegen_response_non_codex_api_fallback_not_full_evidence');
-    if (evidenceClass && evidenceClass !== 'codex_app_imagegen')
-        blockers.push(`imagegen_response_evidence_class_not_codex_app:${evidenceClass}`);
+    blockers.push(...imagegenEvidenceClassBlockers('imagegen_response', evidenceClass));
     const source = String(response.output_source || '');
-    if (!['manual_attach', 'auto_discovered_generated_images'].includes(source))
+    if (!isFullImagegenOutputSource(source))
         blockers.push('imagegen_response_output_source_invalid');
     const outputPath = String(response.output_image_path || '');
     const expectedSha = String(response.output_sha256 || response.output_image_sha256 || '');

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

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { ui as cliUi } from '../../cli/cli-theme.js';
 import { projectRoot } from '../fsx.js';
-import { inspectSksMenuBarStatus, installSksMenuBar, rollbackSksMenuBar, restartSksMenuBar, uninstallSksMenuBar } from '../codex-app/sks-menubar.js';
+import { inspectSksMenuBarStatus, installSksMenuBar, rollbackSksMenuBar, restartSksMenuBar, uninstallSksMenuBar } from '../codex-app/menubar/index.js';
 export async function menubarCommand(subcommand = 'status', args = []) {
     const action = normalizeAction(subcommand);
     if (action === 'help') {

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

@@ -12,6 +12,8 @@ import { NARUTO_GATE_FILENAME, NARUTO_RESULT_SCHEMA, NARUTO_SUMMARY_FILENAME, SU
 import { recordOfficialSubagentParentOutcomesTelemetry } from '../zellij/zellij-official-subagent-telemetry.js';
 import { effectiveSubagentTarget, refreshSubagentWaveLifecycle } from '../subagents/wave-lifecycle.js';
 import { HOST_CAPABILITY_HOOK_RUNTIME_FILENAME, bindParentSummaryToHostCapabilityEvidence, createHostCapabilityHookRuntimeBinding, resolveHostCapabilityHookRuntimeBinding } from '../agent-bridge/host-capability-runtime.js';
+import { renderHostCapabilityBlockedLines } from '../agent-bridge/host-capability-policy.js';
+import { uniqueStrings } from '../text/strings.js';
 export { buildNarutoGateResult } from '../subagents/official-subagent-preparation.js';
 let nextNarutoPreparationFailureInjectionForTest = null;
 export function injectNextNarutoPreparationFailureForTest(value) {
@@ -23,8 +25,10 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
         return blockGlmOverride(args.includes('--json'));
     const parsed = parseNarutoArgs(args);
     if (parsed.argumentErrors.length) {
-        return emit(parsed, argumentBlock(parsed.argumentErrors), () => {
-            console.error(`$sks-naruto argument error: ${parsed.argumentErrors.join(', ')}`);
+        const result = argumentBlock(parsed.argumentErrors);
+        return emit(parsed, result, () => {
+            for (const line of renderNarutoBlockedLines(result.blockers))
+                console.error(line);
         }, true);
     }
     if (!parsed.json)
@@ -451,9 +455,12 @@ async function narutoProof(parsed) {
         return missingMission(parsed, 'proof');
     const result = await buildNarutoProofProjection({ artifactDir: resolved.dir, missionId: resolved.id });
     return emit(parsed, result, () => {
+        if (result.status !== 'completed' && result.blockers?.length) {
+            for (const line of renderNarutoBlockedLines(result.blockers))
+                console.log(line);
+            return;
+        }
         console.log(`Naruto proof ${resolved.id}: ${result.status}`);
-        if (result.blockers?.length)
-            console.log(`Blockers: ${result.blockers.join(', ')}`);
     });
 }
 function narutoHelp(parsed) {
@@ -711,7 +718,8 @@ function blockGlmOverride(json) {
     if (json)
         console.log(JSON.stringify(result, null, 2));
     else
-        console.error(`$sks-naruto blocked: ${result.reason}. ${result.hint}`);
+        for (const line of renderNarutoBlockedLines(result.blockers))
+            console.error(line);
     return result;
 }
 function argumentBlock(errors) {
@@ -733,20 +741,28 @@ function missingMission(parsed, action) {
     }, () => console.log('No Naruto mission found.'));
 }
 function missingRunMission(parsed) {
-    return emit(parsed, {
+    const result = {
         schema: NARUTO_RESULT_SCHEMA,
         ok: false,
         status: 'blocked',
         blockers: [`naruto_mission_not_found:${parsed.missionId}`]
-    }, () => console.error(`Naruto mission not found: ${parsed.missionId}`), true);
+    };
+    return emit(parsed, result, () => {
+        for (const line of renderNarutoBlockedLines(result.blockers))
+            console.error(line);
+    }, true);
 }
 function blockedRunMission(parsed, blockers) {
-    return emit(parsed, {
+    const result = {
         schema: NARUTO_RESULT_SCHEMA,
         ok: false,
         status: 'blocked',
         blockers
-    }, () => console.error(`Naruto mission blocked: ${blockers.join(', ')}`), true);
+    };
+    return emit(parsed, result, () => {
+        for (const line of renderNarutoBlockedLines(result.blockers))
+            console.error(line);
+    }, true);
 }
 function emit(parsed, result, human, failed = false) {
     if (failed)
@@ -758,19 +774,30 @@ function emit(parsed, result, human, failed = false) {
     return result;
 }
 function renderRunResult(result) {
+    if (['blocked', 'incomplete'].includes(result.status) && Array.isArray(result.blockers) && result.blockers.length) {
+        for (const line of renderNarutoBlockedLines(result.blockers))
+            console.log(line);
+        return;
+    }
     console.log(`$sks-naruto ${result.status}: ${result.mission_id}`);
     console.log(`Naruto children: requested ${result.requested_subagents}, target ${result.target_subagents ?? result.requested_subagents}, policy ${result.count_policy || 'exact'}, max threads ${result.max_threads}`);
     console.log(`Started/completed/failed: ${result.started_subagents}/${result.completed_subagents}/${result.failed_subagents}`);
     if (result.status === 'delegation_context_ready')
         console.log('Continue in the current Naruto parent and wait for every requested child before summarizing.');
-    if (Array.isArray(result.blockers) && result.blockers.length)
-        console.log(`Blockers: ${result.blockers.join(', ')}`);
 }
 function renderStatusResult(result) {
+    if (['blocked', 'incomplete'].includes(result.status) && Array.isArray(result.blockers) && result.blockers.length) {
+        for (const line of renderNarutoBlockedLines(result.blockers))
+            console.log(line);
+        return;
+    }
     console.log(`Naruto ${result.action || 'status'}: ${result.mission_id}`);
     console.log(`Requested/target/policy: ${result.requested_subagents ?? 0}/${result.target_subagents ?? result.requested_subagents ?? 0}/${result.count_policy || 'exact'}`);
     console.log(`Started/completed/failed: ${result.started_subagents || 0}/${result.completed_subagents || 0}/${result.failed_subagents || 0}`);
 }
-function uniqueStrings(values) {
-    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
+export function renderNarutoBlockedLines(blockers) {
+    return renderHostCapabilityBlockedLines(blockers, {
+        reason: 'Naruto 실행이 완료 조건을 충족하지 못했습니다.',
+        action: '세부 코드를 확인해 가장 먼저 표시된 원인을 해결한 뒤 다시 실행하세요.'
+    });
 }

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

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { projectRoot, readJson } from '../fsx.js';
-import { listSessionStates, missionDir, stateFile } from '../mission.js';
-import { PIPELINE_PLAN_ARTIFACT, projectGateStatus, writePipelinePlan } from '../pipeline.js';
+import { listSessionStates, missionDir, setCurrent, stateFile } from '../mission.js';
+import { PIPELINE_PLAN_ARTIFACT, pipelinePlanState, projectGateStatus, writePipelinePlan } from '../pipeline.js';
 import { routePrompt } from '../routes.js';
 import { flag, positionalArgs, readFlagValue, resolveMissionId } from './command-utils.js';
 export async function pipelineCommand(args = []) {
@@ -43,6 +43,9 @@ export async function pipelineCommand(args = []) {
                 ambiguity: { required: true, auto_sealed: true, status: 'auto_sealed' },
                 agents
             });
+            if (id === state.mission_id) {
+                await setCurrent(root, { mission_id: id, ...pipelinePlanState(plan) }, { sessionKey: state._session_key });
+            }
             if (flag(args, '--json'))
                 return console.log(JSON.stringify({ schema: 'sks.pipeline-plan.v1', ok: true, mission_id: id, plan }, null, 2));
             console.log(`Pipeline plan written: .sneakoscope/missions/${id}/${PIPELINE_PLAN_ARTIFACT}`);