@lambdacurry/arbor 0.22.28 → 0.22.30

package/dist/arbor.js

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "@lambdacurry/arbor",
-  version: "0.22.28",
+  version: "0.22.30",
   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",
@@ -8012,6 +8012,17 @@ var computerRunReceipt2 = looseObject({
   durability: computerRunDurability,
   finishAssessment: computerRunFinishAssessment.nullable(),
   finishRequest: computerRunFinishRequest.nullable(),
+  finishContinuation: looseObject({
+    state: _enum(["retrying", "unverified"]),
+    phase: _enum(["quiescence", "git", "checkpoint", "release"]),
+    reasonCode: string2(),
+    description: string2(),
+    callerAction: literal("none"),
+    operation: _enum(["run_terminal_checkpoint", "run_release", "run_checkpoint_publication"]).optional(),
+    attempts: number2().int().positive().optional(),
+    lastFailedAt: timestamp.optional(),
+    nextAttemptAt: timestamp.optional()
+  }).nullable(),
   status: _enum(["active", "finished", "failed", "cancelled"]),
   outcome: _enum(["finished", "failed", "cancelled"]).nullable(),
   reason: string2().nullable(),
@@ -8084,7 +8095,13 @@ var computerRunReceipt2 = looseObject({
       providerHttpStatus: number2().int().optional(),
       providerStopClass: string2().optional(),
       providerRoute: _enum(["primary", "standby", "service"]).optional(),
-      parentWorkspaceFrozen: boolean2().optional()
+      parentWorkspaceFrozen: boolean2().optional(),
+      finishIntentId: string2().optional(),
+      finishPhase: _enum(["quiescence", "git", "checkpoint", "release"]).optional(),
+      retryOperation: _enum(["run_terminal_checkpoint", "run_release", "run_checkpoint_publication"]).optional(),
+      retryAttempts: number2().int().positive().optional(),
+      retryLastFailedAt: timestamp.optional(),
+      retryNextAttemptAt: timestamp.optional()
     }))
   })
 });
@@ -9929,6 +9946,8 @@ ${orientation}
 
 // ../actions/src/tldraw-agent.ts
 var TLDRAW_EXEC_MAX_OPERATIONS = 100;
+var TLDRAW_DIAGRAM_MAX_NODES = 64;
+var TLDRAW_DIAGRAM_MAX_EDGES = 96;
 var shapeId = string2().regex(/^shape:[A-Za-z0-9_-]{1,128}$/).describe("stable tldraw shape id, shape:…");
 var shapeType = _enum(["geo", "text", "note", "frame", "arrow", "line", "draw", "group"]).describe("built-in tldraw shape type; use code mode for custom or asset-backed shapes");
 var finite = number2().finite();
@@ -9960,6 +9979,21 @@ var update = object({
   meta: jsonRecord.optional()
 }).strict();
 var shapeIds = array(shapeId).min(1).max(TLDRAW_EXEC_MAX_OPERATIONS);
