@linzumi/cli 0.0.87-beta → 0.0.88-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.87-beta --version
+npx -y @linzumi/cli@0.0.88-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -11541,7 +11541,7 @@ function createClaudeCodeSessionPipeline(host) {
     const toolName2 = pending?.toolName ?? event.toolName ?? "tool";
     const input = pending?.input ?? {};
     const itemId = `tool:${event.itemKey}`;
-    if (!event.isError && isFileChangeTool(toolName2)) {
+    if (isFileChangeTool(toolName2)) {
       const patchText = claudeFileChangePatchText(toolName2, input, {
         targetExistedAtCall: pending?.targetExistedAtCall
       });
@@ -11549,7 +11549,7 @@ function createClaudeCodeSessionPipeline(host) {
         const item2 = {
           type: "fileChange",
           id: itemId,
-          status: "completed",
+          status: event.isError ? "failed" : "completed",
           patchText
         };
         recordItem(turn, item2);
@@ -11569,12 +11569,13 @@ function createClaudeCodeSessionPipeline(host) {
       submit("item/completed", { turnId: turn.turnId, item: item2 });
       return;
     }
-    if (!event.isError && toolName2 === "TodoWrite") {
+    if (!event.isError && isClaudePlanTool(toolName2)) {
       host.onTodoWriteCompleted?.(input);
       const plan = claudePlanItem(itemId, input);
       if (plan !== void 0) {
-        recordItem(turn, plan);
-        submit("item/completed", { turnId: turn.turnId, item: plan });
+        const planRow = { ...plan, id: itemId };
+        recordItem(turn, planRow);
+        submit("item/completed", { turnId: turn.turnId, item: planRow });
         return;
       }
     }
@@ -11605,7 +11606,7 @@ function createClaudeCodeSessionPipeline(host) {
       }
       case "reasoning_delta": {
         const turn = ensureTurn();
-        const itemId = claudeAssistantPipelineItemId(event.itemKey);
+        const itemId = claudeReasoningPipelineItemId(event.itemKey);
         appendRawText(turn, itemId, "reasoning", event.delta);
         submit("item/reasoning/textDelta", {
           turnId: turn.turnId,
@@ -11626,7 +11627,7 @@ function createClaudeCodeSessionPipeline(host) {
       }
       case "reasoning_message": {
         const turn = ensureTurn();
-        const itemId = claudeAssistantPipelineItemId(event.itemKey);
+        const itemId = claudeReasoningPipelineItemId(event.itemKey);
         setRawText(turn, itemId, "reasoning", event.content);
         submit("item/completed", {
           turnId: turn.turnId,
@@ -11636,14 +11637,15 @@ function createClaudeCodeSessionPipeline(host) {
       }
       case "tool_call": {
         const turn = ensureTurn();
+        const targetExistedAtCall = fileChangeTargetExists(
+          event.toolName,
+          event.input,
+          host.cwd
+        );
         turn.pendingTools.set(event.itemKey, {
           toolName: event.toolName,
           input: event.input,
-          targetExistedAtCall: fileChangeTargetExists(
-            event.toolName,
-            event.input,
-            host.cwd
-          )
+          targetExistedAtCall
         });
         if (isWebSearchTool(event.toolName)) {
           const query = stringValue(event.input.query) ?? stringValue(event.input.url) ?? event.toolName;
@@ -11655,7 +11657,34 @@ function createClaudeCodeSessionPipeline(host) {
               query
             }
           });
+          return;
+        }
+        if (isClaudePlanTool(event.toolName)) {
+          return;
+        }
+        const itemId = `tool:${event.itemKey}`;
+        if (isFileChangeTool(event.toolName)) {
+          const patchText = claudeFileChangePatchText(
+            event.toolName,
+            event.input,
+            { targetExistedAtCall }
+          );
+          if (patchText !== void 0 && patchText.trim() !== "") {
+            submit("item/fileChange/outputDelta", {
+              turnId: turn.turnId,
+              itemId,
+              delta: patchText
+            });
+          }
+          return;
         }
+        submit("item/commandExecution/outputDelta", {
+          turnId: turn.turnId,
+          itemId,
+          command: claudeToolCommandLabel(event.toolName, event.input),
+          stream: "stdout",
+          delta: "\n"
+        });
         return;
       }
       case "tool_result": {
@@ -11809,6 +11838,9 @@ function claudeAssistantPipelineItemId(itemKey) {
   const streamIndex = itemKey.match(/^assistant-stream-(\d+)$/)?.[1];
   return streamIndex === void 0 ? itemKey : `content-block-${streamIndex}`;
 }
+function claudeReasoningPipelineItemId(itemKey) {
+  return `reasoning-${claudeAssistantPipelineItemId(itemKey)}`;
+}
 function isFileChangeTool(toolName2) {
   switch (toolName2) {
     case "Edit":
@@ -11823,6 +11855,9 @@ function isFileChangeTool(toolName2) {
 function isWebSearchTool(toolName2) {
   return toolName2 === "WebSearch" || toolName2 === "WebFetch";
 }
+function isClaudePlanTool(toolName2) {
+  return toolName2 === "TodoWrite" || toolName2 === "TaskCreate" || toolName2 === "TaskUpdate";
+}
 function fileChangeTargetExists(toolName2, input, sessionCwd) {
   if (!isFileChangeTool(toolName2)) {
     return void 0;
@@ -11895,9 +11930,18 @@ ${body}
 *** End Patch
 `;
 }
+function claudePlanInputItems(input) {
+  if (Array.isArray(input.todos)) {
+    return input.todos;
+  }
+  if (Array.isArray(input.tasks)) {
+    return input.tasks;
+  }
+  return [];
+}
 function claudePlanItem(itemId, input) {
-  const todos = Array.isArray(input.todos) ? input.todos : [];
-  const lines = todos.flatMap((todo) => {
+  const items = claudePlanInputItems(input);
+  const lines = items.flatMap((todo) => {
     const value = objectValue(todo);
     if (value === void 0) {
       return [];
@@ -11971,7 +12015,7 @@ function objectValue2(value) {
   return isJsonObject(value) ? value : void 0;
 }
 function claudeTodoWritePlanSteps(input) {
-  const todos = Array.isArray(input.todos) ? input.todos : [];
+  const todos = Array.isArray(input.todos) ? input.todos : Array.isArray(input.tasks) ? input.tasks : [];
   const steps = todos.flatMap((todo) => {
     const value = objectValue2(todo);
     if (value === void 0) {
@@ -12042,6 +12086,29 @@ function createClaudeCodePlanMirror(args) {
     settle: () => flight
   };
 }
+async function seedClaudeCodingJobGoal(args) {
+  const goal = args.goal.trim().slice(0, 2e3);
+  if (goal === "") {
+    return false;
+  }
+  try {
+    await args.upsertCodingJobPlan(
+      { thread_id: args.threadId, goal },
+      { signal: args.signal }
+    );
+    args.log("claude_code.goal_seeded", {
+      thread_id: args.threadId,
+      goal_length: goal.length
+    });
+    return true;
+  } catch (error) {
+    args.log("claude_code.goal_seed_failed", {
+      thread_id: args.threadId,
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return false;
+  }
+}
 var todoStatusToPlanStepStatus, planStepTitleMaxLength, planStepDescriptionMaxLength, planStepsMaxCount;
 var init_claudeCodePlanMirror = __esm({
   "src/claudeCodePlanMirror.ts"() {
@@ -12597,6 +12664,87 @@ var init_claudeCodeLiveBashOutput = __esm({
   }
 });
 
+// src/claudeCodeTurnStallWatchdog.ts
+function createClaudeCodeTurnStallWatchdog(options) {
+  if (!(options.thresholdMs > 0)) {
+    throw new Error("Claude turn-stall threshold must be > 0");
+  }
+  const now = options.now ?? (() => Date.now());
+  const setTimer = options.setTimer ?? ((callback, delayMs) => {
+    const handle2 = setTimeout(callback, delayMs);
+    handle2.unref?.();
+    return handle2;
+  });
+  const clearTimer = options.clearTimer ?? ((handle2) => clearTimeout(handle2));
+  const isTurnActive = options.isTurnActive ?? (() => true);
+  let handle;
+  let lastKickMs = now();
+  let stopped = false;
+  let fired = false;
+  let wasActive = isTurnActive();
+  const disarm = () => {
+    if (handle !== void 0) {
+      clearTimer(handle);
+      handle = void 0;
+    }
+  };
+  const onTimeout = () => {
+    handle = void 0;
+    if (stopped || fired) {
+      return;
+    }
+    const active = isTurnActive();
+    if (!active) {
+      wasActive = false;
+      arm();
+      return;
+    }
+    if (!wasActive) {
+      wasActive = true;
+      lastKickMs = now();
+      arm();
+      return;
+    }
+    const silentMs = now() - lastKickMs;
+    if (silentMs < options.thresholdMs) {
+      arm();
+      return;
+    }
+    fired = true;
+    options.onStall({ silentMs });
+  };
+  function arm() {
+    if (stopped || fired) {
+      return;
+    }
+    disarm();
+    const delay = isTurnActive() ? Math.max(0, options.thresholdMs - (now() - lastKickMs)) : options.thresholdMs;
+    handle = setTimer(onTimeout, delay);
+  }
+  arm();
+  return {
+    kick: () => {
+      if (stopped || fired) {
+        return;
+      }
+      wasActive = true;
+      lastKickMs = now();
+      arm();
+    },
+    stop: () => {
+      stopped = true;
+      disarm();
+    }
+  };
+}
+var defaultClaudeCodeTurnStallThresholdMs;
+var init_claudeCodeTurnStallWatchdog = __esm({
+  "src/claudeCodeTurnStallWatchdog.ts"() {
+    "use strict";
+    defaultClaudeCodeTurnStallThresholdMs = 10 * 6e4;
+  }
+});
+
 // src/claudeCodeSession.ts
 import { existsSync as existsSync4, readFileSync as readFileSync5 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
@@ -12864,8 +13012,49 @@ async function startClaudeCodeSession(options) {
     lastCompletedTurnBody: void 0
   };
   const streamUsageTracker = createClaudeCodeStreamUsageTracker();
+  let stallReason;
+  let signalStall;
+  const stallSignal = new Promise((resolve12) => {
+    signalStall = resolve12;
+  });
+  const stallWatchdog = options.turnStallThresholdMs !== void 0 && options.turnStallThresholdMs > 0 ? createClaudeCodeTurnStallWatchdog({
+    thresholdMs: options.turnStallThresholdMs,
+    isTurnActive: options.turnStallIsActive,
+    onStall: ({ silentMs }) => {
+      stallReason = `Claude Code turn stalled: no SDK output for ${Math.round(
+        silentMs / 1e3
+      )}s (threshold ${Math.round(
+        (options.turnStallThresholdMs ?? 0) / 1e3
+      )}s)`;
+      options.abortController?.abort();
+      signalStall?.();
+    }
+  }) : void 0;
   try {
-    for await (const message of runner(options)) {
+    const iterator = runner(options)[Symbol.asyncIterator]();
+    for (; ; ) {
+      let nextStep;
+      if (stallWatchdog) {
+        const nextPromise = iterator.next().then((result) => ({ kind: "next", result }));
+        nextPromise.catch(() => void 0);
+        const raced = await Promise.race([
+          nextPromise,
+          stallSignal.then(() => ({ kind: "stall" }))
+        ]);
+        if (raced.kind === "stall") {
+          void Promise.resolve(iterator.return?.()).catch(() => void 0);
+          break;
+        }
+        nextStep = raced;
+      } else {
+        nextStep = { kind: "next", result: await iterator.next() };
+      }
+      const step = nextStep;
+      if (step.result.done === true) {
+        break;
+      }
+      const message = step.result.value;
+      stallWatchdog?.kick();
       state.sessionId = state.sessionId ?? extractClaudeSessionId(message);
       const sessionId = extractClaudeSessionId(message) ?? state.sessionId;
       if (sessionId !== void 0 && !state.startedSessionIds.has(sessionId)) {
@@ -12931,8 +13120,12 @@ async function startClaudeCodeSession(options) {
       }
     }
   } finally {
+    stallWatchdog?.stop();
     options.streamingInput?.close();
   }
+  if (stallReason !== void 0) {
+    return await failClaudeCodeSession(options, state.sessionId, stallReason);
+  }
   return completeClaudeCodeSession(options, state);
 }
 async function emitClaudeCodeTurnCompleted(options, state) {
@@ -13325,13 +13518,16 @@ function assistantTranscriptEvents(message, sessionId) {
       contentBlockItemKey(block, index)
     )
   );
-  const directText = nonEmptyText(stringValue(message?.text));
+  const hasTextContentBlock = content.some(
+    (block) => stringValue(objectValue(block)?.type) === "text"
+  );
+  const directText = hasTextContentBlock ? void 0 : nonEmptyText(stringValue(message?.text));
   return directText === void 0 ? contentEvents : [
     ...contentEvents,
     {
       type: "assistant_message",
       sessionId,
-      itemKey: stringValue(message?.uuid) ?? "assistant-message",
+      itemKey: `content-block-${content.length}`,
       content: directText,
       streamState: "completed"
     }
@@ -13352,7 +13548,7 @@ function userTranscriptEvents(message, sessionId) {
       {
         type: "tool_result",
         sessionId,
-        itemKey: contentBlockItemKey(block, index),
+        itemKey: stringValue(value?.tool_use_id) ?? stringValue(value?.id) ?? `content-block-${index}`,
         toolName: void 0,
         content: visibleToolResultContent(value),
         isError: value?.is_error === true
@@ -13438,12 +13634,14 @@ function unknownTranscriptEvent(message, sessionId) {
 }
 function streamItemKey(event, _message) {
   const index = integerValue(event?.index);
-  const contentBlock = objectValue(event?.content_block);
-  return stringValue(event?.content_block_id) ?? stringValue(contentBlock?.id) ?? stringValue(contentBlock?.tool_use_id) ?? stringValue(contentBlock?.uuid) ?? (index === void 0 ? "assistant-stream" : `assistant-stream-${index}`);
+  return index === void 0 ? "assistant-stream" : `content-block-${index}`;
 }
 function contentBlockItemKey(block, index) {
   const value = objectValue(block);
-  return stringValue(value?.id) ?? stringValue(value?.tool_use_id) ?? stringValue(value?.uuid) ?? `content-block-${index}`;
+  if (stringValue(value?.type) === "tool_use") {
+    return stringValue(value?.id) ?? stringValue(value?.tool_use_id) ?? `content-block-${index}`;
+  }
+  return `content-block-${index}`;
 }
 function visibleToolResultContent(block) {
   const content = block?.content;
@@ -13491,6 +13689,7 @@ var init_claudeCodeSession = __esm({
     "use strict";
     init_json();
     init_claudeCodeLiveBashOutput();
+    init_claudeCodeTurnStallWatchdog();
     claudeRateLimitWindowLabels = {
       five_hour: "5h window",
       seven_day: "7d window",
@@ -18520,7 +18719,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.87-beta";
+    linzumiCliVersion = "0.0.88-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -20909,7 +21108,7 @@ function createLinzumiMcpApiClient(options) {
   const baseUrl = kandanHttpBaseUrl(options.kandanUrl);
   const apiPrefix = options.authMode === "personal-agent-delegation" ? "/api/v2/personal-agent-mcp" : "/api/v2/local-runner-mcp";
   const operatingMode = options.operatingMode ?? "text";
-  const request = async (method, path2, params) => {
+  const request = async (method, path2, params, requestOptions = {}) => {
     const url = new URL(path2, baseUrl);
     const paramsWithMode = {
       ...params,
@@ -20917,7 +21116,11 @@ function createLinzumiMcpApiClient(options) {
     };
     const requestInit = {
       method,
-      headers: { authorization: `Bearer ${options.accessToken}` }
+      headers: { authorization: `Bearer ${options.accessToken}` },
+      // An aborted signal cancels the in-flight fetch so a caller that has
+      // already given up (e.g. a timed-out goal seed) cannot land a LATE POST
+      // and clobber state written after it gave up (#1864 finding 2).
+      ...requestOptions.signal === void 0 ? {} : { signal: requestOptions.signal }
     };
     if (method === "GET") {
       for (const [key, value] of Object.entries(paramsWithMode)) {
@@ -20950,9 +21153,11 @@ function createLinzumiMcpApiClient(options) {
     getMessage: (params) => request("GET", `${apiPrefix}/message`, params),
     getThread: (params) => request("GET", `${apiPrefix}/thread`, params),
     getChannel: (params) => request("GET", `${apiPrefix}/channel`, params),
+    searchWorkspace: (params) => request("GET", `${apiPrefix}/search`, params),
+    askWorkspace: (params) => request("POST", `${apiPrefix}/ask`, params),
     getCodingJobMetadata: (params) => request("GET", `${apiPrefix}/coding-job-metadata`, params),
     renameCodingJob: (params) => request("POST", `${apiPrefix}/coding-job-title`, params),
-    upsertCodingJobPlan: (params) => request("POST", `${apiPrefix}/coding-job-plan`, params),
+    upsertCodingJobPlan: (params, requestOptions) => request("POST", `${apiPrefix}/coding-job-plan`, params, requestOptions),
     replaceCodingJobPlanSteps: (params) => request("POST", `${apiPrefix}/coding-job-plan/steps`, params),
     updateCodingJobPlanStep: (params) => request("POST", `${apiPrefix}/coding-job-plan/step`, params),
     linkCodingJobPullRequest: (params) => request("POST", `${apiPrefix}/coding-job-primary-pr`, params),
@@ -25879,12 +26084,18 @@ function truncateFailureDetail(message) {
 }
 function commanderDeveloperInstructions(args) {
   const agentLabel = args.agentLabel ?? "Codex";
-  const planStepsInstruction = args.planTool === "todo-write" ? `For coding-job threads, start by setting the current goal with
-linzumi_upsert_coding_job_plan, then record the plan steps with the TodoWrite
-tool. Linzumi mirrors your TodoWrite list into the coding-job plan steps
-automatically, one TodoWrite item per plan step.` : `For coding-job threads, start by setting the current goal with
-linzumi_upsert_coding_job_plan, then replace the plan steps with
-linzumi_replace_coding_job_plan_steps.`;
+  const planOpener = `Before you begin ANY work - and again whenever the job
+changes - call linzumi_upsert_coding_job_plan to set or refresh the current
+goal and the high-level plan. Always record the plan up front, before starting
+work, so the user can see a high-level view of what you are doing at all times
+and trust your work. Keep it accurate as you go: whenever you discover steps to
+add, steps that are no longer needed, or the nature of the job changes, update
+it with linzumi_upsert_coding_job_plan.`;
+  const planStepsInstruction = args.planTool === "todo-write" ? `${planOpener}
+Record and maintain the plan STEPS with the TodoWrite tool. Linzumi mirrors
+your TodoWrite list into the coding-job plan steps automatically, one TodoWrite
+item per plan step.` : `${planOpener}
+Replace the plan STEPS with linzumi_replace_coding_job_plan_steps.`;
   const planUpdateInstruction = args.planTool === "todo-write" ? `As work proceeds, update each step's status with TodoWrite. Do not call
 linzumi_replace_coding_job_plan_steps or linzumi_update_coding_job_plan_step
 directly; TodoWrite is the source of truth for the plan steps.` : `As work proceeds, update each step with linzumi_update_coding_job_plan_step.`;
@@ -26273,6 +26484,14 @@ async function startCodexProviderInstance(args) {
     }
   };
 }
+function claudeCodeTurnStallThresholdMs(env) {
+  const raw = env.LINZUMI_CLAUDE_TURN_STALL_MS?.trim();
+  if (raw === void 0 || raw === "") {
+    return defaultClaudeCodeTurnStallThresholdMs;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : defaultClaudeCodeTurnStallThresholdMs;
+}
 function createClaudeCodeInputQueue(input) {
   const pendingMessages = [
     claudeCodeUserInputMessage(input.content)
@@ -26644,12 +26863,47 @@ async function startClaudeCodeProviderInstance(args) {
     fetchImpl: args.options.fetch,
     operatingMode: "text"
   });
+  const seededGoal = workDescription.trim().slice(0, 2e3);
   const planMirror = createClaudeCodePlanMirror({
     replacePlanSteps: planMirrorClient.replaceCodingJobPlanSteps,
     threadId,
-    goal: workDescription.trim().slice(0, 2e3),
+    goal: seededGoal,
     log: args.log
   });
+  const seedCodingJobGoalBeforeTurn = async () => {
+    if (args.resumeSessionId !== void 0) {
+      return;
+    }
+    const seedTimeoutMs = 5e3;
+    const seedAbort = new AbortController();
+    let timeoutHandle;
+    const timedOut = new Promise((resolve12) => {
+      timeoutHandle = setTimeout(() => {
+        seedAbort.abort(new Error("claude goal seed timed out"));
+        args.log("claude_code.goal_seed_timeout", {
+          thread_id: threadId,
+          timeout_ms: seedTimeoutMs
+        });
+        resolve12();
+      }, seedTimeoutMs);
+    });
+    try {
+      await Promise.race([
+        seedClaudeCodingJobGoal({
+          upsertCodingJobPlan: planMirrorClient.upsertCodingJobPlan,
+          threadId,
+          goal: seededGoal,
+          log: args.log,
+          signal: seedAbort.signal
+        }),
+        timedOut
+      ]);
+    } finally {
+      if (timeoutHandle !== void 0) {
+        clearTimeout(timeoutHandle);
+      }
+    }
+  };
   const adapter = createClaudeCodeSessionPipeline({
     instanceId: args.instanceId,
     cwd: args.cwd,
@@ -26955,6 +27209,7 @@ async function startClaudeCodeProviderInstance(args) {
   });
   const runSession = async () => {
     let result2;
+    await seedCodingJobGoalBeforeTurn();
     try {
       try {
         result2 = await startClaudeCodeSession({
@@ -26983,6 +27238,20 @@ async function startClaudeCodeProviderInstance(args) {
           resumeSessionId: args.resumeSessionId,
           abortController,
           streamingInput: inputQueue,
+          // PROD-RESILIENCE turn-stall watchdog (real-SDK sessions only; mock
+          // runners drive their own timing). A turn that stays in flight with
+          // no SDK output past the threshold is a wedged SILENT subprocess: the
+          // watchdog aborts it and fails the turn so the thread reconnects,
+          // instead of sitting "processing" forever (the ~28-min-hang incident).
+          // The in-flight predicate (currentSourceSeq() is defined only while a
+          // turn is queued/active) keeps a keep-alive session idling between
+          // turns from being a false positive.
+          ...args.options.claudeCodeRunner === void 0 ? {
+            turnStallThresholdMs: claudeCodeTurnStallThresholdMs(
+              process.env
+            ),
+            turnStallIsActive: () => inputQueue.currentSourceSeq() !== void 0
+          } : {},
           runner: args.options.claudeCodeRunner,
           canUseTool,
           ...mcpServers === void 0 ? {} : { mcpServers },
@@ -29343,6 +29612,7 @@ var init_runner = __esm({
     init_engineChildReaper();
     init_claudeCodeLiveBashOutput();
     init_claudeCodeSession();
+    init_claudeCodeTurnStallWatchdog();
     init_codexAppServer();
     init_codexProjectTrust();
     init_codexRuntimeOptions();
@@ -66096,6 +66366,60 @@ async function runMcpServer(args) {
       },
       async (params) => mcpJsonResult(await client.getChannel(params))
     );
+    server.tool(
+      "linzumi_search_workspace",
+      "Search the Linzumi workspace with hybrid lexical+semantic retrieval, scoped to what the authorizing user can access. Returns scored content chunks with provenance (channel, thread, authored time) and a permalink to cite.",
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        query: external_exports2.string().min(1).describe("Natural-language or keyword query to retrieve against."),
+        limit: external_exports2.number().int().min(1).max(25).optional().describe("Maximum results to return (default 10, server-capped)."),
+        source_types: external_exports2.array(
+          external_exports2.enum([
+            "message",
+            "coding_job",
+            "github_pr",
+            "github_pr_review",
+            "github_check_run",
+            "github_workflow_run",
+            "github_diff",
+            "dictation",
+            "file"
+          ])
+        ).optional().describe("Restrict results to these corpora; omit for all."),
+        authored_after: external_exports2.string().optional().describe(
+          "ISO8601 instant; only content authored at or after this time."
+        ),
+        authored_before: external_exports2.string().optional().describe(
+          "ISO8601 instant; only content authored at or before this time."
+        ),
+        repo: external_exports2.string().optional().describe(
+          "Restrict GitHub-sourced results to one repository by full name (owner/name)."
+        ),
+        check_status: external_exports2.enum(["pending", "success", "failed"]).optional().describe(
+          "Restrict check and workflow results to one conclusion bucket."
+        )
+      },
+      async (params) => mcpJsonResult(await client.searchWorkspace(params))
+    );
+    server.tool(
+      "linzumi_ask_workspace",
+      'Ask the Linzumi workspace a natural-language question and get a synthesized, citation-backed answer over what the authorizing user can access. Costs an LLM call on cache misses, so prefer linzumi_search_workspace for simple lookups. A "refused" status means there was not enough accessible evidence - treat it as "the workspace does not know", never retry verbatim.',
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        question: external_exports2.string().min(1).max(2e3).describe("Natural-language question to answer with citations."),
+        channel: external_exports2.string().optional().describe(
+          "Optional channel slug providing conversational context; never widens access."
+        ),
+        allow_cached: external_exports2.boolean().optional().describe(
+          "Allow serving a cached synthesis when the evidence set is unchanged (default true). Set false to force fresh synthesis."
+        )
+      },
+      async (params) => mcpJsonResult(await client.askWorkspace(params))
+    );
     server.tool(
       "linzumi_get_coding_job_metadata",
       "Read the active coding job workflow metadata for a thread, including the agent-owned goal, ordered plan steps, step lock versions, and workflow status.",

package/package.json

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