nolo-cli 0.1.40 → 0.1.42

package/cli/tableCommands.ts

@@ -55,6 +55,11 @@ function parseOutputMode(raw: string): OutputMode {
   throw new Error(`--output must be one of full, raw, items, json, jsonl; got ${raw}`);
 }
 
+function resolveQueryColumns(columns: string[] | undefined, includeActivity: boolean): string[] | undefined {
+  if (!includeActivity) return columns;
+  return Array.isArray(columns) ? includeTableActivityColumns(columns) : undefined;
+}
+
 function parseTableArg(raw: string): { tenantId?: string; tableId?: string } {
   const trimmed = raw.trim();
   if (!trimmed) return {};
@@ -66,6 +71,32 @@ function parseTableArg(raw: string): { tenantId?: string; tableId?: string } {
   };
 }
 
+function normalizeSpaceInput(raw: string): string {
+  const value = raw.trim();
+  if (!value) return "";
+  if (value.startsWith("http://") || value.startsWith("https://")) {
+    const match = new URL(value).pathname.match(/^\/space\/([^/]+)/);
+    return match?.[1] ? decodeURIComponent(match[1]).replace(/^space-/, "") : "";
+  }
+  return value.replace(/^space-/, "");
+}
+
+function getSpaceContentKeys(spaceRecord: any): Set<string> {
+  const keys = new Set<string>();
+  const contents = spaceRecord?.contents;
+  if (!contents || typeof contents !== "object") return keys;
+  for (const [entryKey, value] of Object.entries(contents)) {
+    keys.add(entryKey);
+    if (value && typeof value === "object") {
+      const contentKey = (value as any).contentKey;
+      if (typeof contentKey === "string" && contentKey.trim()) {
+        keys.add(contentKey.trim());
+      }
+    }
+  }
+  return keys;
+}
+
 function resolveServerUrl(args: string[], env: EnvLike): string {
   return (
     readOption(args, "--server-url") ||
@@ -89,16 +120,46 @@ function resolveAuthToken(args: string[], env: EnvLike): string {
 }
 
 function parseJwtTenantId(token: string): string | undefined {
-  const [, payload] = token.split(".");
-  if (!payload) return undefined;
-  try {
-    const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
-    const decoded = Buffer.from(normalized, "base64").toString("utf8");
-    const parsed = JSON.parse(decoded);
-    return typeof parsed.userId === "string" ? parsed.userId : typeof parsed.sub === "string" ? parsed.sub : undefined;
-  } catch {
-    return undefined;
+  for (const parsed of parseJwtPayloadCandidates(token)) {
+    const userId = parsed.userId;
+    const sub = parsed.sub;
+    if (typeof userId === "string" && userId) return userId;
+    if (typeof sub === "string" && sub) return sub;
   }
+  return undefined;
+}
+
+function parseJwtUsername(token: string): string | undefined {
+  for (const parsed of parseJwtPayloadCandidates(token)) {
+    const username = parsed.username;
+    if (typeof username === "string" && username.trim()) return username.trim();
+  }
+  return undefined;
+}
+
+function parseJwtPayloadCandidates(token: string): Array<Record<string, unknown>> {
+  const trimmed = token.trim();
+  if (!trimmed) return [];
+  const parts = trimmed.split(".").filter(Boolean);
+  const payloadCandidates = parts.length >= 3 ? [parts[1], parts[0]] : [parts[0]];
+  const parsed: Array<Record<string, unknown>> = [];
+  for (const payload of payloadCandidates) {
+    try {
+      const decoded = Buffer.from(payload, "base64").toString("utf8");
+      const value = JSON.parse(decoded);
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        parsed.push(value as Record<string, unknown>);
+      }
+    } catch {}
+  }
+  return parsed;
+}
+
+function resolveUserId(args: string[], env: EnvLike, authToken: string): string | undefined {
+  const explicit = readOption(args, "--tenant-id") || env.USER_ID || parseJwtTenantId(authToken);
+  if (explicit) return explicit;
+  const username = parseJwtUsername(authToken);
+  return username && /^[a-z0-9_-]+$/i.test(username) ? username : undefined;
 }
 
 function formatOutput(input: { envelope: any; rawData: any; mode: OutputMode }): string {
@@ -133,6 +194,182 @@ function usage(): string {
   ].join("\n");
 }
 
+function listUsage(): string {
+  return [
+    "Usage:",
+    "  nolo table list [--limit <n>] [--title-query <text>] [--purpose <purpose>] [--output full|raw|items|json|jsonl]",
+    "",
+  ].join("\n");
+}
+
+function tableHasPurpose(table: any, purpose: string): boolean {
+  return typeof table?.purpose === "string" && table.purpose.toLowerCase() === purpose.toLowerCase();
+}
+
+function getComparableUpdatedAt(record: any): number {
+  const raw = record?.updatedAt ?? record?.updated_at ?? record?.createdAt ?? record?.created;
+  if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+  if (typeof raw === "string") return Date.parse(raw) || 0;
+  return 0;
+}
+
+function formatTableListOutput(args: {
+  mode: OutputMode;
+  tables: any[];
+  envelope: any;
+}) {
+  if (args.mode === "full") return JSON.stringify(args.envelope, null, 2);
+  if (args.mode === "raw") return JSON.stringify(args.tables, null, 2);
+  if (args.mode === "items") return JSON.stringify(args.tables, null, 2);
+  return args.tables.map((item) => JSON.stringify(item)).join("\n");
+}
+
+export async function runTableListCommand(args: string[], deps: TableCommandDeps = {}): Promise<number> {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    output.write(listUsage());
+    return 0;
+  }
+
+  let outputMode: OutputMode;
+  try {
+    outputMode = parseOutputMode(readOption(args, "--output") || "items");
+  } catch (error) {
+    output.write(`[nolo] table list failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+
+  const authToken = resolveAuthToken(args, env);
+  const userId = resolveUserId(args, env, authToken);
+  if (!userId) {
+    output.write("[nolo] table list failed: user id is required. Pass --tenant-id or use a login token.\n");
+    return 1;
+  }
+  if (!authToken) {
+    output.write("[nolo] table list failed: AUTH_TOKEN is required.\n");
+    return 1;
+  }
+
+  const limit = Math.max(1, Math.min(Number(readOption(args, "--limit") || 50), 200));
+  const titleQuery = readOption(args, "--title-query").trim().toLowerCase();
+  const purpose = readOption(args, "--purpose").trim();
+  const spaceId = normalizeSpaceInput(readOption(args, "--space") || readOption(args, "--space-id"));
+  const scanLimit = titleQuery || purpose ? Math.max(limit * 5, 200) : limit;
+  const serverUrl = resolveServerUrl(args, env);
+
+  let records: any[];
+  try {
+    records = spaceId
+      ? await fetchSpaceTableRecords({
+          authToken,
+          fetchImpl,
+          serverUrl,
+          spaceId,
+        })
+      : await fetchUserTableRecords({
+          authToken,
+          fetchImpl,
+          limit: Math.min(scanLimit, 500),
+          serverUrl,
+          userId,
+        });
+  } catch (error) {
+    output.write(`[nolo] table list failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+  const tables = records
+    .filter((table: any) => table && typeof table === "object" && !table.deletedAt)
+    .filter((table: any) => !titleQuery || String(table.displayName ?? table.name ?? table.title ?? "").toLowerCase().includes(titleQuery))
+    .filter((table: any) => !purpose || tableHasPurpose(table, purpose))
+    .sort((left: any, right: any) => getComparableUpdatedAt(right) - getComparableUpdatedAt(left))
+    .slice(0, limit)
+    .map((table: any) => ({
+      dbKey: table.dbKey ?? null,
+      tableId: table.tableId ?? null,
+      displayName: table.displayName ?? table.name ?? table.title ?? "(untitled)",
+      spaceId: table.spaceId ?? null,
+      tenantId: table.tenantId ?? null,
+      columnCount: Array.isArray(table.columns) ? table.columns.length : 0,
+      createdAt: table.createdAt ?? null,
+      updatedAt: table.updatedAt ?? table.updated_at ?? null,
+    }));
+
+  const envelope = { success: true, userId, ...(spaceId ? { space: spaceId } : {}), total: tables.length, tables };
+  output.write(`${formatTableListOutput({ mode: outputMode, tables, envelope })}\n`);
+  return 0;
+}
+
+async function readJsonResponse(response: Response) {
+  const text = await response.text();
+  let payload: any;
+  try {
+    payload = text ? JSON.parse(text) : {};
+  } catch {
+    if (!response.ok) throw new Error(text || response.statusText);
+    return text;
+  }
+  if (!response.ok || payload?.error) {
+    throw new Error(payload?.error ?? response.statusText);
+  }
+  return payload;
+}
+
+async function fetchUserTableRecords(args: {
+  authToken: string;
+  fetchImpl: typeof fetch;
+  limit: number;
+  serverUrl: string;
+  userId: string;
+}) {
+  const response = await args.fetchImpl(
+    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}?limit=${args.limit}`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${args.authToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ type: "table" }),
+    }
+  );
+  const payload = await readJsonResponse(response);
+  return Array.isArray(payload?.data?.data)
+    ? payload.data.data
+    : Array.isArray(payload?.data)
+      ? payload.data
+      : [];
+}
+
+async function fetchSpaceTableRecords(args: {
+  authToken: string;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  spaceId: string;
+}) {
+  const readRecord = async (dbKey: string) => {
+    const response = await args.fetchImpl(
+      `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(dbKey)}`,
+      { headers: { Authorization: `Bearer ${args.authToken}` } }
+    );
+    const payload = await readJsonResponse(response);
+    return payload?.data ?? payload;
+  };
+  const space = await readRecord(`space-${args.spaceId}`);
+  const tableKeys = [...getSpaceContentKeys(space)].filter((key) => key.startsWith("meta-"));
+  const records = await Promise.all(
+    tableKeys.map(async (key) => {
+      try {
+        return await readRecord(key);
+      } catch {
+        return null;
+      }
+    })
+  );
+  return records.filter(Boolean);
+}
+
 export async function runTableQueryCommand(args: string[], deps: TableCommandDeps = {}): Promise<number> {
   const env = deps.env ?? process.env;
   const output = deps.output ?? process.stdout;
@@ -159,7 +396,7 @@ export async function runTableQueryCommand(args: string[], deps: TableCommandDep
 
   const tableArg = parseTableArg(readOption(args, "--table"));
   const authToken = resolveAuthToken(args, env);
-  const tenantId = readOption(args, "--tenant-id") || tableArg.tenantId || env.USER_ID || parseJwtTenantId(authToken);
+  const tenantId = readOption(args, "--tenant-id") || tableArg.tenantId || resolveUserId(args, env, authToken);
   const tableId = tableArg.tableId;
   const hasSingleRowShortcut = Boolean(readOption(args, "--row") || readOption(args, "--row-id") || readOption(args, "--row-dbkey"));
   if (!tenantId || !tableId) {
@@ -184,9 +421,7 @@ export async function runTableQueryCommand(args: string[], deps: TableCommandDep
         tenantId,
         tableId,
         filters: filters ?? {},
-        columns: hasFlag(args, "--include-activity")
-          ? includeTableActivityColumns(columns)
-          : columns,
+        columns: resolveQueryColumns(columns, hasFlag(args, "--include-activity")),
         includeBaseFields: !hasFlag(args, "--no-base-fields"),
         limit: Number(readOption(args, "--limit") || (hasSingleRowShortcut ? 1 : 20)),
         offset: Number(readOption(args, "--offset") || 0),

package/cli/workflowInternalCommandEntries.ts

@@ -1,11 +1,10 @@
 import { createEnvCommand } from "./cliCommandFactories";
 import type { CommandEntry } from "./cliCommandTypes";
-import { runTableQueryCommand } from "./tableCommands";
-import { runTaskRunCommand } from "./taskRunCommand";
+import { runTableListCommand, runTableQueryCommand } from "./tableCommands";
 
 export function getWorkflowInternalCommandEntries(): CommandEntry[] {
   return [
+    createEnvCommand(["table", "list"], "List table metadata", runTableListCommand),
     createEnvCommand(["table", "query"], "Query table rows", runTableQueryCommand),
-    createEnvCommand(["task-run"], "Update durable task-run state through the runner bridge", runTaskRunCommand),
   ];
 }

package/client/agentRun.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 import { Writable } from "node:stream";
 
 import {
-  classifyTaskRunReviewStatus,
+  classifyTaskContextReviewStatus,
   findServerPlatformTools,
   runAgentTurn,
 } from "./agentRun";
@@ -24,14 +24,14 @@ class CaptureOutput extends Writable {
 
 describe("cli agent run client", () => {
   test("classifies only clear reviewer outcomes", () => {
-    expect(classifyTaskRunReviewStatus("Review decision: passed")).toBe("passed");
-    expect(classifyTaskRunReviewStatus("Review decision: needs_changes")).toBe("needs_changes");
-    expect(classifyTaskRunReviewStatus("Review decision: blocked")).toBe("blocked");
-    expect(classifyTaskRunReviewStatus("LGTM, no issues found")).toBe("passed");
-    expect(classifyTaskRunReviewStatus("Changes requested for missing test coverage")).toBe(
+    expect(classifyTaskContextReviewStatus("Review decision: passed")).toBe("passed");
+    expect(classifyTaskContextReviewStatus("Review decision: needs_changes")).toBe("needs_changes");
+    expect(classifyTaskContextReviewStatus("Review decision: blocked")).toBe("blocked");
+    expect(classifyTaskContextReviewStatus("LGTM, no issues found")).toBe("passed");
+    expect(classifyTaskContextReviewStatus("Changes requested for missing test coverage")).toBe(
       "needs_changes"
     );
-    expect(classifyTaskRunReviewStatus("I looked at the diff and have notes")).toBeUndefined();
+    expect(classifyTaskContextReviewStatus("I looked at the diff and have notes")).toBeUndefined();
   });
 
   test("identifies server platform tools that local runtime cannot provide", () => {
@@ -111,18 +111,23 @@ describe("cli agent run client", () => {
           reason: "connector_execution_failed",
           code: "connector_disconnected_mid_run",
           message: "Connector disconnected for machine: machine-win",
+          dialogId: "dialog-failed-1",
         }, { status: 502 }),
     });
 
-    expect(result).toEqual({ exitCode: 1 });
+    expect(result).toEqual({ exitCode: 1, dialogId: "dialog-failed-1" });
     expect(output.text()).toContain("[nolo] Agent request failed: HTTP 502");
     expect(output.text()).toContain("Connector execution failed");
     expect(output.text()).toContain("Connector disconnected for machine: machine-win");
     expect(output.text()).toContain("code=connector_disconnected_mid_run");
     expect(output.text()).toContain("reason=connector_execution_failed");
+    expect(output.text()).toContain("[nolo] failed dialog: dialog-failed-1");
+    expect(output.text()).toContain(
+      'nolo agent run agent-win-codex --continue dialog-failed-1 --msg "retry"'
+    );
   });
 
-  test("prepends task-run context for HTTP agent runs", async () => {
+  test("converts task row context to subjectRefs without legacy prompt or runtime taskRun payload", async () => {
     const output = new CaptureOutput();
     const requests: Array<{ body: any }> = [];
 
@@ -135,10 +140,8 @@ describe("cli agent run client", () => {
       env: { AUTH_TOKEN: "token-123" },
       output,
       runtimeMode: "server",
-      taskRunContext: {
+      taskRowContext: {
         rowDbKey: "row-b2e06f801f-01TASK",
-        taskRunId: "taskrun-1",
-        workItemId: "frontend-filter",
         artifactIds: ["artifact-1"],
       },
       fetchImpl: async (_url, init) => {
@@ -147,22 +150,17 @@ describe("cli agent run client", () => {
       },
     });
 
-    expect(requests[0]?.body.userInput).toContain("AI-native task-run context:");
-    expect(requests[0]?.body.userInput).toContain("current task board is only the present observation and validation use case");
-    expect(requests[0]?.body.userInput).toContain("rowDbKey: row-b2e06f801f-01TASK");
-    expect(requests[0]?.body.userInput).toContain("workItemId: frontend-filter");
-    expect(requests[0]?.body.userInput).toContain("User task:\nFix the filter UI");
-    expect(requests[0]?.body.runtimeContext.taskRun).toEqual({
-      rowDbKey: "row-b2e06f801f-01TASK",
-      taskRunId: "taskrun-1",
-      workItemId: "frontend-filter",
-      artifactIds: ["artifact-1"],
+    expect(requests[0]?.body.userInput).toBe("Fix the filter UI");
+    expect(requests[0]?.body.runtimeContext.taskRun).toBeUndefined();
+    expect(requests[0]?.body.runtimeContext.subjectRefs).toContainEqual({
+      kind: "table-row",
+      id: "row-b2e06f801f-01TASK",
+      role: "task",
     });
   });
 
-  test("records task-run completion after an HTTP agent run returns a dialog", async () => {
+  test("does not write task-context completion after an HTTP agent run returns a dialog", async () => {
     const output = new CaptureOutput();
-    const writebacks: any[] = [];
 
     const result = await runAgentTurn({
       agentName: "frontend-implementer",
@@ -173,12 +171,8 @@ describe("cli agent run client", () => {
       env: { AUTH_TOKEN: "token-123" },
       output,
       runtimeMode: "server",
-      taskRunContext: {
+      taskRowContext: {
         rowDbKey: "row-b2e06f801f-01TASK",
-        workItemId: "frontend-filter",
-      },
-      taskRunRecorder: async (args) => {
-        writebacks.push(args);
       },
       fetchImpl: async () => {
         return Response.json({ content: "patched", dialogId: "dialog-1" });
@@ -186,16 +180,6 @@ describe("cli agent run client", () => {
     });
 
     expect(result).toEqual({ exitCode: 0, dialogId: "dialog-1" });
-    expect(writebacks).toHaveLength(1);
-    expect(writebacks[0]).toMatchObject({
-      status: "completed",
-      dialogId: "dialog-1",
-      resultSummary: "patched",
-    });
-    expect(writebacks[0].options.taskRunContext).toEqual({
-      rowDbKey: "row-b2e06f801f-01TASK",
-      workItemId: "frontend-filter",
-    });
   });
 
   test("sends image inputs as multimodal userInput over HTTP", async () => {
@@ -237,6 +221,7 @@ describe("cli agent run client", () => {
       category: "manual-checks",
       inheritedFromDialogKey: "dialog-user-1-dialog-2",
       parentDialogId: "dialog-2",
+      subjectDialogKey: "01SUBJECTDIALOG",
       background: true,
       noStream: true,
       timeoutMs: 600000,
@@ -261,12 +246,45 @@ describe("cli agent run client", () => {
       timeoutMs: 600000,
       stream: false,
     });
+    expect(requests[0]?.body.runtimeContext.subjectRefs).toEqual([
+      { kind: "dialog", id: "01SUBJECTDIALOG", role: "subject" },
+    ]);
     expect(result).toEqual({ exitCode: 0, dialogId: "dialog-1" });
   });
 
-  test("records background task-run handoff as running instead of completed", async () => {
+  test("sends explicit subject refs over HTTP for review evidence", async () => {
+    const output = new CaptureOutput();
+    const requests: Array<{ body: any }> = [];
+
+    await runAgentTurn({
+      agentName: "reviewer",
+      agentKey: "agent-reviewer",
+      serverUrl: "https://nolo.chat",
+      message: "Review this implementation",
+      subjectRefs: [
+        { kind: "table-row", id: "row-user-board-task", role: "subject" },
+        { kind: "dialog", id: "dialog-impl", role: "review-target" },
+        { kind: "external", id: "commit:abc123", role: "commit" },
+      ],
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "server",
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        return Response.json({ content: "queued", dialogId: "dialog-review" });
+      },
+    });
+
+    expect(requests[0]?.body.runtimeContext.subjectRefs).toEqual([
+      { kind: "table-row", id: "row-user-board-task", role: "subject" },
+      { kind: "dialog", id: "dialog-impl", role: "review-target" },
+      { kind: "external", id: "commit:abc123", role: "commit" },
+    ]);
+  });
+
+  test("does not write background handoff state", async () => {
     const output = new CaptureOutput();
-    const writebacks: any[] = [];
 
     const result = await runAgentTurn({
       agentName: "frontend-implementer",
@@ -278,12 +296,8 @@ describe("cli agent run client", () => {
       runtimeMode: "server",
       background: true,
       noStream: true,
-      taskRunContext: {
+      taskRowContext: {
         rowDbKey: "row-b2e06f801f-01TASK",
-        workItemId: "self",
-      },
-      taskRunRecorder: async (args) => {
-        writebacks.push(args);
       },
       output,
       fetchImpl: async () => {
@@ -292,11 +306,6 @@ describe("cli agent run client", () => {
     });
 
     expect(result).toEqual({ exitCode: 0, dialogId: "dialog-bg" });
-    expect(writebacks).toHaveLength(1);
-    expect(writebacks[0]).toMatchObject({
-      status: "running",
-      dialogId: "dialog-bg",
-    });
   });
 
   test("runs forced local turns through the injected runtime adapter without HTTP", async () => {
@@ -571,12 +580,12 @@ describe("cli agent run client", () => {
       round: 1,
       tool: "execShell",
       summary: expect.stringContaining("exit=0"),
+      metadata: { exitCode: 0 },
     });
   });
 
-  test("passes local tool evidence to task-run writeback", async () => {
+  test("does not pass local tool evidence to an external writeback path", async () => {
     const output = new CaptureOutput();
-    const writebacks: any[] = [];
     let completeCalls = 0;
 
     const result = await runAgentTurn({
@@ -588,12 +597,8 @@ describe("cli agent run client", () => {
       env: { AUTH_TOKEN: "token-123" },
       output,
       runtimeMode: "local",
-      taskRunContext: {
+      taskRowContext: {
         rowDbKey: "row-b2e06f801f-01TASK",
-        workItemId: "self",
-      },
-      taskRunRecorder: async (args) => {
-        writebacks.push(args);
       },
       localRuntimeAdapter: {
         host: "cli",
@@ -630,21 +635,10 @@ describe("cli agent run client", () => {
     });
 
     expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
-    expect(writebacks).toHaveLength(1);
-    expect(writebacks[0].toolEvidence).toEqual({
-      toolsUsed: ["readFile"],
-      summary: {
-        callCount: 1,
-        resultCount: 1,
-        errorCount: 0,
-        rounds: 1,
-      },
-    });
   });
 
-  test("records local background task-run handoff as running instead of completed", async () => {
+  test("does not write local background handoff state", async () => {
     const output = new CaptureOutput();
-    const writebacks: any[] = [];
 
     const result = await runAgentTurn({
       agentName: "frontend",
@@ -656,12 +650,8 @@ describe("cli agent run client", () => {
       output,
       runtimeMode: "local",
       background: true,
-      taskRunContext: {
+      taskRowContext: {
         rowDbKey: "row-b2e06f801f-01TASK",
-        workItemId: "self",
-      },
-      taskRunRecorder: async (args) => {
-        writebacks.push(args);
       },
       localRuntimeAdapter: {
         host: "cli",
@@ -685,12 +675,6 @@ describe("cli agent run client", () => {
     });
 
     expect(result).toEqual({ exitCode: 0, dialogId: "dialog-local-bg" });
-    expect(writebacks).toHaveLength(1);
-    expect(writebacks[0]).toMatchObject({
-      status: "running",
-      dialogId: "dialog-local-bg",
-    });
-    expect(writebacks[0].resultSummary).toBeUndefined();
   });
 
   test("auto mode prefers a working local runtime before HTTP", async () => {
@@ -887,6 +871,58 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("pm > server ok");
   });
 
+  test("auto mode keeps local runtime for CLI provider agents even when they declare platform tools", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: string[] = [];
+    let providerCalled = false;
+
+    const result = await runAgentTurn({
+      agentName: "frontend-implementer",
+      agentKey: "frontend-implementer",
+      serverUrl: "https://nolo.chat",
+      message: "polish notifications",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "auto",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["leveldb-agent-config", "local-provider", "local-tools"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "AGY",
+          prompt: "Implement frontend tasks.",
+          provider: "agy",
+          cliProvider: "agy",
+          toolNames: ["streamParallelAgents", "queryTableRows"],
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-agy-auto-local" }),
+        resolveProvider: async () => ({
+          model: "agy",
+          complete: async () => {
+            providerCalled = true;
+            return { content: "agy local ok", model: "agy" };
+          },
+        }),
+        executeTool: async () => {
+          throw new Error("no tools expected");
+        },
+      },
+      fetchImpl: async (url) => {
+        httpCalls.push(String(url));
+        return Response.json({ content: "server" });
+      },
+    });
+
+    expect(providerCalled).toBe(true);
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-agy-auto-local" });
+    expect(httpCalls).toEqual([]);
+    expect(output.text()).not.toContain("skipping local runtime");
+    expect(output.text()).toContain("frontend-implementer -> working locally");
+    expect(output.text()).toContain("frontend-implementer > agy local ok");
+  });
+
   test("auto mode does not skip monthly Mimo when a local shell cwd is already bound", async () => {
     const output = new CaptureOutput();
     const httpCalls: string[] = [];
@@ -1064,7 +1100,7 @@ describe("cli agent run client", () => {
           model: "fake-local",
           runtimeToolPolicy: {
             version: 1,
-            agentTools: ["queryTableRows", "taskRun"],
+            agentTools: ["queryTableRows", "streamParallelAgents"],
             runtimeTools: ["execShell"],
           },
         }),
@@ -1089,7 +1125,7 @@ describe("cli agent run client", () => {
     expect(httpCalls).toHaveLength(1);
     expect(httpCalls[0]?.body.agentKey).toBe("agent-policy-platform-tools");
     expect(output.text()).toContain("auto runtime: skipping local runtime");
-    expect(output.text()).toContain("queryTableRows, taskRun");
+    expect(output.text()).toContain("queryTableRows, streamParallelAgents");
   });
 
   test("auto mode skips known platform agents when local config cannot be read", async () => {