+var diagramKey = string2().min(1).max(80).describe("caller-meaningful node key; returned as the alias for its generated tldraw shape id");
+var diagramLabel = string2().min(1).max(160);
+var diagram = object({
+  op: literal("diagram"),
+  direction: _enum(["LR", "RL", "TB", "BT"]).describe("graph reading direction: left/right or top/bottom"),
+  nodes: array(object({
+    key: diagramKey,
+    label: diagramLabel
+  }).strict()).min(1).max(TLDRAW_DIAGRAM_MAX_NODES),
+  edges: array(object({
+    from: diagramKey,
+    to: diagramKey,
+    label: diagramLabel.optional()
+  }).strict()).max(TLDRAW_DIAGRAM_MAX_EDGES)
+}).strict();
 var TLDRAW_EXEC_OPERATION_SCHEMA = discriminatedUnion("op", [
   create,
   update,
@@ -9978,10 +10012,14 @@ var TLDRAW_EXEC_OPERATION_SCHEMA = discriminatedUnion("op", [
     op: literal("group"),
     ids: shapeIds.min(2),
     groupId: shapeId.optional()
-  }).strict()
+  }).strict(),
+  diagram
 ]);
 var TLDRAW_EXEC_OPERATIONS_SCHEMA = array(TLDRAW_EXEC_OPERATION_SCHEMA).min(1).max(TLDRAW_EXEC_MAX_OPERATIONS).superRefine((operations, ctx) => {
   const createdIds = new Set;
+  const diagramKeys = new Set;
+  let totalDiagramNodes = 0;
+  let totalDiagramEdges = 0;
   operations.forEach((operation, index) => {
     if (operation.op === "create") {
       if (createdIds.has(operation.id)) {
@@ -10006,6 +10044,61 @@ var TLDRAW_EXEC_OPERATIONS_SCHEMA = array(TLDRAW_EXEC_OPERATION_SCHEMA).min(1).m
         seen.add(id);
       });
     }
+    if (operation.op === "diagram") {
+      const previousNodeTotal = totalDiagramNodes;
+      const previousEdgeTotal = totalDiagramEdges;
+      totalDiagramNodes += operation.nodes.length;
+      totalDiagramEdges += operation.edges.length;
+      if (previousNodeTotal <= TLDRAW_DIAGRAM_MAX_NODES && totalDiagramNodes > TLDRAW_DIAGRAM_MAX_NODES) {
+        ctx.addIssue({
+          code: "custom",
+          message: `diagram nodes exceed execution limit: ${TLDRAW_DIAGRAM_MAX_NODES}`,
+          path: [index, "nodes"]
+        });
+      }
+      if (previousEdgeTotal <= TLDRAW_DIAGRAM_MAX_EDGES && totalDiagramEdges > TLDRAW_DIAGRAM_MAX_EDGES) {
+        ctx.addIssue({
+          code: "custom",
+          message: `diagram edges exceed execution limit: ${TLDRAW_DIAGRAM_MAX_EDGES}`,
+          path: [index, "edges"]
+        });
+      }
+      const keys = new Set;
+      operation.nodes.forEach((node, nodeIndex) => {
+        if (keys.has(node.key)) {
+          ctx.addIssue({
+            code: "custom",
+            message: `duplicate diagram node key: ${node.key}`,
+            path: [index, "nodes", nodeIndex, "key"]
+          });
+        }
+        if (diagramKeys.has(node.key)) {
+          ctx.addIssue({
+            code: "custom",
+            message: `diagram node key is already used in this execution: ${node.key}`,
+            path: [index, "nodes", nodeIndex, "key"]
+          });
+        }
+        keys.add(node.key);
+        diagramKeys.add(node.key);
+      });
+      operation.edges.forEach((edge, edgeIndex) => {
+        if (!keys.has(edge.from)) {
+          ctx.addIssue({
+            code: "custom",
+            message: `diagram edge source does not name a node: ${edge.from}`,
+            path: [index, "edges", edgeIndex, "from"]
+          });
+        }
+        if (!keys.has(edge.to)) {
+          ctx.addIssue({
+            code: "custom",
+            message: `diagram edge target does not name a node: ${edge.to}`,
+            path: [index, "edges", edgeIndex, "to"]
+          });
+        }
+      });
+    }
   });
 }).describe("preferred declarative edits, applied in order; mutually exclusive with code");
 // ../actions/src/index.ts
