@awak-app/simy-cli 0.6.12 → 0.6.13

package/README.md

@@ -817,6 +817,32 @@ model responses or credentials. Historical summaries are not a replacement for
 signed proof files or delivery acceptance. Records from versions that kept
 analysis only in memory cannot be recovered after that process exits.
 
+The CLI Agentic Loop uses [proportionate retry and review decisions](docs/stop-prevention/proportionate-continuation.md): reasoning notes are advisory, and an independent reviewer may explicitly defer or dismiss minor/warning/info findings with a nonempty explanation while retaining them in the receipt. Required acceptance evidence and major safety findings remain protected.
+
+### Local coding attempt result collection
+
+For `executeProcessAttempt`, native provider JSONL is read only from a successfully finished turn's final
+assistant/result channel. Tool output and intermediate messages are never a
+fallback result. Legacy line-anchored markers still work and may contain formatted
+JSON; missing, ambiguous, truncated, invalid, oversized and failed-turn results
+have distinct `result_parse.code` values. Invalid collection cannot become a
+successful empty result. Plain-text markers are supported only for explicit
+shell command overrides. This does not independently verify executor claims.
+The parser can re-read a saved raw result without rerunning the provider.
+Local Task and direct-task result parsers are separate boundaries and are not
+covered by this coding-attempt guarantee.
+
+### Explicit desktop provider selection
+
+Local coding requests may specify `model` / `reasoning_effort` and independently
+`audit_model` / `audit_reasoning_effort`. Both selections survive recovery.
+Codex receives the exact model and reasoning config; the CLI does not use a
+catalog to reject unknown model names or silently replace a rejected model.
+Claude receives the exact model; explicit reasoning is unsupported by this
+adapter and fails before dispatch. A custom shell override cannot enforce an
+explicit selection and is rejected instead of dropping it. Provider acceptance,
+authentication and actual availability still require the provider's response.
+This changes command construction only; it does not start any workflow.
 
 ### Reusing a running service and launch recovery
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.6.12",
+  "version": "0.6.13",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -1,3 +1,4 @@
+import { normalizeProviderModelSelection } from "./provider-model-selection.js";
 import { assertConnectionScope, connectionScope, connectionDiagnostic } from "./connection-diagnostics.js";
 import { authorizeLaunch } from "./launch-authorization.js";
 import { normalizePurposeVerification, assertPurposeActor, preparePurposeVerification, verifyPurposeLocalTask, purposeSigningKeyPath, purposeVerificationCapability, purposeWorkspaceBusy } from "./purpose-local-proof.js";
