@lambdacurry/arbor 0.21.9 → 0.21.10

package/dist/arbor.js

@@ -18365,7 +18365,9 @@ var MCP_OUTPUT_SCHEMAS = {
     exitCode: exports_external.number().optional(),
     processId: exports_external.string().optional(),
     status: exports_external.string().optional(),
-    cwd: exports_external.string().optional()
+    cwd: exports_external.string().optional(),
+    execution: exports_external.enum(["completed", "running"]).optional(),
+    nextAction: exports_external.literal("computer_process_read").optional()
   }),
   computer_process_read: exports_external.looseObject({
     status: exports_external.string(),
@@ -18682,6 +18684,8 @@ var OUTPUT_SHAPERS = {
     ["exitCode", result.exitCode],
     ["processId", result.processId],
     ["status", result.status],
+    ["execution", result.execution],
+    ["nextAction", result.nextAction],
     ["cwd", input.cwd === undefined ? result.cwd : undefined]
   ]),
   computer_process_read: (result) => defined([
@@ -18906,7 +18910,9 @@ Arbor's MCP is the collaboration and durable-knowledge surface. Configure, autho
 8. DURABLE OUTPUT IS AN ARTIFACT, NOT A LONG CONTRIBUTION (AD-201). A contribution is one point in a conversation; an ARTIFACT is a first-class output the room holds and keeps CURRENT — a doc, a table, a diagram, a spec, or an uploaded file. When your point is really a deliverable the team will read or UPDATE later — a table of options, a reference doc, a plan, a rubric — make it an artifact (\`artifact\` verb=create with kind doc/table/diagram/html + \`source\`, or promote a file) instead of pasting it into prose. Text-kind artifacts are LIVING: \`artifact_get\` it, then \`artifact\` verb=edit naming the \`baseVersion\` you read — patches apply exact-match and atomically, one version per call, every version attributed. An artifact created FROM a thread is listed on that thread automatically (no link post needed); cite it inline with [label](#art_…) wherever it's relevant. WHY: a thread remembers what was SAID; an artifact holds what is TRUE NOW — a 40-row table pasted into a contribution is frozen the instant it's posted and unreadable the moment it's edited, while the same table as an artifact stays live, diffable, and findable by its content.
 
 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 COMPUTER_ORIENTATION = `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.
+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\`.
+
+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.
 
 ${ARBOR_FEEDBACK_GUIDANCE}
 
@@ -19612,14 +19618,14 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_exec",
     title: "Run a command",
-    description: "Run one bounded shell operation in a parent Computer or Run with ambient GitHub authorization for connected humans. For long work prefer background:true + computer_process_read; explicit timeout terminates execution, while 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 operation in a parent Computer or Run with ambient GitHub authorization for connected humans. A long command returns processId if still running — poll computer_process_read (background:true skips the wait; timeout kills the process); after a missed isolated response use computer_run_receipt.operations[].operationId with computer_process_read instead of repeating the mutation.",
     inputSchema: {
       computerSessionId: exports_external.string().optional().describe("the computerSessionId returned by computer_open, cms_…; required unless runId is supplied"),
       command: exports_external.string().min(1).describe("the shell command to run"),
       runId: exports_external.string().optional().describe("route this command according to this Run execution placement, run_… (from computer_run_start)"),
       cwd: exports_external.string().optional().describe("working directory under /workspace, or under the run; omit to use defaultCwd"),
-      timeout: exports_external.number().int().min(1000).max(1800000).optional().describe("command deadline in milliseconds, from 1,000 through 1,800,000"),
-      background: exports_external.boolean().optional().describe("start a container process and return its pid"),
+      timeout: exports_external.number().int().min(1000).max(1800000).optional().describe("process kill deadline in milliseconds, from 1,000 through 1,800,000 — not the RPC hold"),
+      background: exports_external.boolean().optional().describe("start the process and return immediately without the short RPC wait"),
       activityLabel: exports_external.string().min(1).max(COMPUTER_RUN_ACTIVITY_LABEL_MAX).optional().describe("short human-readable label for run-scoped background work; Arbor records this label instead of the raw command or output"),
       activityKind: exports_external.literal("verification").optional().describe("mark a labeled run-scoped background command as a verification check; its provider-observed terminal result is recorded as verification.finished"),
       strict: exports_external.boolean().optional().describe("fail on the first unhandled command or pipeline failure; defaults to true, set false only for intentional best-effort execution")
@@ -21633,7 +21639,8 @@ var GLOBAL_BOOLEAN_FLAGS = new Set([
   "json",
   "quiet",
   "no-quiet",
-  "help"
+  "help",
+  "no-wait"
 ]);
 var RESERVED_FLAGS = new Set([
   ...GLOBAL_BOOLEAN_FLAGS,
@@ -21725,6 +21732,66 @@ function emitDual(data, human, action, ctx) {
     process.stdout.write(human);
 }
 
+// src/computer-exec-wait.ts
+var DEFAULT_PROCESS_DEADLINE_MS = 1800000;
+var POLL_MS = 400;
+var processRead = ACTIONS.find((action) => action.name === "computer_process_read");
+function record3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function isRunning(value) {
+  const status = typeof value.status === "string" ? value.status.toLowerCase() : "";
+  if (value.done === false)
+    return true;
+  if (status === "running" || status === "started" || status === "starting")
+    return true;
+  if (value.done === true)
+    return false;
+  if (status === "completed" || status === "exited" || status === "failed" || status === "cancelled" || status === "terminated" || status === "killed" || status === "unknown") {
+    return false;
+  }
+  if (typeof value.exitCode === "number")
+    return false;
+  return typeof value.processId === "string";
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isComputerExecHandle(value) {
+  const rec = record3(value);
+  return Boolean(rec && typeof rec.processId === "string" && isRunning(rec));
+}
+async function waitForComputerExec(executor, input, value, ctx) {
+  if (!processRead || !isComputerExecHandle(value))
+    return value;
+  let latest = value;
+  let cursor = typeof latest.nextCursor === "string" && latest.nextCursor ? latest.nextCursor : undefined;
+  const deadline = Date.now() + (typeof input.timeout === "number" && Number.isFinite(input.timeout) ? input.timeout : DEFAULT_PROCESS_DEADLINE_MS);
+  advise(`Process ${String(latest.processId)} is still running; polling computer_process_read.
+`, ctx);
+  while (isRunning(latest) && Date.now() < deadline) {
+    await sleep(POLL_MS);
+    const read = record3(await processRead.run(executor, {
+      processId: latest.processId,
+      ...cursor ? { cursor } : {},
+      ...typeof input.runId === "string" ? { runId: input.runId } : {},
+      ...typeof input.computerSessionId === "string" ? { computerSessionId: input.computerSessionId } : {}
+    }));
+    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 : "";
+    if (stdout)
+      advise(stdout, ctx);
+    if (latest.recovery)
+      break;
+  }
+  return latest;
+}
+
 // src/schema.ts
 import { readFileSync as readFileSync2 } from "node:fs";
 function kebab(field) {
@@ -22067,11 +22134,14 @@ Bare arguments fill ${explicitPositionals.map((spec) => `--${spec.flag}`).join("
 
 Alias: \`arbor ${alias2}\` (the tool-name form) resolves to this same command.` : "";
   const heading = `${commandWords(action)}${alias2 ? ` (alias: ${alias2})` : ""}`;
+  const waitLines = action.name === "computer_exec" ? [
+    "  --no-wait [<boolean>]  [optional] — return a running processId immediately instead of polling computer_process_read"
+  ] : [];
   return `${heading} — ${action.description}
 
-${usage}
+${usage}${waitLines.length > 0 ? " [--no-wait]" : ""}
 
-${lines.join(`
+${[...lines, ...waitLines].join(`
 `)}${primaryNote}${explicitNote}${aliasNote}
 `;
 }
@@ -22080,13 +22150,24 @@ function commandCatalog() {
     command: commandWords(action),
     name: action.name,
     description: action.description,
-    flags: flagsForSchema(action.inputSchema).map((f) => ({
-      flag: f.flag,
-      kind: f.kind,
-      required: f.required,
-      acceptsFile: f.kind === "string",
-      description: f.description
-    }))
+    flags: [
+      ...flagsForSchema(action.inputSchema).map((f) => ({
+        flag: f.flag,
+        kind: f.kind,
+        required: f.required,
+        acceptsFile: f.kind === "string",
+        description: f.description
+      })),
+      ...action.name === "computer_exec" ? [
+        {
+          flag: "no-wait",
+          kind: "boolean",
+          required: false,
+          acceptsFile: false,
+          description: "return a running processId immediately instead of polling computer_process_read"
+        }
+      ] : []
+    ]
   }));
 }
 function applyPositionals(action, extras, flags) {
@@ -22165,13 +22246,16 @@ async function runObjectVerb(positionals, flags, ctx) {
     advise(`Agent registered. Save its apiKey now — it is shown only once:
 `, ctx);
   }
-  const value = await action.run(httpExecutor, input);
+  let value = await action.run(httpExecutor, input);
+  if (action.name === "computer_exec" && !truthyFlag(flags["no-wait"])) {
+    value = await waitForComputerExec(httpExecutor, input, value, ctx);
+  }
   emitData(shapeActionOutput(action.name, value, input), action.name, ctx);
 }
 
 // src/connect.ts
 var DEFAULT_POLL_INTERVAL_MS = 2000;
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
 function bareConnectUrl(apiUrl, returnedUrl) {
   const fallback = `${apiUrl.replace(/\/$/, "")}/connect`;
   if (!returnedUrl)
@@ -22215,7 +22299,7 @@ async function connect(opts) {
     if (Date.now() > deadline) {
       throw new Error("pairing timed out — ask for a new pairing key and run `arbor connect` again");
     }
-    await sleep(pollIntervalMs);
+    await sleep2(pollIntervalMs);
     const tokRes = await fetch(`${apiUrl}/api/agent/connect/token`, {
       method: "POST",
       headers,
@@ -22241,7 +22325,7 @@ async function connect(opts) {
 // src/login.ts
 var CLIENT_ID = "arbor-cli";
 var GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
-var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+var sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
 async function login(opts) {
   const apiUrl = opts.url ?? loadConfig().apiUrl;
   const codeRes = await fetch(`${apiUrl}/api/auth/device/code`, {
@@ -22266,7 +22350,7 @@ async function login(opts) {
   for (;; ) {
     if (Date.now() > deadline)
       throw new Error("login timed out — run `arbor login` again");
-    await sleep2(interval);
+    await sleep3(interval);
     const tokRes = await fetch(`${apiUrl}/api/auth/device/token`, {
       method: "POST",
       headers: { "content-type": "application/json" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lambdacurry/arbor",
-  "version": "0.21.9",
+  "version": "0.21.10",
   "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",