@lambdacurry/arbor 0.22.24 → 0.22.26

package/dist/arbor.js

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "@lambdacurry/arbor",
-  version: "0.22.24",
+  version: "0.22.26",
   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",
@@ -6636,6 +6636,7 @@ var computerRuns = sqliteTable("computer_runs", {
   runtimeState: text("runtime_state").$type().notNull().default("shared"),
   runtimeUpdatedAt: ts("runtime_updated_at"),
   gitStart: text("git_start", { mode: "json" }).$type(),
+  finishRequest: text("finish_request", { mode: "json" }).$type(),
   status: text("status").$type().notNull().default("active"),
   label: text("label"),
   reason: text("reason"),
@@ -7976,6 +7977,21 @@ var computerRun = looseObject({
   startedAt: string2(),
   endedAt: string2().nullable()
 });
+var computerRunFinishRequest = looseObject({
+  intentId: id,
+  outcome: _enum(["finished", "failed", "cancelled"]),
+  reason: string2().nullable(),
+  discard: boolean2(),
+  expectedCurrentSnapshotId: id,
+  requestedAt: timestamp,
+  updatedAt: timestamp,
+  state: _enum(["pending", "rejected", "completed"]),
+  phase: _enum(["quiescence", "git", "checkpoint", "release", "rejected"]),
+  reasonCode: string2().nullable(),
+  finishAssessment: computerRunFinishAssessment.nullable(),
+  providerGeneration: number2().int().nonnegative().nullable(),
+  releasedSnapshotId: id.nullable()
+});
 var computerRunReceipt2 = looseObject({
   runId: id,
   threadId: id,
@@ -7995,6 +8011,7 @@ var computerRunReceipt2 = looseObject({
   gitStart: computerRunGitStart.nullable().optional(),
   durability: computerRunDurability,
   finishAssessment: computerRunFinishAssessment.nullable(),
+  finishRequest: computerRunFinishRequest.nullable(),
   status: _enum(["active", "finished", "failed", "cancelled"]),
   outcome: _enum(["finished", "failed", "cancelled"]).nullable(),
   reason: string2().nullable(),
@@ -9119,10 +9136,12 @@ var MCP_OUTPUT_SCHEMAS = {
     parentAsleep: boolean2().optional()
   }),
   computer_run_finish: looseObject({
+    runId: id,
     status: string2(),
     replayed: boolean2(),
     durability: computerRunDurability,
     finishAssessment: computerRunFinishAssessment.nullable(),
+    finishRequest: computerRunFinishRequest.nullable(),
     parent: object({
       checkpoint: string2().nullable(),
       stopped: boolean2(),
@@ -9606,10 +9625,12 @@ var OUTPUT_SHAPERS = {
   computer_run_finish: (result) => {
     const run = record2(result.run) ?? {};
     return defined([
+      ["runId", run.runId],
       ["status", run.status],
       ["replayed", result.replayed],
       ["durability", run.durability],
       ["finishAssessment", result.finishAssessment],
+      ["finishRequest", result.finishRequest ?? null],
       ["parent", result.parent]
     ]);
   },
@@ -10024,8 +10045,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 and prove it with computer_repo_work_status before computer_run_finish destroys the final placement. discard=true with outcome failed or cancelled is the explicit choice to abandon unknown or proven non-durable work without replaying it.
-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) makes the final one; finishing the last active shared Run also stops the parent. 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 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.
 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.
@@ -10801,7 +10822,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_run_finish",
     title: "Finish a run",
-    description: "Finish a Run with unread terminal output preserved for 30 days without caller drain; active/unknown work, failed preservation, incomplete Git discovery, or unsafe worktrees block release. The last shared Run stops the parent; to abandon an unknown or non-durable disposable Run, pass discard=true with outcome failed or cancelled and retry safely from its receipt.",
+    description: "Request final Run release with unread terminal output preserved for 30 days. An isolated Run may return status active with finishRequest pending while its lifecycle owner proves quiescence, Git durability, checkpoint, and release without caller cleanup; send once, observe the receipt optionally, and use discard=true with failed or cancelled only to abandon Git after provider quiescence.",
     inputSchema: {
       runId: string2().describe("the runId returned by computer_run_start, run_…"),
       outcome: _enum(["finished", "failed", "cancelled"]).optional().describe("terminal outcome; defaults to finished"),
@@ -10815,7 +10836,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_run_receipt",
     title: "Read a run receipt",
-    description: "Inspect one Run's durable receipt during or after execution, including its Run-owned operation/activity state and a compact providerLifecycle journal (generation, last phase, typed reason) separate from command/process activity. Use this instead of parent computer_status; it returns compact history, not transcripts, and does not rewrite terminal reasonCode.",
+    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.",
     inputSchema: {
       runId: string2().describe("the run to read, run_… (from computer_run_start or computer_runs)")
     },

package/package.json

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