@@ -10045,8 +10138,8 @@ ${ARBOR_FEEDBACK_GUIDANCE}
 
 1. ORIENT, CONFIGURE, AND AUTHORIZE. Start with provider-free get_computer(threadId) to inspect the effective inherited recipe, repository authorization, compatibility, recoverySafety, and durable lineage without contacting execution. Use set_organization_computer, set_space_computer, set_topic_computer, or set_thread_computer only when the corresponding complete sparse layer must be replaced; use github_connect_repository with a known installed id, exact owner/name, or canonical GitHub URL, or use github_repositories when browsing, to authorize repositories at the narrowest scope that should inherit them. If github_repositories looks stale, github_refresh_installation reconciles the cached inventory from GitHub. computer_run_start(threadId, mode) is the front door: it attaches durable identity itself and starts an isolated write Run from the Thread's base snapshot without booting the parent. Each returned repository entry includes verified root instruction pointers when that repo has an AGENTS.md: read surfaced repository instructions before substantial edits or verification, then check for a nearer nested AGENTS.md once the target path is known. Repo-local instructions/scripts/config beat guessed formatter, test, lint, or build commands.
 2. READ THE CAPABILITIES CARD, NOT THE BACKEND. runId is the one address: every runtime tool takes it, and the computerSessionId a Run carries is legacy input. computer_status(runId) describes the live PARENT Thread Computer behind a shared Run; it does not establish isolated Run activity, so use computer_run_receipt(runId) and computer_process_read for Run-owned work. Command-line utilities, including Git and package managers, run through computer_exec; check unfamiliar binaries with command -v.
-3. ONE RUN PER TASK. A write Run defaults to an isolated execution environment with its own filesystem, processes, ports, and /tmp while preserving /workspace paths; a read Run shares the parent. Pass runId to Run-aware tools. If a response is lost, recover the durable operation/process identity from computer_run_receipt and read it before retrying. computer_process_read and computer_process_terminate settle a provider-absent current-generation process from exact evidence; computer_run_suspend performs that bounded settlement internally and never replays unknown work. A still-active process returns a retryable busy state; an unknown current-generation mutation fail-closes. An isolated local commit or Preview is not Git publication; push coherent work before computer_run_finish. discard=true with outcome failed or cancelled explicitly abandons Git work only after provider work is quiescent; it never overrides active or unknown execution.
-4. CHECKPOINT COMPLETE UNITS THROUGH THE RUN. computer_run_suspend(runId) checkpoints an intermediate complete unit — an isolated Run publishes its exact workspace and releases its Sandbox, a shared Run advances the parent lineage — and computer_run_finish(runId) requests the final release; finishing the last active shared Run also stops the parent. An accepted isolated finish may return status active with finishRequest.state pending while the lifecycle owner preserves output, verifies Git, checkpoints, and releases without caller cleanup; one request is sufficient, and computer_run_receipt is an optional observation rather than a progress trigger. An isolated Run Preview is durable review output, not adoption or a checkpoint. The internal provider-handle publication operations are not agent tools.
+3. ONE RUN PER TASK. A write Run defaults to an isolated execution environment with its own filesystem, processes, ports, and /tmp while preserving /workspace paths; a read Run shares the parent. Pass runId to Run-aware tools. If a response is lost, recover the durable operation/process identity from computer_run_receipt and read it before retrying. computer_process_read settles a provider-absent current-generation process from exact evidence; computer_process_terminate sends one termination request and preserves the actual native terminal outcome from one bounded read. computer_run_suspend performs bounded settlement internally and never replays unknown work. A still-active process returns a retryable busy state; an unknown current-generation mutation fail-closes. An isolated local commit or Preview is not Git publication; push coherent work before computer_run_finish. discard=true with outcome failed or cancelled explicitly abandons Git work only after provider work is quiescent; it never overrides active or unknown execution.
+4. CHECKPOINT COMPLETE UNITS THROUGH THE RUN. computer_run_suspend(runId) checkpoints an intermediate complete unit — an isolated Run publishes its exact workspace and releases its Sandbox, a shared Run advances the parent lineage — and computer_run_finish(runId) requests the final release; finishing the last active shared Run also stops the parent. An accepted isolated finish may return status active with finishRequest.state pending while the lifecycle owner preserves output, verifies Git, checkpoints, and releases without caller cleanup; one request is sufficient, and computer_run_receipt is an optional observation rather than a progress trigger. A verified finishContinuation names the blocked stage and says callerAction none while that owner continues its capped retry. An isolated Run Preview is durable review output, not adoption or a checkpoint. The internal provider-handle publication operations are not agent tools.
 5. GIT AND GITHUB ARE ORDINARY COMMANDS AFTER AUTHORIZATION. Clone, fetch, pull, push, and gh run through computer_exec using a connected human's just-in-time ambient GitHub identity. Credentials never enter argv, workspace files, Git config, checkpoints, Events, logs, or receipts. A restored Computer deliberately keeps the checkout age of its snapshot, so fetch/pull before trusting remote state.
 6. VERIFY, PREVIEW, AND EXPORT. computer_verify captures a public URL directly without opening a project runtime. computer_publish_preview preserves immutable static output from either the parent or an active isolated write Run. computer_export moves bounded files into durable Thread Attachments; for a computer:// file Artifact asleep face, export the exact locator path .tldr and a same-Thread PNG, then use artifact set_snapshot. computer_export itself does not call set_snapshot; place returned Markdown exactly where the media belongs and cite the matching attachment ids.
 7. PACKAGE, DEPLOY, ACTIVATE, AND OPERATE APPS HERE. computer_publish_app_bundle creates the immutable executable bundle from verified parent bytes through a shared write Run: push isolated work, computer_run_start with execution shared, pull, then publish. For short-lived public Artifact experiments use preview_app_create/get/retire; for published Space Apps use app_create, app_config_apply, app_deploy, app_deployment_get, app_activate, app_get, app_fetch/app_request, app_rollback, app_set_access, app_reset_state/app_restore_state, and app_archive as one workflow-closed release surface. First-class Organization/Profile Secrets remain on Arbor's collaboration MCP because they are broader identity-owned resources; App configuration here references existing Secret ids and never accepts or returns secret material.
