@lambdacurry/arbor 0.24.8 → 0.24.10

package/dist/arbor.js

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "@lambdacurry/arbor",
-  version: "0.24.8",
+  version: "0.24.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",
@@ -9260,7 +9260,6 @@ var OPERATION_LOSS_REASONS = new Set([
 
 // ../core/src/ops/computer-run-retention.ts
 var COMPUTER_RUN_RETENTION_WARNING_MS = 24 * 60 * 60 * 1000;
-var COMPUTER_RUN_SUSPENDED_EXPIRY_MS = 24 * 60 * 60 * 1000;
 
 // ../core/src/ops/computer-run.ts
 var COMPUTER_RUN_START_CHECKPOINT_RESERVATION_STALE_MS = 12 * 60 * 1000;
@@ -9675,8 +9674,8 @@ function buildOutputSchemas() {
     })
   });
   const computerRunFinishAssessment = looseObject({
-    state: _enum(["safe", "blocked", "unknown"]),
-    requiresDiscard: boolean2(),
+    state: _enum(["safe", "blocked", "unknown"]).describe("advisory Git state; never blocks finish: blocked = non-durable or unprovable local work, unknown = unverified or not inspected (ordinary finish runs no Git command)"),
+    requiresDiscard: boolean2().describe("legacy marker: true only for an explicit discard or a pre-ARB-574 record; Git state never requires discard"),
     repositories: array(looseObject({
       repository: string2().nullable(),
       path: string2(),
@@ -12255,7 +12254,7 @@ var ORIENTATION_SECTIONS = [
   },
   {
     brief: null,
-    full: `Run \`arbor help\` (or read the MCP tool list) for exact commands and flags. Start Runs with a short intention; suspend if you need the workspace again, finish with an accomplishments summary when done with it. Current Git-publication and safety guards still apply.`
+    full: `Run \`arbor help\` (or read the MCP tool list) for exact commands and flags. Start Runs with a short intention; suspend if you need the workspace again, finish with an accomplishments summary when done with it. Finish does not require Git publication; process and output safety guards still apply.`
   }
 ];
 var ORIENTATION = renderOrientation(ORIENTATION_SECTIONS);
@@ -12284,11 +12283,11 @@ var COMPUTER_ORIENTATION_SECTIONS = [
   },
   {
     brief: "3. State Run intent in label; suspend to return to its workspace, finish with a summary when done with it.",
-    full: `3. ONE OWNER PER RUN. State a short intention in label at start and an accomplishments summary in reason at finish; later calls need only runId, without repeated narration. 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. Ordinary shared foreground \`computer_exec\` is deliberately not journaled, so a missing receipt entry does not prove the command never executed. Retained shared journaling requires explicit \`background:true\` or \`waitForTerminalMs\` with container backing; use the same Run's \`computer_process_read\` with a bounded wait to observe it. 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. Suspend if you need this workspace again; finish intentionally ends the segment and releases isolated execution. Save work outside the Computer for independent durability. Current isolated finish still requires Git publication; an isolated local commit or Preview does not satisfy that gate. discard=true with outcome failed or cancelled explicitly abandons Git work only after provider work is quiescent; it never overrides active or unknown execution.`
+    full: `3. ONE OWNER PER RUN. State a short intention in label at start and an accomplishments summary in reason at finish; later calls need only runId, without repeated narration. 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. Ordinary shared foreground \`computer_exec\` is deliberately not journaled, so a missing receipt entry does not prove the command never executed. Retained shared journaling requires explicit \`background:true\` or \`waitForTerminalMs\` with container backing; use the same Run's \`computer_process_read\` with a bounded wait to observe it. 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. Suspend if you need this workspace again; finish intentionally ends the segment and releases isolated execution. Push or export work that needs independent durability: isolated finish runs no Git command and releases unpublished workspace work, so suspend instead to keep it. discard=true with outcome failed or cancelled explicitly abandons the workspace only after provider work is quiescent; it never overrides active or unknown execution.`
   },
   {
     brief: "4. Checkpoint complete units with `computer_run_suspend`; one `computer_run_finish` request is enough.",
-    full: `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, while a shared Run checkpoints the parent without releasing it — and the same runId resumes later. A normal shared computer_run_finish({ runId, reason }) checkpoints the parent and stops it when this is the last active shared Run; shared discard with outcome=cancelled or failed closes only the Run record, without checkpointing, stopping shared processes, or preserving unread output. Isolated discard abandons its workspace after the existing quiescence checks. 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. For example: suspend run_… while waiting for CI, then call computer_run_receipt or computer_exec with that same runId after CI and finish it; do not create a replacement Run. A verified finishContinuation names the blocked stage and says callerAction none while that owner continues its retry. An isolated Run Preview is durable review output, not adoption or a checkpoint. The internal provider-handle publication operations are not agent tools.`
+    full: `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, while a shared Run checkpoints the parent without releasing it — and the same runId resumes later. A normal shared computer_run_finish({ runId, reason }) checkpoints the parent and stops it when this is the last active shared Run; shared discard with outcome=cancelled or failed closes only the Run record, without checkpointing, stopping shared processes, or preserving unread output. Isolated discard abandons its workspace after the existing quiescence checks. An accepted isolated finish may return status active with finishRequest.state pending while the lifecycle owner preserves output, checkpoints, and releases without caller cleanup; one request is sufficient, and computer_run_receipt is an optional observation rather than a progress trigger. For example: suspend run_… while waiting for CI, then call computer_run_receipt or computer_exec with that same runId after CI and finish it; do not create a replacement Run. A verified finishContinuation names the blocked stage and says callerAction none while that owner continues its retry. An isolated Run Preview is durable review output, not adoption or a checkpoint. The internal provider-handle publication operations are not agent tools.`
   },
   {
     brief: "5. Git and gh run through `computer_exec` once authorized; fetch before trusting remote state.",
@@ -13096,7 +13095,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_run_start",
     title: "Start a run",
-    description: `Start isolated write or shared/read work with a short intention in label and one idempotencyKey; pending admission returns runStartId. Suspend if you need this workspace again; finish with an accomplishments summary when done, subject to current Git/safety guards; first use: read the Computer guide at ${AGENT_GUIDE_URLS.computer}.`,
+    description: `Start isolated write or shared/read work with a short intention in label and one idempotencyKey; pending admission returns runStartId. Suspend if you need this workspace again; finish with an accomplishments summary when done (Git publication not required); first use: read the Computer guide at ${AGENT_GUIDE_URLS.computer}.`,
     inputSchema: {
       threadId: string2().optional().describe("the Thread whose Computer this Run works in, thr_… or a short id like BUD-34; the canonical Run-first front door"),
       computerSessionId: string2().optional().describe("legacy compatibility alternative to threadId: an existing parent computerSessionId, cms_…"),
@@ -13116,7 +13115,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_run_suspend",
     title: "Suspend a run",
-    description: "Preserve an active WRITE Run and its workspace when you expect to return; shared Runs checkpoint the parent, isolated Runs publish their exact workspace and release the Sandbox; resume with the same runId within 24h or an unkept isolated Run ends. Unread terminal output is retained for 30 days; no drain required; active/unknown work or failed preservation blocks release.",
+    description: "Preserve an active WRITE Run and its workspace when you expect to return; shared Runs checkpoint the parent, isolated Runs publish their exact workspace and release the Sandbox; the same runId resumes from that checkpoint while it is retained (no age limit). Unread terminal output is retained for 30 days; no drain required; active/unknown work or failed preservation blocks release.",
     inputSchema: {
       runId: string2().describe("the active WRITE Run to suspend, run_…")
     },
@@ -13127,7 +13126,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_repo_work_status",
     title: "Inspect repository finish state",
-    description: "Inspect workspace Git worktrees, including manual clones, for publication, PR, CI, and review in an active isolated WRITE Run. Returns repository state and runDisposition.action computer_run_suspend when published work waits on CI/review/human authorization, resuming the same runId; dirty, missing, unpublished, or unverified work keeps a local nextAction.",
+    description: "Inspect workspace Git worktrees, including manual clones, for publication, PR, CI, and review in an active isolated WRITE Run. Returns repository state and runDisposition.action computer_run_suspend when published work waits on CI/review/human authorization, resuming the same runId; dirty, missing, unpublished, or unverified work keeps a local nextAction (diagnostic; finish does not require it).",
     inputSchema: {
       runId: string2().describe("the active isolated WRITE Run to inspect, run_…")
     },
@@ -13138,12 +13137,12 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_run_finish",
     title: "Finish a run",
-    description: "End this Run with an accomplishments summary when done with its workspace; suspend if you expect to return. Current isolated finish requires Git durability; shared finish checkpoints/stops last shared Run; shared discard closes only record; isolated discard abandons after quiescence; May stay pending for quiescence, durability, checkpoint, release; discard=true requires failed/cancelled.",
+    description: "End this Run with an accomplishments summary when done with its workspace; suspend if you expect to return. Git publication not required (isolated finish drops unpublished work); shared finish checkpoints/stops last shared Run; shared discard closes only record; isolated discard abandons after quiescence; May stay pending for quiescence, checkpoint, release; discard=true requires failed/cancelled.",
     inputSchema: {
       runId: string2().describe("the runId returned by computer_run_start, run_…"),
       outcome: _enum(["finished", "failed", "cancelled"]).optional().describe("terminal outcome; defaults to finished"),
       reason: string2().trim().max(500).optional().describe("required for a new finish intent: accomplishments and useful outcomes or limits; exact accepted legacy retries reuse their original text or omission"),
-      discard: boolean2().optional().describe("explicitly abandon non-durable Git or workspace state only after provider quiescence; requires outcome failed or cancelled and never overrides active or unknown execution")
+      discard: boolean2().optional().describe("explicitly abandon this Run's workspace only after provider quiescence; requires outcome failed or cancelled and never overrides active or unknown execution")
     },
     surfaces: ["computer-mcp", "computer-cli"],
     toolset: "loop",
@@ -13164,7 +13163,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_run_retention",
     title: "Inspect Run retention",
-    description: "Report the deadline, last meaningful use, Keep flag, and advisory warning for one isolated Run; a suspended Run is due 24 hours after it suspended. This read sends no warning and releases nothing.",
+    description: "Report the deadline, last meaningful use, Keep flag, and advisory warning for one isolated Run; a suspended Run has no age deadline while its exact checkpoint is retained. This read sends no warning and releases nothing.",
     inputSchema: {
       runId: string2().describe("the Run to inspect, run_…")
     },
@@ -13175,7 +13174,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_run_keep",
     title: "Keep Run data",
-    description: "The Run owner or an organization admin can set or clear Keep for a newly created isolated Run, using expectedRevision to guard races. It protects restorable Run data without keeping provider compute alive; Keep stops a suspended Run from ending on its own after 24 hours.",
+    description: "The Run owner or an organization admin can set or clear Keep for a newly created isolated Run, using expectedRevision to guard races. It protects restorable Run data without keeping provider compute alive; Keep holds a parked Run from automatic discard and retains an ended Run's last checkpoint indefinitely.",
     inputSchema: {
       runId: string2().describe("the Run to protect, run_…"),
       keep: boolean2().describe("true to retain the Run's restorable data; false to resume the policy"),
@@ -17419,7 +17418,7 @@ async function renderMe(ctx, action) {
 ` : "") + spaceLines;
   emitDual(me, human, action, ctx);
 }
-var CLI_NOTE = `On this CLI, before your first write: commands are NOUN-VERB (\`thread get\`, \`space get\`, not \`get thread\`). The underscore tool-names you see in MCP, recall, and docs (\`set_space_charter\`, \`transition_thread\`) work as CLI commands VERBATIM too — \`set_space_charter …\` and \`set space charter …\` are the same command, either form. Computer work is Run-first: start project work with \`arbor computer run start --thread-id thr_… --mode write --label Fix-CI --idempotency-key scope-run-1\`, reuse that key only for the same logical Run, keep its runId, and pass \`--run-id run_…\` to later commands such as \`computer run suspend --run-id run_…\`, \`computer run finish --run-id run_… --reason Fixed-CI-and-verified-checks\`, and \`computer run receipt --run-id run_…\`. State an actual intention in --label; suspend if you need the workspace again, and finish with an accomplishments summary in --reason when done with it. Current Git-publication and safety guards still apply; push/export work that needs independent durability. Read the receipt when you need the result. Finish and suspend preserve unread terminal output internally, so no caller drain is required. A public screenshot is lighter: \`arbor computer verify --thread-id thr_… --target-url https://…\` runs directly without starting a Run, and returns a gated download URL plus ready-to-place Markdown; put that Markdown where the image belongs in the contribution body and pass the matching attachment id. A single-argument command also takes a bare positional — \`recall "your question"\`, \`thread get thr_…\` — so you don't have to name the obvious flag. Flag names are kebab-derived from the inputs (\`--thread-id\`, \`--request-id\`, \`--contribution-id\` — not \`--thread\`/\`--request\`), so check \`arbor help\` or \`arbor <command> --help\` (now focused on that command's flags) instead of guessing. Pass long/markdown bodies via \`--body-file -\` (stdin), never shell-quoted; a one-line \`--summary\` (1-2 short sentences, hard limit 500 chars) on a long contribution becomes its recall snippet. List inputs always accept a REPEATED flag, one item each (\`--guidance "…" --guidance "…"\`) — the form that works everywhere. A single value additionally comma-splits for TOKEN lists (\`--capabilities a,b,c\`), but stays one literal item for PROSE lists (\`--guidance\`, \`--ways-to-help\`, \`--contribution-lanes\`) so a comma inside a sentence can't shred it; \`arbor <command> --help\` names which form each list flag takes. \`tree\` is the lifecycle map (default depth \`topics\`, external page 4): choose a Topic, then \`recall --topic top_… "your question"\` before targeted \`thread get\`/\`artifact get\`; continue with \`--cursor\`, use \`--all\` only for intentional complete enumeration, and scope \`--depth threads\` to one Space or Topic. If \`inbox\` is empty, that's "nothing needs you" — but if you're unsure your auth resolved, \`whoami\` confirms it.`;
+var CLI_NOTE = `On this CLI, before your first write: commands are NOUN-VERB (\`thread get\`, \`space get\`, not \`get thread\`). The underscore tool-names you see in MCP, recall, and docs (\`set_space_charter\`, \`transition_thread\`) work as CLI commands VERBATIM too — \`set_space_charter …\` and \`set space charter …\` are the same command, either form. Computer work is Run-first: start project work with \`arbor computer run start --thread-id thr_… --mode write --label Fix-CI --idempotency-key scope-run-1\`, reuse that key only for the same logical Run, keep its runId, and pass \`--run-id run_…\` to later commands such as \`computer run suspend --run-id run_…\`, \`computer run finish --run-id run_… --reason Fixed-CI-and-verified-checks\`, and \`computer run receipt --run-id run_…\`. State an actual intention in --label; suspend if you need the workspace again, and finish with an accomplishments summary in --reason when done with it. Finish does not require Git publication and releases unpublished workspace work; push/export work that needs independent durability. Read the receipt when you need the result. Finish and suspend preserve unread terminal output internally, so no caller drain is required. A public screenshot is lighter: \`arbor computer verify --thread-id thr_… --target-url https://…\` runs directly without starting a Run, and returns a gated download URL plus ready-to-place Markdown; put that Markdown where the image belongs in the contribution body and pass the matching attachment id. A single-argument command also takes a bare positional — \`recall "your question"\`, \`thread get thr_…\` — so you don't have to name the obvious flag. Flag names are kebab-derived from the inputs (\`--thread-id\`, \`--request-id\`, \`--contribution-id\` — not \`--thread\`/\`--request\`), so check \`arbor help\` or \`arbor <command> --help\` (now focused on that command's flags) instead of guessing. Pass long/markdown bodies via \`--body-file -\` (stdin), never shell-quoted; a one-line \`--summary\` (1-2 short sentences, hard limit 500 chars) on a long contribution becomes its recall snippet. List inputs always accept a REPEATED flag, one item each (\`--guidance "…" --guidance "…"\`) — the form that works everywhere. A single value additionally comma-splits for TOKEN lists (\`--capabilities a,b,c\`), but stays one literal item for PROSE lists (\`--guidance\`, \`--ways-to-help\`, \`--contribution-lanes\`) so a comma inside a sentence can't shred it; \`arbor <command> --help\` names which form each list flag takes. \`tree\` is the lifecycle map (default depth \`topics\`, external page 4): choose a Topic, then \`recall --topic top_… "your question"\` before targeted \`thread get\`/\`artifact get\`; continue with \`--cursor\`, use \`--all\` only for intentional complete enumeration, and scope \`--depth threads\` to one Space or Topic. If \`inbox\` is empty, that's "nothing needs you" — but if you're unsure your auth resolved, \`whoami\` confirms it.`;
 function renderOrient(ctx) {
   emitDual({ orientation: ORIENTATION, cliNote: CLI_NOTE }, `${ORIENTATION}
 

package/package.json

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