chatroom-cli 1.102.2 → 1.103.1

package/dist/index.js

@@ -27788,6 +27788,110 @@ function createHarnessActivityEmitter() {
 }
 var init_harness_activity_emitter = () => {};
 
+// ../../services/backend/src/domain/entities/harness/model-variant.ts
+function parseParamList(encoded, paramsPart) {
+  const params = {};
+  for (const param of paramsPart.split(",")) {
+    if (!PARAM_RE.test(param)) {
+      throw new ModelVariantParseError(`malformed variant param "${param}" in "${encoded}" (expected key=value)`);
+    }
+    const eq = param.indexOf("=");
+    const key = param.slice(0, eq);
+    if (Object.prototype.hasOwnProperty.call(params, key)) {
+      throw new ModelVariantParseError(`duplicate variant param "${key}" in "${encoded}"`);
+    }
+    params[key] = param.slice(eq + 1);
+  }
+  return params;
+}
+function decodeModelVariant(encoded) {
+  if (encoded.length === 0) {
+    throw new ModelVariantParseError("empty model variant");
+  }
+  const match17 = MODEL_VARIANT_RE.exec(encoded);
+  if (!match17) {
+    throw new ModelVariantParseError(`malformed model variant: "${encoded}"`);
+  }
+  const [, model, paramsPart] = match17;
+  if (paramsPart === undefined) {
+    return { model, params: {} };
+  }
+  return { model, params: parseParamList(encoded, paramsPart) };
+}
+function encodeModelVariant(model, params = {}) {
+  const entries2 = Object.entries(params);
+  if (entries2.length === 0)
+    return model;
+  const paramsPart = entries2.map(([key, value]) => `${key}=${value}`).join(",");
+  return `${model}[${paramsPart}]`;
+}
+function expandModelVariantCatalog(baseModelIds, combinations) {
+  return baseModelIds.flatMap((id3) => combinations.map((combo) => encodeModelVariant(id3, combo)));
+}
+function describeCombination(combo) {
+  const entries2 = Object.entries(combo);
+  return entries2.length === 0 ? "no params" : entries2.map(([k, v2]) => `${k}=${v2}`).join(",");
+}
+function validateModelVariantParams(variant, schema) {
+  const supported = schema.find((combo) => Object.keys(combo).length === Object.keys(variant.params).length && Object.entries(combo).every(([key, value]) => variant.params[key] === value));
+  if (!supported) {
+    throw new ModelVariantValidationError(`unsupported variant params for model "${variant.model}": ` + `${describeCombination(variant.params)}; ` + `allowed: ${schema.map(describeCombination).join(" | ")}`);
+  }
+  return variant;
+}
+var ModelVariantParseError, ModelVariantValidationError, MODEL_VARIANT_RE, PARAM_RE;
+var init_model_variant = __esm(() => {
+  ModelVariantParseError = class ModelVariantParseError extends Error {
+    code = "MODEL_VARIANT_PARSE";
+    constructor(message) {
+      super(message);
+      this.name = "ModelVariantParseError";
+    }
+  };
+  ModelVariantValidationError = class ModelVariantValidationError extends Error {
+    code = "MODEL_VARIANT_VALIDATION";
+    constructor(message) {
+      super(message);
+      this.name = "ModelVariantValidationError";
+    }
+  };
+  MODEL_VARIANT_RE = /^([^\[\]]+?)(?:\[([^\]]*)\])?$/;
+  PARAM_RE = /^[A-Za-z0-9_-]+=[^,\[\]\=]+$/;
+});
+
+// src/daemon/infrastructure/local/harness/services/opencode-sdk/pure.ts
+function parseModelId(model) {
+  if (!model)
+    return;
+  const slashIdx = model.indexOf("/");
+  if (slashIdx === -1)
+    return;
+  const providerID = model.substring(0, slashIdx);
+  const modelID = model.substring(slashIdx + 1);
+  if (!providerID || !modelID)
+    return;
+  return { providerID, modelID };
+}
+function parseOpencodeSpawnModel(model) {
+  if (!model.includes("["))
+    return { model };
+  const decoded = decodeModelVariant(model);
+  const variant = decoded.params.variant;
+  let resolvedModel = decoded.model;
+  if (!resolvedModel.includes("/")) {
+    const slashIdx = model.indexOf("/");
+    const bracketIdx = model.indexOf("[");
+    if (slashIdx !== -1 && slashIdx < bracketIdx) {
+      resolvedModel = `${model.slice(0, slashIdx)}/${resolvedModel}`;
+    }
+  }
+  return { model: resolvedModel, ...variant ? { variant } : {} };
+}
+var isInfoLine = (line) => line.trimStart().startsWith("INFO ");
+var init_pure = __esm(() => {
+  init_model_variant();
+});
+
 // src/daemon/infrastructure/local/harness/services/session-log-callbacks.ts
 function createSessionLogCallbacks() {
   let logCb;
@@ -27805,6 +27909,7 @@ var OPENCODE_COMMAND = "opencode", OpenCodeAgentService;
 var init_opencode_agent_service = __esm(() => {
   init_harness_activity_emitter();
   init_base_cli_agent_service();
+  init_pure();
   OpenCodeAgentService = class OpenCodeAgentService extends BaseCLIAgentService {
     id = "opencode";
     displayName = "OpenCode";
@@ -27826,9 +27931,13 @@ var init_opencode_agent_service = __esm(() => {
 `).map((line) => line.trim()).filter((line) => line.length > 0);
     }
     async spawn(options) {
+      const parsed = options.model ? parseOpencodeSpawnModel(options.model) : undefined;
       const args2 = ["run"];
-      if (options.model) {
-        args2.push("--model", options.model);
+      if (parsed?.model) {
+        args2.push("--model", parsed.model);
+      }
+      if (parsed?.variant) {
+        args2.push("--variant", parsed.variant);
       }
       const fullPrompt = options.systemPrompt ? `${options.systemPrompt}
 
@@ -28025,6 +28134,36 @@ class PiRpcReader {
 }
 var init_pi_rpc_reader = () => {};
 
+// src/daemon/infrastructure/local/harness/services/pi/pure.ts
+function parsePiSpawnModel(model) {
+  if (!model.includes("["))
+    return { model };
+  const decoded = decodeModelVariant(model);
+  const thinking = decoded.params.thinking;
+  let resolvedModel = decoded.model;
+  if (!resolvedModel.includes("/")) {
+    const slashIdx = model.indexOf("/");
+    const bracketIdx = model.indexOf("[");
+    if (slashIdx !== -1 && slashIdx < bracketIdx) {
+      resolvedModel = `${model.slice(0, slashIdx)}/${resolvedModel}`;
+    }
+  }
+  return { model: resolvedModel, ...thinking ? { thinking } : {} };
+}
+function resolvePiThinkingLevel(thinking) {
+  if (!thinking)
+    return;
+  if (PI_THINKING_LEVELS.includes(thinking)) {
+    return thinking;
+  }
+  return;
+}
+var PI_THINKING_LEVELS;
+var init_pure2 = __esm(() => {
+  init_model_variant();
+  PI_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
+});
+
 // src/daemon/infrastructure/local/harness/services/agent-log-format.ts
 function buildAgentLogPrefix(agent, context5) {
   const roleTag = context5.role ?? "unknown";
@@ -28128,9 +28267,10 @@ function isExplicitToolError(result) {
 function getPiSessionDir(workingDir) {
   return join6(workingDir, ".chatroom", "pi-sessions");
 }
-var PI_COMMAND = "pi", GET_STATE_TIMEOUT_MS = 5000, SPAWN_READY_DELAY_MS2 = 500, PiAgentService;
+var PI_COMMAND = "pi", GET_STATE_TIMEOUT_MS = 5000, PiAgentService;
 var init_pi_agent_service = __esm(() => {
   init_pi_rpc_reader();
+  init_pure2();
   init_spawn_env();
   init_harness_activity_emitter();
   init_base_cli_agent_service();
@@ -28170,13 +28310,15 @@ var init_pi_agent_service = __esm(() => {
     }
     async spawn(options) {
       const { prompt, systemPrompt, model, context: context5, workingDir } = options;
+      const parsed = model ? parsePiSpawnModel(model) : undefined;
       const childProcess = this.spawnPiRpcProcess({
         workingDir,
         systemPrompt,
-        model,
+        model: parsed?.model,
+        thinking: parsed?.thinking,
         resolvedConvexUrl: options.resolvedConvexUrl
       });
-      await this.waitForSpawnReady(childProcess);
+      await this.assertChildProcessStarted(childProcess);
       if (!childProcess.stdout) {
         throw new Error("Pi RPC process has no stdout");
       }
@@ -28198,6 +28340,9 @@ var init_pi_agent_service = __esm(() => {
       if (args2.model) {
         rpcArgs.push("--model", args2.model);
       }
+      if (args2.thinking) {
+        rpcArgs.push("--thinking", args2.thinking);
+      }
       if (args2.systemPrompt) {
         rpcArgs.push("--system-prompt", args2.systemPrompt);
       }
@@ -28210,15 +28355,6 @@ var init_pi_agent_service = __esm(() => {
       });
       return childProcess;
     }
-    async waitForSpawnReady(childProcess) {
-      await new Promise((resolve2) => setTimeout(resolve2, SPAWN_READY_DELAY_MS2));
-      if (childProcess.killed || childProcess.exitCode !== null) {
-        throw new Error(`Agent process exited immediately (exit code: ${childProcess.exitCode})`);
-      }
-      if (!childProcess.pid) {
-        throw new Error("Agent process started but has no PID");
-      }
-    }
     writePrompt(child, prompt) {
       return new Promise((resolve2, reject) => {
         if (!child.stdin) {
@@ -28512,13 +28648,27 @@ function cursorLegacySlugToVariant(flatSlug) {
   }
   const effort = base.match(/-(low|medium|high|xhigh|max)$/)?.[1];
   if (effort) {
-    params.effort = effort === "max" ? "xhigh" : effort;
+    params.effort = effort === "max" && base.includes("opus") ? "xhigh" : effort;
     base = base.slice(0, -(effort.length + 1));
   }
   if (Object.keys(params).length === 0)
     return;
   return { base, params };
 }
+function normalizeCursorParamsForCliSlug(params) {
+  const out = {};
+  const effort = params.effort ?? (params.reasoning && params.reasoning !== "none" ? params.reasoning : undefined);
+  if (effort && effort !== "none") {
+    out.effort = effort;
+  }
+  if (params.fast === "enabled" || params.fast === "true") {
+    out.fast = "enabled";
+  }
+  if (params.thinking === "enabled" || params.thinking === "true") {
+    out.thinking = "enabled";
+  }
+  return out;
+}
 function cursorVariantToCliSlug(base, params) {
   const suffix = [];
   if (params.effort && params.effort !== "none")
@@ -28530,77 +28680,6 @@ function cursorVariantToCliSlug(base, params) {
   return suffix.length ? `${base}-${suffix.join("-")}` : base;
 }
 
-// ../../services/backend/src/domain/entities/harness/model-variant.ts
-function parseParamList(encoded, paramsPart) {
-  const params = {};
-  for (const param of paramsPart.split(",")) {
-    if (!PARAM_RE.test(param)) {
-      throw new ModelVariantParseError(`malformed variant param "${param}" in "${encoded}" (expected key=value)`);
-    }
-    const eq = param.indexOf("=");
-    const key = param.slice(0, eq);
-    if (Object.prototype.hasOwnProperty.call(params, key)) {
-      throw new ModelVariantParseError(`duplicate variant param "${key}" in "${encoded}"`);
-    }
-    params[key] = param.slice(eq + 1);
-  }
-  return params;
-}
-function decodeModelVariant(encoded) {
-  if (encoded.length === 0) {
-    throw new ModelVariantParseError("empty model variant");
-  }
-  const match17 = MODEL_VARIANT_RE.exec(encoded);
-  if (!match17) {
-    throw new ModelVariantParseError(`malformed model variant: "${encoded}"`);
-  }
-  const [, model, paramsPart] = match17;
-  if (paramsPart === undefined) {
-    return { model, params: {} };
-  }
-  return { model, params: parseParamList(encoded, paramsPart) };
-}
-function encodeModelVariant(model, params = {}) {
-  const entries2 = Object.entries(params);
-  if (entries2.length === 0)
-    return model;
-  const paramsPart = entries2.map(([key, value]) => `${key}=${value}`).join(",");
-  return `${model}[${paramsPart}]`;
-}
-function expandModelVariantCatalog(baseModelIds, combinations) {
-  return baseModelIds.flatMap((id3) => combinations.map((combo) => encodeModelVariant(id3, combo)));
-}
-function describeCombination(combo) {
-  const entries2 = Object.entries(combo);
-  return entries2.length === 0 ? "no params" : entries2.map(([k, v2]) => `${k}=${v2}`).join(",");
-}
-function validateModelVariantParams(variant, schema) {
-  const supported = schema.find((combo) => Object.keys(combo).length === Object.keys(variant.params).length && Object.entries(combo).every(([key, value]) => variant.params[key] === value));
-  if (!supported) {
-    throw new ModelVariantValidationError(`unsupported variant params for model "${variant.model}": ` + `${describeCombination(variant.params)}; ` + `allowed: ${schema.map(describeCombination).join(" | ")}`);
-  }
-  return variant;
-}
-var ModelVariantParseError, ModelVariantValidationError, MODEL_VARIANT_RE, PARAM_RE;
-var init_model_variant = __esm(() => {
-  ModelVariantParseError = class ModelVariantParseError extends Error {
-    code = "MODEL_VARIANT_PARSE";
-    constructor(message) {
-      super(message);
-      this.name = "ModelVariantParseError";
-    }
-  };
-  ModelVariantValidationError = class ModelVariantValidationError extends Error {
-    code = "MODEL_VARIANT_VALIDATION";
-    constructor(message) {
-      super(message);
-      this.name = "ModelVariantValidationError";
-    }
-  };
-  MODEL_VARIANT_RE = /^([^\[\]]+?)(?:\[([^\]]*)\])?$/;
-  PARAM_RE = /^[A-Za-z0-9_-]+=[^,\[\]\=]+$/;
-});
-
 // ../../services/backend/src/domain/entities/harness/model-provider.ts
 function prefixModelWithProvider(provider, modelId) {
   const bracket = modelId.indexOf("[");
@@ -28809,7 +28888,7 @@ function decodeCursorVariant(encoded) {
   try {
     const decoded = decodeModelVariant(encoded);
     return {
-      cliSlug: cursorVariantToCliSlug(decoded.model, decoded.params),
+      cliSlug: cursorVariantToCliSlug(decoded.model, normalizeCursorParamsForCliSlug(decoded.params)),
       params: decoded.params
     };
   } catch {
@@ -28838,9 +28917,7 @@ function decodedVariantToModelSelection(decoded) {
     ...params.length > 0 ? { params } : {}
   };
 }
-function resolveCursorSdkSpawnModelSelection(model, defaultModel = "composer-2.5") {
-  if (!model)
-    return { id: defaultModel };
+function resolveCursorSdkSpawnModelSelection(model) {
   const bare = resolveCursorSdkModel(model);
   if (bare.includes("[")) {
     const decoded = decodeModelVariant(bare);
@@ -29949,6 +30026,18 @@ var init_claude_sdk_stream_adapter = __esm(() => {
   };
 });
 
+// src/daemon/infrastructure/local/harness/services/require-harness-model.ts
+function requireHarnessModel(model, context5) {
+  const trimmed = model?.trim();
+  if (!trimmed) {
+    throw new Error(`Harness model is required (${context5})`);
+  }
+  return trimmed;
+}
+function resolveHarnessResumeModel(spawnModel, storedModel, context5) {
+  return requireHarnessModel(spawnModel ?? storedModel, context5);
+}
+
 // src/daemon/infrastructure/local/harness/services/wire-native-stream-adapter.ts
 function wireNativeStreamAdapter(args2) {
   args2.adapter.setAssistantTextCapture((text) => {
@@ -29985,7 +30074,7 @@ async function withTimeout(p, ms, label) {
 // src/daemon/infrastructure/local/harness/services/claude-sdk/claude-sdk-agent-service.ts
 import { randomUUID } from "node:crypto";
 function decodeClaudeSdkModel(model) {
-  const variant = decodeClaudeVariant(model);
+  const variant = decodeClaudeVariant(requireHarnessModel(model, "claude-sdk"));
   return { model: variant?.model, effort: variant?.effort };
 }
 async function loadSdk() {
@@ -30408,7 +30497,8 @@ var init_claude_sdk_agent_service = __esm(() => {
       }
     }
     async spawn(options) {
-      const { model, effort } = decodeClaudeSdkModel(options.model);
+      const resolvedModel = requireHarnessModel(options.model, "claude-sdk spawn");
+      const { model, effort } = decodeClaudeSdkModel(resolvedModel);
       const deferInitialTurn = options.deferInitialTurn ?? false;
       const keeper = this.spawnKeeper(options.workingDir);
       const pid = keeper.pid;
@@ -30442,7 +30532,8 @@ var init_claude_sdk_agent_service = __esm(() => {
         const pid = keeper.pid;
         await loadSdk();
         const executablePath = await resolvePathToClaudeCodeExecutable();
-        const { model, effort } = decodeClaudeSdkModel(options.model ?? stored.model);
+        const resolvedModel = resolveHarnessResumeModel(options.model, stored.model, "claude-sdk resumeFromDaemonMemory");
+        const { model, effort } = decodeClaudeSdkModel(resolvedModel);
         return this.startRunningSession({
           pid,
           keeper,
@@ -30478,7 +30569,8 @@ var init_codex_sdk_model_variants = __esm(() => {
     { reasoning: "low" },
     { reasoning: "medium" },
     { reasoning: "high" },
-    { reasoning: "xhigh" }
+    { reasoning: "xhigh" },
+    { reasoning: "max" }
   ];
 });
 
@@ -31511,7 +31603,8 @@ ${deferredResume}` : deferredResume;
       }
     }
     async spawn(options) {
-      const variant = decodeCodexVariant(options.model);
+      const model = requireHarnessModel(options.model, "codex-sdk spawn");
+      const variant = decodeCodexVariant(model);
       const deferInitialTurn = options.deferInitialTurn ?? false;
       const keeper = this.spawnKeeper(options.workingDir);
       const pid = keeper.pid;
@@ -31542,7 +31635,7 @@ ${options.prompt}`;
         thread,
         context: context5,
         workingDir: options.workingDir,
-        model: options.model,
+        model,
         initialPrompt: fullPrompt,
         deferInitialTurn,
         storedSystemPrompt: options.systemPrompt
@@ -31552,7 +31645,8 @@ ${options.prompt}`;
       try {
         const keeper = this.spawnKeeper(stored.workingDir);
         const pid = keeper.pid;
-        const variant = decodeCodexVariant(options.model ?? stored.model);
+        const model = resolveHarnessResumeModel(options.model, stored.model, "codex-sdk resumeFromDaemonMemory");
+        const variant = decodeCodexVariant(model);
         const { Codex } = await loadSdk2();
         const codexPath = resolveCodexExecutablePath();
         const codex = new Codex({
@@ -31567,7 +31661,7 @@ ${options.prompt}`;
           thread,
           context: options.context,
           workingDir: stored.workingDir,
-          model: options.model ?? stored.model,
+          model,
           initialPrompt: options.prompt,
           storedSystemPrompt: options.systemPrompt,
           resumedThreadId: stored.harnessSessionId
@@ -32225,7 +32319,8 @@ var init_cursor_sdk_agent_service = __esm(() => {
       const context5 = options.context;
       const logPrefix = buildAgentLogPrefix("cursor-sdk", context5);
       const agentName = stored.agentName;
-      const modelSelection = resolveCursorSdkSpawnModelSelection(options.model ?? stored.model);
+      const model = resolveHarnessResumeModel(options.model, stored.model, "cursor-sdk resumeFromDaemonMemory");
+      const modelSelection = resolveCursorSdkSpawnModelSelection(model);
       const systemPrompt = options.systemPrompt ? `${NO_SUBAGENT_DIRECTIVE2}
 
 ${options.systemPrompt}` : NO_SUBAGENT_DIRECTIVE2;
@@ -32252,7 +32347,7 @@ ${options.prompt}`;
         agent,
         context: context5,
         agentName,
-        model: options.model ?? stored.model,
+        model,
         workingDir: stored.workingDir,
         initialPrompt: fullPrompt,
         forceFirstTurn: true
@@ -32512,7 +32607,8 @@ ${deferredResume}` : deferredResume;
       const context5 = options.context;
       const logPrefix = buildAgentLogPrefix("cursor-sdk", context5);
       const agentName = buildAgentName2(context5);
-      const modelSelection = resolveCursorSdkSpawnModelSelection(options.model);
+      const model = requireHarnessModel(options.model, "cursor-sdk spawn");
+      const modelSelection = resolveCursorSdkSpawnModelSelection(model);
       const systemPrompt = options.systemPrompt ? `${NO_SUBAGENT_DIRECTIVE2}
 
 ${options.systemPrompt}` : NO_SUBAGENT_DIRECTIVE2;
@@ -32540,7 +32636,7 @@ ${options.prompt}`;
         agent,
         context: context5,
         agentName,
-        model: options.model,
+        model,
         workingDir: options.workingDir,
         initialPrompt: fullPrompt,
         forceFirstTurn: !deferInitialTurn,
@@ -34513,21 +34609,6 @@ var init_parse_listening_url = __esm(() => {
   LISTENING_URL_RE = /opencode server listening on (https?:\/\/127\.0\.0\.1:\d+(?:\/[^\s]*)?)/;
 });
 
-// src/daemon/infrastructure/local/harness/services/opencode-sdk/pure.ts
-function parseModelId(model) {
-  if (!model)
-    return;
-  const slashIdx = model.indexOf("/");
-  if (slashIdx === -1)
-    return;
-  const providerID = model.substring(0, slashIdx);
-  const modelID = model.substring(slashIdx + 1);
-  if (!providerID || !modelID)
-    return;
-  return { providerID, modelID };
-}
-var isInfoLine = (line) => line.trimStart().startsWith("INFO ");
-
 // src/daemon/infrastructure/local/harness/services/opencode-sdk/select-agent.ts
 function selectAgent(agents) {
   const primaries = agents.filter((a) => a.mode !== "subagent");
@@ -35018,12 +35099,15 @@ var init_binary_agent_service = __esm(() => {
 
 // src/daemon/infrastructure/local/harness/services/opencode-sdk/opencode-sdk-agent-service.ts
 function buildDisabledToolsPromptBody(args2) {
-  const modelParts = args2.model ? parseModelId(args2.model) : undefined;
+  const model = requireHarnessModel(args2.model, "opencode-sdk prompt");
+  const parsed = parseOpencodeSpawnModel(model);
+  const modelParts = parseModelId(parsed.model);
   return {
     agent: args2.agentName,
     ...args2.composedSystem ? { system: args2.composedSystem } : {},
     parts: [{ type: "text", text: args2.prompt }],
     ...modelParts ? { model: modelParts } : {},
+    ...parsed.variant ? { variant: parsed.variant } : {},
     tools: {
       task: false,
       question: false,
@@ -35035,6 +35119,7 @@ var SERVE_STARTUP_TIMEOUT_MS = 1e4, SESSION_CREATE_TIMEOUT_MS = 30000, PROMPT_AS
 var init_opencode_sdk_agent_service = __esm(() => {
   init_dist();
   init_parse_listening_url();
+  init_pure();
   init_session_event_forwarder();
   init_session_metadata_store();
   init_spawn_env();
@@ -35299,6 +35384,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
         this.sessionStore.remove(args2.sessionId);
     }
     async startFreshSessionOnServe(args2) {
+      const model = requireHarnessModel(args2.model, "opencode-sdk resume fallback");
       const existingForwarder = this.forwarders.get(args2.pid);
       existingForwarder?.stop();
       this.forwarders.delete(args2.pid);
@@ -35354,14 +35440,14 @@ var init_opencode_sdk_agent_service = __esm(() => {
       await this.promptSessionAsync(client4, newSessionId2, buildDisabledToolsPromptBody({
         agentName: args2.agentName,
         prompt: args2.prompt,
-        model: args2.model
+        model
       }));
     }
     async resumeFromDaemonMemory(options, session2) {
       const { prompt, systemPrompt, model, context: context5 } = options;
       const sessionId = session2.harnessSessionId;
       const agentName = session2.agentName;
-      const modelForSession = model ?? session2.model;
+      const modelForSession = resolveHarnessResumeModel(model, session2.model, "opencode-sdk resumeFromDaemonMemory");
       const workingDir = session2.workingDir;
       const { childProcess, pid, baseUrl, client: client4 } = await this.startServeAndClient(workingDir, options.resolvedConvexUrl);
       let forwarder;
@@ -35408,7 +35494,8 @@ var init_opencode_sdk_agent_service = __esm(() => {
       });
     }
     async spawn(options) {
-      const { prompt, systemPrompt, model, context: context5 } = options;
+      const { prompt, systemPrompt, context: context5 } = options;
+      const model = requireHarnessModel(options.model, "opencode-sdk spawn");
       const deferInitialTurn = options.deferInitialTurn ?? false;
       const { childProcess, pid, baseUrl, client: client4 } = await this.startServeAndClient(options.workingDir, options.resolvedConvexUrl);
       let sessionId;
@@ -35488,6 +35575,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
       const activityEmitter = this.activityEmittersByPid.get(pid);
       activityEmitter?.beginTurn();
       const client4 = createOpencodeClient({ baseUrl: meta.baseUrl });
+      const model = requireHarnessModel(meta.model, "opencode-sdk resumeTurn");
       const deferredSystem = meta.deferredSystemPrompt;
       const context5 = {
         machineId: meta.machineId,
@@ -35499,7 +35587,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
           agentName: meta.agentName,
           prompt,
           composedSystem: deferredSystem,
-          model: meta.model
+          model
         }));
         if (deferredSystem) {
           this.sessionStore.upsert({ ...meta, deferredSystemPrompt: undefined });
@@ -35511,7 +35599,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
           baseUrl: meta.baseUrl,
           context: context5,
           agentName: meta.agentName,
-          model: meta.model,
+          model,
           prompt,
           oldSessionId: meta.sessionId
         });
@@ -35775,17 +35863,13 @@ function waitForResumeOrAbort4(session2) {
     })
   ]);
 }
-function resolveModel(modelRegistry, model) {
-  if (model) {
-    const slash = model.indexOf("/");
-    if (slash === -1) {
-      return modelRegistry.getAll().find((entry) => entry.id === model);
-    }
-    const provider = model.slice(0, slash);
-    const modelId = model.slice(slash + 1);
-    return modelRegistry.find(provider, modelId);
+function resolveRequiredModel(modelRegistry, model) {
+  const slash = model.indexOf("/");
+  const resolved = slash === -1 ? modelRegistry.getAll().find((entry) => entry.id === model) : modelRegistry.find(model.slice(0, slash), model.slice(slash + 1));
+  if (!resolved) {
+    throw new Error(`Pi model not found: ${model}`);
   }
-  return modelRegistry.getAvailable()[0];
+  return resolved;
 }
 function writeSpawnError4(logPrefix, err, emitLogLine) {
   const line = formatAgentLogLine(logPrefix, "spawn-error", formatPiSdkLoadError(err));
@@ -35803,6 +35887,7 @@ var init_pi_sdk_agent_service = __esm(() => {
   init_base_cli_agent_service();
   init_detection_result();
   init_pi_agent_service();
+  init_pure2();
   PiSdkAgentService = class PiSdkAgentService extends BaseCLIAgentService {
     id = "pi-sdk";
     displayName = "Pi (SDK)";
@@ -35848,6 +35933,78 @@ var init_pi_sdk_agent_service = __esm(() => {
         return [];
       }
     }
+    getHarnessReconnectContext(pid) {
+      const session2 = this.sessions.get(pid);
+      if (!session2) {
+        return;
+      }
+      return {
+        agentName: "builder",
+        model: session2.model
+      };
+    }
+    async resumeFromDaemonMemory(options, stored) {
+      const model = resolveHarnessResumeModel(options.model, stored.model, "pi-sdk resumeFromDaemonMemory");
+      const keeper = this.spawnKeeper(stored.workingDir);
+      const pid = keeper.pid;
+      try {
+        const session2 = await this.openResumedSession({
+          workingDir: stored.workingDir,
+          systemPrompt: options.systemPrompt,
+          harnessSessionId: stored.harnessSessionId
+        });
+        const fullPrompt = `${options.systemPrompt}
+
+${options.prompt}`;
+        return this.startRunningSession({
+          pid,
+          keeper,
+          session: session2,
+          context: options.context,
+          workingDir: stored.workingDir,
+          model,
+          initialPrompt: fullPrompt,
+          deferInitialTurn: false,
+          storedSystemPrompt: options.systemPrompt
+        });
+      } catch (err) {
+        writeSpawnError4(buildAgentLogPrefix("pi-sdk", options.context), err);
+        keeper.kill();
+        this.deleteProcess(pid);
+        return this.spawn({ ...options, model });
+      }
+    }
+    async openResumedSession(args2) {
+      const {
+        AuthStorage,
+        createAgentSession,
+        DefaultResourceLoader,
+        getAgentDir,
+        ModelRegistry,
+        SessionManager
+      } = await loadSdk4();
+      const authStorage = AuthStorage.create();
+      const modelRegistry = ModelRegistry.create(authStorage);
+      const sessions = await SessionManager.list(args2.workingDir, getPiSessionDir(args2.workingDir));
+      const match17 = sessions.find((s) => s.id === args2.harnessSessionId);
+      if (!match17) {
+        throw new Error(`Pi session ${args2.harnessSessionId} not found`);
+      }
+      const resourceLoader = new DefaultResourceLoader({
+        cwd: args2.workingDir,
+        agentDir: getAgentDir(),
+        systemPromptOverride: () => args2.systemPrompt
+      });
+      await resourceLoader.reload();
+      const { session: session2 } = await withTimeout(createAgentSession({
+        cwd: args2.workingDir,
+        sessionManager: SessionManager.open(match17.path, getPiSessionDir(args2.workingDir)),
+        authStorage,
+        modelRegistry,
+        resourceLoader
+      }), SESSION_CREATE_TIMEOUT_MS2, "createAgentSession");
+      return session2;
+    }
     async resumeTurn(pid, prompt) {
       const session2 = this.sessions.get(pid);
       if (!session2) {
@@ -35907,10 +36064,10 @@ var init_pi_sdk_agent_service = __esm(() => {
       } = await loadSdk4();
       const authStorage = AuthStorage.create();
       const modelRegistry = ModelRegistry.create(authStorage);
-      const resolvedModel = resolveModel(modelRegistry, args2.model);
-      if (!resolvedModel) {
-        throw new Error("No Pi model available — configure provider credentials in ~/.pi/agent/auth.json");
-      }
+      const model = requireHarnessModel(args2.model, "pi-sdk spawn");
+      const parsed = parsePiSpawnModel(model);
+      const resolvedModel = resolveRequiredModel(modelRegistry, parsed.model ?? model);
+      const thinkingLevel = resolvePiThinkingLevel(parsed?.thinking);
       const agentDir = getAgentDir();
       const resourceLoader = new DefaultResourceLoader({
         cwd: args2.workingDir,
@@ -35921,6 +36078,7 @@ var init_pi_sdk_agent_service = __esm(() => {
       const { session: session2 } = await withTimeout(createAgentSession({
         cwd: args2.workingDir,
         model: resolvedModel,
+        ...thinkingLevel ? { thinkingLevel } : {},
         sessionManager: SessionManager.create(getPiSessionDir(args2.workingDir)),
         authStorage,
         modelRegistry,
@@ -35934,6 +36092,7 @@ var init_pi_sdk_agent_service = __esm(() => {
         keeper,
         session: session2,
         context: context5,
+        model,
         initialPrompt,
         deferInitialTurn = false,
         storedSystemPrompt
@@ -35943,6 +36102,7 @@ var init_pi_sdk_agent_service = __esm(() => {
       const logPrefix = buildAgentLogPrefix("pi-sdk", context5);
       const sdkSession = {
         session: session2,
+        model,
         keeper,
         aborted: false,
         storedSystemPrompt
@@ -36096,6 +36256,7 @@ ${deferredResume}` : deferredResume;
     }
     async spawn(options) {
       const deferInitialTurn = options.deferInitialTurn ?? false;
+      const model = requireHarnessModel(options.model, "pi-sdk spawn");
       const keeper = this.spawnKeeper(options.workingDir);
       const pid = keeper.pid;
       const context5 = options.context;
@@ -36107,7 +36268,7 @@ ${options.prompt}`;
         session2 = await this.createSession({
           workingDir: options.workingDir,
           systemPrompt: options.systemPrompt,
-          model: options.model
+          model
         });
       } catch (err) {
         keeper.kill();
@@ -36120,7 +36281,7 @@ ${options.prompt}`;
         session: session2,
         context: context5,
         workingDir: options.workingDir,
-        model: options.model,
+        model,
         initialPrompt: fullPrompt,
         deferInitialTurn,
         storedSystemPrompt: options.systemPrompt
@@ -79996,6 +80157,40 @@ var init_builder_to_planner = __esm(() => {
 // ../../services/backend/src/domain/usecase/enhancer/enhancer-handoff-content.ts
 var ENHANCER_USER_MESSAGE_PLACEHOLDER = "{{USER_MESSAGE}}";
 
+// ../../services/backend/prompts/utils/data-query-design.ts
+function getDataQueryDesignTemplateBlock() {
+  return `## Persistent state and query pattern design
+
+**Goal:** Small updates must not cause large cache invalidations. High-frequency writes use projections to smaller tables.
+
+### 1. Sources of concern
+| Source | Write frequency | Read pattern | Risk |
+|--------|---------------|--------------|------|
+| \`<table/mutation>\` | \`<frequency>\` | \`<pattern>\` | \`<scan / hot partition>\` |
+
+### 2. Schema design
+**Hot path:** \`<table>\` — fields, projection from \`<source>\`
+**Cold path:** \`<table>\` — …
+
+\`\`\`typescript
+// target schema shape
+\`\`\`
+
+### 3. Index design (within limits)
+| Table | Index | Serves query | Budget |
+|-------|-------|--------------|--------|
+
+### 4. Query design (within limits)
+| Query | Index | Rows scanned | Timeout | Invalidation scope |
+|-------|-------|--------------|---------|-------------------|
+
+\`\`\`typescript
+// target query signature
+\`\`\`
+
+<!-- Write exactly "Not Applicable." for the entire section if no persistence changes -->`;
+}
+
 // ../../services/backend/prompts/utils/frontend-design-ux-checklist.ts
 function getFrontendDesignUxPlanningPrinciplesBlock() {
   return `<!-- Ground every flow in user history and repository patterns. Recommend one existing pattern when multiple exist; do not prescribe style choices the project has not adopted. -->`;
@@ -80073,36 +80268,7 @@ export function ComponentName({ ... }: Props) {
 </handoff-frontend-design>
 
 <handoff-data-design>
-## Persistent state and query pattern design
-
-**Goal:** Small updates must not cause large cache invalidations. High-frequency writes use projections to smaller tables.
-
-### 1. Sources of concern
-| Source | Write frequency | Read pattern | Risk |
-|--------|---------------|--------------|------|
-| \`<table/mutation>\` | \`<frequency>\` | \`<pattern>\` | \`<scan / hot partition>\` |
-
-### 2. Schema design
-**Hot path:** \`<table>\` — fields, projection from \`<source>\`
-**Cold path:** \`<table>\` — …
-
-\`\`\`typescript
-// target schema shape
-\`\`\`
-
-### 3. Index design (within limits)
-| Table | Index | Serves query | Budget |
-|-------|-------|--------------|--------|
-
-### 4. Query design (within limits)
-| Query | Index | Rows scanned | Timeout | Invalidation scope |
-|-------|-------|--------------|---------|-------------------|
-
-\`\`\`typescript
-// target query signature
-\`\`\`
-
-<!-- Write exactly "Not Applicable." for the entire section if no persistence changes -->
+${getDataQueryDesignTemplateBlock()}
 </handoff-data-design>
 
 <handoff-notes>
@@ -80731,14 +80897,22 @@ var init_backlog = __esm(() => {
 // ../../services/backend/src/domain/usecase/skills/modules/code-review/index.ts
 var init_code_review = () => {};
 
+// ../../services/backend/src/domain/usecase/skills/modules/data-design/index.ts
+var init_data_design = () => {};
+
 // ../../services/backend/src/domain/usecase/skills/modules/defragmentation/index.ts
 var init_defragmentation = () => {};
 
+// ../../services/backend/src/domain/usecase/skills/modules/user-centricity/index.ts
+var init_user_centricity = () => {};
+
 // ../../services/backend/src/domain/usecase/skills/registry.ts
 var init_registry4 = __esm(() => {
   init_backlog();
   init_code_review();
+  init_data_design();
   init_defragmentation();
+  init_user_centricity();
 });
 
 // ../../services/backend/prompts/sections/glossary.ts
@@ -80774,9 +80948,23 @@ var init_glossary = __esm(() => {
       linkedSkillId: "code-review"
     },
     {
-      term: "structural-decisions",
-      definition: "Meta-level architectural choices that persist in the codebase and influence consistency: " + "folder structure, file naming, interface definitions, and key abstraction names/locations " + "(e.g., Repository/Service layers).",
+      term: "defragmentation",
+      definition: "Workflow for large or multi-surface revisions: study all relevant surfaces, establish a golden path, migrate every caller, then delete legacy implementations.",
       linkedSkillId: "defragmentation"
+    },
+    {
+      term: "user-centricity",
+      definition: "Design guidance for UI changes: translate user intent into complete flows with explicit loading, empty, error, and success states, stable layout, project patterns, keyboard behavior, feedback, affordances, and destructive-action safeguards.",
+      linkedSkillId: "user-centricity"
+    },
+    {
+      term: "data-design",
+      definition: "Persistence and query design guidance: make write/read risks, hot and cold paths, projections, indexes, scan limits, timeouts, and invalidation scope explicit.",
+      linkedSkillId: "data-design"
+    },
+    {
+      term: "structural-decisions",
+      definition: "Meta-level architectural choices that persist in the codebase and influence consistency: " + "folder structure, file naming, interface definitions, and key abstraction names/locations " + "(e.g., Repository/Service layers)."
     }
   ];
   NATIVE_GLOSSARY_TERMS = [
@@ -81041,6 +81229,14 @@ var init_cursor_sdk_config = __esm(() => {
       outputActivity: true,
       processExited: true
     },
+    crashRecovery: {
+      onSessionFailure: {
+        maxAttempts: 6,
+        intervalMs: 1e4,
+        resumeFirstAttempts: 3,
+        recoveryReason: "platform.cursor_sdk_session_reopen"
+      }
+    },
     wireEvents: ["sdk.cursor.message", "sdk.cursor.run.completed", "wire.log.agent_end"]
   };
 });
@@ -102818,6 +103014,25 @@ function resolveResumableHarnessSessionId(snapshot) {
   return snapshot.resumableHarnessSessionId ?? snapshot.harnessSessionId;
 }
 
+// src/daemon/domain/entities/session-recovery-policy.ts
+function resolveSessionRecoveryPolicy(harness, classification2) {
+  const caps = getHarnessCapabilities(harness);
+  if (classification2.hadSessionFailure && caps.crashRecovery?.onSessionFailure) {
+    return caps.crashRecovery.onSessionFailure;
+  }
+  return DEFAULT_CRASH_RECOVERY_POLICY;
+}
+var DEFAULT_CRASH_RECOVERY_POLICY;
+var init_session_recovery_policy = __esm(() => {
+  init_types();
+  DEFAULT_CRASH_RECOVERY_POLICY = {
+    maxAttempts: 1,
+    intervalMs: 0,
+    resumeFirstAttempts: 0,
+    recoveryReason: "platform.crash_recovery"
+  };
+});
+
 // src/daemon/domain/usecase/classify-resume-storm-reason.ts
 function classifyResumeStormReason(logLines) {
   const blob = logLines.join(`
@@ -102926,18 +103141,6 @@ function appendRecentLogLine(slot, line) {
 }
 var RECENT_LOG_LINE_CAP2 = 100;
 
-// src/daemon/domain/usecase/cursor-sdk-session-reopen-retry.ts
-var CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS = 20, CURSOR_SDK_SESSION_REOPEN_INTERVAL_MS = 5000, CURSOR_SDK_SESSION_REOPEN_REASON = "platform.cursor_sdk_session_reopen", CURSOR_SDK_SESSION_RESUME_FIRST_ATTEMPTS = 3;
-
-// src/daemon/domain/usecase/detect-cursor-sdk-run-error.ts
-function isCursorSdkRunErrorInLogs(logLines) {
-  return logLines.some((line) => line.includes(" run-error]"));
-}
-function formatCursorSdkRunErrorMessage(logLines) {
-  const line = [...logLines].reverse().find((l) => l.includes(" run-error]"));
-  return line?.trim() ?? "Cursor SDK run failed";
-}
-
 // src/daemon/domain/usecase/handle-turn-completed.ts
 async function handleTurnCompleted(deps, input, slot) {
   if (await tryAbortResumeStorm(deps, input, slot)) {
@@ -103074,6 +103277,19 @@ var init_native_spawn_presence = __esm(() => {
   init_execution_kind();
 });
 
+// src/daemon/infrastructure/local/harness/session-monitors/no-op-session-monitor.ts
+var NO_FAILURE, noOpSessionMonitor;
+var init_no_op_session_monitor = __esm(() => {
+  NO_FAILURE = {
+    hadSessionFailure: false,
+    failureKind: "none",
+    recoverable: true
+  };
+  noOpSessionMonitor = {
+    classifyExitFailure: () => NO_FAILURE
+  };
+});
+
 // src/daemon/infrastructure/agent-process-manager/agent-process-manager.ts
 function agentKey3(chatroomId, role) {
   return `${chatroomId}:${role.toLowerCase()}`;
@@ -103083,7 +103299,7 @@ class AgentProcessManager {
   deps;
   slots = new Map;
   lastHarnessSessions = new Map;
-  sessionReopenRetryInFlight = new Set;
+  sessionRecoveryRetryInFlight = new Set;
   exitRetryQueue = [];
   exitRetryTimer = null;
   turnEndQueue = new TurnEndQueue;
@@ -103501,12 +103717,12 @@ class AgentProcessManager {
       });
     }));
     this.resetSlotAfterExit(slot);
-    await this.emitExitEvent(slot, opts, ctx);
+    const exitLifecyclePromise = this.emitExitEvent(slot, opts, ctx);
     try {
       await this.deps.persistence.clearAgentPid(this.deps.machineId, opts.chatroomId, opts.role);
     } catch {}
     this.untrackAllServices(opts.pid);
-    lifecyclePromise.then(() => this.dispatchRestartAfterExit(opts, ctx, key)).catch(() => {});
+    lifecyclePromise.then(() => this.dispatchRestartAfterExit(opts, ctx, key, exitLifecyclePromise)).catch(() => {});
   }
   captureExitContext(slot, opts, stopReason) {
     return {
@@ -103554,7 +103770,7 @@ class AgentProcessManager {
     slot.pendingOperation = undefined;
     slot.nativeTurnPhase = undefined;
   }
-  async emitExitEvent(slot, opts, ctx) {
+  emitExitEvent(slot, opts, ctx) {
     const stopReason = ctx.stopReason;
     const exitArgs = {
       sessionId: this.deps.sessionId,
@@ -103568,14 +103784,14 @@ class AgentProcessManager {
       signal: opts.signal ?? undefined,
       agentHarness: ctx.harness
     };
-    this.recordAgentExit(opts.role, exitArgs, "Failed to record agent exit event");
+    return this.recordAgentExit(opts.role, exitArgs, "Failed to record agent exit event");
   }
   untrackAllServices(pid) {
     for (const service3 of this.deps.agentServices.values()) {
       service3.untrack(pid);
     }
   }
-  dispatchRestartAfterExit(opts, ctx, _key) {
+  dispatchRestartAfterExit(opts, ctx, _key, exitLifecyclePromise) {
     if (this.isStopRequested(opts.chatroomId, opts.role)) {
       return;
     }
@@ -103586,14 +103802,123 @@ class AgentProcessManager {
       }
       return;
     }
-    this.maybeRestartAgent(opts, ctx);
+    this.maybeRestartAgent(opts, ctx, exitLifecyclePromise);
   }
-  hasCursorSdkRunErrorInContext(recentLogLines) {
-    if (!isCursorSdkRunErrorInLogs(recentLogLines)) {
-      return false;
+  maybeRestartAgent(opts, ctx, exitLifecyclePromise) {
+    const { harness, recentLogLines } = ctx;
+    const logs = recentLogLines ?? [];
+    if (!harness || !ctx.workingDir) {
+      console.log(`[AgentProcessManager] ⚠️  Cannot restart — missing harness or workingDir ` + `(role: ${opts.role}, harness: ${harness ?? "none"}, workingDir: ${ctx.workingDir ?? "none"})`);
+      return;
     }
-    console.log(`[AgentProcessManager] cursor-sdk run-error detected: ${formatCursorSdkRunErrorMessage(recentLogLines)}`);
-    return true;
+    const monitor = this.deps.sessionMonitors.get(harness) ?? noOpSessionMonitor;
+    const monitorCtx = {
+      recentLogLines: logs,
+      harness,
+      wantResume: ctx.wantResume
+    };
+    const classification2 = monitor.classifyExitFailure(monitorCtx);
+    this.retrySessionRecovery(opts, ctx, classification2, monitor, monitorCtx, exitLifecyclePromise);
+  }
+  async retrySessionRecovery(opts, ctx, classification2, monitor, monitorCtx, exitLifecyclePromise) {
+    const harness = ctx.harness;
+    const policy = resolveSessionRecoveryPolicy(harness, classification2);
+    const key = agentKey3(opts.chatroomId, opts.role);
+    const multiAttempt = policy.maxAttempts > 1;
+    if (multiAttempt && this.sessionRecoveryRetryInFlight.has(key)) {
+      return;
+    }
+    if (multiAttempt) {
+      this.sessionRecoveryRetryInFlight.add(key);
+    }
+    try {
+      await this.prepareSessionRecoveryBeforeRetry(opts, classification2, exitLifecyclePromise);
+      const lastError = await this.runSessionRecoveryAttempts(opts, ctx, classification2, monitor, monitorCtx, policy, key, multiAttempt);
+      if (lastError === null)
+        return;
+      if (multiAttempt) {
+        const failureMessage = `${harness} session recovery failed after ${policy.maxAttempts} attempts: ${lastError}`;
+        console.log(`[AgentProcessManager] ⛔ ${failureMessage}`);
+        this.emitStartFailedEvent(opts.role, opts.chatroomId, failureMessage);
+      } else {
+        console.log(`[AgentProcessManager] ⚠️  Agent restart did not complete for ${opts.role}: ${lastError}`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.log(`   ⚠️  Session recovery retry loop failed: ${message}`);
+      this.emitStartFailedEvent(opts.role, opts.chatroomId, message);
+    } finally {
+      if (multiAttempt) {
+        this.sessionRecoveryRetryInFlight.delete(key);
+      }
+    }
+  }
+  async prepareSessionRecoveryBeforeRetry(opts, classification2, exitLifecyclePromise) {
+    if (!classification2.requiresTaskReleaseBeforeRecovery)
+      return;
+    this.clearLastInFlightTask(opts.chatroomId, opts.role);
+    if (exitLifecyclePromise) {
+      await exitLifecyclePromise;
+    }
+  }
+  async runSessionRecoveryAttempts(opts, ctx, classification2, monitor, monitorCtx, policy, key, multiAttempt) {
+    const generation = this.slots.get(key)?.stopGeneration;
+    let lastError = "unknown";
+    for (let attempt = 1;attempt <= policy.maxAttempts; attempt++) {
+      if (this.isStopRequested(opts.chatroomId, opts.role, generation))
+        return null;
+      if (classification2.hadSessionFailure && policy.resumeFirstAttempts > 0 && attempt === policy.resumeFirstAttempts + 1) {
+        this.clearHarnessSessionAfterResumePhaseFailure(key, opts);
+      }
+      const wantResume = monitor.resolveWantResume?.(attempt, classification2, monitorCtx) ?? (classification2.hadSessionFailure ? false : ctx.wantResume ?? true);
+      if (multiAttempt) {
+        const stored = this.lastHarnessSessions.get(key);
+        const storedSessionId = stored ? resolveResumableHarnessSessionId(stored) : undefined;
+        await this.emitSessionReopenRetry(opts.chatroomId, opts.role, attempt, policy.maxAttempts, attempt > 1 ? lastError : undefined, storedSessionId);
+        if (this.isStopRequested(opts.chatroomId, opts.role, generation))
+          return null;
+      }
+      const attemptResult = await this.executeSessionRecoveryAttempt(opts, ctx, policy, wantResume, multiAttempt, generation);
+      if (attemptResult.kind === "success" || attemptResult.kind === "stopped")
+        return null;
+      if (attemptResult.kind === "crash_loop")
+        return null;
+      lastError = attemptResult.lastError;
+      if (attempt < policy.maxAttempts && policy.intervalMs > 0) {
+        await this.deps.clock.delay(policy.intervalMs);
+        if (this.isStopRequested(opts.chatroomId, opts.role, generation))
+          return null;
+      }
+    }
+    return lastError;
+  }
+  async executeSessionRecoveryAttempt(opts, ctx, policy, wantResume, multiAttempt, generation) {
+    const harness = ctx.harness;
+    const ensureOpts = {
+      chatroomId: opts.chatroomId,
+      role: opts.role,
+      agentHarness: harness,
+      model: ctx.model,
+      workingDir: ctx.workingDir,
+      reason: policy.recoveryReason,
+      wantResume
+    };
+    const result = await this.ensureRunning(ensureOpts);
+    if (result.success)
+      return { kind: "success" };
+    if (this.isStopRequested(opts.chatroomId, opts.role, generation)) {
+      return { kind: "stopped" };
+    }
+    const error51 = result.error ?? "unknown";
+    if (!multiAttempt && result.error === "backoff") {
+      await this.retryCrashRecoveryAfterBackoff(opts, ctx, ensureOpts, result.retryAfterMs);
+      return { kind: "success" };
+    }
+    if (result.error === "crash_loop") {
+      this.handleCrashLoopLimitReached(opts, ctx.recentLogLines);
+      return { kind: "crash_loop" };
+    }
+    return { kind: "failed", lastError: error51 };
   }
   maybeEmitProviderUnavailable(chatroomId, role, slot) {
     if (!slot || slot.harness !== "codex-sdk" || slot.providerUnavailableEmitted)
@@ -103625,48 +103950,6 @@ class AgentProcessManager {
       recoverable: providerUnavailableRecoverable(classification2.reason)
     }).catch(() => {});
   }
-  maybeRestartAgent(opts, ctx) {
-    const { harness, model, workingDir, recentLogLines } = ctx;
-    const logs = recentLogLines ?? [];
-    if (!harness || !workingDir) {
-      console.log(`[AgentProcessManager] ⚠️  Cannot restart — missing harness or workingDir ` + `(role: ${opts.role}, harness: ${harness ?? "none"}, workingDir: ${workingDir ?? "none"})`);
-      return;
-    }
-    const hadRunError = this.hasCursorSdkRunErrorInContext(logs);
-    if (harness === "cursor-sdk") {
-      this.retryCursorSdkSessionReopen(opts, ctx, hadRunError);
-      return;
-    }
-    this.attemptCrashRecoveryRestart(opts, ctx, {
-      chatroomId: opts.chatroomId,
-      role: opts.role,
-      agentHarness: harness,
-      model,
-      workingDir,
-      reason: "platform.crash_recovery",
-      wantResume: hadRunError ? false : ctx.wantResume ?? true
-    });
-  }
-  async attemptCrashRecoveryRestart(exitOpts, ctx, ensureOpts) {
-    try {
-      const result = await this.ensureRunning(ensureOpts);
-      if (result.success)
-        return;
-      if (result.error === "backoff") {
-        await this.retryCrashRecoveryAfterBackoff(exitOpts, ctx, ensureOpts, result.retryAfterMs);
-        return;
-      }
-      if (result.error === "crash_loop") {
-        this.handleCrashLoopLimitReached(exitOpts, ctx.recentLogLines);
-        return;
-      }
-      console.log(`[AgentProcessManager] ⚠️  Agent restart did not complete for ${exitOpts.role}: ${result.error ?? "unknown"}`);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.log(`   ⚠️  Failed to restart agent: ${message}`);
-      this.emitStartFailedEvent(exitOpts.role, exitOpts.chatroomId, message);
-    }
-  }
   async retryCrashRecoveryAfterBackoff(exitOpts, ctx, ensureOpts, retryAfterMs) {
     if (retryAfterMs === undefined || retryAfterMs <= 0) {
       return;
@@ -103704,71 +103987,6 @@ class AgentProcessManager {
       });
     }
   }
-  resolveCursorSdkReopenWantResume(hadRunError, attempt, ctx) {
-    if (hadRunError && attempt <= CURSOR_SDK_SESSION_RESUME_FIRST_ATTEMPTS) {
-      return true;
-    }
-    if (hadRunError) {
-      return false;
-    }
-    return ctx.wantResume ?? true;
-  }
-  async retryCursorSdkSessionReopen(opts, ctx, hadRunError) {
-    const key = agentKey3(opts.chatroomId, opts.role);
-    if (this.sessionReopenRetryInFlight.has(key)) {
-      return;
-    }
-    this.sessionReopenRetryInFlight.add(key);
-    const generation = this.slots.get(key)?.stopGeneration;
-    const harness = ctx.harness;
-    const model = ctx.model;
-    const workingDir = ctx.workingDir;
-    let lastError = "unknown";
-    try {
-      for (let attempt = 1;attempt <= CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS; attempt++) {
-        if (this.isStopRequested(opts.chatroomId, opts.role, generation))
-          return;
-        if (hadRunError && attempt === CURSOR_SDK_SESSION_RESUME_FIRST_ATTEMPTS + 1) {
-          this.clearHarnessSessionAfterResumePhaseFailure(key, opts);
-        }
-        const wantResume = this.resolveCursorSdkReopenWantResume(hadRunError, attempt, ctx);
-        const stored = this.lastHarnessSessions.get(key);
-        const storedSessionId = stored ? resolveResumableHarnessSessionId(stored) : undefined;
-        await this.emitSessionReopenRetry(opts.chatroomId, opts.role, attempt, attempt > 1 ? lastError : undefined, storedSessionId);
-        if (this.isStopRequested(opts.chatroomId, opts.role, generation))
-          return;
-        const result = await this.ensureRunning({
-          chatroomId: opts.chatroomId,
-          role: opts.role,
-          agentHarness: harness,
-          model,
-          workingDir,
-          reason: CURSOR_SDK_SESSION_REOPEN_REASON,
-          wantResume
-        });
-        if (result.success) {
-          return;
-        }
-        if (this.isStopRequested(opts.chatroomId, opts.role, generation))
-          return;
-        lastError = result.error ?? "unknown";
-        if (attempt < CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS) {
-          await this.deps.clock.delay(CURSOR_SDK_SESSION_REOPEN_INTERVAL_MS);
-          if (this.isStopRequested(opts.chatroomId, opts.role, generation))
-            return;
-        }
-      }
-      const failureMessage = `cursor-sdk session reopen failed after ${CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS} attempts: ${lastError}`;
-      console.log(`[AgentProcessManager] ⛔ ${failureMessage}`);
-      this.emitStartFailedEvent(opts.role, opts.chatroomId, failureMessage);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.log(`   ⚠️  cursor-sdk session reopen retry loop failed: ${message}`);
-      this.emitStartFailedEvent(opts.role, opts.chatroomId, message);
-    } finally {
-      this.sessionReopenRetryInFlight.delete(key);
-    }
-  }
   emitStartFailedEvent(role, chatroomId, error51) {
     logDaemonAuditEvent(this.deps.logEvent, {
       type: "agent.startFailed",
@@ -103978,7 +104196,11 @@ class AgentProcessManager {
       this.queueExitRetry({ role, args: exitArgs });
     });
     const emittedAt = this.deps.clock.now();
-    this.deps.lifecycleOutbox.enqueue(buildExitedLifecycleFact(exitArgs, emittedAt)).catch((err) => console.log(`   ⚠️  Failed to enqueue agent exited lifecycle fact: ${err.message}`));
+    return this.deps.lifecycleOutbox.enqueue(buildExitedLifecycleFact(exitArgs, emittedAt)).then(() => {
+      return;
+    }).catch((err) => {
+      console.log(`   ⚠️  Failed to enqueue agent exited lifecycle fact: ${err.message}`);
+    });
   }
   async clearAgentPidQuietly(chatroomId, role) {
     try {
@@ -104156,7 +104378,7 @@ class AgentProcessManager {
       console.log(`   ⚠️  Failed to emit sessionResumeFailed event: ${err.message}`);
     }
   }
-  async emitSessionReopenRetry(chatroomId, role, attempt, error51, harnessSessionId) {
+  async emitSessionReopenRetry(chatroomId, role, attempt, maxAttempts, error51, harnessSessionId) {
     try {
       await logDaemonAuditEvent(this.deps.logEvent, {
         type: "agent.sessionReopenRetry",
@@ -104164,7 +104386,7 @@ class AgentProcessManager {
         role,
         machineId: this.deps.machineId,
         attempt,
-        maxAttempts: CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS,
+        maxAttempts,
         ...error51 ? { error: error51 } : {},
         ...harnessSessionId ? { harnessSessionId } : {}
       });
@@ -104174,11 +104396,11 @@ class AgentProcessManager {
         chatroomId,
         role,
         attempt,
-        maxAttempts: CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS,
+        maxAttempts,
         ...error51 ? { error: error51 } : {},
         ...harnessSessionId ? { harnessSessionId } : {}
       });
-      console.log(`[AgentProcessManager] ✅ Emitted agent.sessionReopenRetry for ${role} (attempt ${attempt}/${CURSOR_SDK_SESSION_REOPEN_MAX_ATTEMPTS})`);
+      console.log(`[AgentProcessManager] ✅ Emitted agent.sessionReopenRetry for ${role} (attempt ${attempt}/${maxAttempts})`);
     } catch (err) {
       console.log(`   ⚠️  Failed to emit sessionReopenRetry event: ${err.message}`);
     }
@@ -104757,6 +104979,7 @@ var init_agent_process_manager = __esm(() => {
   init_agent_lifecycle_runtime();
   init_agent_lifecycle_types();
   init_agent_stop();
+  init_session_recovery_policy();
   init_spawn_policy();
   init_abort_resume_storm();
   init_classify_provider_error();
@@ -104768,6 +104991,99 @@ var init_agent_process_manager = __esm(() => {
   init_native_task_delivery_coordinator();
   init_native_turn_phase2();
   init_native_spawn_presence();
+  init_no_op_session_monitor();
+});
+
+// src/daemon/domain/usecase/cursor-sdk-session-reopen-retry.ts
+var CURSOR_SDK_SESSION_RESUME_FIRST_ATTEMPTS = 3;
+
+// src/daemon/domain/usecase/detect-cursor-sdk-run-error.ts
+function isCursorSdkRunErrorInLogs(logLines) {
+  return logLines.some((line) => line.includes(" run-error]"));
+}
+function formatCursorSdkRunErrorMessage(logLines) {
+  const line = [...logLines].reverse().find((l) => l.includes(" run-error]"));
+  return line?.trim() ?? "Cursor SDK run failed";
+}
+function isCursorSdkAuthErrorInLogs(logLines) {
+  if (classifyResumeStormReason(logLines) !== "auth_error")
+    return false;
+  return logLines.some((line) => line.includes("[cursor-sdk:"));
+}
+function hasCursorSdkSessionReopenTrigger(logLines) {
+  return isCursorSdkRunErrorInLogs(logLines) || isCursorSdkAuthErrorInLogs(logLines);
+}
+var init_detect_cursor_sdk_run_error = __esm(() => {
+  init_classify_resume_storm_reason();
+});
+
+// src/daemon/infrastructure/local/harness/session-monitors/cursor-sdk-session-monitor.ts
+var cursorSdkSessionMonitor;
+var init_cursor_sdk_session_monitor = __esm(() => {
+  init_detect_cursor_sdk_run_error();
+  cursorSdkSessionMonitor = {
+    classifyExitFailure(ctx) {
+      const logs = ctx.recentLogLines;
+      if (!hasCursorSdkSessionReopenTrigger(logs)) {
+        return { hadSessionFailure: false, failureKind: "none", recoverable: true };
+      }
+      const auth = isCursorSdkAuthErrorInLogs(logs);
+      console.log(`[CursorSdkSessionMonitor] session failure detected: ${formatCursorSdkRunErrorMessage(logs)}`);
+      return {
+        hadSessionFailure: true,
+        failureKind: auth ? "auth_error" : "run_error",
+        recoverable: true,
+        requiresTaskReleaseBeforeRecovery: auth
+      };
+    },
+    resolveWantResume(attempt, classification2, ctx) {
+      if (classification2.hadSessionFailure && attempt <= CURSOR_SDK_SESSION_RESUME_FIRST_ATTEMPTS) {
+        return true;
+      }
+      if (classification2.hadSessionFailure) {
+        return false;
+      }
+      return ctx.wantResume ?? true;
+    }
+  };
+});
+
+// src/daemon/infrastructure/local/harness/session-monitors/session-monitor-registry.ts
+function registerSessionMonitor(harnessId, monitor) {
+  registry3.set(harnessId, monitor);
+}
+function getSessionMonitor(harnessId) {
+  return registry3.get(harnessId);
+}
+function getAllSessionMonitors() {
+  return new Map(registry3);
+}
+var registry3;
+var init_session_monitor_registry = __esm(() => {
+  registry3 = new Map;
+});
+
+// src/daemon/infrastructure/local/harness/session-monitors/init-session-monitors.ts
+function initSessionMonitorRegistry() {
+  if (initialized2)
+    return;
+  for (const harness of AGENT_HARNESSES) {
+    registerSessionMonitor(harness, harness === "cursor-sdk" ? cursorSdkSessionMonitor : noOpSessionMonitor);
+  }
+  for (const service3 of getAllHarnesses()) {
+    if (!getSessionMonitor(service3.id)) {
+      registerSessionMonitor(service3.id, noOpSessionMonitor);
+    }
+  }
+  initialized2 = true;
+}
+var initialized2 = false;
+var init_init_session_monitors = __esm(() => {
+  init_agent2();
+  init_cursor_sdk_session_monitor();
+  init_no_op_session_monitor();
+  init_session_monitor_registry();
+  init_registry2();
 });
 
 // src/daemon/entry/init-daemon.ts
@@ -104831,6 +105147,7 @@ function assembleDaemonSessionInit(args2) {
     config: config4,
     convexUrl,
     agentServices,
+    sessionMonitors,
     cachedModels,
     deps
   } = args2;
@@ -104847,6 +105164,7 @@ function assembleDaemonSessionInit(args2) {
     }),
     logSink: activeLogSink,
     agentServices,
+    sessionMonitors,
     backend: deps.backend,
     sessionId: typedSessionId,
     machineId,
@@ -105028,11 +105346,13 @@ Run: ${formatAuthLoginCommand(convexUrl)}`);
   const config4 = yield* setupMachineEffect();
   const { machineId } = config4;
   initHarnessRegistry();
+  initSessionMonitorRegistry();
   const agentServices = new Map(getAllHarnesses().map((s) => [s.id, s]));
+  const sessionMonitors = getAllSessionMonitors();
   yield* registerMachineEffect(client4, typedSessionId, config4);
   const cachedModels = yield* fetchCachedMachineModelsEffect(client4, typedSessionId, machineId);
   yield* connectDaemonEffect(client4, typedSessionId, machineId);
-  return { typedSessionId, config: config4, machineId, agentServices, cachedModels };
+  return { typedSessionId, config: config4, machineId, agentServices, sessionMonitors, cachedModels };
 }), activeLogSink, activeLogEvent, connectDaemonEffect = (client4, sessionId, machineId) => exports_Effect.tryPromise({
   try: () => client4.mutation(api.machines.updateDaemonStatus, {
     sessionId: asConvexSessionId(sessionId),
@@ -105120,6 +105440,8 @@ var init_init_daemon = __esm(() => {
   init_agent_process_manager();
   init_registry3();
   init_services2();
+  init_init_session_monitors();
+  init_session_monitor_registry();
   AUTH_WAIT_TIMEOUT_MS = 5 * 60 * 1000;
   initDaemonEffect = exports_Effect.gen(function* () {
     const lockAcquired = yield* exports_Effect.tryPromise({
@@ -105149,7 +105471,7 @@ var init_init_daemon = __esm(() => {
       try: () => getConvexClient(),
       catch: (e) => e
     });
-    const { typedSessionId, config: config4, machineId, agentServices, cachedModels } = yield* connectWithRetryEffect(client4, sessionId, convexUrl);
+    const { typedSessionId, config: config4, machineId, agentServices, sessionMonitors, cachedModels } = yield* connectWithRetryEffect(client4, sessionId, convexUrl);
     const init2 = assembleDaemonSessionInit({
       client: client4,
       typedSessionId,
@@ -105157,6 +105479,7 @@ var init_init_daemon = __esm(() => {
       config: config4,
       convexUrl,
       agentServices,
+      sessionMonitors,
       cachedModels,
       deps: createDefaultDeps22()
     });
@@ -105455,7 +105778,8 @@ async function resumeSession(deps, input) {
   const { harness, journalFactory, chunkExtractor, nowFn = Date.now } = deps;
   const { harnessSessionId, opencodeSessionId } = input;
   const session2 = await harness.resumeSession(opencodeSessionId, {
-    harnessSessionId
+    harnessSessionId,
+    ...input.model ? { model: input.model } : {}
   });
   const journal = journalFactory.create(harnessSessionId);
   const unsubscribeEvents = session2.onEvent((event) => {
@@ -105781,6 +106105,7 @@ class ClaudeSdkHarness {
   async newSession(config4) {
     if (this.closed)
       throw new Error("Harness is closed");
+    const defaultModel = requireHarnessModel(config4.model, "claude-sdk newSession");
     const opencodeSessionId = randomUUID6();
     const session2 = new ClaudeSdkSession({
       cwd: this.cwd,
@@ -105788,25 +106113,27 @@ class ClaudeSdkHarness {
       query: this.query,
       opencodeSessionId,
       sessionTitle: config4.title ?? "",
-      defaultModel: config4.model ?? DEFAULT_MODEL,
+      defaultModel,
       systemPrompt: config4.systemPrompt,
       onClose: (id3) => this.sessions.delete(id3)
     });
     this.sessions.set(opencodeSessionId, session2);
     return session2;
   }
-  async resumeSession(sessionId, _options) {
+  async resumeSession(sessionId, options) {
     if (this.closed)
       throw new Error("Harness is closed");
     const existing = this.sessions.get(sessionId);
     if (existing)
       return existing;
+    const defaultModel = requireHarnessModel(options?.model, "claude-sdk resumeSession");
     const session2 = new ClaudeSdkSession({
       cwd: this.cwd,
       executablePath: this.executablePath,
       query: this.query,
       opencodeSessionId: sessionId,
       sessionTitle: "",
+      defaultModel,
       providerSessionId: sessionId,
       resumeOnFirstQuery: true,
       onClose: (id3) => this.sessions.delete(id3)
@@ -105829,7 +106156,7 @@ class ClaudeSdkHarness {
     this.sessions.clear();
   }
 }
-var DEFAULT_MODEL = "anthropic/sonnet", _sdkCache5, _sdkLoadError5, _executablePathCache, startClaudeSdkHarness = async (config4) => {
+var _sdkCache5, _sdkLoadError5, _executablePathCache, startClaudeSdkHarness = async (config4) => {
   try {
     const sdk = await loadSdk5();
     const executablePath = await loadExecutablePath();
@@ -106082,51 +106409,51 @@ class CursorSdkHarness {
       }
     ];
   }
-  async newSession(config4) {
-    if (this.closed)
-      throw new Error("Harness is closed");
+  requireApiKey() {
     const apiKey = process.env.CURSOR_API_KEY?.trim();
     if (!apiKey)
       throw new Error("CURSOR_API_KEY is not set");
-    const modelSelection = resolveCursorSdkSpawnModelSelection(config4.model ?? DEFAULT_MODEL2);
-    const { Agent } = await loadSdk6();
-    const agent = await withTimeout(Agent.create({
-      apiKey,
-      model: modelSelection,
-      local: { cwd: this.cwd, settingSources: [], enableAgentRetries: true }
-    }), AGENT_CREATE_TIMEOUT_MS2, "Agent.create");
+    return apiKey;
+  }
+  registerAgentSession(agent, sessionTitle) {
     const session2 = new CursorSdkSession({
       agent,
       opencodeSessionId: agent.agentId,
-      sessionTitle: config4.title ?? "",
+      sessionTitle,
       onClose: (id3) => this.sessions.delete(id3)
     });
     this.sessions.set(agent.agentId, session2);
     return session2;
   }
-  async resumeSession(sessionId, _options) {
+  async newSession(config4) {
+    if (this.closed)
+      throw new Error("Harness is closed");
+    const apiKey = this.requireApiKey();
+    const model = requireHarnessModel(config4.model, "cursor-sdk newSession");
+    const modelSelection = resolveCursorSdkSpawnModelSelection(model);
+    const { Agent } = await loadSdk6();
+    const agent = await withTimeout(Agent.create({
+      apiKey,
+      model: modelSelection,
+      local: { cwd: this.cwd, settingSources: [], enableAgentRetries: true }
+    }), AGENT_CREATE_TIMEOUT_MS2, "Agent.create");
+    return this.registerAgentSession(agent, config4.title ?? "");
+  }
+  async resumeSession(sessionId, options) {
     if (this.closed)
       throw new Error("Harness is closed");
     const existing = this.sessions.get(sessionId);
     if (existing)
       return existing;
-    const apiKey = process.env.CURSOR_API_KEY?.trim();
-    if (!apiKey)
-      throw new Error("CURSOR_API_KEY is not set");
+    const model = requireHarnessModel(options?.model, "cursor-sdk resumeSession");
+    const apiKey = this.requireApiKey();
     const { Agent } = await loadSdk6();
     const agent = await withTimeout(Agent.resume(sessionId, {
       apiKey,
-      model: resolveCursorSdkSpawnModelSelection(DEFAULT_MODEL2),
+      model: resolveCursorSdkSpawnModelSelection(model),
       local: { cwd: this.cwd, settingSources: [], enableAgentRetries: true }
     }), AGENT_CREATE_TIMEOUT_MS2, "Agent.resume");
-    const session2 = new CursorSdkSession({
-      agent,
-      opencodeSessionId: agent.agentId,
-      sessionTitle: "",
-      onClose: (id3) => this.sessions.delete(id3)
-    });
-    this.sessions.set(agent.agentId, session2);
-    return session2;
+    return this.registerAgentSession(agent, "");
   }
   async fetchSessionTitle(_opencodeSessionId) {
     return;
@@ -106143,7 +106470,7 @@ class CursorSdkHarness {
     this.sessions.clear();
   }
 }
-var DEFAULT_MODEL2 = "composer-2.5", AGENT_CREATE_TIMEOUT_MS2 = 60000, _sdkCache6, _sdkLoadError6, startCursorSdkHarness = async (config4) => {
+var AGENT_CREATE_TIMEOUT_MS2 = 60000, _sdkCache6, _sdkLoadError6, startCursorSdkHarness = async (config4) => {
   try {
     await loadSdk6();
   } catch (err) {
@@ -106470,6 +106797,7 @@ class OpencodeSdkHarness {
   async newSession(config4) {
     if (this.closed)
       throw new Error("Harness is closed");
+    requireHarnessModel(config4.model, "opencode-sdk newSession");
     const created = await this.client.session.create({
       body: {
         ...config4.title ? { title: config4.title } : {}
@@ -106805,17 +107133,13 @@ async function loadSdk7() {
     throw err;
   }
 }
-function resolveModel2(modelRegistry, model) {
-  if (model) {
-    const slash = model.indexOf("/");
-    if (slash === -1) {
-      return modelRegistry.getAll().find((entry) => entry.id === model);
-    }
-    const provider = model.slice(0, slash);
-    const modelId = model.slice(slash + 1);
-    return modelRegistry.find(provider, modelId);
+function resolveRequiredModel2(modelRegistry, model) {
+  const slash = model.indexOf("/");
+  const resolved = slash === -1 ? modelRegistry.getAll().find((entry) => entry.id === model) : modelRegistry.find(model.slice(0, slash), model.slice(slash + 1));
+  if (!resolved) {
+    throw new Error(`Pi model not found: ${model}`);
   }
-  return modelRegistry.getAvailable()[0];
+  return resolved;
 }
 
 class PiSdkHarness {
@@ -106857,7 +107181,14 @@ class PiSdkHarness {
   async newSession(config4) {
     if (this.closed)
       throw new Error("Harness is closed");
-    const session2 = await this.createAgentSession(config4.systemPrompt ?? "", config4.model);
+    const model = requireHarnessModel(config4.model, "pi-sdk newSession");
+    const { SessionManager } = await loadSdk7();
+    const session2 = await this.openAgentSession({
+      systemPrompt: config4.systemPrompt ?? "",
+      model,
+      sessionManager: SessionManager.create(getPiSessionDir(this.cwd)),
+      requireModel: true
+    });
     const piSession = new PiSdkSession({
       session: session2,
       opencodeSessionId: session2.sessionId,
@@ -106867,36 +107198,24 @@ class PiSdkHarness {
     this.sessions.set(session2.sessionId, piSession);
     return piSession;
   }
-  async resumeSession(sessionId, _options) {
+  async resumeSession(sessionId, options) {
     if (this.closed)
       throw new Error("Harness is closed");
     const existing = this.sessions.get(sessionId);
     if (existing)
       return existing;
-    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk7();
+    const { SessionManager } = await loadSdk7();
     const sessions = await SessionManager.list(this.cwd, getPiSessionDir(this.cwd));
     const match17 = sessions.find((s) => s.id === sessionId);
     if (!match17) {
       throw new Error(`Session ${sessionId} not found on the harness`);
     }
-    const resourceLoader = new DefaultResourceLoader({
-      cwd: this.cwd,
-      agentDir: getAgentDir(),
-      systemPromptOverride: () => ""
-    });
-    await resourceLoader.reload();
-    const resolvedModel = resolveModel2(this.modelRegistry);
-    if (!resolvedModel) {
-      throw new Error("No Pi model available");
-    }
-    const { session: session2 } = await withTimeout(createAgentSession({
-      cwd: this.cwd,
-      model: resolvedModel,
+    const session2 = await this.openAgentSession({
+      systemPrompt: "",
+      model: options?.model,
       sessionManager: SessionManager.open(match17.path, getPiSessionDir(this.cwd)),
-      authStorage: this.authStorage,
-      modelRegistry: this.modelRegistry,
-      resourceLoader
-    }), SESSION_CREATE_TIMEOUT_MS3, "createAgentSession");
+      requireModel: false
+    });
     const piSession = new PiSdkSession({
       session: session2,
       opencodeSessionId: session2.sessionId,
@@ -106920,30 +107239,34 @@ class PiSdkHarness {
     await Promise.all(closing);
     this.sessions.clear();
   }
-  async createAgentSession(systemPrompt, model) {
-    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk7();
-    const resolvedModel = resolveModel2(this.modelRegistry, model ?? DEFAULT_MODEL3);
-    if (!resolvedModel) {
+  async openAgentSession(args2) {
+    const { createAgentSession, DefaultResourceLoader, getAgentDir } = await loadSdk7();
+    const parsed = args2.model ? parsePiSpawnModel(args2.model) : undefined;
+    const modelSlug = parsed?.model ?? args2.model;
+    const resolvedModel = args2.requireModel ? resolveRequiredModel2(this.modelRegistry, requireHarnessModel(modelSlug, "pi-sdk openAgentSession")) : modelSlug ? resolveRequiredModel2(this.modelRegistry, modelSlug) : undefined;
+    const thinkingLevel = resolvePiThinkingLevel(parsed?.thinking);
+    if (args2.requireModel && !resolvedModel) {
       throw new Error("No Pi model available — configure provider credentials in ~/.pi/agent/auth.json");
     }
     const resourceLoader = new DefaultResourceLoader({
       cwd: this.cwd,
       agentDir: getAgentDir(),
-      systemPromptOverride: () => systemPrompt
+      systemPromptOverride: () => args2.systemPrompt
     });
     await resourceLoader.reload();
     const { session: session2 } = await withTimeout(createAgentSession({
       cwd: this.cwd,
-      model: resolvedModel,
-      sessionManager: SessionManager.create(getPiSessionDir(this.cwd)),
+      sessionManager: args2.sessionManager,
       authStorage: this.authStorage,
       modelRegistry: this.modelRegistry,
-      resourceLoader
+      resourceLoader,
+      ...resolvedModel ? { model: resolvedModel } : {},
+      ...thinkingLevel ? { thinkingLevel } : {}
     }), SESSION_CREATE_TIMEOUT_MS3, "createAgentSession");
     return session2;
   }
 }
-var SESSION_CREATE_TIMEOUT_MS3 = 60000, DEFAULT_MODEL3 = "opencode/big-pickle", _sdkCache7, _sdkLoadError7, startPiSdkHarness = async (config4) => {
+var SESSION_CREATE_TIMEOUT_MS3 = 60000, _sdkCache7, _sdkLoadError7, startPiSdkHarness = async (config4) => {
   try {
     const { AuthStorage, ModelRegistry } = await loadSdk7();
     const authStorage = AuthStorage.create();
@@ -106959,6 +107282,7 @@ var SESSION_CREATE_TIMEOUT_MS3 = 60000, DEFAULT_MODEL3 = "opencode/big-pickle",
 var init_pi_harness = __esm(() => {
   init_pi_session();
   init_pi_agent_service();
+  init_pure2();
   init_pi_sdk_package();
 });
 
@@ -107145,6 +107469,8 @@ async function resolveSessionHandle(daemonSession, deps, info) {
     const harness = await ensureHarnessAlive(daemonSession, deps, info);
     if (!harness)
       return null;
+    const modelConfig = info.lastUsedConfig.model;
+    const model = modelConfig ? requireHarnessModel(`${modelConfig.providerID}/${modelConfig.modelID}`, "agentic-query resumeSession") : requireHarnessModel(undefined, "agentic-query resumeSession");
     const resumed = await resumeSession({
       harness,
       journalFactory: deps.journalFactory,
@@ -107153,7 +107479,8 @@ async function resolveSessionHandle(daemonSession, deps, info) {
       harnessSessionId: rowId,
       opencodeSessionId: info.opencodeSessionId,
       workspaceId: info.workspaceId,
-      harnessName: info.harnessName
+      harnessName: info.harnessName,
+      model
     });
     deps.activeSessions.set(rowId, resumed);
     wireResumedIdle(resumed, deps, info);
@@ -107265,7 +107592,10 @@ async function openPendingHarnessSession(daemonSession, deps, input, options) {
       logPrefix
     });
     const modelConfig = lastUsedConfig.model;
-    const model = modelConfig ? `${modelConfig.providerID}/${modelConfig.modelID}` : undefined;
+    if (!modelConfig) {
+      throw new Error("Harness model is required (agentic-query open session)");
+    }
+    const model = requireHarnessModel(`${modelConfig.providerID}/${modelConfig.modelID}`, "agentic-query newSession");
     const liveSession = await harness.newSession({
       agent: lastUsedConfig.agent,
       model,
@@ -134762,4 +135092,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=B34E804643624D4B64756E2164756E21
+//# debugId=48E3BD8E7ACDCBFA64756E2164756E21