@@ -10836,7 +10929,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_run_receipt",
     title: "Read a run receipt",
-    description: "Observe one Run's durable receipt during or after execution, including its finishRequest, Run-owned operation/activity state, and compact providerLifecycle journal; reading it never advances a pending finish. Use this instead of parent computer_status for compact history rather than transcripts; it does not rewrite terminal reasonCode.",
+    description: "Read a Run's durable receipt, including finishRequest, derived finishContinuation, Run-owned operation/activity state, and compact providerLifecycle. A verified pending continuation names the stage the existing owner is retrying with callerAction none; reads never advance finish or rewrite terminal reasonCode, so use this instead of parent computer_status for compact history.",
     inputSchema: {
       runId: string2().describe("the run to read, run_… (from computer_run_start or computer_runs)")
     },
@@ -10895,7 +10988,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_process_terminate",
     title: "Terminate a background process",
-    description: "Terminate a background process started by computer_exec when it should no longer run, stopping the provider-owned process tree without shell PIDs or ps/kill. Repeating terminate for an already-absent or already-complete process is a no-op that settles that exact durable operation from the available evidence.",
+    description: "Request termination once for a computer_exec process without shell PIDs or ps/kill; an already-absent or already-complete process is a no-op. Control performs one bounded native read and returns its actual terminal result, preserving completion races and provider-reported failed signal exits; if uncertain, inspect this process with computer_process_read instead of repeating termination.",
     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"),
@@ -12250,7 +12343,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "tldraw_exec",
     title: "Run a one-shot tldraw program",
-    description: `Modify the current live tldraw board with preferred declarative operations or bounded JavaScript, then return a durable execution receipt; use IDs from a fresh observe, reacquire this current schema after compaction, and never replay an unknown result. First use: read the tldraw guide at ${AGENT_GUIDE_URLS.tldraw}.`,
+    description: `Modify the current live tldraw board with preferred declarative operations or bounded JavaScript, including a graph-scoped diagram operation that lays out keyed nodes and native bound edges without caller-supplied coordinates, then return a durable execution receipt; use IDs from a fresh observe, reacquire this current schema after compaction, and never replay an unknown result. First use: read the tldraw guide at ${AGENT_GUIDE_URLS.tldraw}.`,
     inputSchema: {
       artifactId: string2().describe("the tldraw Artifact, art_…"),
       code: string2().min(1).max(1e5).optional().describe("advanced script source; mutually exclusive with operations"),

package/package.json

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