@linzumi/cli 0.0.109-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.109-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.109-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;
   }
 });
 
@@ -27033,7 +27080,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 +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}`;
@@ -33486,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);
@@ -33498,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,

package/package.json

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