@lambdacurry/arbor 0.23.36 → 0.23.38

package/dist/arbor.js

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "@lambdacurry/arbor",
-  version: "0.23.36",
+  version: "0.23.38",
   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",
@@ -7384,6 +7384,9 @@ var artifactVersions = sqliteTable("artifact_versions", {
   source: text("source").notNull(),
   sourceAttachmentId: text("source_attachment_id").references(() => attachments.id),
   sourceSha256: text("source_sha256"),
+  gitCommitSha: text("git_commit_sha"),
+  gitSourceSha256: text("git_source_sha256"),
+  gitRepositoryName: text("git_repository_name"),
   tldrawDocumentClock: integer2("tldraw_document_clock"),
   editorProfileId: text("editor_profile_id").notNull().references(() => profiles.id),
   executionContextId: text("execution_context_id").references(() => executionContexts.id),
@@ -7392,6 +7395,29 @@ var artifactVersions = sqliteTable("artifact_versions", {
 }, (t) => ({
   artifactVersionUq: uniqueIndex("artifact_versions_artifact_version_uq").on(t.artifactId, t.version)
 }));
+var artifactGitWriteIntents = sqliteTable("artifact_git_write_intents", {
+  artifactId: text("artifact_id").notNull(),
+  requestKey: text("request_key").notNull(),
+  fingerprint: text("fingerprint").notNull(),
+  baseVersion: integer2("base_version").notNull(),
+  expectedParentSha: text("expected_parent_sha"),
+  targetVersion: integer2("target_version").notNull(),
+  targetVersionId: text("target_version_id").notNull(),
+  targetSourceSha256: text("target_source_sha256").notNull(),
+  state: text("state").$type().notNull().default("pending"),
+  gitCommitSha: text("git_commit_sha"),
+  gitRepositoryName: text("git_repository_name"),
+  createdAt: ts("created_at").notNull(),
+  finalizedAt: ts("finalized_at"),
+  requestJson: text("request_json")
+}, (t) => ({
+  pk: primaryKey({ columns: [t.artifactId, t.requestKey] }),
+  pendingUq: uniqueIndex("artifact_git_write_intents_one_pending_uq").on(t.artifactId).where(sql`${t.state} = 'pending'`),
+  targetVersionIdx: index("artifact_git_write_intents_artifact_target_idx").on(t.artifactId, t.targetVersion),
+  stateCheck: check("artifact_git_write_intents_state_check", sql`(${t.state} = 'pending' AND ${t.finalizedAt} IS NULL)
+        OR (${t.state} = 'finalized' AND ${t.gitCommitSha} IS NOT NULL AND ${t.finalizedAt} IS NOT NULL)`),
+  versionCheck: check("artifact_git_write_intents_version_check", sql`${t.baseVersion} >= 0 AND ${t.targetVersion} > 0`)
+}));
 var artifactTldrawBoards = sqliteTable("artifact_tldraw_boards", {
   artifactId: text("artifact_id").primaryKey().references(() => artifacts.id, { onDelete: "cascade" }),
   roomGeneration: integer2("room_generation").notNull().default(1),
@@ -8245,6 +8271,12 @@ var SPACE_ARTIFACT_STATUSES = [
   "archived"
 ];
 var artifactUpdatedAt = sql`coalesce((select max(${events.createdAt}) from ${events} where ${events.objectType} = 'artifact' and ${events.objectId} = ${artifacts.id}), ${artifacts.createdAt})`;
+// ../core/src/ops/artifact-git-intent.ts
+var RETRYABLE_REPAIR = new Set([
+  "pending_push_unconfirmed",
+  "remote_unavailable",
+  "finalize_failed"
+]);
 // ../core/src/ops/request.ts
 var REQUEST_TTL_MS = 14 * 24 * 60 * 60 * 1000;
 
@@ -11133,11 +11165,11 @@ var COMPUTER_ORIENTATION_SECTIONS = [
   },
   {
     brief: "3. Computers are temporary: one Run per task; save work outside the Computer, then finish; suspend for a wait.",
-    full: `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. A local commit or Preview is not Git publication; push Git work or publish/export a needed artifact outside the Computer, then call computer_run_finish when done. Suspend for an external wait. 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 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. 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. Save or publish needed work outside the temporary Computer before suspending or finishing; an isolated local commit or Preview is not Git publication, so 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.`
   },
   {
     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, 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.`
+    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) 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.`
   },
   {
     brief: "5. Git and gh run through `computer_exec` once authorized; fetch before trusting remote state.",
@@ -11954,7 +11986,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_run_suspend",
     title: "Suspend a run",
-    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 same runId resumes. Preserves unread terminal output internally for 30 days; no caller drain is required, and active/unknown work or failed preservation blocks release without replay; save needed work outside the temporary Computer first.",
+    description: "Checkpoint an active WRITE Run for an external wait: save or publish needed work outside the Computer first; shared Runs checkpoint the parent without releasing it, while isolated Runs publish their exact workspace and release the Sandbox; resume with the same runId. 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_…")
     },
@@ -11976,7 +12008,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_run_finish",
     title: "Finish a run",
-    description: "Finish after pushing Git or publishing/exporting artifacts outside this Computer; unread output lasts 30 days. An isolated Run may return status active with finishRequest pending while its owner proves Git durability, quiescence, checkpoint, and release without caller cleanup; send once, read the receipt, and use discard=true with failed or cancelled only to abandon Git after provider quiescence.",
+    description: "Finish after saving/publishing needed work outside the Computer; shared finish checkpoints parent and stops last shared Run; shared discard with failed/cancelled only closes record (no checkpoint, shared stop, unread preservation); isolated discard abandons workspace after quiescence. May stay pending for quiescence, durability, 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"),
@@ -12414,7 +12446,8 @@ var ACTION_DEFINITIONS = [
       baseVersion: number2().describe("the version you READ (get_artifact) — stale is rejected"),
       source: string2().optional().describe("full replace: the complete new content"),
       patches: array(object({ old: string2(), new: string2() })).optional().describe("exact-match hunks applied in order; each old must match exactly once"),
-      note: string2().optional().describe("one-line summary of what changed")
+      note: string2().optional().describe("one-line summary of what changed"),
+      idempotencyKey: string2().min(1).max(200).optional().describe("stable retry key for this logical edit; the CLI derives one from the artifact, base version, and content when omitted")
     },
     surfaces: ["cli"],
     toolset: "artifacts",
@@ -15220,6 +15253,159 @@ function buildInput(inputSchema, flags, command) {
 }
 
 // src/commands.ts
+var SHA256_K = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+function rotateRight(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+function sha256Hex(value) {
+  const bytes = new TextEncoder().encode(value);
+  const bitLength = bytes.length * 8;
+  const paddedLength = bytes.length + 9 + 63 >> 6 << 6;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(bytes);
+  padded[bytes.length] = 128;
+  const highLength = Math.floor(bitLength / 4294967296);
+  const lowLength = bitLength >>> 0;
+  for (let i = 0;i < 4; i++) {
+    padded[paddedLength - 8 + i] = highLength >>> 24 - i * 8;
+    padded[paddedLength - 4 + i] = lowLength >>> 24 - i * 8;
+  }
+  const hash = [
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ];
+  const words = new Uint32Array(64);
+  for (let offset = 0;offset < padded.length; offset += 64) {
+    for (let i = 0;i < 16; i++) {
+      const index = offset + i * 4;
+      words[i] = padded[index] << 24 | padded[index + 1] << 16 | padded[index + 2] << 8 | padded[index + 3];
+    }
+    for (let i = 16;i < 64; i++) {
+      const x = words[i - 15];
+      const y = words[i - 2];
+      const sigma0 = rotateRight(x, 7) ^ rotateRight(x, 18) ^ x >>> 3;
+      const sigma1 = rotateRight(y, 17) ^ rotateRight(y, 19) ^ y >>> 10;
+      words[i] = words[i - 16] + sigma0 + words[i - 7] + sigma1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = hash;
+    for (let i = 0;i < 64; i++) {
+      const sigma1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const choice = e & f ^ ~e & g;
+      const temp1 = h + sigma1 + choice + SHA256_K[i] + words[i] >>> 0;
+      const sigma0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const majority = a & b ^ a & c ^ b & c;
+      const temp2 = sigma0 + majority >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    hash[0] = hash[0] + a >>> 0;
+    hash[1] = hash[1] + b >>> 0;
+    hash[2] = hash[2] + c >>> 0;
+    hash[3] = hash[3] + d >>> 0;
+    hash[4] = hash[4] + e >>> 0;
+    hash[5] = hash[5] + f >>> 0;
+    hash[6] = hash[6] + g >>> 0;
+    hash[7] = hash[7] + h >>> 0;
+  }
+  return hash.map((word) => word.toString(16).padStart(8, "0")).join("");
+}
+function artifactEditIdempotencyKey(input) {
+  const artifactId = input.artifactId;
+  const baseVersion = input.baseVersion;
+  const hasSource = typeof input.source === "string";
+  const hasPatches = Array.isArray(input.patches);
+  if (typeof artifactId !== "string" || !Number.isInteger(baseVersion) || !hasSource && !hasPatches) {
+    return;
+  }
+  const version = baseVersion;
+  const payload = JSON.stringify({
+    artifactId,
+    baseVersion: version,
+    source: hasSource ? input.source : undefined,
+    patches: hasPatches ? input.patches : undefined,
+    note: typeof input.note === "string" ? input.note : undefined,
+    retainSource: typeof input.retainSource === "boolean" ? input.retainSource : undefined
+  });
+  const digest = sha256Hex(payload);
+  return `cli-artifact-edit:${artifactId}:${version}:${digest}`;
+}
 var COMMAND_WORD_OVERRIDES = {
   contribute_arbor_feedback: "feedback",
   feedback_recall: "feedback find",
@@ -15502,6 +15688,11 @@ async function runObjectVerb(positionals, flags, ctx) {
     delete inputFlags.json;
   }
   const input = buildInput(action.inputSchema, inputFlags, commandWords(action));
+  if (action.name === "edit_artifact" && input.idempotencyKey === undefined) {
+    const idempotencyKey = artifactEditIdempotencyKey(input);
+    if (idempotencyKey !== undefined)
+      input.idempotencyKey = idempotencyKey;
+  }
   if (action.name === "computer_exec" && flags["no-wait"] !== undefined && input.waitForTerminalMs !== undefined) {
     throw new UsageError("--no-wait and --wait-for-terminal-ms are mutually exclusive", {
       reason: "validation.invalid_value",

package/package.json

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