@lambdacurry/arbor 0.22.21 → 0.22.23

package/dist/arbor.js

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "@lambdacurry/arbor",
-  version: "0.22.21",
+  version: "0.22.23",
   description: "The Arbor CLI — a shared workspace for people and agents. The human + headless-agent write path over Arbor's guarded operation surface.",
   keywords: [
     "agents",
@@ -6712,6 +6712,69 @@ var computerRunStarts = sqliteTable("computer_run_starts", {
   snapshotIdx: index("computer_run_starts_snapshot_idx").on(t.snapshotId),
   runIdx: uniqueIndex("computer_run_starts_run_idx").on(t.runId)
 }));
+var computerOutputCaptures = sqliteTable("computer_output_captures", {
+  id: text("id").primaryKey(),
+  runId: text("run_id").notNull().references(() => computerRuns.id),
+  processId: text("process_id").notNull(),
+  computerId: text("computer_id").notNull().references(() => threadComputers.id),
+  threadId: text("thread_id").notNull().references(() => threads.id),
+  computerSessionId: text("computer_session_id").notNull().references(() => computerSessions.id),
+  runProfileId: text("run_profile_id").notNull().references(() => profiles.id),
+  runExecutionContextId: text("run_execution_context_id").notNull().references(() => executionContexts.id),
+  sessionProfileId: text("session_profile_id").notNull().references(() => profiles.id),
+  sessionExecutionContextId: text("session_execution_context_id").notNull().references(() => executionContexts.id),
+  execution: text("execution").$type().notNull(),
+  processState: text("process_state").$type().notNull(),
+  processActivityKind: text("process_activity_kind").$type(),
+  processExecution: text("process_execution").$type(),
+  providerGeneration: integer2("provider_generation"),
+  workspaceGeneration: text("workspace_generation"),
+  expectedCurrentSnapshotId: text("expected_current_snapshot_id").references(() => computerSnapshots.id),
+  terminalOutcome: text("terminal_outcome").$type(),
+  exitCode: integer2("exit_code"),
+  timedOut: integer2("timed_out", { mode: "boolean" }),
+  durationMs: integer2("duration_ms"),
+  status: text("status").$type().notNull().default("pending"),
+  stdoutBytes: integer2("stdout_bytes").notNull().default(0),
+  stderrBytes: integer2("stderr_bytes").notNull().default(0),
+  requestedStdoutBytes: integer2("requested_stdout_bytes"),
+  requestedStderrBytes: integer2("requested_stderr_bytes"),
+  pageIntentDigest: text("page_intent_digest"),
+  intentStdoutBytes: integer2("intent_stdout_bytes"),
+  intentStderrBytes: integer2("intent_stderr_bytes"),
+  intentTerminalOutcome: text("intent_terminal_outcome").$type(),
+  intentExitCode: integer2("intent_exit_code"),
+  intentTimedOut: integer2("intent_timed_out", { mode: "boolean" }),
+  intentDurationMs: integer2("intent_duration_ms"),
+  lastPublishedIntentDigest: text("last_published_intent_digest"),
+  cleanupToken: text("cleanup_token"),
+  cleanupClaimedAt: ts("cleanup_claimed_at"),
+  completedAt: ts("completed_at"),
+  expiresAt: ts("expires_at"),
+  updatedAt: ts("updated_at").notNull(),
+  createdAt: ts("created_at").notNull()
+}, (t) => ({
+  runProcessIdx: uniqueIndex("computer_output_captures_run_process_idx").on(t.runId, t.processId),
+  computerIdx: index("computer_output_captures_computer_idx").on(t.computerId, t.status),
+  pendingIdx: index("computer_output_captures_pending_idx").on(t.status, t.updatedAt),
+  expiresIdx: index("computer_output_captures_expires_idx").on(t.status, t.expiresAt)
+}));
+var computerOutputChunks = sqliteTable("computer_output_chunks", {
+  id: text("id").primaryKey(),
+  captureId: text("capture_id").notNull().references(() => computerOutputCaptures.id),
+  stream: text("stream").$type().notNull(),
+  startOffset: integer2("start_offset").notNull(),
+  size: integer2("size").notNull(),
+  blobKey: text("blob_key").notNull(),
+  sha256: text("sha256").notNull(),
+  pageIntentDigest: text("page_intent_digest").notNull(),
+  verifiedAt: ts("verified_at"),
+  deletedAt: ts("deleted_at"),
+  createdAt: ts("created_at").notNull()
+}, (t) => ({
+  rangeIdx: uniqueIndex("computer_output_chunks_range_idx").on(t.captureId, t.stream, t.startOffset),
+  blobKeyIdx: uniqueIndex("computer_output_chunks_blob_key_idx").on(t.blobKey)
+}));
 var previews = sqliteTable("previews", {
   id: text("id").primaryKey(),
   threadId: text("thread_id").notNull().references(() => threads.id),
@@ -7548,6 +7611,8 @@ var assigneeColumns = {
   color: profiles.color,
   emoji: profiles.emoji
 };
+// ../core/src/ops/computer-output.ts
+var COMPUTER_OUTPUT_DEFAULT_STALE_MS = 24 * 60 * 60 * 1000;
 // ../core/src/ops/computer-recovery.ts
 var COMPUTER_RECOVERY_GRANT_MAX_TTL_MS = 24 * 60 * 60 * 1000;
 // ../core/src/ops/preview.ts
@@ -9163,6 +9228,7 @@ var MCP_OUTPUT_SCHEMAS = {
   computer_process_read: looseObject({
     processId: string2(),
     status: string2(),
+    outputRetention: object({ state: literal("preserved"), expiresAt: timestamp }).optional(),
     timedOut: boolean2().optional(),
     endedAt: timestamp.nullable().optional(),
     durationMs: number2().int().min(0).nullable().optional(),
@@ -9563,6 +9629,7 @@ var OUTPUT_SHAPERS = {
   computer_process_read: (result) => defined([
     ["processId", result.processId],
     ["status", result.status],
+    ["outputRetention", omitNull(result.outputRetention)],
     ["timedOut", omitNull(result.timedOut)],
     ["stdout", result.stdout],
     ["stderr", result.stderr],
@@ -9949,7 +10016,7 @@ Arbor's MCP is the collaboration and durable-knowledge surface. Configure, autho
 
 Run \`arbor help\` (or read the MCP tool list) for the exact command/flags — those stay generated from the live action surface, so they're always current.`;
 var ARBOR_SKILL_MARKDOWN = renderArborSkill(ORIENTATION);
-var COMPUTER_ORIENTATION = `Long Computer work returns a handle — do not hold one tool call for a full test or build. \`computer_exec\` runs a command; if the result is still running, take \`processId\` and poll \`computer_process_read\`. Do not chain \`pnpm test && pnpm build\` in one exec; split steps or pass \`background:true\`. The CLI waits on the same handle unless \`--no-wait\`.
+var COMPUTER_ORIENTATION = `Long Computer work returns a processId handle — do not hold one tool call for a full test or build. \`computer_exec\` runs a command; if the result is still running, observe it with \`computer_process_read\`; read a truncated continuation only when you need more output. Finish and suspend preserve unread terminal output internally, with original process IDs/cursors recoverable for 30 days. Do not chain \`pnpm test && pnpm build\` in one exec; split steps or pass \`background:true\`. The CLI polls only while the process is silent unless \`--no-wait\`; it returns the first bounded output page instead of concatenating continuation pages into one agent context.
 
 Arbor Computer is the complete software execution platform attached to Arbor's durable collaboration graph. It configures project environments, executes and verifies work, packages and releases Apps, and preserves reviewable evidence; it does not schedule agents or replace Arbor collaboration.
 
@@ -10712,9 +10779,9 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_run_suspend",
     title: "Suspend a run",
-    description: "Checkpoint an active WRITE Run for an external wait (the same runId resumes next): an isolated Run publishes its exact workspace and releases its Sandbox, a shared Run checkpoints the parent lineage. Performs bounded process read/terminate/settlement internally: suspends when settled, returns retryable busy if a process is active, or fail-closes on unknown mutation and never replays unknown work.",
+    description: "Checkpoint an active WRITE Run for an external wait: isolated Runs publish their exact workspace and release the Sandbox; shared Runs checkpoint the parent, and the same runId resumes next. Preserves unread terminal output internally for 30 days; no caller drain is required, larger captures use bounded same-Run retries, and active/unknown work or failed preservation blocks release without replay.",
     inputSchema: {
-      runId: string2().describe("the active isolated WRITE Run to suspend, run_…")
+      runId: string2().describe("the active WRITE Run to suspend, run_…")
     },
     surfaces: ["computer-mcp", "computer-cli"],
     toolset: "loop",
@@ -10734,7 +10801,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_run_finish",
     title: "Finish a run",
-    description: "Finish a Run with an explicit terminal outcome; ordinary finish refuses unsettled operations and proven non-durable isolated WRITE work, and the last shared Run's finish also stops the parent. To abandon an unknown or non-durable disposable Run without replaying it, pass discard=true with outcome failed or cancelled; the receipt keeps the evidence and repeating the outcome is a safe no-op.",
+    description: "Finish a Run, preserving unread terminal output for 30 days without caller drain; active/unknown operations, failed preservation, and proven non-durable isolated WRITE work block release, and the last shared Run stops the parent. To abandon an unknown or non-durable disposable Run, pass discard=true with outcome failed or cancelled; the receipt keeps evidence and repeating that outcome is safe.",
     inputSchema: {
       runId: string2().describe("the runId returned by computer_run_start, run_…"),
       outcome: _enum(["finished", "failed", "cancelled"]).optional().describe("terminal outcome; defaults to finished"),
@@ -10773,7 +10840,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_exec",
     title: "Run a command",
-    description: "Run one bounded shell operation in a Run (pass runId) with ambient GitHub authorization; timeout kills the process. If the command is running or a truncated output page is returned, use processId with computer_process_read and nextCursor when present; after a missed isolated response use computer_run_receipt.operations[].operationId with computer_process_read instead of repeating the mutation.",
+    description: "Run one bounded shell command in runId with ambient GitHub authorization; timeout kills the process. Observe running work with computer_process_read; use nextCursor for a truncated output page only when needed and finish without draining; after a missed response use computer_run_receipt.operations[].operationId with computer_process_read instead of repeating the mutation.",
     inputSchema: {
       computerSessionId: string2().optional().describe("legacy alternative to runId: a computerSessionId on that Computer, cms_…; required unless runId is supplied"),
       command: string2().min(1).describe("the shell command to run"),
@@ -10792,12 +10859,12 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_process_read",
     title: "Read a background process",
-    description: "Read one provider-owned process from computer_exec, including a recovered Run operation, using nextCursor for incremental output. Successful Run reads durably retain the latest provider observation; a later timeout stays unknown and unsafe while returning it with age, and Arbor settles the durable operation only from terminal or exact provider-absence proof.",
+    description: "Read original process output using nextCursor; preserved output stays readable for 30 days after preservation, including repeated cursors after finish/suspend, without provider wake. Live reads retain the latest observation; a later timeout remains unknown/unsafe with its age, and Arbor settles the durable operation only from terminal or exact provider-absence proof.",
     inputSchema: {
       computerSessionId: string2().optional().describe("legacy alternative to runId: a computerSessionId on that Computer, cms_…; required unless runId is supplied"),
       runId: string2().optional().describe("the Run that owns this process, if it was started inside a Run"),
       processId: string2().min(1).describe("the processId returned by background exec, or matching computer_run_receipt.operations[].operationId for recovered foreground Run work, proc_…"),
-      cursor: string2().optional().describe("continue after nextCursor from the prior process read; omit for a small latest tail"),
+      cursor: string2().optional().describe("continue after nextCursor from the prior result; omit to read from the beginning"),
       maxBytes: number2().int().min(1024).max(65536).optional().describe("maximum combined output bytes to return; default 4,096, opt up only when needed")
     },
     surfaces: ["computer-mcp", "computer-cli"],
@@ -11658,7 +11725,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "service_register",
     title: "Register a Computer lifecycle service",
-    description: "Register a persistent service identity for Currybox Computer lifecycle maintenance and mint its API key (shown ONCE). Human owner/admin CLI setup only. The credential is restricted to computer.get + computer.lifecycle_runs + computer.append_run_lifecycle + computer.checkpoint + computer.suspend_run + computer.resume_run + computer.reconcile_runs and to the Spaces listed here; store it as the Currybox control plane's Arbor credential.",
+    description: "Register a persistent service identity for Currybox Computer lifecycle maintenance and mint its API key (shown ONCE). Human owner/admin CLI setup only. The credential is restricted to computer.get + computer.lifecycle_runs + computer.append_run_lifecycle + computer.checkpoint + computer.preserve_run_output + computer.suspend_run + computer.resume_run + computer.reconcile_runs and to the Spaces listed here; store it as the Currybox control plane's Arbor credential.",
     inputSchema: {
       displayName: string2().min(1).describe("the service display name, e.g. Currybox lifecycle service"),
       spaceIds: array(string2().min(1)).min(1).describe("Spaces whose Thread computers the service may maintain")
@@ -12918,6 +12985,7 @@ function codeForStatus(status) {
     case 403:
       return "FORBIDDEN";
     case 404:
+    case 410:
       return "NOT_FOUND";
     case 409:
       return "CONFLICT";
@@ -12978,6 +13046,12 @@ function parseErrorDetails(value) {
     details.operationId = raw.operationId;
   if (typeof raw.processId === "string")
     details.processId = raw.processId;
+  if (raw.outputRetention && typeof raw.outputRetention === "object") {
+    const retention = raw.outputRetention;
+    if (retention.state === "expired" && typeof retention.expiresAt === "string") {
+      details.outputRetention = { state: "expired", expiresAt: retention.expiresAt };
+    }
+  }
   if (raw.commandExecution === "not-routed" || raw.commandExecution === "unknown") {
     details.commandExecution = raw.commandExecution;
   }
@@ -13520,6 +13594,7 @@ function emitDual(data, human, action, ctx) {
 
 // src/computer-exec-wait.ts
 var DEFAULT_PROCESS_DEADLINE_MS = 1800000;
+var PROCESS_OUTPUT_PAGE_BYTES = 4096;
 var POLL_MS = 400;
 var processRead = ACTIONS3.find((action) => action.name === "computer_process_read");
 function record3(value) {
@@ -13540,6 +13615,12 @@ function isRunning(value) {
     return false;
   return typeof value.processId === "string";
 }
+function hasCallerVisibleOutputPage(value) {
+  return typeof value.stdout === "string" && value.stdout.length > 0 || typeof value.stderr === "string" && value.stderr.length > 0 || value.truncated === true;
+}
+function withContinuation(value) {
+  return isRunning(value) || value.truncated === true ? { ...value, nextAction: "computer_process_read" } : value;
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -13551,39 +13632,32 @@ async function waitForComputerExec(executor, input, value, ctx) {
   if (!processRead || !isComputerExecHandle(value))
     return value;
   let latest = value;
+  if (hasCallerVisibleOutputPage(latest))
+    return withContinuation(latest);
   let cursor = typeof latest.nextCursor === "string" && latest.nextCursor ? latest.nextCursor : undefined;
-  let stdoutPages = typeof latest.stdout === "string" ? latest.stdout : "";
-  let stderrPages = typeof latest.stderr === "string" ? latest.stderr : "";
-  if (stdoutPages)
-    advise(stdoutPages, ctx);
   const deadline = Date.now() + (typeof input.timeout === "number" && Number.isFinite(input.timeout) ? input.timeout : DEFAULT_PROCESS_DEADLINE_MS);
-  advise(isRunning(latest) ? `Process ${String(latest.processId)} is still running; polling computer_process_read.
-` : `Process ${String(latest.processId)} has unread output; polling computer_process_read.
+  advise(`Process ${String(latest.processId)} is still running; polling computer_process_read.
 `, ctx);
-  while ((isRunning(latest) || latest.truncated === true) && Date.now() < deadline) {
+  while (isRunning(latest) && Date.now() < deadline) {
     await sleep(POLL_MS);
     const read = record3(await processRead.run(executor, {
       processId: latest.processId,
+      maxBytes: PROCESS_OUTPUT_PAGE_BYTES,
       ...cursor ? { cursor } : {},
       ...typeof input.runId === "string" ? { runId: input.runId } : {},
       ...typeof input.computerSessionId === "string" ? { computerSessionId: input.computerSessionId } : {}
     }));
-    if (!read) {
+    if (!read)
       throw new Error("computer_process_read returned an empty result");
-    }
     latest = read;
     if (typeof read.nextCursor === "string" && read.nextCursor)
       cursor = read.nextCursor;
-    const stdout = typeof latest.stdout === "string" ? latest.stdout : "";
-    const stderr = typeof latest.stderr === "string" ? latest.stderr : "";
-    if (stdout)
-      advise(stdout, ctx);
-    stdoutPages += stdout;
-    stderrPages += stderr;
     if (latest.recovery)
-      break;
+      return latest;
+    if (hasCallerVisibleOutputPage(latest) || !isRunning(latest))
+      return withContinuation(latest);
   }
-  return { ...latest, stdout: stdoutPages, stderr: stderrPages };
+  return withContinuation(latest);
 }
 
 // src/schema.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lambdacurry/arbor",
-  "version": "0.22.21",
+  "version": "0.22.23",
   "description": "The Arbor CLI — a shared workspace for people and agents. The human + headless-agent write path over Arbor's guarded operation surface.",
   "keywords": [
     "agents",