nolo-cli 0.1.32 → 0.1.33

package/cli/tableMutationCommands.ts

@@ -1,266 +0,0 @@
-import type { OutputLike } from "./cliIoTypes";
-import {
-  formatOutput,
-  hasFlag,
-  parseJsonOption,
-  parseJwtTenantId,
-  parseOutputMode,
-  parseTableArg,
-  readOption,
-  resolveAuthToken,
-  resolveServerUrl,
-  type EnvLike,
-} from "./tableQueryParsing";
-import { assertTableSchemaWriteAllowed } from "./tableDataSafety";
-
-type TableMutationDeps = {
-  env?: EnvLike;
-  output?: OutputLike;
-  fetchImpl?: typeof fetch;
-};
-
-function usage() {
-  return [
-    "Usage:",
-    "  nolo table data --table <tableId|metaKey> [--tenant-id <userId>] [--action <add-column|add-row|add-rows|update-row|update-rows|delete-row|delete-rows>] [payload flags]",
-    "",
-  ].join("\n");
-}
-
-function resolveRowTarget(raw?: string) {
-  if (!raw?.trim()) return {};
-  const trimmed = raw.trim();
-  if (trimmed.startsWith("row-")) {
-    return { dbKey: trimmed };
-  }
-  return { rowId: trimmed };
-}
-
-async function readTableMeta(args: {
-  authToken: string;
-  dbKey: string;
-  fetchImpl: typeof fetch;
-  serverUrl: string;
-}) {
-  const response = await args.fetchImpl(`${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.dbKey)}`, {
-    method: "GET",
-    headers: {
-      Authorization: `Bearer ${args.authToken}`,
-    },
-  });
-  const data = await response.json().catch(() => ({}));
-  if (!response.ok) {
-    throw new Error(`failed to read table meta (${response.status}): ${JSON.stringify(data)}`);
-  }
-  return data?.data ?? data;
-}
-
-async function postTableAction(args: {
-  authToken: string;
-  body: Record<string, unknown>;
-  fetchImpl: typeof fetch;
-  path: string;
-  serverUrl: string;
-}) {
-  const response = await args.fetchImpl(`${args.serverUrl}${args.path}`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${args.authToken}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(args.body),
-  });
-  const data = await response.json().catch(() => ({}));
-  if (!response.ok) {
-    throw new Error(`${args.path} failed (${response.status}): ${JSON.stringify(data)}`);
-  }
-  return data?.rawData ?? data;
-}
-
-function buildMutationRequest(args: {
-  action: string;
-  rawArgs: string[];
-  tableId: string;
-  tenantId: string;
-}) {
-  const { action, rawArgs, tableId, tenantId } = args;
-  switch (action) {
-    case "add-column": {
-      const name = readOption(rawArgs, "--name")?.trim();
-      if (!name) throw new Error("--name is required.");
-      const options = parseJsonOption<string[]>(rawArgs, "--options");
-      return {
-        path: "/api/table/add-column",
-        body: {
-          tenantId,
-          tableId,
-          name,
-          ...(readOption(rawArgs, "--label") ? { label: readOption(rawArgs, "--label") } : {}),
-          ...(readOption(rawArgs, "--type") ? { type: readOption(rawArgs, "--type") } : {}),
-          ...(options ? { options } : {}),
-        },
-      };
-    }
-    case "add-row": {
-      const values = parseJsonOption<Record<string, unknown>>(rawArgs, "--values");
-      if (!values || Array.isArray(values)) {
-        throw new Error("--values must be a JSON object.");
-      }
-      return {
-        path: "/api/table/add-row",
-        body: { tenantId, tableId, values },
-      };
-    }
-    case "add-rows": {
-      const rows = parseJsonOption<Array<Record<string, unknown>>>(rawArgs, "--rows");
-      if (!Array.isArray(rows) || rows.length === 0) {
-        throw new Error("--rows must be a non-empty JSON array.");
-      }
-      return {
-        path: "/api/table/add-rows",
-        body: { tenantId, tableId, rows },
-      };
-    }
-    case "update-row": {
-      const target = resolveRowTarget(readOption(rawArgs, "--row"));
-      const changes = parseJsonOption<Record<string, unknown>>(rawArgs, "--changes");
-      if ((!target.rowId && !target.dbKey) || !changes || Array.isArray(changes)) {
-        throw new Error("--row and --changes are required, and --changes must be an object.");
-      }
-      return {
-        path: "/api/table/update-row",
-        body: { tenantId, tableId, ...target, changes },
-      };
-    }
-    case "update-rows": {
-      const updates = parseJsonOption<Array<Record<string, unknown>>>(rawArgs, "--updates");
-      if (!Array.isArray(updates) || updates.length === 0) {
-        throw new Error("--updates must be a non-empty JSON array.");
-      }
-      return {
-        path: "/api/table/update-rows",
-        body: { tenantId, tableId, updates },
-      };
-    }
-    case "delete-row": {
-      const target = resolveRowTarget(readOption(rawArgs, "--row"));
-      if (!target.rowId && !target.dbKey) {
-        throw new Error("--row is required and may be rowId or row dbKey.");
-      }
-      return {
-        path: "/api/table/delete-row",
-        body: { tenantId, tableId, ...target },
-      };
-    }
-    case "delete-rows": {
-      const rowIds = parseJsonOption<string[]>(rawArgs, "--row-ids");
-      const dbKeys = parseJsonOption<string[]>(rawArgs, "--row-dbkeys");
-      if ((!Array.isArray(rowIds) || rowIds.length === 0) && (!Array.isArray(dbKeys) || dbKeys.length === 0)) {
-        throw new Error("--row-ids or --row-dbkeys must provide a non-empty JSON array.");
-      }
-      return {
-        path: "/api/table/delete-rows",
-        body: {
-          tenantId,
-          tableId,
-          ...(Array.isArray(rowIds) && rowIds.length > 0 ? { rowIds } : {}),
-          ...(Array.isArray(dbKeys) && dbKeys.length > 0 ? { dbKeys } : {}),
-        },
-      };
-    }
-    default:
-      throw new Error(`unsupported action: ${action}`);
-  }
-}
-
-export async function runTableDataCommand(args: string[], deps: TableMutationDeps = {}) {
-  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(usage());
-    return 0;
-  }
-
-  const action = (readOption(args, "--action") || "query").trim();
-  const outputMode = parseOutputMode(readOption(args, "--output"));
-  let tableArg: { tenantId?: string; tableId?: string };
-  try {
-    tableArg = parseTableArg(readOption(args, "--table"));
-    assertTableSchemaWriteAllowed({
-      action,
-      allowSchemaWrite: hasFlag(args, "--schema-write-ok"),
-    });
-  } catch (error) {
-    output.write(`[nolo] table data failed: ${error instanceof Error ? error.message : String(error)}\n`);
-    return 1;
-  }
-
-  const authToken = resolveAuthToken(args, env);
-  const tenantId = readOption(args, "--tenant-id") || tableArg.tenantId || env.USER_ID || parseJwtTenantId(authToken);
-  const tableId = tableArg.tableId;
-  const tableDbKey = tenantId && tableId ? `meta-${tenantId}-${tableId}` : "";
-  if (!authToken) {
-    output.write("[nolo] table data failed: AUTH_TOKEN is required.\n");
-    return 1;
-  }
-  if (!tenantId || !tableId || !tableDbKey) {
-    output.write(usage());
-    return 1;
-  }
-
-  const serverUrl = resolveServerUrl(args, env);
-  try {
-    const tableMeta = await readTableMeta({
-      authToken,
-      dbKey: tableDbKey,
-      fetchImpl,
-      serverUrl,
-    });
-    if (!tableMeta || tableMeta.type !== "table") {
-      throw new Error(`table definition not found: ${tableDbKey}`);
-    }
-
-    const request = buildMutationRequest({
-      action,
-      rawArgs: args,
-      tableId,
-      tenantId,
-    });
-    const result = await postTableAction({
-      authToken,
-      body: request.body,
-      fetchImpl,
-      path: request.path,
-      serverUrl,
-    });
-    const envelope = {
-      ok: true,
-      action,
-      baseUrl: serverUrl,
-      tenantId,
-      tableId,
-      tableDbKey,
-      tableName: tableMeta.displayName ?? null,
-      result,
-    };
-    output.write(`${formatOutput({ envelope, rawData: result, mode: outputMode })}\n`);
-    return 0;
-  } catch (error) {
-    output.write(`[nolo] table data failed: ${error instanceof Error ? error.message : String(error)}\n`);
-    return 1;
-  }
-}
-
-function withAction(action: string) {
-  return (args: string[], deps: TableMutationDeps = {}) =>
-    runTableDataCommand(["--action", action, ...args], deps);
-}
-
-export const runTableAddColumnCommand = withAction("add-column");
-export const runTableAddRowCommand = withAction("add-row");
-export const runTableAddRowsCommand = withAction("add-rows");
-export const runTableUpdateRowCommand = withAction("update-row");
-export const runTableUpdateRowsCommand = withAction("update-rows");
-export const runTableDeleteRowCommand = withAction("delete-row");
-export const runTableDeleteRowsCommand = withAction("delete-rows");

