@linzumi/cli 0.0.108-beta → 0.0.110-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.108-beta --version
+npx -y @linzumi/cli@0.0.110-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -20078,7 +20078,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.108-beta";
+    linzumiCliVersion = "0.0.110-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -23182,24 +23182,52 @@ import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, rmSync as
 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
+      });
+    } 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,10 +23245,12 @@ async function runCodexTaskSuggestion(args) {
       codexTaskSuggestionProcess({
         command: args.codexBin,
         model: args.model,
+        modelProvider: args.modelProvider,
         projectPath: args.projectPath,
         schemaPath,
         outputPath,
-        prompt
+        prompt,
+        timeoutMs: args.timeoutMs
       })
     );
     return readFileSync16(outputPath, "utf8");
@@ -23236,9 +23266,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",
@@ -23254,7 +23294,8 @@ function codexTaskSuggestionProcess(args) {
     ],
     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 +23313,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.",
@@ -23347,6 +23385,9 @@ function runProcess2(args) {
   return new Promise((resolveProcess, rejectProcess) => {
     const child = spawn7(args.command, [...args.args], {
       cwd: args.cwd,
+      // 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 } },
       stdio: ["pipe", "ignore", "pipe"]
     });
     let stderr = "";
@@ -23387,9 +23428,15 @@ 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();
+    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;
   }
 });
 
@@ -25064,6 +25111,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close, runnerDrainHo
   const latestResumeReconcileByThread = /* @__PURE__ */ new Map();
   let acceptingInbound = true;
   const inboundQueueWorkspace = () => runnerWorkspaceSlug(options) ?? "default";
+  const resolveRunnerBoundChannel = () => options.channelSession?.channelSlug ?? threadSessionRegistry.list()[0]?.channel;
   const durableInboundQueueFor = (channel, kandanThreadId) => {
     const workspace = inboundQueueWorkspace();
     const cacheKey = `${workspace}:${channel}:${kandanThreadId}`;
@@ -26845,7 +26893,25 @@ async function openLocalCodexRunner(options, log2, cleanup, close, runnerDrainHo
     }
     const record = threadSessionRegistry.list().find((entry) => entry.kandanThreadId === kandanThreadId);
     if (record === void 0) {
-      return "ignored";
+      const boundChannel = resolveRunnerBoundChannel();
+      if (boundChannel === void 0 || !acceptingInbound) {
+        return "ignored";
+      }
+      const queue2 = durableInboundQueueFor(boundChannel, kandanThreadId);
+      const enqueued = queue2.enqueue(
+        event.seq,
+        event.localRunnerEventType === void 0 ? "live" : "replay",
+        serializeKandanChatEventForQueue(event),
+        Date.now()
+      );
+      log2("runner.spawn_on_miss_enqueued_without_local_record", {
+        kandanThreadId,
+        channel: boundChannel,
+        seq: event.seq,
+        enqueued: enqueued.accepted
+      });
+      await publishUnroutedDurableEnqueueState(boundChannel, event);
+      return "spawned";
     }
     const queueChannel = record.channel;
     const watermarkKey = threadSourceSeqWatermarkKey(
@@ -26971,12 +27037,53 @@ async function openLocalCodexRunner(options, log2, cleanup, close, runnerDrainHo
       }
     });
   };
+  const drainThreadQueueAfterSpawn = async (kandanThreadId, spawnResponse) => {
+    if (spawnResponse !== void 0 && spawnResponse.ok === false) {
+      return;
+    }
+    if (!acceptingInbound) {
+      return;
+    }
+    const record = threadSessionRegistry.list().find((entry) => entry.kandanThreadId === kandanThreadId);
+    if (record === void 0) {
+      return;
+    }
+    const queue = durableInboundQueueFor(record.channel, kandanThreadId);
+    if (queue.entries().length === 0) {
+      return;
+    }
+    log2("runner.inbound_drain_after_spawn", {
+      kandanThreadId,
+      channel: record.channel,
+      pending: queue.entries().length
+    });
+    await drainOwnedThreadQueue(
+      record,
+      latestResumeReconcileByThread.get(kandanThreadId) ?? []
+    ).catch((error) => {
+      log2("runner.inbound_drain_after_spawn_failed", {
+        kandanThreadId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    });
+  };
+  const startThreadRunnerProcessFromServerControl = async (control, cwd) => {
+    const response = await startThreadRunnerProcess(control, cwd);
+    const kandanThreadId = optionalThreadControlField(control, "threadId");
+    if (kandanThreadId !== void 0) {
+      await drainThreadQueueAfterSpawn(kandanThreadId, response);
+    }
+    return response;
+  };
   const consumeResumeReconcile = (reconcileValue) => {
     const byThread = /* @__PURE__ */ new Map();
     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,
@@ -27228,6 +27335,29 @@ async function openLocalCodexRunner(options, log2, cleanup, close, runnerDrainHo
       });
     }
   };