@@ -1998,6 +1999,13 @@ export async function startAgent({
           return;
         }
         const { body, attachments } = await readCodingLoopStart(req);
+        let providerSelection;
+        try {
+          providerSelection = normalizeProviderModelSelection(body);
+        } catch (error) {
+          json(res, 400, { error: error.message, code: "invalid_provider_selection" });
+          return;
+        }
         const guardrailSource = String(body.source_message || "").trim();
         if (guardrailSource) {
           const guardrail = classifyExecutionRequirement(guardrailSource);
@@ -2101,6 +2109,7 @@ export async function startAgent({
         const run = createRun({
           runId,
           request: {
+            ...providerSelection,
             backend: body.backend === "claude" ? "claude" : "codex",
             execution_target: executionTarget,
             execution_device_id: session?.device_id || null,
@@ -2752,6 +2761,7 @@ export async function startAgent({
       scanRepositories,
       selectRepository,
       create: (input) => withUpdateWork(updateManager, async () => {
+        const providerSelection = normalizeProviderModelSelection(input);
         const scope = await authorizeDesktopWork();
         if (!isSessionValid(session, Date.now(), apiOrigin)) {
           throw new Error("Sign in to SIMY before starting a coding task.");
@@ -2767,6 +2777,8 @@ export async function startAgent({
         }
         const indexedRepository = await ensureRepositoryIndexed(repository);
         const request = {
+          ...providerSelection,
+          audit_backend: input.audit_backend === "claude" || input.audit_backend === "codex" ? input.audit_backend : null,
           requirement,
           repository,
           local_path: indexedRepository?.local_path || input.localPath || workspace.localPath,

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.6.12";
+export const CLI_VERSION = "0.6.13";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

package/src/desktop-executor.js

@@ -1,4 +1,5 @@
 import spawn from "cross-spawn";
+import { normalizeProviderModelSelection } from "./provider-model-selection.js";
 
 import {
   BACKEND_VERSION_POLICIES,
@@ -48,6 +49,7 @@ export function desktopExecutorCapability(inspection) {
 export async function resolveDesktopExecutorCommand({
   backend,
   model = null,
+  reasoningEffort = null,
   instruction,
   repositoryPath,
   executionKind = "agentic_loop",
@@ -62,17 +64,26 @@ export async function resolveDesktopExecutorCommand({
     throw new Error("Desktop execution kind must be agentic_loop or direct.");
   }
   const normalizedPermissionMode = normalizePermissionMode(permissionMode);
-  const normalizedModel =
-    model === null || model === undefined
-      ? null
-      : String(model).trim();
-  if (normalizedModel !== null && !/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,159}$/.test(normalizedModel)) {
-    throw new Error("Desktop executor model is invalid.");
+  const { model: normalizedModel, reasoning_effort: effort } =
+    normalizeProviderModelSelection({ model, reasoning_effort: reasoningEffort });
+  if (provider !== "codex" && effort !== null) {
+    const error = new Error("Explicit reasoning effort is not supported by this Claude command adapter.");
+    error.code = "desktop_executor_selection_unsupported";
+    throw error;
   }
+  const selectionArgs = [
+    ...(normalizedModel ? ["--model", normalizedModel] : []),
+    ...(effort ? ["--config", `model_reasoning_effort=${JSON.stringify(effort)}`] : []),
+  ];
   const target = normalizeDesktopExecutionTarget(DESKTOP_EXECUTION_TARGET);
   const override =
     provider === "claude" ? environment.SIMY_CLAUDE_COMMAND : environment.SIMY_CODEX_COMMAND;
   if (override) {
+    if (normalizedModel || effort) {
+      const error = new Error("Explicit provider selection cannot be enforced by a shell command override.");
+      error.code = "desktop_executor_selection_unsupported";
+      throw error;
+    }
     return {
       ...shellCommand(override, repositoryPath, instruction, spawnImpl),
       backend: provider,
@@ -100,7 +111,7 @@ export async function resolveDesktopExecutorCommand({
               normalizedPermissionMode,
               normalizedModel,
             )
-          : claudeBackendArgs(instruction)
+          : claudeBackendArgs(instruction, normalizedModel)
         : directExecution
           ? [
               "exec",
@@ -108,22 +119,24 @@ export async function resolveDesktopExecutorCommand({
               "--skip-git-repo-check",
               "--sandbox",
               normalizedPermissionMode === "read_only" ? "read-only" : "workspace-write",
-              ...(normalizedModel ? ["--model", normalizedModel] : []),
+              ...selectionArgs,
               instruction,
             ]
-          : ["exec", "--json", instruction],
+          : ["exec", "--json", ...selectionArgs, instruction],
     env: {},
     spawn: spawnImpl,
     backend: provider,
     execution_target: target,
     execution_kind: executionKind,
     permission_mode: normalizedPermissionMode,
+    requested_model: normalizedModel,
+    requested_reasoning_effort: effort,
     verification: "compatible_version",
     installed_version: inspection.installed_version,
   };
 }
 
-export function claudeBackendArgs(instruction) {
+export function claudeBackendArgs(instruction, model = null) {
   return [
     "-p",
     instruction,
@@ -134,6 +147,7 @@ export function claudeBackendArgs(instruction) {
     // by the user. Print mode cannot display permission prompts, so edits would
     // otherwise be silently unavailable to the desktop executor.
     "--dangerously-skip-permissions",
+    ...(model ? ["--model", model] : []),
   ];
 }
 

package/src/orchestrator/audit.js

@@ -134,7 +134,7 @@ export async function auditAttempt(charter, attempt, { previousAttempt = null, s
 
   const retryProblemSolving = evaluateRetryProblemSolving(attempt, previousAttempt);
   for (const check of retryProblemSolving.checks) {
-    addCheck(check.id, check.label, check.passed, check.detail);
+    addCheck(check.id, check.label, check.passed, check.detail, check.severity);
   }
   attempt.retry_problem_solving = retryProblemSolving;
 
@@ -220,7 +220,7 @@ export async function auditAttempt(charter, attempt, { previousAttempt = null, s
   }
 
   const findings = checks
-    .filter((check) => !check.passed)
+    .filter((check) => !check.passed && check.severity !== "advisory")
     .map((check) => ({
       code: check.id.toUpperCase(),
       title: check.label,

package/src/orchestrator/contract.js

@@ -1,3 +1,4 @@
+import { normalizeProviderModelSelection } from "../provider-model-selection.js";
 import { randomUUID } from "node:crypto";
 
 import {
@@ -103,6 +104,7 @@ export function createCodingLoopSnapshot({ runId, request, metadata = {} }) {
     charter: {
       id: `${runId}_charter`,
       requirement: cleanString(request.requirement),
+      ...normalizeProviderModelSelection(request),
       repository: cleanString(request.repository),
       backend: request.backend === "claude" ? "claude" : "codex",
       execution_target: executionTarget,

package/src/orchestrator/independent-audit.js

@@ -112,7 +112,7 @@ export function buildIndependentAuditInstruction(charter, attempt) {
         "criterion_results must contain one entry per stable criterion ID with criterion_id, passed, verification_method, evidence_refs, and observed_result.",
         "visual_review must contain inspected, artifacts, and acceptance_observations.",
         "Only passed=false entries are findings. Omit passing checks, and never report passed=true evidence as a finding.",
-        "Use passed=false when a blocker or major finding remains, or when evidence is unavailable.",
+        "Use passed=false when a blocker or major finding remains, or when required evidence is unavailable. For minor/warning/info findings, choose disposition=fix, defer, or dismiss based on impact and reversibility. Include the reason in explanation. Deferring or dismissing a non-major finding does not require human input and must not hide it. Major/blocker findings cannot be deferred by this field.",
       ].join("\n"),
     ),
   ].join("\n\n");
@@ -165,6 +165,8 @@ export function buildIndependentAudit(execution, charter = null, attempt = null)
       target: cleanString(item.target) || "pull_request",
       explanation: cleanString(item.explanation) || "Independent audit finding.",
       repairability: item.repairability === "manual" ? "manual" : "auto",
+      disposition: ["defer", "dismiss"].includes(item.disposition) && cleanString(item.explanation)
+        ? item.disposition : "fix",
       blocker_kind: ["machine", "human", "external"].includes(item.blocker_kind)
         ? item.blocker_kind : item.repairability === "manual" ? "human" : "machine",
       auto_fix_hint: cleanString(item.auto_fix_hint) || null,
@@ -249,10 +251,16 @@ export function buildIndependentAudit(execution, charter = null, attempt = null)
     findings.push({ passed: false, code: "USER_OUTCOME_UNPROVEN", severity: "blocker",
       target: "user_outcome", explanation: "The original user goal lacks independently observed operation and postcondition evidence.", repairability: "auto" });
   }
-  const requiresHuman = findings.some((item) => item.repairability === "manual");
+  // Only the independent reviewer can defer/dismiss a non-major finding.
+  // Unknown severities, generated evidence failures and major findings remain blocking.
+  const followUps = findings.filter(item => ["minor", "warning", "info"].includes(item.severity) &&
+    ["defer", "dismiss"].includes(item.disposition));
+  const blockingFindings = findings.filter(item => !followUps.includes(item));
+  const requiresHuman = blockingFindings.some((item) => item.repairability === "manual");
   return {
     ...objectiveBinding,
-    passed: result.passed === true && findings.length === 0,
+    passed: blockingFindings.length === 0 && (result.passed === true || followUps.length > 0),
+    follow_ups: followUps,
     summary: cleanString(result.summary) || "Independent audit completed.",
     findings,
     criterion_results: criterionResults,

package/src/orchestrator/instruction.js

@@ -171,8 +171,8 @@ export function buildCodingInstruction(
       [
         "Treat implementation as hypothesis testing: state assumptions, list plausible causes or approaches, inspect discriminating evidence, then choose the smallest strategy supported by that evidence.",
         attemptNumber > 1
-          ? "This is a retry. Before editing, generate at least eight distinct MECE hypotheses, select a different primary hypothesis or approach, and do not repeat the previous strategy."
-          : "For the first attempt, identify the single highest uncertainty and run the smallest discriminating verification before editing.",
+          ? "This is a retry. Repair clear failures directly; compare plausible causes when needed. Reasoning notes are advisory, not a prerequisite to editing."
+          : "For the first attempt, investigate material uncertainty before a risky operation; use a reasonable assumption for low-impact reversible choices and verify as you proceed.",
         attemptNumber > 1
           ? "Explain exactly what changed from the previous attempt and why the new evidence supports this strategy."
           : "Record the uncertainty, first verification, concrete evidence checked, observed result, selected hypothesis, and strategy in the structured result.",
@@ -244,7 +244,7 @@ export function buildPromptInterventions(
       trigger: "repair_focus",
       title: "Repair focus",
       prompt:
-        "Diagnose the reported gate failures with at least eight distinct hypotheses, select a new strategy supported by evidence, and do not repeat the previous approach.",
+        "Repair clear failures directly and verify the change. Investigate competing causes only when uncertainty warrants it; do not invent eight hypotheses or change strategy merely to satisfy a form.",
       evidence_required: [
         "hypotheses",
         "selected_hypothesis_id",

package/src/orchestrator/loop.js

@@ -10,7 +10,7 @@ import {
 } from "./independent-audit.js";
 import { buildCodingInstruction, buildPromptInterventions } from "./instruction.js";
 import { canStartProvider, codingAttemptCeiling, refreshBudgetState } from "./budget.js";
-import { buildAttempt, mergeTokenUsage } from "./result.js";
+import { buildAttempt, mergeTokenUsage, normalizeResultParseDiagnostic } from "./result.js";
 import { evaluateRetryCircuit } from "./retry.js";
 import { assessOutcomeProgress, verifyObjective } from "./outcome-monitor.js";
 import { appendEvent, publish } from "./shared.js";
@@ -291,6 +291,7 @@ async function runCodingLoopOwned({
       return snapshot;
     }
 
+    attempt.independent_audit.result_parse = normalizeResultParseDiagnostic(auditExecution.result_parse);
     attempt.independent_audit.minimum_matrix_sha256 = reviewedMatrix;
     attempt.independent_audit.evidence_identity_sha256 = reviewedEvidenceIdentity;
     attempt.independent_audit.objective_digest = reviewedObjectiveDigest;

package/src/orchestrator/problem-solving.js

@@ -1,6 +1,6 @@
 import { cleanString, stringArray } from "./shared.js";
 
-const MIN_RETRY_HYPOTHESES = 8;
+const MIN_RETRY_HYPOTHESES = 1;
 
 export function normalizeProblemSolving(value) {
   const record = value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -49,7 +49,7 @@ export function evaluateRetryProblemSolving(attempt, previousAttempt) {
   const checks = [
     {
       id: "retry_hypotheses_expanded",
-      label: "Retry considers at least eight distinct hypotheses",
+      label: "Retry considers a plausible explanation",
       passed: distinctHypotheses >= MIN_RETRY_HYPOTHESES,
       detail: `Expected at least ${MIN_RETRY_HYPOTHESES} distinct hypotheses; recorded ${distinctHypotheses}.`,
     },
@@ -78,9 +78,10 @@ export function evaluateRetryProblemSolving(attempt, previousAttempt) {
     },
   ];
   return {
-    required: true,
-    passed: checks.every((check) => check.passed),
-    checks,
+    required: false,
+    passed: true,
+    assessment_complete: checks.every((check) => check.passed),
+    checks: checks.map(check => ({ ...check, severity: "advisory" })),
     current,
     previous,
   };
@@ -91,7 +92,7 @@ export function problemSolvingResultContract() {
     "problem_solving must be an object with hypotheses, selected_hypothesis_id, evidence_checked, strategy, and changed_from_previous.",
     "Each hypothesis must use {id, statement}; evidence_checked must list concrete observations or commands.",
     "On attempt 1, record the assumptions, hypotheses considered, selected hypothesis, and implementation strategy; changed_from_previous may be null.",
-    `On every retry, record at least ${MIN_RETRY_HYPOTHESES} distinct MECE hypotheses, select one of them, check discriminating evidence, use a strategy different from the previous attempt, and explain the change in changed_from_previous.`,
+    "On retry, use reasoning proportional to the uncertainty. If the repair is clear, make it and verify it; do not invent a fixed number of hypotheses or change a working strategy merely to satisfy a form. For persistent unexplained failures, compare plausible causes and inspect discriminating evidence. These reasoning notes are advisory; unchanged failures are still subject to the retry circuit.",
   ].join("\n");
 }
 

package/src/orchestrator/result.js

@@ -56,6 +56,7 @@ export function buildAttempt({ attemptNumber, charter, instruction, promptInterv
     visual_qa_result: null,
     release_gate: null,
     executor_logs: stringArray(execution.logs).slice(-100),
+    result_parse: normalizeResultParseDiagnostic(execution.result_parse),
     token_usage:
       execution.tokenUsage && typeof execution.tokenUsage === "object"
         ? execution.tokenUsage
@@ -79,16 +80,104 @@ export function parseStructuredResult(text) {
 }
 
 export function parseStructuredMarker(text, marker) {
-  const index = String(text || "").lastIndexOf(marker);
-  if (index < 0) return {};
-  const afterMarker = String(text).slice(index + marker.length).trim();
-  const firstLine = afterMarker.split(/\r?\n/, 1)[0].trim();
+  return diagnoseStructuredMarker(text, marker).value;
+}
+
+// Parse only a line-anchored result channel. Braces in JSON strings are not
+// boundaries; JSON.parse remains responsible for syntax and object validation.
+export function diagnoseStructuredMarker(text, marker, { maxBytes = 1024 * 1024 } = {}) {
+  const failure = code => ({ code, value: {} });
+  if (typeof text !== "string") return failure("missing_marker");
+  if (Buffer.byteLength(text, "utf8") > maxBytes) return failure("result_too_large");
+  const escaped = marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const matches = [...text.matchAll(new RegExp(`(?:^|\\n)[ \t]*${escaped}`, "g"))];
+  if (!matches.length) return failure("missing_marker");
+  if (matches.length !== 1) return failure("ambiguous_marker");
+  const payload = text.slice(matches[0].index + matches[0][0].length).trim();
+  if (!payload) return failure("truncated_json");
+  if (!payload.startsWith("{")) return failure("result_root_not_object");
+  let depth = 0, quoted = false, escapedChar = false, end = -1;
+  for (let index = 0; index < payload.length; index += 1) {
+    const char = payload[index];
+    if (quoted) {
+      if (escapedChar) escapedChar = false;
+      else if (char === "\\") escapedChar = true;
+      else if (char === '"') quoted = false;
+    } else if (char === '"') quoted = true;
+    else if (char === "{" || char === "[") depth += 1;
+    else if (char === "}" || char === "]") {
+      depth -= 1;
+      if (depth === 0) { end = index + 1; break; }
+    }
+  }
+  if (end < 0) return failure("truncated_json");
+  if (payload.slice(end).trim()) return failure("trailing_result_content");
   try {
-    const value = JSON.parse(firstLine);
-    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-  } catch {
-    return {};
+    const value = JSON.parse(payload.slice(0, end));
+    if (!value || Array.isArray(value) || typeof value !== "object") return failure("result_root_not_object");
+    if (!Object.keys(value).length) return failure("empty_result");
+    return { code: "parsed", value };
+  } catch { return failure("invalid_json"); }
+}
+
+// Native JSONL admits results only from a successfully finished provider turn.
+// Command output, echoed prompts and intermediate assistant items cannot be a
+// fallback channel. Explicit shell overrides retain the documented legacy text.
+export function parseProviderStructuredResult(raw, { backend, marker = "SIMY_RESULT_JSON:", allowPlainText = false,
+  maxBytes = 1024 * 1024, maxStreamBytes = 64 * 1024 * 1024 } = {}) {
+  const failure = code => ({ code, value: {} });
+  if (typeof raw !== "string") return failure("missing_provider_final");
+  if (Buffer.byteLength(raw, "utf8") > maxStreamBytes) return failure("provider_stream_too_large");
+  const events = [];
+  let malformedStream = false;
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const event = JSON.parse(line);
+      if (event && typeof event === "object" && !Array.isArray(event) && typeof event.type === "string") {
+        // Tool payload size is independent of the bounded final result. Retain
+        // event identity/order, not arbitrary command output, during selection.
+        events.push(event.type === "result" || event.item?.type === "agent_message"
+          ? event : { type: event.type, item: { type: event.item?.type } });
+      } else malformedStream = true;
+    }
+    catch { malformedStream = true; }
   }
+  const nativeTypes = new Set(backend === "claude"
+    ? ["system", "assistant", "user", "result", "stream_event", "tool_progress", "tool_use_summary", "rate_limit_event", "auth_status"]
+    : ["thread.started", "turn.started", "turn.completed", "turn.failed", "item.started", "item.updated", "item.completed", "error"]);
+  const native = events.some(e => nativeTypes.has(e.type));
+  // A discarded line could be a later error or unfinished turn. Native streams
+  // must stay intact; only an explicit non-native override admits plain text.
+  if (malformedStream && (native || !allowPlainText)) return failure("malformed_provider_stream");
+  if (!native) return allowPlainText ? diagnoseStructuredMarker(raw, marker, {maxBytes}) : failure("missing_provider_final");
+  if (backend === "claude") {
+    const results = events.filter(e => e.type === "result");
+    if (results.length > 1) return failure("contradictory_provider_terminal");
+    const final = results[0];
+    if (!final) return failure("missing_provider_final");
+    if (events.slice(events.indexOf(final) + 1).some(e => typeof e.type === "string")) return failure("unsettled_provider_turn");
+    if (final.is_error === true || String(final.subtype || "").startsWith("error")) return failure("provider_failed");
+    return diagnoseStructuredMarker(final.result, marker, {maxBytes});
+  }
+  const end = events.findLastIndex(e => e.type === "turn.completed" || e.type === "turn.failed");
+  if (end < 0) return failure("missing_provider_final");
+  if (events[end].type === "turn.failed") return failure("provider_failed");
+  const start = events.slice(0, end).findLastIndex(e => e.type === "turn.started");
+  const turn = events.slice(start + 1, end);
+  if (turn.some(e => e.type === "turn.failed" || e.type === "turn.completed")) {
+    return failure("contradictory_provider_terminal");
+  }
+  const finalIndex = turn.findLastIndex(e => e.type === "item.completed" &&
+    e.item?.type === "agent_message" && (!e.item.phase || e.item.phase === "final_answer"));
+  if (finalIndex < 0) return failure("missing_provider_final");
+  if (turn.slice(finalIndex + 1).some(e => typeof e.type === "string")) {
+    return failure("nonterminal_agent_message");
+  }
+  const final = turn[finalIndex].item;
+  // A later unsettled turn must not replay an earlier completed result.
+  if (events.slice(end + 1).some(e => typeof e.type === "string")) return failure("unsettled_provider_turn");
+  return diagnoseStructuredMarker(final.text, marker, {maxBytes});
 }
 
 function buildArtifactPreviews(result) {
@@ -125,3 +214,10 @@ function isUsageRecord(value) {
 }
 
 function safeDigest(compute) { try { return compute(); } catch { return null; } }
+
+export function normalizeResultParseDiagnostic(value) {
+  if (!value) return null;
+  const codes = ["parsed", "missing_marker", "result_too_large", "ambiguous_marker", "truncated_json", "result_root_not_object", "trailing_result_content", "empty_result", "invalid_json", "missing_provider_final", "provider_failed", "unsettled_provider_turn", "nonterminal_agent_message", "contradictory_provider_terminal", "provider_stream_too_large", "malformed_provider_stream"];
+  return { code: codes.includes(value.code) ? value.code : "unknown_parse_diagnostic",
+    channel: ["override_or_native", "provider_final"].includes(value.channel) ? value.channel : "unknown" };
+}

package/src/provider-model-selection.js

@@ -0,0 +1,24 @@
+const SELECTION_FIELDS = ["model", "reasoning_effort", "audit_model", "audit_reasoning_effort"];
+const REASONING_EFFORTS = new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"]);
+
+// Preserve explicit selections at request boundaries; do not infer a model catalog.
+export function normalizeProviderModelSelection(input = {}) {
+  const result = {};
+  for (const field of SELECTION_FIELDS) {
+    const value = input[field];
+    if (value == null) {
+      result[field] = null;
+      continue;
+    }
+    if (typeof value !== "string" || !value.trim()) {
+      throw new Error(`${field} must be a non-empty string.`);
+    }
+    const normalized = value.trim();
+    const valid = field.endsWith("reasoning_effort")
+      ? REASONING_EFFORTS.has(normalized)
+      : /^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,159}(?:\[1m\])?$/.test(normalized);
+    if (!valid) throw new Error(`${field} is invalid.`);
+    result[field] = normalized;
+  }
+  return result;
+}

package/src/runner.js

@@ -8,11 +8,10 @@ import { promisify } from "node:util";
 import {
   collectPrEvidence,
   createCodingLoopSnapshot,
-  parseStructuredMarker,
-  parseStructuredResult,
   recheckPrReadiness,
   runCodingLoop,
 } from "./orchestrator/index.js";
+import { parseProviderStructuredResult } from "./orchestrator/result.js";
 import {
   EXECUTION_IO_POLICY_VERSION,
   executionTextSha256,
@@ -180,6 +179,10 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null, loc
     sqmHistoryRoot,
     request: {
       backend: charter.backend === "claude" ? "claude" : "codex",
+      model: charter.model || null,
+      reasoning_effort: charter.reasoning_effort || null,
+      audit_model: charter.audit_model || null,
+      audit_reasoning_effort: charter.audit_reasoning_effort || null,
       execution_target: normalizeDesktopExecutionTarget(charter.execution_target),
       execution_device_id:
         String(snapshot.metadata?.execution_device_id || session?.device_id || "").trim() || null,
@@ -1012,18 +1015,21 @@ export async function executeProcessAttempt({
   marker = "SIMY_RESULT_JSON:",
   attemptNumber = null,
   resolveCommandImpl = resolveDesktopExecutorCommand,
+  charter = run?.snapshot?.charter,
   onExecutionComplete = null,
 }) {
+  const phase = marker === "SIMY_AUDIT_JSON:" ? "reviewer" : "executor";
   const command = await resolveCommandImpl({
     backend,
     instruction,
     repositoryPath,
+    model: phase === "reviewer" ? charter?.audit_model : charter?.model,
+    reasoningEffort: phase === "reviewer" ? charter?.audit_reasoning_effort : charter?.reasoning_effort,
   });
   const startedAt = new Date().toISOString();
   const stdout = [];
   const stderr = [];
   const tokenUsageRecords = [];
-  const phase = marker === "SIMY_AUDIT_JSON:" ? "reviewer" : "executor";
   const initialBudget = budgetState(run.snapshot);
   const invocationId = randomUUID();
   const observationSender =
@@ -1106,18 +1112,17 @@ export async function executeProcessAttempt({
       run.child = null;
       await Promise.all(checkpointWrites);
       const rawStdout = stdout.join("");
-      const assistantText = extractAssistantText(rawStdout);
-      const parse =
-        marker === "SIMY_RESULT_JSON:"
-          ? parseStructuredResult
-          : (value) => parseStructuredMarker(value, marker);
-      const result = parse(assistantText);
+      const parsed = parseProviderStructuredResult(rawStdout, {
+        backend, marker, allowPlainText: command.verification === "explicit_command_override",
+      });
+      const parseError = parsed.code === "parsed" ? null : `Provider result unavailable: ${parsed.code}.`;
       const execution = {
         invocationId,
         exitCode: terminalError && exitCode === 0 ? 1 : exitCode,
-        error: error || terminalError,
+        error: error || terminalError || parseError,
         ...(terminalErrorCode ? { errorCode: terminalErrorCode } : {}),
-        result: Object.keys(result).length > 0 ? result : parse(rawStdout),
+        result: parsed.value,
+        result_parse: { code: parsed.code, channel: command.verification === "explicit_command_override" ? "override_or_native" : "provider_final" },
         tokenUsage:
           tokenUsageRecords.length > 0 ? { records: tokenUsageRecords } : {},
         logs: [...stdout, ...stderr]
@@ -1212,25 +1217,6 @@ async function pathExists(value) {
   }
 }
 
-function extractAssistantText(raw) {
-  const messages = [];
-  for (const line of String(raw || "").split(/\r?\n/)) {
-    if (!line.trim().startsWith("{")) continue;
-    try {
-      const item = JSON.parse(line);
-      if (item.type === "result" && typeof item.result === "string") messages.push(item.result);
-      if (item.type === "item.completed" && item.item?.type === "agent_message") {
-        if (typeof item.item.text === "string") messages.push(item.item.text);
-      }
-      if (item.type === "assistant" && typeof item.message?.content === "string") {
-        messages.push(item.message.content);
-      }
-    } catch {
-      // Non-JSON executor output is still available to the fallback parser.
-    }
-  }
-  return messages.join("\n");
-}
 
 function emitOutput(run, text, { backend = run.request.backend, promote = true } = {}) {
   for (const line of String(text).split(/\r?\n/)) {