sneakoscope 6.5.1 → 6.7.0

package/dist/core/agents/agent-orchestrator.js

@@ -1158,9 +1158,6 @@ function enforceWorkerQualityProtocolForSlice(result, slice) {
     const kind = String(slice?.work_item_kind || result?.work_item_kind || '').toLowerCase();
     const text = [kind, slice?.id, slice?.title].join(' ').toLowerCase();
     const blockers = [];
-    if ((kind === 'bugfix' || /\b(fix|bug|regression|broken|failure|crash|error)\b|버그|회귀/.test(text)) && !validRegressionProof(result.regression_proof || firstEnvelopeField(result, 'regression_proof'))) {
-        blockers.push('tdd_evidence_missing');
-    }
     if ((kind === 'conflict_resolution' || /\b(repair|conflict|rebase|rollback)\b|수리|충돌/.test(text)) && !(result.repair_hypothesis || firstEnvelopeField(result, 'repair_hypothesis'))) {
         blockers.push('repair_without_hypothesis');
     }
@@ -1176,9 +1173,6 @@ function enforceWorkerQualityProtocolForSlice(result, slice) {
 function firstEnvelopeField(result, field) {
     return (Array.isArray(result?.patch_envelopes) ? result.patch_envelopes : []).find((envelope) => envelope?.[field])?.[field] || null;
 }
-function validRegressionProof(proof) {
-    return Boolean(proof && proof.failed_before === true && proof.passed_after === true && String(proof.test_file || '').trim());
-}
 function normalizePathList(values) {
     return (Array.isArray(values) ? values : []).map((file) => String(file || '').replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/\/+$/, '')).filter(Boolean);
 }

package/dist/core/agents/agent-output-validator.js

@@ -62,7 +62,8 @@ export const AGENT_RESULT_RUNTIME_SCHEMA = {
             required: ['status', 'checks'],
             properties: {
                 status: { type: 'string' },
-                checks: { type: 'array', items: { type: 'string' } }
+                checks: { type: 'array', items: { type: 'string' } },
+                reason: { type: 'string', minLength: 1 }
             },
             additionalProperties: false
         },

package/dist/core/agents/agent-patch-queue-store.js

@@ -64,7 +64,6 @@ export class PersistentAgentPatchQueueStore {
             ...(impact.cochange_required?.length && !cochangeAck ? [`impact_scan_cochange_missing:${impact.cochange_required.slice(0, 5).join(',')}`] : []),
             ...((diffQuality.errors || []).map((issue) => `diff_quality:${issue}`)),
             ...(feedback.ok === false ? ['machine_feedback_failed'] : []),
-            ...(isBugfixKind(context.work_item_kind, envelope.task_slice_id) && !validRegressionProof(envelope.regression_proof || context.regression_proof) ? ['tdd_evidence_missing'] : []),
             ...(isRepairKind(context.work_item_kind, envelope.task_slice_id) && !(envelope.repair_hypothesis || context.repair_hypothesis) ? ['repair_without_hypothesis'] : [])
         ];
         return {
@@ -145,17 +144,10 @@ export class PersistentAgentPatchQueueStore {
         await appendJsonlMany(path.join(this.artifactDir, AGENT_PATCH_QUEUE_EVENTS_ARTIFACT), events.filter(Boolean));
     }
 }
-function isBugfixKind(kind, id) {
-    const text = `${String(kind || '')} ${String(id || '')}`.toLowerCase();
-    return /\b(bugfix|fix|bug|regression|broken|failure|crash|error)\b|버그|회귀/.test(text);
-}
 function isRepairKind(kind, id) {
     const text = `${String(kind || '')} ${String(id || '')}`.toLowerCase();
     return /\b(conflict_resolution|repair|conflict|rebase|rollback)\b|수리|충돌/.test(text);
 }
-function validRegressionProof(proof) {
-    return Boolean(proof && proof.failed_before === true && proof.passed_after === true && String(proof.test_file || '').trim());
-}
 function changedFilesForEnvelope(envelope) {
     const files = envelope.git_worktree?.changed_files?.length
         ? envelope.git_worktree.changed_files

package/dist/core/agents/agent-worker-pipeline.js

@@ -100,17 +100,22 @@ function qualityProtocolBlockers(result) {
         return [];
     const kind = String(result.work_item_kind || result.naruto_runtime?.work_item_kind || '').toLowerCase();
     const text = [kind, result.task_slice_id].join(' ').toLowerCase();
-    const proof = result.regression_proof || result.patch_envelopes?.find((envelope) => envelope.regression_proof)?.regression_proof || null;
     const repair = result.repair_hypothesis || result.patch_envelopes?.find((envelope) => envelope.repair_hypothesis)?.repair_hypothesis || null;
     const blockers = [];
-    if ((kind === 'bugfix' || /\b(fix|bug|regression|broken|failure|crash|error)\b|버그|회귀/.test(text)) && !validRegressionProof(proof))
-        blockers.push('tdd_evidence_missing');
+    if (!validWriteVerification(result.verification))
+        blockers.push('verification_evidence_missing');
     if ((kind === 'conflict_resolution' || /\b(repair|conflict|rebase|rollback)\b|수리|충돌/.test(text)) && !repair)
         blockers.push('repair_without_hypothesis');
     return blockers;
 }
-function validRegressionProof(proof) {
-    return Boolean(proof && proof.failed_before === true && proof.passed_after === true && String(proof.test_file || '').trim());
+function validWriteVerification(verification) {
+    const status = String(verification?.status || '').trim().toLowerCase();
+    const checks = Array.isArray(verification?.checks)
+        ? verification.checks.map((check) => String(check || '').trim()).filter(Boolean)
+        : [];
+    if (status === 'passed')
+        return checks.length > 0;
+    return status === 'not_applicable' && Boolean(String(verification?.reason || '').trim());
 }
 export function agentWorkerPipelineContract() {
     return {
@@ -169,7 +174,8 @@ function isRecord(value) {
 function normalizeVerification(value) {
     return {
         status: String(value?.status || 'not_run'),
-        checks: Array.isArray(value?.checks) ? value.checks : []
+        checks: Array.isArray(value?.checks) ? value.checks : [],
+        ...(String(value?.reason || '').trim() ? { reason: String(value.reason).trim() } : {})
     };
 }
 function acceptsNoPatchReadOnlyOrNoop(value) {

package/dist/core/agents/native-worker-backend-router.js

@@ -418,7 +418,7 @@ function buildWorkerPrompt(slice) {
             ? 'Quality gates run before queue acceptance: impact-scan requires cochanged callers for exported signature changes, machine-feedback runs type/lint/related tests, diff-quality blocks dead exports, and compiled mistake rules block repeated mistakes.'
             : '',
         write.length
-            ? 'If this is a bugfix, create a regression test first and include regression_proof with failed_before true and passed_after true. For repair work, include repair_hypothesis before patching.'
+            ? 'Every write result must report verification status passed with at least one concrete check, or status not_applicable with a specific reason. For a reproducible bug or changed observable behavior, add the smallest regression check that would catch it. Do not manufacture a dedicated test when a smaller real check is sufficient. For repair work, include repair_hypothesis before patching.'
             : '',
         leanEngineeringCompactText(),
         'Required JSON fields: status, summary, findings, changed_files, patch_envelopes, verification, rollback_notes, blockers.'

package/dist/core/bench.js

@@ -343,7 +343,7 @@ export async function runLeanPolicyBench(root = process.cwd()) {
 async function fakeGptFinalScenario(candidate, leanEnabled) {
     const prompt = [
         leanEnabled ? leanEngineeringCompactText() : 'Baseline implementation context without lean policy.',
-        leanEnabled ? 'Lean review: evaluate over-build, dependency, fallback, root-cause, and validation safety.' : 'Review only catastrophic safety issues.',
+        leanEnabled ? 'Apply the Core Engineering Directive to the candidate and the available evidence.' : 'Review only catastrophic safety issues.',
         `Candidate: ${candidate}`
     ].join('\n');
     const result = await runFakeCodexSdkTask({

package/dist/core/codex/official-goal-mode.js

@@ -20,7 +20,7 @@ export async function detectOfficialGoalMode(opts = {}) {
         ok: true,
         official_goal_available: official,
         default_enabled: official,
-        mode: official ? 'official_goal_default' : 'sks_goal_fallback',
+        mode: official ? 'official_goal_default' : 'official_goal_unavailable',
         codex_help_checked: Boolean(helpText),
         codex_goal_help_checked: Boolean(goalHelpText),
         codex_features_checked: Boolean(featuresText),
@@ -28,9 +28,11 @@ export async function detectOfficialGoalMode(opts = {}) {
         codex_goals_feature_enabled: goalsFeature,
         config_goal_defaults_detected: configDefault,
         blockers: [],
-        warnings: official ? [] : ['official_goal_unavailable_using_sks_goal_fallback']
+        warnings: official ? [] : ['official_goal_unavailable_no_fallback']
     };
 }
+// Capability evidence for non-Goal routes. This records whether the active
+// Codex runtime exposes native Goal; it never creates or controls a goal.
 export async function writeOfficialGoalModeArtifact(dir, detection) {
     const artifact = path.join(dir, 'goal-mode-applied.json');
     await writeJsonAtomic(artifact, detection);

package/dist/core/codex-control/codex-control-proof.js

@@ -18,6 +18,7 @@ export async function writeCodexControlProof(root, input) {
         zellij_pane_id: input.task.zellijPaneId || null,
         sdk_thread_id: input.result.sdkThreadId,
         sdk_run_id: input.result.sdkRunId,
+        runtime_identity: input.result.runtimeIdentity || null,
         stream_event_count: input.result.streamEventCount,
         structured_output_valid: input.result.structuredOutputValid,
         output_schema_id: input.task.outputSchemaId,

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

@@ -31,7 +31,7 @@ export async function runFakeCodexSdkTask(input) {
 function fakeStructuredOutput(input) {
     if (input.outputSchemaId === GPT_FINAL_ARBITER_RESULT_SCHEMA_ID) {
         const prompt = String(input.prompt || '');
-        const leanEnabled = /\b(Lean review|Lean Engineering Policy|sks\.lean-engineering-policy)\b/i.test(prompt);
+        const leanEnabled = /\b(Core Engineering Directive|sks\.lean-engineering-policy)\b/i.test(prompt);
         const unsafe = /\b(truncate|delete all|drop table|credential|delete validation|validation removed|path traversal|sql injection|secret leak)\b/i.test(prompt);
         const overbuild = leanEnabled ? classifyLeanOverbuild(prompt) : null;
         const status = unsafe ? 'rejected' : overbuild ? 'needs_more_work' : 'approved';

package/dist/core/codex-control/codex-lb-launch-recovery.js

@@ -46,9 +46,8 @@ export async function inspectCodexLbCliLaunchRecovery(input) {
         : configLayer(await readText(projectConfigPath, '').catch(() => ''), 'project');
     const overrides = cliConfigOverrides(args);
     const environmentSelectsCodexLb = env.SKS_PROVIDER === 'codex-lb' || env.SKS_USE_CODEX_LB === '1';
-    // Codex CLI options are the final operator intent. They override SKS's
-    // environment-selected default just as `-c` overrides config.toml.
-    if (cliSelectsLocalProvider(args) || (overrides.modelProvider && overrides.modelProvider !== 'codex-lb')) {
+    // Local-provider CLI options are the final operator intent.
+    if (cliSelectsLocalProvider(args)) {
         return codexLbToolOutputRecoveryNotSelected();
     }
     const loadedLayers = [userConfig, profileConfig, projectConfig];
@@ -60,6 +59,11 @@ export async function inspectCodexLbCliLaunchRecovery(input) {
     if (projectConfig.hasMachineLocalProviderConfig) {
         return projectProviderConfigBlocked();
     }
+    // Explicit model-provider overrides still win over user/profile defaults,
+    // but only after repository-local provider redirects have been rejected.
+    if (overrides.modelProvider && overrides.modelProvider !== 'codex-lb') {
+        return codexLbToolOutputRecoveryNotSelected();
+    }
     const selectedProvider = overrides.modelProvider
         ?? (environmentSelectsCodexLb ? 'codex-lb' : null)
         ?? profileConfig.modelProvider

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

@@ -5,7 +5,7 @@ import { buildCodexExecutionPolicy, buildCodexSdkConfig } from './codex-sdk-conf
 import { buildCodexSdkEnv } from './codex-sdk-env-policy.js';
 import { translateCodexSdkEvent } from './codex-event-translator.js';
 import { codexTimeoutClassForRoute } from './codex-reliability-shield.js';
-import { resolveCodexRuntime } from '../codex-runtime/resolve-codex-runtime.js';
+import { resolveOfficialCodexPackageRuntime } from '../codex-runtime/resolve-codex-runtime.js';
 import { codexLbToolCatalogPath, ensureCodexLbToolCatalog, isCodexLbGpt56Model } from '../codex-lb/codex-lb-tool-catalog.js';
 export async function runRealCodexSdkTask(input, policy) {
     if (codexSdkTurnTimeoutMs(input) <= 0) {
@@ -23,16 +23,14 @@ export async function runRealCodexSdkTask(input, policy) {
             raw: { aborted: true, hard_deadline_exceeded: true }
         };
     }
+    const runtime = await resolveCodexSdkRuntime(input);
+    if (!runtime.ok || !runtime.identity) {
+        throw new Error(`Trusted Codex SDK runtime unavailable: ${runtime.blockers.join(',')}`);
+    }
     const mod = await import('@openai/codex-sdk');
     const Codex = mod.Codex || mod.default?.Codex || mod.default;
     if (typeof Codex !== 'function')
         throw new Error('Codex SDK export Codex not found');
-    const runtime = await resolveCodexRuntime({
-        explicitPath: typeof input.requestedScopeContract?.codex_bin === 'string' ? input.requestedScopeContract.codex_bin : null,
-        requestedBy: 'codex-sdk-adapter'
-    });
-    if (!runtime.identity)
-        throw new Error(`Codex runtime not found: ${runtime.blockers.join(',')}`);
     const toolCatalog = await prepareCodexLbToolCatalog(input, policy);
     if (toolCatalog.required && !toolCatalog.ok) {
         return {
@@ -160,6 +158,9 @@ export async function runRealCodexSdkTask(input, policy) {
         raw: { item_count: events.filter((event) => String(event?.type || '').startsWith('item.')).length, tool_catalog: toolCatalog }
     };
 }
+export async function resolveCodexSdkRuntime(_input) {
+    return resolveOfficialCodexPackageRuntime({ requestedBy: 'codex-sdk-adapter' });
+}
 export function codexSdkRuntimePolicies(input) {
     const env = buildCodexSdkEnv(input);
     const config = buildCodexSdkConfig(input);

package/dist/core/codex-control/codex-sdk-config-policy.js

@@ -3,6 +3,10 @@ export function buildCodexSdkConfig(input) {
     const model = String(input.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || '').trim();
     const serviceTier = String(input.serviceTier || process.env.SKS_SERVICE_TIER || 'fast');
     const config = {
+        // Internal control-plane work is always native Codex. Ambient proxy
+        // credentials are not provider-selection consent.
+        model_provider: 'openai',
+        forced_login_method: 'chatgpt',
         service_tier: serviceTier === 'standard' ? 'standard' : 'fast',
         model_reasoning_effort: String(input.modelReasoningEffort || input.reasoningEffort || process.env.SKS_CODEX_REASONING || process.env.CODEX_MODEL_REASONING_EFFORT || 'medium'),
         mcp_servers: {},
@@ -20,21 +24,6 @@ export function buildCodexSdkConfig(input) {
         config.mcp_servers = {};
         config.sks = { ...config.sks, no_mcp: true };
     }
-    const codexLbApiKey = String(process.env.CODEX_LB_API_KEY || '').trim();
-    const codexLbBaseUrl = normalizeCodexLbBaseUrl(process.env.CODEX_LB_BASE_URL);
-    if (process.env.SKS_CODEX_LB_AUTOBYPASS !== '1' && codexLbApiKey && codexLbBaseUrl) {
-        config.model_provider = 'codex-lb';
-        config.model_providers = {
-            'codex-lb': {
-                name: 'openai',
-                base_url: codexLbBaseUrl,
-                wire_api: 'responses',
-                env_key: 'CODEX_LB_API_KEY',
-                supports_websockets: true,
-                requires_openai_auth: true
-            }
-        };
-    }
     return config;
 }
 export function buildCodexExecutionPolicy(input) {
@@ -60,12 +49,3 @@ export function redactCodexSdkConfig(config) {
         return value;
     }));
 }
-function normalizeCodexLbBaseUrl(value) {
-    let host = String(value || '').trim();
-    if (!host)
-        return '';
-    if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(host))
-        host = `https://${host}`;
-    host = host.replace(/\/+$/, '');
-    return /\/backend-api\/codex$/i.test(host) ? host : `${host}/backend-api/codex`;
-}