package/cli/tableQueryParsing.ts

@@ -1,90 +0,0 @@
-import {
-  decodeJwtPayload,
-  hasFlag as hasCliFlag,
-  readCliOptionValue,
-  resolveAuthTokenFromArgs,
-  resolveServerUrlFromArgs,
-} from "./cliEnvHelpers";
-import {
-  formatTableDataOutput,
-  parseTableDataOutputMode,
-  type TableDataOutputMode,
-} from "./tableDataOutput";
-
-export type EnvLike = Record<string, string | undefined>;
-export type OutputMode = TableDataOutputMode;
-
-export function readOption(args: string[], flag: string): string {
-  return readCliOptionValue(args, flag);
-}
-
-export function hasFlag(args: string[], flag: string): boolean {
-  return hasCliFlag(args, flag);
-}
-
-export function parseJsonOption<T>(args: string[], flag: string): T | undefined {
-  const raw = readOption(args, flag);
-  if (!raw) return undefined;
-  try {
-    return JSON.parse(raw) as T;
-  } catch (error) {
-    throw new Error(`${flag} must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-export function parseJsonOptionAlias<T>(
-  args: string[],
-  primaryFlag: string,
-  aliasFlag: string,
-): T | undefined {
-  const primary = readOption(args, primaryFlag);
-  const alias = readOption(args, aliasFlag);
-  const raw = primary || alias;
-  if (!raw) return undefined;
-  try {
-    return JSON.parse(raw) as T;
-  } catch (error) {
-    const usedFlag = primary ? primaryFlag : aliasFlag;
-    throw new Error(`${usedFlag} must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-export function parseOutputMode(raw: string): OutputMode {
-  return parseTableDataOutputMode(raw);
-}
-
-export function parseTableArg(raw: string): { tenantId?: string; tableId?: string } {
-  const trimmed = raw.trim();
-  if (!trimmed) return {};
-  if (!trimmed.startsWith("meta-")) return { tableId: trimmed };
-  const parts = trimmed.split("-");
-  return {
-    tenantId: parts[1],
-    tableId: parts.slice(2).join("-"),
-  };
-}
-
-export function resolveServerUrl(args: string[], env: EnvLike): string {
-  return resolveServerUrlFromArgs(args, env);
-}
-
-export function resolveAuthToken(args: string[], env: EnvLike): string {
-  return resolveAuthTokenFromArgs(args, env);
-}
-
-export function parseJwtTenantId(token: string): string | undefined {
-  const parsed = decodeJwtPayload(token);
-  return typeof parsed?.userId === "string"
-    ? parsed.userId
-    : typeof parsed?.sub === "string"
-      ? parsed.sub
-      : undefined;
-}
-
-export function formatOutput(input: { envelope: any; rawData: any; mode: OutputMode }): string {
-  return formatTableDataOutput({
-    envelope: input.envelope,
-    result: input.rawData,
-    mode: input.mode,
-  });
-}

package/cli/tableQueryRequest.ts

@@ -1,53 +0,0 @@
-import { includeTableActivityColumns } from "../render/table/activityColumns";
-import { readOption } from "./tableQueryParsing";
-
-export type TableQueryFilters = Record<string, unknown>;
-
-export type TableQueryRequestInput = {
-  tenantId: string;
-  tableId: string;
-  filters?: TableQueryFilters;
-  columns?: string[];
-  includeActivity?: boolean;
-  includeBaseFields?: boolean;
-  hasSingleRowShortcut?: boolean;
-  limit?: string | number;
-  offset?: string | number;
-  sortBy?: string;
-  sortOrder?: string;
-};
-
-export function mergeQueryShortcutFilters(
-  args: string[],
-  filters: TableQueryFilters | undefined,
-): TableQueryFilters | undefined {
-  const row = readOption(args, "--row") || readOption(args, "--row-id");
-  const rowDbKey = readOption(args, "--row-dbkey");
-  const shortcutFilters: TableQueryFilters = {};
-  if (row) {
-    if (row.startsWith("row-")) shortcutFilters.dbKey = row;
-    else shortcutFilters.rowId = row;
-  }
-  if (rowDbKey) shortcutFilters.dbKey = rowDbKey;
-  if (Object.keys(shortcutFilters).length === 0) return filters;
-  return {
-    ...(filters ?? {}),
-    ...shortcutFilters,
-  };
-}
-
-export function buildTableQueryRequest(input: TableQueryRequestInput) {
-  return {
-    tenantId: input.tenantId,
-    tableId: input.tableId,
-    filters: input.filters ?? {},
-    columns: input.includeActivity
-      ? includeTableActivityColumns(input.columns)
-      : input.columns,
-    includeBaseFields: input.includeBaseFields ?? true,
-    limit: Number(input.limit || (input.hasSingleRowShortcut ? 1 : 20)),
-    offset: Number(input.offset || 0),
-    sortBy: input.sortBy || "updatedAt",
-    sortOrder: input.sortOrder === "asc" ? "asc" : "desc",
-  };
-}

package/cli/taskRunActions.ts

@@ -1,122 +0,0 @@
-import { csv, optional, optionalJson, required } from "./taskRunParsing";
-
-export function buildBody(command: string, args: string[]) {
-  const dbKey = required(args, "--row-dbkey");
-  if (command === "read-context" || command === "readTaskContext") {
-    return { action: "readTaskContext", dbKey };
-  }
-  if (command === "claim-work-item" || command === "claimWorkItem") {
-    return {
-      action: "claimWorkItem",
-      dbKey,
-      workItemId: required(args, "--work-item-id"),
-      agentKey: required(args, "--agent-key"),
-      role: optional(args, "--role"),
-    };
-  }
-  if (command === "record-agent-run" || command === "recordAgentRun") {
-    const toolTraceSummary = optionalJson(args, "--tool-trace-summary");
-    return {
-      action: "recordAgentRun",
-      dbKey,
-      ...(optional(args, "--run-id") ? { runId: optional(args, "--run-id") } : {}),
-      agentKey: required(args, "--agent-key"),
-      ...(optional(args, "--role") ? { role: optional(args, "--role") } : {}),
-      runStatus: required(args, "--run-status"),
-      ...(optional(args, "--work-item-id") ? { workItemId: optional(args, "--work-item-id") } : {}),
-      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
-      ...(optional(args, "--result-summary") ? { resultSummary: optional(args, "--result-summary") } : {}),
-      ...(optional(args, "--error-code") ? { errorCode: optional(args, "--error-code") } : {}),
-      ...(optional(args, "--tools-used") ? { toolsUsed: csv(optional(args, "--tools-used")!) } : {}),
-      ...(toolTraceSummary ? { toolTraceSummary } : {}),
-    };
-  }
-  if (command === "set-blocker" || command === "setBlocker") {
-    return {
-      action: "setBlocker",
-      dbKey,
-      workItemId: optional(args, "--work-item-id"),
-      blocker: {
-        layer: required(args, "--layer"),
-        code: required(args, "--code"),
-        message: required(args, "--message"),
-      },
-    };
-  }
-  if (command === "clear-blocker" || command === "clearBlocker") {
-    return {
-      action: "clearBlocker",
-      dbKey,
-      blockerId: required(args, "--blocker-id"),
-      workItemId: optional(args, "--work-item-id"),
-    };
-  }
-  if (command === "submit-outcome" || command === "submitOutcome") {
-    return {
-      action: "submitOutcome",
-      dbKey,
-      workItemId: required(args, "--work-item-id"),
-      summary: required(args, "--summary"),
-      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
-      ...(optional(args, "--artifact-ids") ? { artifactIds: csv(optional(args, "--artifact-ids")!) } : {}),
-    };
-  }
-  if (command === "request-review" || command === "requestReview") {
-    return {
-      action: "requestReview",
-      dbKey,
-      workItemId: optional(args, "--work-item-id"),
-      reviewerAgentKey: required(args, "--reviewer-agent-key"),
-      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
-      ...(optional(args, "--message") ? { message: optional(args, "--message") } : {}),
-      ...(optional(args, "--artifact-ids") ? { artifactIds: csv(optional(args, "--artifact-ids")!) } : {}),
-    };
-  }
-  if (command === "record-review" || command === "recordReview") {
-    return {
-      action: "recordReview",
-      dbKey,
-      ...(optional(args, "--work-item-id") ? { workItemId: optional(args, "--work-item-id") } : {}),
-      reviewStatus: required(args, "--review-status"),
-      ...(optional(args, "--reviewer-agent-key")
-        ? { reviewerAgentKey: optional(args, "--reviewer-agent-key") }
-        : {}),
-      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
-      ...(optional(args, "--findings") ? { findings: optional(args, "--findings") } : {}),
-      ...(optional(args, "--artifact-ids") ? { artifactIds: csv(optional(args, "--artifact-ids")!) } : {}),
-    };
-  }
-  if (
-    command === "close-work-item" ||
-    command === "complete-work-item" ||
-    command === "closeWorkItem" ||
-    command === "completeWorkItem"
-  ) {
-    return {
-      action: "closeWorkItem",
-      dbKey,
-      workItemId: required(args, "--work-item-id"),
-      summary: required(args, "--summary"),
-      ...(optional(args, "--reason") ? { reason: optional(args, "--reason") } : {}),
-      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
-      ...(optional(args, "--artifact-ids") ? { artifactIds: csv(optional(args, "--artifact-ids")!) } : {}),
-    };
-  }
-  throw new Error(`Unknown task-run command: ${command}`);
-}
-
-export function usage() {
-  return [
-    "Usage:",
-    "  nolo task-run read-context --row-dbkey <row>",
-    "  nolo task-run claim-work-item --row-dbkey <row> --work-item-id <id> --agent-key <agent> [--role <role>]",
-    "  nolo task-run record-agent-run --row-dbkey <row> --agent-key <agent> --run-status <status> [--tools-used <csv>]",
-    "  nolo task-run set-blocker --row-dbkey <row> [--work-item-id <id>] --layer <layer> --code <code> --message <message>",
-    "  nolo task-run clear-blocker --row-dbkey <row> --blocker-id <id> [--work-item-id <id>]",
-    "  nolo task-run submit-outcome --row-dbkey <row> --work-item-id <id> --summary <summary> [--dialog-id <id>]",
-    "  nolo task-run request-review --row-dbkey <row> --reviewer-agent-key <agent> [--work-item-id <id>]",
-    "  nolo task-run record-review --row-dbkey <row> [--work-item-id <id>] --review-status <passed|needs_changes|blocked> [--findings <text>]",
-    "  nolo task-run close-work-item --row-dbkey <row> --work-item-id <id> --summary <summary>",
-    "",
-  ].join("\n");
-}

package/cli/taskRunParsing.ts

@@ -1,86 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-import {
-  readCliOptionValue,
-  resolveAuthTokenFromArgs,
-  resolveServerUrlFromArgs,
-} from "./cliEnvHelpers";
-
-export type EnvLike = Record<string, string | undefined>;
-
-export function parseEnvFile(path: string): EnvLike {
-  if (!path || !existsSync(path)) return {};
-  const parsed: EnvLike = {};
-  for (const rawLine of readFileSync(path, "utf8").split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#")) continue;
-    const index = line.indexOf("=");
-    if (index <= 0) continue;
-    const key = line.slice(0, index).trim();
-    let value = line.slice(index + 1).trim();
-    if (
-      (value.startsWith('"') && value.endsWith('"')) ||
-      (value.startsWith("'") && value.endsWith("'"))
-    ) {
-      value = value.slice(1, -1);
-    }
-    if (key) parsed[key] = value;
-  }
-  return parsed;
-}
-
-export function loadTaskRunEnv(
-  env: EnvLike,
-  options: { includeDefaultEnvFiles?: boolean } = {},
-) {
-  const envFileCandidates = [
-    env.NOLO_TASK_RUN_ENV_FILE,
-    env.NOLO_MACHINE_ENV_FILE,
-    ...(options.includeDefaultEnvFiles
-      ? ["/etc/nolo/machine-runner.env", join(homedir(), ".nolo", "machine-runner.env")]
-      : []),
-  ].filter((path): path is string => Boolean(path));
-  const fileEnv = Object.assign({}, ...envFileCandidates.map(parseEnvFile));
-  return { ...fileEnv, ...env };
-}
-
-export function readOption(args: string[], flag: string) {
-  return readCliOptionValue(args, flag);
-}
-
-export function csv(raw: string) {
-  return raw.split(",").map((item) => item.trim()).filter(Boolean);
-}
-
-export function required(args: string[], flag: string) {
-  const value = readOption(args, flag).trim();
-  if (!value) throw new Error(`${flag} is required`);
-  return value;
-}
-
-export function optional(args: string[], flag: string) {
-  const value = readOption(args, flag).trim();
-  return value || undefined;
-}
-
-export function optionalJson(args: string[], flag: string) {
-  const value = optional(args, flag);
-  if (!value) return undefined;
-  try {
-    return JSON.parse(value);
-  } catch (error) {
-    throw new Error(
-      `${flag} must be valid JSON: ${error instanceof Error ? error.message : String(error)}`,
-    );
-  }
-}
-
-export function resolveServerUrl(args: string[], env: EnvLike) {
-  return resolveServerUrlFromArgs(args, env);
-}
-
-export function resolveAuthToken(args: string[], env: EnvLike) {
-  return resolveAuthTokenFromArgs(args, env);
-}

package/cli/taskRunPromptShared.ts

@@ -1,55 +0,0 @@
-export type TaskRunPromptContext = {
-  rowDbKey: string;
-  taskRunId?: string;
-  workItemId?: string;
-  artifactIds?: string[];
-};
-
-export type TaskRunPromptRuntime = "cli" | "server-tool";
-
-function buildTaskRunPromptRuntimeLines(runtime: TaskRunPromptRuntime): string[] {
-  if (runtime === "cli") {
-    return [
-      "- When you create, update, hand off, block, or review work, update the task context with `bun run task:run -- ...`.",
-      "- If this turn already includes a server TaskRun preflight snapshot, use that snapshot directly for read-only reporting or planning.",
-    ];
-  }
-
-  return [
-    "- Use the server-side `taskRun` tool when you create, update, hand off, block, or review work.",
-    "- If this turn already includes a server TaskRun preflight snapshot, use that snapshot directly for read-only reporting or planning. Otherwise start with `readTaskContext`.",
-    "- Use primitive actions such as `upsertWorkItem`, `claimWorkItem`, `openDialog`, `setBlocker`, `requestReview`, `recordReview`, `submitOutcome`, and `closeWorkItem`.",
-    "- Do not emulate `taskRun` by directly editing `meta.taskRun` with table tools. Table tools are only for human-readable columns such as status, progress, and result.",
-    "- Do not delegate `taskRun` state writes through `streamParallelAgents`. The coordinating agent must write task-run state itself, then delegate implementation or review work if needed.",
-    "- If the `taskRun` tool is not exposed at runtime, report that as an infrastructure blocker instead of inventing a compatible-looking meta shape.",
-    "- Keep actions generic and configurable. Do not invent hardcoded workflow verbs like `handoff_frontend` when an `openDialog` or work item update is enough.",
-  ];
-}
-
-export function buildTaskRunPromptBlock(
-  context: TaskRunPromptContext,
-  runtime: TaskRunPromptRuntime
-): string {
-  const artifactIds = context.artifactIds?.filter(Boolean) ?? [];
-  return [
-    "AI-native task-run context:",
-    "- This system is AI-native. The current task board is only the present observation and validation use case; different users, companies, and workflows may use different task owners later.",
-    "- Treat the task row meta as the durable execution context. Do not infer branch, runner, handoff, review, or blocker state from chat history alone.",
-    `- rowDbKey: ${context.rowDbKey}`,
-    ...(context.taskRunId ? [`- taskRunId: ${context.taskRunId}`] : []),
-    ...(context.workItemId ? [`- workItemId: ${context.workItemId}`] : []),
-    ...(artifactIds.length ? [`- artifactIds: ${artifactIds.join(",")}`] : []),
-    "- Handoff rule: start from the durable task context, then inspect existing refs such as workItems.dialogIds, workItems.outcome, review.dialogId, activityRefs, agentRuns.dialogId/resultSummary, and artifactRefs. Use dialog read/search for exact evidence.",
-    ...buildTaskRunPromptRuntimeLines(runtime),
-    "- Keep long reasoning and logs in the dialog; record only resumable references in task row meta.",
-  ].join("\n");
-}
-
-export function prependTaskRunPromptForRuntime(
-  message: string,
-  context: TaskRunPromptContext | undefined,
-  runtime: TaskRunPromptRuntime
-): string {
-  if (!context?.rowDbKey) return message;
-  return `${buildTaskRunPromptBlock(context, runtime)}\n\nUser task:\n${message}`;
-}