+  const publishUnroutedDurableEnqueueState = async (channel, event) => {
+    if (event.threadId === void 0) {
+      return;
+    }
+    const payload = {
+      workspace: inboundQueueWorkspace(),
+      channel,
+      thread_id: event.threadId,
+      instance_id: instanceId,
+      seq: event.seq,
+      status: "queued",
+      reason: "queued for durable resume"
+    };
+    try {
+      await kandan.push(topic, "message_state", payload);
+    } catch (error) {
+      log2("runner.spawn_on_miss_state_push_failed", {
+        thread_id: event.threadId,
+        status: "queued",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
   const deadLetterPublisherFor = (record) => {
     return async ({ sourceSeq, reason, attempts, alreadyPublished }) => {
       log2("runner.inbound_dead_lettered", {
@@ -27738,7 +27868,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close, runnerDrainHo
           control,
           log2,
           attachThreadSession,
-          shouldUseThreadProcesses(options) ? startThreadRunnerProcess : void 0,
+          shouldUseThreadProcesses(options) ? startThreadRunnerProcessFromServerControl : void 0,
           (id) => leaseEpochRegistry.current(id),
           commitLiveWorkerAcceptedSourceSeq,
           captureLiveFollowUpEvent,
@@ -27816,10 +27946,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}`;
@@ -31326,7 +31453,8 @@ ${developerPrompt}`,
       metadata: {
         local_codex_runner: {
           event_type: "codex_start_instructions",
-          codex_thread_id: codexThreadId
+          codex_thread_id: codexThreadId,
+          instructions_body: developerPrompt
         }
       }
     },
@@ -33405,6 +33533,26 @@ function projectPathExists(projectPath) {
     throw error;
   }
 }
+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) {
   const requestId = stringValue(control.requestId) ?? null;
   const cwd = resolveAllowedCwd(control.cwd, allowedCwds);
@@ -33417,10 +33565,14 @@ async function suggestRunnerTasks(control, options, allowedCwds) {
       error: cwd.reason
     };
   }
+  const modelProvider = resolveSuggestTasksModelProvider(control);
+  const model = stringValue(control.model)?.trim();
   try {
     const tasks = await suggestSignupTasksWithCodex({
       projectPath: cwd.cwd,
-      codexBin: options.codexBin
+      codexBin: options.codexBin,
+      ...model === void 0 || model === "" ? {} : { model },
+      ...modelProvider === void 0 ? {} : { modelProvider }
     });
     return {
       instanceId: options.runnerId,
@@ -70921,22 +71073,49 @@ async function resolveMcpAuth(args) {
       mode: "personal-agent-delegation"
     };
   }
-  const token = args.explicitToken ?? readCachedLocalRunnerToken(args.kandanUrl, args.authFilePath)?.accessToken;
+  const accessToken = await resolveMcpLocalRunnerToken({
+    kandanUrl: args.kandanUrl,
+    explicitToken: args.explicitToken,
+    authFilePath: args.authFilePath,
+    workspaceSlug: args.workspaceSlug,
+    channelSlug: args.channelSlug
+  });
+  return { accessToken, mode: "local-runner" };
+}
+async function resolveMcpLocalRunnerToken(args, deps = {
+  readCachedToken: readCachedLocalRunnerToken,
+  validateTokenOutcome: validateLocalRunnerTokenOutcome,
+  resolveToken: resolveLocalRunnerToken
+}) {
+  const token = args.explicitToken ?? deps.readCachedToken(args.kandanUrl, args.authFilePath)?.accessToken;
   if (token === void 0) {
     throw new Error(
       "missing Linzumi MCP token; run linzumi auth or pass --token"
     );
   }
-  const valid = await validateLocalRunnerToken({
+  const outcome = await deps.validateTokenOutcome({
     kandanUrl: args.kandanUrl,
     accessToken: token,
     workspaceSlug: args.workspaceSlug,
     channelSlug: args.channelSlug
   });
-  if (!valid) {
-    throw new Error("Linzumi MCP token was rejected by the server");
+  if (outcome === "usable") {
+    return token;
+  }
+  const _recoverable = outcome;
+  void _recoverable;
+  try {
+    return await deps.resolveToken({
+      kandanUrl: args.kandanUrl,
+      workspaceSlug: args.workspaceSlug,
+      channelSlug: args.channelSlug,
+      authFilePath: args.authFilePath
+    });
+  } catch (error) {
+    throw new Error(
+      `Linzumi MCP token was rejected by the server and re-mint failed: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
-  return { accessToken: token, mode: "local-runner" };
 }
 function mcpJsonResult(value) {
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.108-beta",
+  "version": "0.0.110-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": {