@linzumi/cli 0.0.109-beta → 0.0.111-beta

package/README.md

@@ -58,7 +58,7 @@ Install the CLI or run it with `npx`:
 ```bash
 npm install -g @linzumi/cli@latest
 npx -y @linzumi/cli@latest signup
-npx -y @linzumi/cli@0.0.109-beta --version
+npx -y @linzumi/cli@0.0.111-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -5863,6 +5863,9 @@ function handleEvent(state, event, deps, effects) {
   }
   handleCodexNotification(state, event, deps, effects);
 }
+function modelInteractionMethod(method) {
+  return modelInteractionMethods.has(method);
+}
 function handleCodexNotification(state, event, deps, effects) {
   const method = event.notification.method;
   const params = event.notification.params ?? {};
@@ -5879,9 +5882,7 @@ function handleCodexNotification(state, event, deps, effects) {
   const explicitTurnId = notificationTurnId(params);
   const turnId = explicitTurnId ?? singleActiveTurnId(state);
   if (turnId === void 0) {
-    effects.push(
-      log("pipeline.loop.notification_without_turn", { method })
-    );
+    effects.push(log("pipeline.loop.notification_without_turn", { method }));
     return;
   }
   if (state.terminalTurnIds.has(turnId)) {
@@ -5902,6 +5903,10 @@ function handleCodexNotification(state, event, deps, effects) {
     }
     turn = createTurn(state, turnId, sourceSeq);
   }
+  turn.notificationCount += 1;
+  if (modelInteractionMethod(method)) {
+    turn.modelInteractionSeen = true;
+  }
   if (method === "turn/started") {
     return;
   }
@@ -5915,6 +5920,7 @@ function handleCodexNotification(state, event, deps, effects) {
     return;
   }
   if (method === "error") {
+    turn.errorNotificationCount += 1;
     const upstreamReason = upstreamErrorReason(params);
     if (upstreamReason !== void 0) {
       turn.lastUpstreamErrorReason = upstreamReason;
@@ -5924,6 +5930,17 @@ function handleCodexNotification(state, event, deps, effects) {
           reason: upstreamReason
         })
       );
+    } else {
+      const diagnosticText = errorDiagnosticText(params);
+      if (diagnosticText !== void 0) {
+        turn.lastErrorDiagnosticText = diagnosticText;
+        effects.push(
+          log("codex.error_without_http_status_captured", {
+            turn_id: turn.turnId,
+            diagnostic_text: diagnosticText
+          })
+        );
+      }
     }
     return;
   }
@@ -5978,6 +5995,10 @@ function createTurn(state, turnId, sourceSeq) {
     phase: "active",
     protocolFailureReason: void 0,
     lastUpstreamErrorReason: void 0,
+    lastErrorDiagnosticText: void 0,
+    errorNotificationCount: 0,
+    notificationCount: 0,
+    modelInteractionSeen: false,
     items: []
   };
   state.turns.set(turnId, turn);
@@ -6144,7 +6165,11 @@ function handleItemCompleted(turn, params, deps, effects) {
   );
 }
 function emitRowUpdate(turn, item, deltaIndex, streamState, deps, effects) {
-  const rendered = renderPipelineItem(item.wireItemKey, item.content, streamState);
+  const rendered = renderPipelineItem(
+    item.wireItemKey,
+    item.content,
+    streamState
+  );
   if (!item.posted) {
     if (rendered.body.trim() === "") {
       return;
@@ -6238,9 +6263,7 @@ function createItem(turn, streamKind, itemId, deps) {
 }
 function handleSnapshot(state, turnId, snapshot, deps, effects) {
   if (state.terminalTurnIds.has(turnId)) {
-    effects.push(
-      log("pipeline.loop.duplicate_snapshot", { turn_id: turnId })
-    );
+    effects.push(log("pipeline.loop.duplicate_snapshot", { turn_id: turnId }));
     return;
   }
   const turn = state.turns.get(turnId);
@@ -6363,7 +6386,9 @@ function handleSnapshot(state, turnId, snapshot, deps, effects) {
   const assistantResponseSeen = turn.items.some(
     (item) => item.identity.streamKind === "assistant" && item.posted
   ) || projected.some((proj) => proj.streamKind === "assistant");
-  const terminalFailureReason = turn.protocolFailureReason ?? (assistantResponseSeen ? void 0 : turn.lastUpstreamErrorReason ?? completedWithoutAssistantOutputReason);
+  const emptyTurnDiagnostic = !assistantResponseSeen && turn.protocolFailureReason === void 0 && turn.lastUpstreamErrorReason === void 0 ? classifyEmptyTurn(turn, projected.length) : void 0;
+  const baseNoOutputReason = turn.lastUpstreamErrorReason ?? (emptyTurnDiagnostic === void 0 ? completedWithoutAssistantOutputReason : `${completedWithoutAssistantOutputReason} [${emptyTurnDiagnostic.cause}]`);
+  const terminalFailureReason = turn.protocolFailureReason ?? (assistantResponseSeen ? void 0 : baseNoOutputReason);
   if (turn.protocolFailureReason !== void 0) {
     effects.push(
       log("codex.turn_completed_with_protocol_failure", {
@@ -6381,7 +6406,19 @@ function handleSnapshot(state, turnId, snapshot, deps, effects) {
         turn_id: turn.turnId,
         source_seq: turn.sourceSeq,
         streamed_item_count: turn.items.length,
-        snapshot_item_count: projected.length
+        snapshot_item_count: projected.length,
+        // LAUNCH-LIVE self-diagnosing fields: tell apart "codex never called the
+        // model" from "model returned empty" from "error without HTTP status".
+        notification_count: turn.notificationCount,
+        error_notification_count: turn.errorNotificationCount,
+        model_interaction_seen: turn.modelInteractionSeen,
+        last_error_diagnostic_text: turn.lastErrorDiagnosticText ?? null,
+        last_upstream_error_reason: turn.lastUpstreamErrorReason ?? null,
+        empty_turn_cause: emptyTurnDiagnostic?.cause ?? null,
+        // True iff the surfaced failure is the safe, retryable empty/no-response
+        // terminal (no output produced, no real upstream error) - the signal
+        // the client uses to offer a one-click retry (PART B, loud affordance).
+        retryable_empty_turn: emptyTurnDiagnostic !== void 0
       })
     );
   }
@@ -6394,7 +6431,13 @@ function handleSnapshot(state, turnId, snapshot, deps, effects) {
       seq: turn.sourceSeq,
       ...terminalFailureReason === void 0 ? { status: "processed" } : {
         status: "failed",
-        reason: terminalFailureReason
+        reason: terminalFailureReason,
+        // PART B (loud retry affordance): mark the safe empty/no-response
+        // terminal as retryable so the client can offer a one-click retry.
+        // Additive optional field; older servers ignore it. Only the empty
+        // terminal is retryable - real upstream errors (402/429/gateway,
+        // protocol failures) carry their own handling and are NOT flagged.
+        ...emptyTurnDiagnostic !== void 0 ? { retryable: true } : {}
       }
     },
     resolution: "must_ack"
@@ -6483,7 +6526,9 @@ function failureReason(params) {
   return stringValue(params.reason) ?? stringValue(params.message) ?? stringValue(objectValue(params.error)?.message) ?? stringValue(params.error) ?? "codex_turn_aborted";
 }
 function upstreamErrorReason(params) {
-  const summaryRaw = stringValue(params.diagnostic_summary) ?? stringValue(objectValue(objectValue(params.diagnostic_payload)?.error)?.message);
+  const summaryRaw = stringValue(params.diagnostic_summary) ?? stringValue(
+    objectValue(objectValue(params.diagnostic_payload)?.error)?.message
+  );
   if (summaryRaw === void 0) {
     return void 0;
   }
@@ -6501,10 +6546,33 @@ function upstreamErrorHttpStatus(params) {
   const code = disconnected?.httpStatusCode;
   return typeof code === "number" ? code : void 0;
 }
+function errorDiagnosticText(params) {
+  const raw = stringValue(params.message) ?? stringValue(params.reason) ?? stringValue(objectValue(params.error)?.message) ?? stringValue(params.error) ?? stringValue(params.diagnostic);
+  if (raw === void 0) {
+    return void 0;
+  }
+  const cleaned = raw.replace(/<[^>]*>/g, " ").replace(/data:[^"' )]+/g, "").replace(/\s+/g, " ").trim().slice(0, 180);
+  return cleaned.length === 0 ? void 0 : cleaned;
+}
+function classifyEmptyTurn(turn, snapshotItemCount) {
+  if (turn.lastErrorDiagnosticText !== void 0) {
+    return {
+      cause: `codex error without HTTP status: ${turn.lastErrorDiagnosticText}`
+    };
+  }
+  if (!turn.modelInteractionSeen) {
+    return {
+      cause: `codex never called the model: 0 model interactions, ${turn.notificationCount} notifications, ${turn.errorNotificationCount} errors`
+    };
+  }
+  return {
+    cause: `model returned no assistant output: ${turn.items.length} streamed items, ${snapshotItemCount} snapshot items`
+  };
+}
 function log(event, fields) {
   return { type: "log", event, fields };
 }
-var terminalRowStreamStates, turnMappingReadyMethod, turnMappingFailedMethod, maxTerminalTurnIds, completedWithoutAssistantOutputReason, unsupportedCodexToolCallReasonPrefix, turnTerminalFailureMethods, handledNotificationMethods;
+var terminalRowStreamStates, turnMappingReadyMethod, turnMappingFailedMethod, maxTerminalTurnIds, completedWithoutAssistantOutputReason, unsupportedCodexToolCallReasonPrefix, turnTerminalFailureMethods, handledNotificationMethods, modelInteractionMethods;
 var init_transition = __esm({
   "src/pipeline/transition.ts"() {
     "use strict";
@@ -6545,6 +6613,17 @@ var init_transition = __esm({
       "item/completed",
       "response_item"
     ]);
+    modelInteractionMethods = /* @__PURE__ */ new Set([
+      "item/agentMessage/delta",
+      "item/reasoning/textDelta",
+      "item/commandExecution/outputDelta",
+      "command/exec/outputDelta",
+      "item/fileChange/outputDelta",
+      "item/commandExecution/terminalInteraction",
+      "item/started",
+      "item/completed",
+      "response_item"
+    ]);
   }
 });
 
@@ -20078,7 +20157,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.109-beta";
+    linzumiCliVersion = "0.0.111-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -23176,30 +23255,225 @@ var init_threadCodexWorkerIpc = __esm({
   }
 });
 
+// src/signupTaskSuggestionsProgress.ts
+function basenameOf(rawPath) {
+  const trimmed = rawPath.trim();
+  if (trimmed === "") {
+    return void 0;
+  }
+  const withoutTrailing = trimmed.replace(/[/\\]+$/, "");
+  const segments = withoutTrailing.split(/[/\\]+/);
+  const last = segments[segments.length - 1];
+  if (last === void 0 || last === "" || last === "." || last === "..") {
+    return void 0;
+  }
+  if (last.length > MAX_BASENAME_LENGTH) {
+    return `${last.slice(0, MAX_BASENAME_LENGTH - 1)}\u2026`;
+  }
+  return last;
+}
+function lookingAtFileLabel(rawPath) {
+  if (typeof rawPath !== "string") {
+    return void 0;
+  }
+  const basename10 = basenameOf(rawPath);
+  return basename10 === void 0 ? void 0 : `Looking at ${basename10}...`;
+}
+function commandLabel2(command) {
+  let head;
+  let target;
+  if (Array.isArray(command)) {
+    const parts = command.filter((part) => typeof part === "string");
+    const meaningful = parts.filter(
+      (part) => part !== "bash" && part !== "sh" && part !== "-lc" && part !== "-c"
+    );
+    head = meaningful[0];
+    target = meaningful.slice(1).find((part) => !part.startsWith("-"));
+  } else if (typeof command === "string") {
+    const tokens = command.trim().split(/\s+/);
+    head = tokens[0];
+    target = tokens.slice(1).find((part) => !part.startsWith("-"));
+  } else {
+    return void 0;
+  }
+  if (head === void 0) {
+    return void 0;
+  }
+  const baseCommand = basenameOf(head) ?? head;
+  if (!READ_COMMAND_PREFIXES.includes(baseCommand)) {
+    return READING_REPO;
+  }
+  const fileLabel = target === void 0 ? void 0 : lookingAtFileLabel(target);
+  return fileLabel ?? READING_REPO;
+}
+function progressLabelForCodexEvent(event) {
+  if (typeof event !== "object" || event === null || Array.isArray(event)) {
+    return void 0;
+  }
+  const record = event;
+  const item = record["item"];
+  if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+    const itemRecord = item;
+    const itemType = itemRecord["item_type"] ?? itemRecord["type"];
+    switch (itemType) {
+      case "reasoning":
+        return READING_REPO;
+      case "command_execution":
+      case "local_shell_call":
+        return commandLabel2(itemRecord["command"] ?? itemRecord["argv"]) ?? READING_REPO;
+      case "file_change":
+      case "file_read":
+        return lookingAtFileLabel(itemRecord["path"]) ?? READING_REPO;
+      case "agent_message":
+      case "assistant_message":
+        return DRAFTING_TASKS;
+      default:
+        return void 0;
+    }
+  }
+  const msg = record["msg"];
+  const msgRecord = typeof msg === "object" && msg !== null && !Array.isArray(msg) ? msg : record;
+  const msgType = msgRecord["type"] ?? record["type"];
+  switch (msgType) {
+    case "task_started":
+    case "agent_reasoning":
+    case "agent_reasoning_delta":
+    case "agent_reasoning_section_break":
+      return READING_REPO;
+    case "exec_command_begin":
+    case "exec_command_end":
+      return commandLabel2(msgRecord["command"]) ?? READING_REPO;
+    case "agent_message":
+    case "agent_message_delta":
+      return DRAFTING_TASKS;
+    default:
+      return void 0;
+  }
+}
+function createTaskSuggestionProgressParser(onLabel) {
+  let buffer = "";
+  let lastLabel;
+  const emit = (label) => {
+    if (label === void 0 || label === lastLabel) {
+      return;
+    }
+    lastLabel = label;
+    try {
+      onLabel(label);
+    } catch {
+    }
+  };
+  const consumeLine = (line) => {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed[0] !== "{") {
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    emit(progressLabelForCodexEvent(parsed));
+  };
+  return {
+    push: (chunk) => {
+      buffer += chunk;
+      let newlineIndex = buffer.indexOf("\n");
+      while (newlineIndex !== -1) {
+        const line = buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+        consumeLine(line);
+        newlineIndex = buffer.indexOf("\n");
+      }
+    },
+    flush: () => {
+      if (buffer.trim() !== "") {
+        consumeLine(buffer);
+        buffer = "";
+      }
+    }
+  };
+}
+var READING_REPO, DRAFTING_TASKS, MAX_BASENAME_LENGTH, READ_COMMAND_PREFIXES;
+var init_signupTaskSuggestionsProgress = __esm({
+  "src/signupTaskSuggestionsProgress.ts"() {
+    "use strict";
+    READING_REPO = "Reading your repository...";
+    DRAFTING_TASKS = "Drafting tasks...";
+    MAX_BASENAME_LENGTH = 60;
+    READ_COMMAND_PREFIXES = [
+      "ls",
+      "cat",
+      "head",
+      "tail",
+      "find",
+      "rg",
+      "grep",
+      "tree",
+      "wc",
+      "sed",
+      "awk",
+      "pwd",
+      "stat",
+      "file"
+    ];
+  }
+});
+
 // src/signupTaskSuggestions.ts
 import { spawn as spawn7 } from "node:child_process";
 import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, rmSync as rmSync4, writeFileSync as writeFileSync11 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join20 } from "node:path";
 async function suggestSignupTasksWithCodex(args) {
-  const attempts = 2;
+  const model = resolveTaskSuggestionModel(args.model, args.modelProvider);
+  const startedAt = Date.now();
   let previousResponse;
-  for (let attempt = 1; attempt <= attempts; attempt += 1) {
-    const response = await runCodexTaskSuggestion({
-      projectPath: args.projectPath,
-      codexBin: args.codexBin,
-      model: args.model ?? process.env.LINZUMI_SIGNUP_TASK_MODEL ?? "gpt-5.4-mini",
-      previousResponse
-    });
+  let lastFailure;
+  for (let attempt = 0; attempt <= MAX_SCHEMA_REPAIR_ATTEMPTS; attempt += 1) {
+    const elapsed = Date.now() - startedAt;
+    const remaining = SUGGESTION_TIMEOUT_MS - elapsed;
+    if (remaining <= 0) {
+      break;
+    }
+    let response;
+    try {
+      response = await runCodexTaskSuggestion({
+        projectPath: args.projectPath,
+        codexBin: args.codexBin,
+        model,
+        modelProvider: args.modelProvider,
+        previousResponse,
+        timeoutMs: remaining,
+        onProgress: args.onProgress
+      });
+    } catch (error) {
+      throw error instanceof Error ? error : new Error(String(error));
+    }
     const tasks = parseTaskSuggestionResponse(response);
     if (tasks !== void 0) {
       return tasks;
     }
     previousResponse = response;
+    lastFailure = new Error(
+      "Codex returned a response that did not match the task suggestion schema"
+    );
   }
-  throw new Error(
-    "Codex did not return valid task suggestions after 2 attempts"
-  );
+  throw lastFailure ?? new Error("Codex did not return valid task suggestions in the time budget");
+}
+function resolveTaskSuggestionModel(explicitModel, modelProvider) {
+  const envModel = process.env.LINZUMI_SIGNUP_TASK_MODEL;
+  if (explicitModel !== void 0 && explicitModel !== "") {
+    return explicitModel;
+  }
+  if (envModel !== void 0 && envModel !== "") {
+    return envModel;
+  }
+  if (modelProvider !== void 0) {
+    return DEFAULT_WAFER_SUGGESTION_MODEL;
+  }
+  return DEFAULT_CODEX_AUTH_SUGGESTION_MODEL;
 }
 async function runCodexTaskSuggestion(args) {
   const tempRoot = mkdtempSync3(join20(tmpdir2(), "linzumi-signup-codex-tasks-"));
@@ -23217,11 +23491,14 @@ async function runCodexTaskSuggestion(args) {
       codexTaskSuggestionProcess({
         command: args.codexBin,
         model: args.model,
+        modelProvider: args.modelProvider,
         projectPath: args.projectPath,
         schemaPath,
         outputPath,
-        prompt
-      })
+        prompt,
+        timeoutMs: args.timeoutMs
+      }),
+      args.onProgress
     );
     return readFileSync16(outputPath, "utf8");
   } finally {
@@ -23236,9 +23513,19 @@ function codexTaskSuggestionProcess(args) {
       "--model",
       args.model,
       "-c",
-      'model_reasoning_effort="low"',
+      // RELIABILITY: minimal reasoning effort keeps the agentic turn fast and
+      // far less flaky while still producing repo-specific tasks (it still
+      // inspects the real repo below). The latency/flake budget was the main
+      // driver of runner_task_suggestion_failed.
+      'model_reasoning_effort="minimal"',
       "-c",
       'approval_policy="never"',
+      // Wafer routing: render the `-c model_providers.linzumi.*` config args
+      // plus `-c model_provider=linzumi`, identical to the main per-thread codex
+      // app-server start (codexModelProviderConfigArgs). Secrets stay in env via
+      // env_key/env_http_headers, never argv. Omitted for native-codex-auth
+      // users, who keep their own provider.
+      ...args.modelProvider === void 0 ? [] : codexModelProviderConfigArgs(args.modelProvider.config),
       "--sandbox",
       "read-only",
       "--skip-git-repo-check",
@@ -23248,13 +23535,22 @@ function codexTaskSuggestionProcess(args) {
       args.schemaPath,
       "--output-last-message",
       args.outputPath,
+      // LIVE PROGRESS: stream the agentic turn as JSONL events on stdout so we
+      // can parse privacy-safe step labels ("Reading your repository...",
+      // "Looking at <file>...", "Drafting tasks...") and relay them to the
+      // onboarding wizard while the (up to ~150s) turn runs. The final task
+      // JSON still comes from --output-last-message, so this is purely additive
+      // - if a codex build ignores or changes --json, we simply get no progress
+      // and the suggestion result is unaffected.
+      "--json",
       "--color",
       "never",
       "-"
     ],
     cwd: args.projectPath,
     stdin: args.prompt,
-    timeoutMs: 55e3
+    ...args.modelProvider === void 0 ? {} : { env: args.modelProvider.env },
+    timeoutMs: args.timeoutMs ?? SUGGESTION_TIMEOUT_MS
   };
 }
 function taskSuggestionPrompt(previousResponse) {
@@ -23272,16 +23568,13 @@ function taskSuggestionPrompt(previousResponse) {
     "Task:",
     "Inspect this repository read-only and suggest exactly 5 useful quick starter tasks for Codex agents.",
     "",
-    "GitHub context:",
-    "- First check whether the GitHub CLI is available and authenticated with a cheap command such as `gh auth status`.",
-    "- If `gh` is missing, unauthenticated, or this repository has no GitHub remote, skip GitHub context and rely on local files.",
-    "- When `gh` is authenticated, use bounded reads such as `gh pr list --limit 30 --state all` and `gh issue list --limit 30 --state all` to inspect recent open and closed pull requests and issues.",
-    "- Be mindful of GitHub rate limits, CPU usage, and network usage; prefer one or two small calls and do not paginate or crawl exhaustively.",
-    "- If a GitHub call returns unauthorized, forbidden, or not found for this repository, stop GitHub lookups for this repository.",
-    "- Use pull request and issue titles, states, labels, and recent activity to infer what the repo is about, what the user has been working on, and likely next tasks.",
+    "How to inspect (be fast - aim to answer within a single short pass):",
+    "- Read the repo locally: top-level files, README, package manifests, and a shallow look at the main source directories are enough to infer what the project is.",
+    "- Base the suggestions on the ACTUAL repository contents you observe, not on generic templates.",
+    "- Do NOT crawl GitHub. Skip `gh` entirely; local files are sufficient and far faster.",
     "",
     "Constraints:",
-    "- Prefer tasks that are small, concrete, and likely to produce useful first results.",
+    "- Prefer tasks that are small, concrete, and specific to THIS repository (reference real files, modules, or features you saw).",
     "- Do not modify files.",
     "- Do not include markdown fences or prose outside the JSON response.",
     "- Keep each task title under 120 characters.",
@@ -23343,12 +23636,28 @@ function parseTaskSuggestionResponse(response) {
     return void 0;
   }
 }
-function runProcess2(args) {
+function runProcess2(args, onProgress) {
   return new Promise((resolveProcess, rejectProcess) => {
     const child = spawn7(args.command, [...args.args], {
       cwd: args.cwd,
-      stdio: ["pipe", "ignore", "pipe"]
+      // Inherit the runner env (codex auth, PATH, etc.) and layer the wafer
+      // proxy credential (LINZUMI_LLM_PROXY_TOKEN) on top when wafer-routed.
+      ...args.env === void 0 ? {} : { env: { ...process.env, ...args.env } },
+      // LIVE PROGRESS: capture stdout (the `--json` JSONL event stream) only
+      // when a progress callback is supplied; otherwise discard it as before.
+      // We never depend on stdout for the result (that's --output-last-message),
+      // so stdout parsing is purely a best-effort enhancement.
+      stdio: ["pipe", onProgress === void 0 ? "ignore" : "pipe", "pipe"]
     });
+    const progress = onProgress === void 0 ? void 0 : createTaskSuggestionProgressParser(onProgress);
+    if (progress !== void 0) {
+      child.stdout?.on("data", (chunk) => {
+        try {
+          progress.push(String(chunk));
+        } catch {
+        }
+      });
+    }
     let stderr = "";
     let settled = false;
     const timeout = setTimeout(() => {
@@ -23361,6 +23670,10 @@ function runProcess2(args) {
       }
       settled = true;
       clearTimeout(timeout);
+      try {
+        progress?.flush();
+      } catch {
+      }
       if (error === void 0) {
         resolveProcess();
         return;
@@ -23387,9 +23700,16 @@ function runProcess2(args) {
     child.stdin?.end(args.stdin);
   });
 }
+var DEFAULT_CODEX_AUTH_SUGGESTION_MODEL, DEFAULT_WAFER_SUGGESTION_MODEL, SUGGESTION_TIMEOUT_MS, MAX_SCHEMA_REPAIR_ATTEMPTS;
 var init_signupTaskSuggestions = __esm({
   "src/signupTaskSuggestions.ts"() {
     "use strict";
+    init_codexAppServer();
+    init_signupTaskSuggestionsProgress();
+    DEFAULT_CODEX_AUTH_SUGGESTION_MODEL = "gpt-5.4-mini";
+    DEFAULT_WAFER_SUGGESTION_MODEL = "GLM-5.2";
+    SUGGESTION_TIMEOUT_MS = 15e4;
+    MAX_SCHEMA_REPAIR_ATTEMPTS = 1;
   }
 });
 
@@ -27033,7 +27353,10 @@ async function openLocalCodexRunner(options, log2, cleanup, close, runnerDrainHo
     const entries = parseResumeReconcileEntries(reconcileValue);
     for (const entry of entries) {
       if (entry.leaseEpoch !== void 0) {
-        const adopted = leaseEpochRegistry.adopt(entry.threadId, entry.leaseEpoch);
+        const adopted = leaseEpochRegistry.adopt(
+          entry.threadId,
+          entry.leaseEpoch
+        );
         if (adopted) {
           log2("runner.resume_reconcile_lease_adopted", {
             kandanThreadId: entry.threadId,
@@ -27896,10 +28219,7 @@ function appliedSourceSeqStorePath(runnerId) {
   const sanitized = runnerId.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, 80);
   const digest = createHash7("sha256").update(runnerId).digest("hex").slice(0, 8);
   const stem = sanitized === "" ? "runner" : sanitized;
-  return join22(
-    controlCursorsDir(),
-    `${stem}.${digest}.source-seq.json`
-  );
+  return join22(controlCursorsDir(), `${stem}.${digest}.source-seq.json`);
 }
 function startTurnWatermarkKey(topic, threadId) {
   return `${topic} ${threadId}`;
@@ -29549,7 +29869,10 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
       return createRunnerProject(control, options, allowedCwds);
     }
     case "suggest_tasks": {
-      return suggestRunnerTasks(control, options, allowedCwds.value);
+      return suggestRunnerTasks(control, options, allowedCwds.value, {
+        kandan,
+        topic
+      });
     }
     case "remote_codex_exec": {
       return await applyRemoteCodexExecControl(
@@ -33486,7 +33809,27 @@ function projectPathExists(projectPath) {
     throw error;
   }
 }
-async function suggestRunnerTasks(control, options, allowedCwds) {
+function resolveSuggestTasksModelProvider(control) {
+  if (stringValue(control.modelProvider)?.trim() !== "wafer") {
+    return void 0;
+  }
+  const llmProxy = objectValue(control.llmProxy);
+  const baseUrl = stringValue(llmProxy?.baseUrl)?.trim();
+  const token = stringValue(llmProxy?.token)?.trim();
+  if (baseUrl === void 0 || baseUrl === "" || token === void 0 || token === "") {
+    return void 0;
+  }
+  const runtime = {
+    provider: "wafer",
+    llmProxyBaseUrl: baseUrl,
+    llmProxyToken: token
+  };
+  return {
+    config: linzumiCodexModelProviderConfig(runtime),
+    env: codexModelProviderAppServerEnv(runtime)
+  };
+}
+async function suggestRunnerTasks(control, options, allowedCwds, progressSink) {
   const requestId = stringValue(control.requestId) ?? null;
   const cwd = resolveAllowedCwd(control.cwd, allowedCwds);
   if (!cwd.ok) {
@@ -33498,10 +33841,25 @@ async function suggestRunnerTasks(control, options, allowedCwds) {
       error: cwd.reason
     };
   }
+  const modelProvider = resolveSuggestTasksModelProvider(control);
+  const model = stringValue(control.model)?.trim();
+  const workspaceSlug = stringValue(control.workspace)?.trim();
+  const onProgress = progressSink === void 0 || requestId === null ? void 0 : (label) => {
+    void progressSink.kandan.pushIfConnected(progressSink.topic, "suggest_tasks_progress", {
+      instanceId: options.runnerId,
+      controlType: control.type,
+      requestId,
+      ...workspaceSlug === void 0 || workspaceSlug === "" ? {} : { workspace: workspaceSlug },
+      label
+    }).catch(() => void 0);
+  };
   try {
     const tasks = await suggestSignupTasksWithCodex({
       projectPath: cwd.cwd,
-      codexBin: options.codexBin
+      codexBin: options.codexBin,
+      ...model === void 0 || model === "" ? {} : { model },
+      ...modelProvider === void 0 ? {} : { modelProvider },
+      ...onProgress === void 0 ? {} : { onProgress }
     });
     return {
       instanceId: options.runnerId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.109-beta",
+  "version": "0.0.111-beta",
   "description": "Linzumi CLI \u2014 point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {