nolo-cli 0.1.40 → 0.1.42

package/cli/docCreateCommands.ts

@@ -0,0 +1,345 @@
+import { NOLO_CLUSTER_SERVERS } from "../database/config";
+import { DEFAULT_LOCAL_API_ORIGIN } from "../core/localOrigins";
+import { buildSkillSummaryMarker } from "../ai/skills/skillSummaryMarker";
+import { writeAgentRecord } from "./agentRecordHelpers";
+import {
+  parseUserIdFromAuthToken,
+  readOption,
+  resolveAuthToken,
+  resolveServerUrl,
+} from "./cliEnvHelpers";
+import {
+  buildPageKey,
+  buildPageRecord,
+  createPageId,
+  readBodyArg,
+} from "./docPageHelpers";
+import {
+  buildSkillDocId,
+  buildSkillPageKey,
+  buildSkillPageRecord,
+  parseJsonArg,
+} from "./docSkillHelpers";
+import { ensurePageAttachedToSpace } from "./docSpaceHelpers";
+import { findPotentialSecrets, formatSecretFindings } from "./secretScan";
+
+type DocKind = "page" | "skill";
+
+type DocCreateDeps = {
+  env: NodeJS.ProcessEnv;
+};
+
+const VALUE_FLAGS = new Set([
+  "--title",
+  "--description",
+  "--body",
+  "--body-file",
+  "--id",
+  "--space",
+  "--sync",
+  "--server",
+  "--server-url",
+  "--token",
+  "--tools",
+  "--required-skills",
+  "--recommended-skills",
+  "--preferred-agents",
+  "--trigger-mode",
+  "--budget-tier",
+  "--prompt-patch",
+  "--kind",
+]);
+
+function hasHelpArg(args: string[]) {
+  return args.includes("--help") || args.includes("-h");
+}
+
+function hasFlag(args: string[], flag: string) {
+  return args.includes(flag);
+}
+
+function printDocCreateUsage(output: { write(chunk: string): unknown }) {
+  output.write(`Usage:
+  nolo doc create --title <title> [--body ... | --body-file path] [--id ...] [--space ...]
+
+Options:
+  --description <text>      Optional page description stored in meta.
+  --sync local,main,us      Choose write targets. Values may also be full URLs.
+  --local-only              Write only to the local server target.
+  --no-local                Exclude local targets when --sync includes them.
+  --dry-run                 Build and validate without writing.
+  --json                    Print machine-readable JSON.
+  --allow-secrets           Allow bodies that look like credentials.
+  --server <url>            Default write target when --sync is omitted.
+  --token <jwt>             Auth token. Required for writes.
+`);
+}
+
+function printSkillDocCreateUsage(output: { write(chunk: string): unknown }) {
+  output.write(`Usage:
+  nolo skill-doc create --title <title> --description <text> [--body ... | --body-file path]
+  nolo skill create-doc --title <title> --description <text> [--body ... | --body-file path]
+
+Options:
+  --tools '["readDoc"]'                 Tool names this skill expects.
+  --required-skills '["skill-a"]'       Required skill references.
+  --recommended-skills '["skill-b"]'    Recommended skill references.
+  --preferred-agents '["agent-key"]'    Preferred agent keys.
+  --trigger-mode explicit|required|recommended
+  --budget-tier low|medium|high
+  --prompt-patch <text>
+  --page | --kind page                  Create a normal page instead of a skill-backed page.
+  --sync local,main,us                  Choose write targets. Values may also be full URLs.
+  --dry-run                             Build and validate without writing.
+  --json                                Print machine-readable JSON.
+  --token <jwt>                         Auth token. Required for writes.
+`);
+}
+
+function normalizeBaseUrl(base: string) {
+  return base.trim().replace(/\/+$/, "");
+}
+
+function localBaseFromEnv(env: NodeJS.ProcessEnv) {
+  return normalizeBaseUrl(env.SCRIPT_LOCAL_BASE_URL || DEFAULT_LOCAL_API_ORIGIN);
+}
+
+function targetToBase(target: string, env: NodeJS.ProcessEnv) {
+  const normalized = target.trim().toLowerCase();
+  if (normalized === "local") return localBaseFromEnv(env);
+  if (normalized === "main") return normalizeBaseUrl(NOLO_CLUSTER_SERVERS[0]);
+  if (normalized === "us") return normalizeBaseUrl(NOLO_CLUSTER_SERVERS[1]);
+  return normalizeBaseUrl(target);
+}
+
+function parseSyncTargets(raw: string | undefined, env: NodeJS.ProcessEnv) {
+  if (!raw) return undefined;
+  return raw
+    .split(",")
+    .map((value) => value.trim())
+    .filter(Boolean)
+    .filter((value) => value !== "none")
+    .map((value) => targetToBase(value, env));
+}
+
+function isLocalBaseUrl(baseUrl: string) {
+  try {
+    const hostname = new URL(baseUrl).hostname;
+    return hostname === "localhost" || hostname === "127.0.0.1";
+  } catch {
+    return false;
+  }
+}
+
+function resolveWriteTargets(args: string[], env: NodeJS.ProcessEnv) {
+  const explicitSync = parseSyncTargets(readOption(args, "--sync"), env);
+  const targets = hasFlag(args, "--local-only")
+    ? [localBaseFromEnv(env)]
+    : explicitSync ?? [resolveServerUrl(args, env)];
+  const filtered = hasFlag(args, "--no-local")
+    ? targets.filter((target) => !isLocalBaseUrl(target))
+    : targets;
+  return Array.from(new Set(filtered.map(normalizeBaseUrl)));
+}
+
+function readTitle(args: string[]) {
+  return readOption(args, "--title") ?? args.find((value, index) => {
+    if (index === 0) return false;
+    if (VALUE_FLAGS.has(args[index - 1])) return false;
+    return !value.startsWith("-");
+  });
+}
+
+function resolveDocKind(args: string[], fallback: DocKind): DocKind {
+  if (hasFlag(args, "--page") || readOption(args, "--kind") === "page") return "page";
+  return fallback;
+}
+
+function requireTokenUser(args: string[], env: NodeJS.ProcessEnv, dryRun: boolean) {
+  const authToken = resolveAuthToken(args, env);
+  const userId = parseUserIdFromAuthToken(authToken) || env.USER_ID || "";
+  if (!authToken && !dryRun) {
+    throw new Error("doc create requires an auth token. Pass --token or set AUTH_TOKEN.");
+  }
+  if (!userId && !dryRun) {
+    throw new Error("auth token does not contain userId. Pass a user-scoped token.");
+  }
+  return {
+    authToken,
+    userId: userId || "dry-run",
+  };
+}
+
+async function writePageRecord(args: {
+  authToken: string;
+  dbKey: string;
+  record: Record<string, any>;
+  serverUrl: string;
+  spaceId: string | null;
+  title: string;
+  userId: string;
+  skillSummary?: Record<string, any> | null;
+}) {
+  await writeAgentRecord({
+    agentKey: args.dbKey,
+    authToken: args.authToken,
+    fetchImpl: fetch,
+    serverUrl: args.serverUrl,
+    userId: args.userId,
+    record: args.record,
+  });
+  if (args.spaceId) {
+    await ensurePageAttachedToSpace({
+      baseUrl: args.serverUrl,
+      userId: args.userId,
+      authToken: args.authToken,
+      spaceId: args.spaceId,
+      contentKey: args.dbKey,
+      title: args.title,
+      skillSummary: args.skillSummary,
+    });
+  }
+}
+
+async function runCreateCommand(
+  args: string[],
+  deps: DocCreateDeps,
+  options: { defaultKind: DocKind; usage: (output: { write(chunk: string): unknown }) => void }
+) {
+  if (hasHelpArg(args)) {
+    options.usage(process.stdout);
+    return 0;
+  }
+
+  const title = readTitle(args);
+  const description = readOption(args, "--description") ?? "";
+  const docKind = resolveDocKind(args, options.defaultKind);
+  const shouldDryRun = hasFlag(args, "--dry-run");
+  const shouldOutputJson = hasFlag(args, "--json");
+  const allowSecrets = hasFlag(args, "--allow-secrets");
+  const spaceId = readOption(args, "--space") ?? null;
+
+  if (!title || (docKind === "skill" && !description)) {
+    options.usage(process.stderr);
+    return 1;
+  }
+
+  const body = readBodyArg(args, "");
+  const secretFindings = findPotentialSecrets(body);
+  if (secretFindings.length && !allowSecrets) {
+    throw new Error(
+      [
+        "Document body appears to contain credentials or secrets. Pass --allow-secrets to write it anyway.",
+        formatSecretFindings(secretFindings),
+      ].join("\n")
+    );
+  }
+
+  const { authToken, userId } = requireTokenUser(args, deps.env, shouldDryRun);
+  const targets = resolveWriteTargets(args, deps.env);
+  if (!targets.length) {
+    throw new Error("No write targets resolved. Check --sync / --local-only / --no-local.");
+  }
+
+  const explicitId = readOption(args, "--id");
+  const docId = explicitId ?? (docKind === "skill" ? buildSkillDocId(title) : createPageId());
+  const dbKey = docKind === "skill" ? buildSkillPageKey(userId, docId) : buildPageKey(userId, docId);
+  const record =
+    docKind === "skill"
+      ? buildSkillPageRecord({
+          dbKey,
+          skillId: docId,
+          title,
+          spaceId,
+          body,
+          skillConfig: {
+            version: "0.1",
+            kind: "skill",
+            id: docId,
+            name: title,
+            description,
+            ...(parseJsonArg<string[]>(readOption(args, "--tools"), []).length
+              ? { toolNames: parseJsonArg<string[]>(readOption(args, "--tools"), []) }
+              : {}),
+            ...(parseJsonArg<string[]>(readOption(args, "--required-skills"), []).length
+              ? { requiredSkills: parseJsonArg<string[]>(readOption(args, "--required-skills"), []) }
+              : {}),
+            ...(parseJsonArg<string[]>(readOption(args, "--recommended-skills"), []).length
+              ? { recommendedSkills: parseJsonArg<string[]>(readOption(args, "--recommended-skills"), []) }
+              : {}),
+            ...(parseJsonArg<string[]>(readOption(args, "--preferred-agents"), []).length
+              ? { preferredAgents: parseJsonArg<string[]>(readOption(args, "--preferred-agents"), []) }
+              : {}),
+            ...(readOption(args, "--trigger-mode")
+              ? { triggerMode: readOption(args, "--trigger-mode") as "explicit" | "required" | "recommended" }
+              : {}),
+            ...(readOption(args, "--budget-tier")
+              ? { budgetTier: readOption(args, "--budget-tier") as "low" | "medium" | "high" }
+              : {}),
+            ...(readOption(args, "--prompt-patch") ? { promptPatch: readOption(args, "--prompt-patch") } : {}),
+          },
+        })
+      : buildPageRecord({
+          dbKey,
+          pageId: docId,
+          title,
+          spaceId,
+          content: body,
+          meta: description ? { description } : undefined,
+        });
+
+  const skillSummary = docKind === "skill" ? buildSkillSummaryMarker(record.meta) : undefined;
+  const summary = {
+    dryRun: shouldDryRun,
+    kind: docKind,
+    title,
+    dbKey,
+    id: docId,
+    userId,
+    spaceId,
+    syncTargets: targets,
+    writtenTargets: [] as string[],
+    secretFindingCount: secretFindings.length,
+    secretFindings,
+  };
+
+  if (!shouldDryRun) {
+    for (const serverUrl of targets) {
+      await writePageRecord({
+        authToken,
+        dbKey,
+        record,
+        serverUrl,
+        spaceId,
+        title,
+        userId,
+        skillSummary,
+      });
+      summary.writtenTargets.push(serverUrl);
+    }
+  }
+
+  if (shouldOutputJson) {
+    process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
+  } else if (shouldDryRun) {
+    process.stdout.write(`dry-run ok: ${dbKey}\n`);
+  } else {
+    process.stdout.write(`created ${docKind}: ${dbKey}\n`);
+  }
+
+  return 0;
+}
+
+export async function runDocCreateCommand(args: string[], deps: DocCreateDeps) {
+  return runCreateCommand(args, deps, {
+    defaultKind: "page",
+    usage: printDocCreateUsage,
+  });
+}
+
+export async function runSkillDocCreateCommand(args: string[], deps: DocCreateDeps) {
+  return runCreateCommand(args, deps, {
+    defaultKind: "skill",
+    usage: printSkillDocCreateUsage,
+  });
+}

package/cli/docInternalCommandEntries.ts

@@ -0,0 +1,11 @@
+import type { CommandEntry } from "./cliCommandTypes";
+import { createEnvCommand } from "./cliCommandFactories";
+import { runDocCreateCommand, runSkillDocCreateCommand } from "./docCreateCommands";
+
+export function getDocInternalCommandEntries(): CommandEntry[] {
+  return [
+    createEnvCommand(["doc", "create"], "Create a normal doc", runDocCreateCommand),
+    createEnvCommand(["skill-doc", "create"], "Create a skill-backed doc", runSkillDocCreateCommand),
+    createEnvCommand(["skill", "create-doc"], "Create a skill-backed doc", runSkillDocCreateCommand),
+  ];
+}

package/cli/docPageHelpers.ts

@@ -0,0 +1,80 @@
+import { readFileSync } from "node:fs";
+import { ulid } from "ulid";
+
+function getCliArg(args: string[], flag: string): string | undefined {
+  const idx = args.indexOf(flag);
+  return idx !== -1 ? args[idx + 1] : undefined;
+}
+
+export function readBodyArg(args: string[], fallback = "") {
+  const bodyFile = getCliArg(args, "--body-file");
+  if (bodyFile !== undefined) {
+    return readFileSync(bodyFile, "utf8");
+  }
+  return getCliArg(args, "--body") ?? fallback;
+}
+
+function textToSlate(text: string) {
+  return text.split("\n").map((line) => ({
+    type: "paragraph",
+    children: [{ text: line }],
+  }));
+}
+
+export function createPageId() {
+  return ulid();
+}
+
+export function buildPageKey(userId: string, pageId: string) {
+  return `page-${userId}-${pageId}`;
+}
+
+export function buildPageRecord(args: {
+  dbKey: string;
+  pageId: string;
+  title: string;
+  spaceId: string | null;
+  content: string;
+  existing?: Record<string, any> | null;
+  meta?: Record<string, any> | null;
+  slateData?: Record<string, any>[] | null;
+}) {
+  const { dbKey, pageId, title, spaceId, content, existing, meta, slateData } = args;
+  const now = Date.now();
+  const createdAt = typeof existing?.createdAt === "number" ? existing.createdAt : now;
+  const created =
+    typeof existing?.created === "string" ? existing.created : new Date(createdAt).toISOString();
+
+  const nextRecord: Record<string, any> = {
+    ...(existing ?? {}),
+    id: existing?.id ?? pageId,
+    dbKey,
+    type: "page",
+    title,
+    spaceId,
+    content,
+    updatedAt: now,
+    createdAt,
+    created,
+  };
+
+  if (meta !== undefined) {
+    if (meta === null) {
+      delete nextRecord.meta;
+    } else {
+      nextRecord.meta = meta;
+    }
+  }
+
+  if (slateData !== undefined) {
+    if (slateData === null) {
+      delete nextRecord.slateData;
+    } else {
+      nextRecord.slateData = slateData;
+    }
+  } else if (!existing?.slateData) {
+    nextRecord.slateData = textToSlate(content);
+  }
+
+  return nextRecord;
+}

package/cli/docSkillHelpers.ts

@@ -0,0 +1,67 @@
+import {
+  buildSkillDocMarkdown,
+  type SkillDocConfig,
+} from "../ai/skills/skillDocProtocol";
+import { buildPageKey, buildPageRecord } from "./docPageHelpers";
+
+function normalizeSkillSeed(input: string) {
+  return input
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function deterministicId(prefix: string, seed: string): string {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < seed.length; i++) {
+    h ^= seed.charCodeAt(i);
+    h = (h * 0x01000193) >>> 0;
+  }
+  const suffix = h.toString(36).toUpperCase().padStart(14, "0");
+  return (prefix + suffix).slice(0, 26);
+}
+
+export function buildSkillDocId(input: string) {
+  return deterministicId("01SK", normalizeSkillSeed(input) || input);
+}
+
+export function buildSkillPageKey(userId: string, skillId: string) {
+  return buildPageKey(userId, skillId);
+}
+
+export function buildSkillPageRecord(args: {
+  dbKey: string;
+  skillId: string;
+  title: string;
+  spaceId: string | null;
+  body: string;
+  skillConfig: SkillDocConfig;
+  existing?: Record<string, any> | null;
+}) {
+  const { dbKey, skillId, title, spaceId, body, skillConfig, existing } = args;
+  return {
+    ...buildPageRecord({
+      dbKey,
+      pageId: skillId,
+      title,
+      spaceId,
+      content: buildSkillDocMarkdown({
+        body,
+        skillConfig,
+      }),
+      existing,
+      meta: {
+        ...(existing?.meta ?? {}),
+        kind: "skill",
+        skillConfig,
+      },
+      slateData: null,
+    }),
+  };
+}
+
+export function parseJsonArg<T>(raw: string | undefined, fallback: T): T {
+  if (raw === undefined) return fallback;
+  return JSON.parse(raw) as T;
+}

package/cli/docSpaceHelpers.ts

@@ -0,0 +1,46 @@
+import { createSpaceKey } from "../create/space/spaceKeys";
+import { readDbRecord, writeAgentRecord } from "./agentRecordHelpers";
+
+export async function ensurePageAttachedToSpace(params: {
+  baseUrl: string;
+  userId: string;
+  authToken: string;
+  spaceId: string;
+  contentKey: string;
+  title: string;
+  skillSummary?: Record<string, any> | null;
+}) {
+  const { baseUrl, userId, authToken, spaceId, contentKey, title, skillSummary } = params;
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceRecord = await readDbRecord({
+    dbKey: spaceKey,
+    authToken,
+    fetchImpl: fetch,
+    serverUrl: baseUrl,
+  });
+  const now = Date.now();
+
+  await writeAgentRecord({
+    agentKey: spaceKey,
+    authToken,
+    fetchImpl: fetch,
+    serverUrl: baseUrl,
+    userId,
+    record: {
+      ...spaceRecord,
+      contents: {
+        ...(spaceRecord.contents ?? {}),
+        [contentKey]: {
+          ...(spaceRecord.contents?.[contentKey] ?? {}),
+          title,
+          type: "page",
+          contentKey,
+          ...(skillSummary !== undefined ? { skillSummary } : {}),
+          updatedAt: now,
+          createdAt: spaceRecord.contents?.[contentKey]?.createdAt ?? now,
+        },
+      },
+      updatedAt: now,
+    },
+  });
+}

package/cli/internalCommandEntries.ts

@@ -1,6 +1,8 @@
 import { getAgentInternalCommandEntries } from "./agentInternalCommandEntries";
 import { getDialogInternalCommandEntries } from "./dialogInternalCommandEntries";
+import { getDocInternalCommandEntries } from "./docInternalCommandEntries";
 import type { CommandEntry } from "./cliCommandTypes";
+import { getMemoryInternalCommandEntries } from "./memoryInternalCommandEntries";
 import { getSystemInternalCommandEntries } from "./systemInternalCommandEntries";
 import { getWorkflowInternalCommandEntries } from "./workflowInternalCommandEntries";
 
@@ -8,6 +10,8 @@ export function getInternalCommandEntries(renderHelpText: () => string): Command
   return [
     ...getAgentInternalCommandEntries(),
     ...getDialogInternalCommandEntries(),
+    ...getDocInternalCommandEntries(),
+    ...getMemoryInternalCommandEntries(),
     ...getWorkflowInternalCommandEntries(),
     ...getSystemInternalCommandEntries(renderHelpText),
   ];

package/cli/machineCommands.ts

@@ -132,50 +132,34 @@ function detectLaunchableMachineInfo() {
   return detectMachineInfo({ probeLaunchable: true });
 }
 
-function inferTaskRunRole(agentKey: string, agentConfig: any) {
-  const haystack = [
-    agentKey,
-    agentConfig?.name,
-    agentConfig?.prompt,
-  ].filter(Boolean).join("\n").toLowerCase();
-  if (haystack.includes("frontend") || haystack.includes("前端")) return "frontend";
-  if (haystack.includes("fullstack") || haystack.includes("全栈")) return "fullstack";
-  if (haystack.includes("review") || haystack.includes("审查")) return "reviewer";
-  if (haystack.includes("project-manager") || haystack.includes("项目经理")) return "pm";
-  return "codex";
+function findTaskRowSubjectRef(runtimeContext: any) {
+  const subjectRefs = Array.isArray(runtimeContext?.subjectRefs) ? runtimeContext.subjectRefs : [];
+  for (const ref of subjectRefs) {
+    if (!ref || typeof ref !== "object" || Array.isArray(ref)) continue;
+    if (ref.kind !== "table-row") continue;
+    const id = typeof ref.id === "string" ? ref.id.trim() : "";
+    if (id) return id;
+  }
+  return "";
 }
 
-function buildTaskRunBridgePrompt(args: {
+function buildTaskEvidencePrompt(args: {
   agentKey: string;
   agentConfig: any;
   runtimeContext: any;
 }) {
-  const taskRun = args.runtimeContext?.taskRun;
-  const rowDbKey = typeof taskRun?.rowDbKey === "string" ? taskRun.rowDbKey.trim() : "";
+  const rowDbKey = findTaskRowSubjectRef(args.runtimeContext);
   if (!rowDbKey) return "";
-  const workItemId = typeof taskRun?.workItemId === "string" ? taskRun.workItemId.trim() : "";
-  const role = inferTaskRunRole(args.agentKey, args.agentConfig);
   return [
-    "--- Nolo task-run tool bridge ---",
+    "--- Nolo task evidence context ---",
     "This CLI runtime does not receive server-side function tools directly.",
-    "Use the local task-run bridge command for durable task state writes. Do not edit meta.taskRun with table or database commands.",
+    "Use the task row subjectRef and linked dialog/activity evidence as the durable task context.",
     "Run commands from the repository root. The runner already provides server URL and auth in the environment.",
     "Release boundary: after review passes, AI/reviewer/Codex may advance alpha for verification. Do not merge, push, or release main/release unless the human owner explicitly authorizes it in the current task context.",
-    "Cost boundary: read taskRun.control from context. Prefer low-cost/free-window models for routine work, and reserve Codex for supervision, quality gates, complex unblocking, and main/release decisions.",
-    "Handoff context: start from read-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; do not infer completion from handoff text alone.",
-    `Read context: bun packages/cli/index.ts task-run read-context --row-dbkey ${JSON.stringify(rowDbKey)}`,
-    ...(workItemId
-      ? [
-          `Claim work item: bun packages/cli/index.ts task-run claim-work-item --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --agent-key ${JSON.stringify(args.agentKey)} --role ${role}`,
-          `Set blocker: bun packages/cli/index.ts task-run set-blocker --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --layer tool --code <CODE> --message <MESSAGE>`,
-          `Clear resolved blocker: bun packages/cli/index.ts task-run clear-blocker --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --blocker-id <BLOCKER_ID>`,
-          `Submit outcome: bun packages/cli/index.ts task-run submit-outcome --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --summary <SUMMARY>`,
-          `Request review: bun packages/cli/index.ts task-run request-review --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --reviewer-agent-key <AGENT_KEY> --message <MESSAGE>`,
-          `Record review: bun packages/cli/index.ts task-run record-review --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --review-status <passed|needs_changes|blocked> --reviewer-agent-key ${JSON.stringify(args.agentKey)} --findings <FINDINGS>`,
-          `Close work item: bun packages/cli/index.ts task-run close-work-item --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --summary <SUMMARY>`,
-        ]
-      : []),
-    "If a bridge command fails, report the exact command and error.",
+    "Handoff context: inspect activityRefs/latestActivityRef, dialog checkpoints, artifacts, commits, and test evidence. Use dialog read/search for exact evidence; do not infer completion from handoff text alone.",
+    `Read task row: bun packages/cli/index.ts table query --table meta-0e95801d90-NOLOTASKBOARD --row ${JSON.stringify(rowDbKey)} --include-activity --output json`,
+    "Then read linked activity dialog ids with: bun packages/cli/index.ts dialog read <dialogId>",
+    "Report progress, blockers, worktree, branch, commit/diff, tests, and unverified items in the dialog.",
   ].join("\n");
 }
 
@@ -186,7 +170,7 @@ function buildConnectorCliPrompt(agentConfig: any, userInput: string, bridgeArgs
   const policy = permissionPolicy ?? resolveMachineRunPermissionPolicy(agentConfig);
   return [
     typeof agentConfig?.prompt === "string" ? agentConfig.prompt.trim() : "",
-    bridgeArgs ? buildTaskRunBridgePrompt({
+    bridgeArgs ? buildTaskEvidencePrompt({
       agentKey: bridgeArgs.agentKey,
       agentConfig,
       runtimeContext: bridgeArgs.runtimeContext,