@lambdacurry/arbor 0.14.3 → 0.14.5

package/dist/arbor.js

@@ -38,6 +38,7 @@ var ERROR_REASONS = new Set([
   "authorization.denied",
   "resource.not_found",
   "conflict.state",
+  "conflict.computer_recipe",
   "limit.exceeded",
   "provider.timeout",
   "provider.failure",
@@ -1581,12 +1582,55 @@ var githubWebhookDeliveries = sqliteTable("github_webhook_deliveries", {
 var threadComputers = sqliteTable("thread_computers", {
   id: text("id").primaryKey(),
   threadId: text("thread_id").notNull().references(() => threads.id),
+  generation: integer("generation").notNull().default(1),
   provider: text("provider").$type().notNull(),
+  backend: text("backend").$type().notNull().default("worker-shell"),
+  containerProfile: text("container_profile"),
+  repositories: text("repositories", { mode: "json" }).$type().notNull().default([]),
+  setupScriptConfigured: integer("setup_script_configured", { mode: "boolean" }).notNull().default(false),
+  configKey: text("config_key").notNull().default("legacy"),
+  configRevision: text("config_revision").notNull().default("legacy"),
+  predecessorComputerId: text("predecessor_computer_id"),
+  successorComputerId: text("successor_computer_id"),
+  restoredFromSnapshotId: text("restored_from_snapshot_id"),
   currentSnapshotId: text("current_snapshot_id"),
   createdByProfileId: text("created_by_profile_id").notNull().references(() => profiles.id),
   createdExecutionContextId: text("created_execution_context_id").notNull().references(() => executionContexts.id),
   createdAt: ts("created_at").notNull()
-}, (t) => ({ threadIdx: uniqueIndex("thread_computers_thread_idx").on(t.threadId) }));
+}, (t) => ({
+  threadIdx: index("thread_computers_thread_idx").on(t.threadId, t.generation),
+  generationIdx: uniqueIndex("thread_computers_generation_idx").on(t.threadId, t.generation)
+}));
+var threadComputerHeads = sqliteTable("thread_computer_heads", {
+  threadId: text("thread_id").primaryKey().references(() => threads.id),
+  activeComputerId: text("active_computer_id").notNull().unique().references(() => threadComputers.id),
+  updatedByProfileId: text("updated_by_profile_id").notNull().references(() => profiles.id),
+  updatedExecutionContextId: text("updated_execution_context_id").notNull().references(() => executionContexts.id),
+  updatedAt: ts("updated_at").notNull()
+});
+var computerReprovisions = sqliteTable("computer_reprovisions", {
+  id: text("id").primaryKey(),
+  threadId: text("thread_id").notNull().references(() => threads.id),
+  actorProfileId: text("actor_profile_id").notNull().references(() => profiles.id),
+  executionContextId: text("execution_context_id").notNull().references(() => executionContexts.id),
+  idempotencyKey: text("idempotency_key").notNull(),
+  targetConfigKey: text("target_config_key").notNull(),
+  reason: text("reason").notNull(),
+  status: text("status").$type().notNull().default("pending"),
+  oldComputerId: text("old_computer_id").notNull().references(() => threadComputers.id),
+  newComputerId: text("new_computer_id").references(() => threadComputers.id),
+  sourceSessionId: text("source_session_id"),
+  targetSessionId: text("target_session_id"),
+  checkpointOutcome: text("checkpoint_outcome").$type().notNull().default("not_needed"),
+  restorationOutcome: text("restoration_outcome").$type().notNull().default("not_needed"),
+  restoredSnapshotId: text("restored_snapshot_id"),
+  failureCode: text("failure_code"),
+  createdAt: ts("created_at").notNull(),
+  completedAt: ts("completed_at")
+}, (t) => ({
+  idempotencyIdx: uniqueIndex("computer_reprovisions_idempotency_idx").on(t.threadId, t.actorProfileId, t.idempotencyKey),
+  threadIdx: index("computer_reprovisions_thread_idx").on(t.threadId, t.createdAt)
+}));
 var computerSessions = sqliteTable("computer_sessions", {
   id: text("id").primaryKey(),
   computerId: text("computer_id").notNull().references(() => threadComputers.id),
@@ -16576,6 +16620,15 @@ var computerConfig = exports_external.looseObject({
   setupScript: nullableString,
   repositories: exports_external.array(exports_external.string())
 });
+var redactedComputerRecipe = exports_external.looseObject({
+  provider: exports_external.string(),
+  backend: exports_external.enum(["worker-shell", "container"]),
+  containerProfile: nullableString,
+  repositories: exports_external.array(exports_external.string()),
+  setupScriptConfigured: exports_external.boolean(),
+  configRevision: exports_external.string(),
+  layers: exports_external.array(exports_external.looseObject({ scope: exports_external.string() }))
+});
 var computerConfigLayer = exports_external.looseObject({
   id,
   scope: exports_external.string(),
@@ -16903,11 +16956,20 @@ var MCP_OUTPUT_SCHEMAS = {
   }),
   get_computer: exports_external.looseObject({
     threadId: id,
-    config: computerConfig,
-    topicBase: snapshot.nullable(),
+    config: redactedComputerRecipe,
+    compatibility: exports_external.looseObject({
+      state: exports_external.enum(["ready", "stale_config", "backend_mismatch", "replacement_required"]),
+      reason: exports_external.string(),
+      effectiveRecipe: redactedComputerRecipe,
+      materializedRecipe: redactedComputerRecipe.nullable()
+    }),
+    topicBase: jsonObject.nullable(),
     computer: jsonObject.nullable(),
+    activeGenerationId: id.nullable(),
+    generations: exports_external.array(jsonObject),
     sessions: exports_external.array(jsonObject),
-    lineage: exports_external.array(snapshot)
+    lineage: exports_external.array(jsonObject),
+    reprovisions: exports_external.array(jsonObject)
   }),
   publish_topic_computer: exports_external.looseObject({
     published: exports_external.boolean(),
@@ -17181,6 +17243,19 @@ var MCP_OUTPUT_SCHEMAS = {
     materialized: checkpoint.nullable(),
     runtime: jsonObject
   }),
+  computer_reprovision: exports_external.looseObject({
+    reprovisionId: id,
+    threadId: id,
+    status: exports_external.string(),
+    oldComputerId: id,
+    newComputerId: id.nullable(),
+    computerSessionId: id.nullable(),
+    checkpointOutcome: exports_external.string(),
+    restorationOutcome: exports_external.string(),
+    restoredSnapshotId: id.nullable(),
+    failureCode: exports_external.string().nullable(),
+    reason: exports_external.string()
+  }),
   computer_exec: exports_external.looseObject({
     stdout: exports_external.string().optional(),
     stderr: exports_external.string().optional(),
@@ -17421,6 +17496,7 @@ var MCP_TOOL_ANNOTATIONS = {
   app_archive: additive,
   charter: destructive,
   computer_open: additive,
+  computer_reprovision: destructiveIdempotent,
   computer_exec: destructiveOpenWorld,
   computer_status: readOnly,
   computer_verify: openWorld,
@@ -17459,7 +17535,7 @@ var ORIENTATION = `Arbor is your team's deliberation room and shared memory —
 3. ANSWER through requests. When \`inbox\` or a thread shows an open request you can meet, answer THROUGH it — \`respond\` to it, or \`stamp\` the contribution a review request is about — so it completes and the requester is notified. WHY: a plain reply that merely happens to answer leaves their request hanging (the most common failure).
 4. REVIEW honestly; promote the standout, sparingly. \`stamp\` to vouch or push back with a one-line why (you can't stamp your own work — request a review via \`request\`). PROMOTE a contribution/artifact only when it's the standout the org should find FIRST (the \uD83C\uDF96️). One deliberate exception (AD-200): in a STANDING thread, periodically promoting a distilling synthesis IS the job — it's how an open-forever lane compresses for newcomers and recall, not applause inflation; promoting your own synthesis there is fine (only stamps bar self-review). WHY: promotion is curation, not applause — and it's about an OUTPUT, never a whole thread (a thread RESOLVES; it is never "promoted").
 5. EDIT, don't repost. \`edit\` your own contribution to sharpen it; the record stays audited. A genuinely different point is a NEW contribution.
-6. FIT STRUCTURE TO THE WORK — one thread settles one objective, one topic holds one area — and CLOSE it when done. Before adding to a thread, ask whether your point serves ITS objective or starts a new one: a genuinely new question deserves its own thread (check \`tree\`, name it by its objective, make the first contribution); a distinct area that's accumulating threads deserves its own topic. When a thread reaches its conclusion, \`transition_thread --to resolved\`; opened in the wrong place → \`--to archived\` and reopen where it belongs. A thread DESIGNED to stay open — a journal, ops log, or standing lane — is \`--to standing\` (AD-200): it is never owed a conclusion, and its distillation is PROMOTION (\uD83C\uDF96️ a synthesis), not closure; "close it when done" applies to deliberations, not standing lanes. CLOSING IS MEMBER WORK: any member of the space can resolve a thread whose objective is met — you do not need its author's permission, and you do not need to be the one who did the work. Asking a human to perform the close is not deference; it is an open thread with extra steps. If the objective is met, close it and say why. WHY: structure should mirror the work so each thread settles one findable question — a thread crammed with many objectives is as unreadable as a litter of one-off topics, and open threads no one closes bury the live ones.
+6. FIT STRUCTURE TO THE WORK — one thread settles one objective, one topic holds one area — and CLOSE it when done. Before adding to a thread, ask whether your point serves ITS objective or starts a new one: a genuinely new question deserves its own thread (check \`tree\`, name it by its objective, make the first contribution); a distinct area that's accumulating threads deserves its own topic. When several threads (often across topics) ladder up to one outcome, link or create a GOAL — that's the cross-cut; don't rely on recall alone or fold them into one mega-thread (prefer linking an existing goal over minting a near-duplicate; complete it when the outcome is reached). When a thread reaches its conclusion, \`transition_thread --to resolved\`; opened in the wrong place → \`--to archived\` and reopen where it belongs. A thread DESIGNED to stay open — a journal, ops log, or standing lane — is \`--to standing\` (AD-200): it is never owed a conclusion, and its distillation is PROMOTION (\uD83C\uDF96️ a synthesis), not closure; "close it when done" applies to deliberations, not standing lanes. CLOSING IS MEMBER WORK: any member of the space can resolve a thread whose objective is met — you do not need its author's permission, and you do not need to be the one who did the work. Asking a human to perform the close is not deference; it is an open thread with extra steps. If the objective is met, close it and say why. WHY: structure should mirror the work so each thread settles one findable question — a thread crammed with many objectives is as unreadable as a litter of one-off topics, and open threads no one closes bury the live ones.
 7. ACT, THEN REPORT — escalate by exception (AD-197). Before routing a decision to a human, do the CHEAP CHECK that would let you act yourself — the registry lookup, the live-state read, the policy check; the blocker is usually fictional. Then: recoverable + conclusive evidence → act and say why. Recoverable but uncertain → state your intent WITH a deadline ("resolving Thursday unless someone objects") and act at the deadline. Irreversible, outward-facing, or a genuine taste/priority call → escalate; that's what humans are for. Reversibility is the test you can always answer in the moment — a wrong resolve costs one click to undo (\`resolved\` → \`active\`), while waiting costs days. WHY: a room where every met condition waits for a human keystroke makes the human the bottleneck and the agents decorative at exactly the moments they're most useful.
 
 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.
@@ -17685,7 +17761,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "create_thread",
     title: "Open a thread",
-    description: "Open a NEW deliberation thread under a topic, named by its OBJECTIVE (the question to settle or outcome to reach). Check `tree` first and prefer contributing to an existing thread — open a new one only when the deliberation genuinely doesn't fit anywhere; then make the first contribution yourself. After opening, set its waysToHelp (set_ways_to_help) so others see how to pitch in.",
+    description: "Open a NEW deliberation thread under a topic, named by its OBJECTIVE (the question to settle or outcome to reach). Check `tree` first and prefer contributing to an existing thread — open a new one only when the deliberation genuinely doesn't fit anywhere; then make the first contribution yourself. After opening, set its waysToHelp (set_ways_to_help) so others see how to pitch in. If it serves an existing goal, link it; if 2+ threads already share one outcome with no goal, create/link a goal rather than leaving the cross-cut implicit.",
     inputSchema: {
       spaceId: exports_external.string().describe("the space, spc_…"),
       topicId: exports_external.string().describe("the topic to file it under, top_…"),
@@ -17779,6 +17855,19 @@ var ACTION_DEFINITIONS = [
     toolset: "loop",
     run: forward("computer_runtime.open")
   },
+  {
+    name: "computer_reprovision",
+    title: "Replace a Thread computer",
+    description: "Explicitly replace an incompatible active Computer generation from the Thread's effective recipe. The old generation remains authoritative unless the successor restores supported state and passes health. Same-provider worker-shell→container migration is supported; container→worker-shell and cross-provider migration fail explicitly. Reuse one idempotencyKey only for the same replacement request.",
+    inputSchema: {
+      threadId: exports_external.string().describe("the Thread whose active Computer generation is replaced, thr_…"),
+      idempotencyKey: exports_external.string().min(1).max(200).describe("stable key for this ONE replacement request; reuse it unchanged for retries"),
+      reason: exports_external.string().min(1).max(500).describe("concise auditable reason for replacing the active generation")
+    },
+    surfaces: ["computer-mcp", "computer-cli"],
+    toolset: "loop",
+    run: forward("computer_runtime.reprovision")
+  },
   {
     name: "computer_exec",
     title: "Run a command",
@@ -17988,7 +18077,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "get_computer",
     title: "Read a Thread computer",
-    description: "Read a Thread's effective recipe, stable computer identity, current Topic/Thread snapshot refs, recent attachment receipts, and bounded lineage. This is durable Arbor protocol state, not live process/presence status; use Currybox for ephemeral runtime observations.",
+    description: "Read a Thread's redacted effective recipe, active materialized generation, compatibility state, historical generation lineage, current Topic/Thread snapshot refs, recent attachment receipts, and replacement outcomes. Recipe metadata includes provider/backend/profile/repositories/config revision and whether setup is configured, never setup content or credentials. This is durable Arbor protocol state, not live process/presence status.",
     inputSchema: {
       threadId: exports_external.string().describe("the Thread, thr_…"),
       lineageLimit: exports_external.number().int().min(1).max(100).optional().describe("recent receipts/lineage rows (default 20)")
@@ -18729,7 +18818,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "goal",
     title: "Manage goals",
-    description: "Create, update, change lifecycle, or change the Space/Thread links of a goal (initiative). Hard deletion is isolated in goal_delete; use goal_get or goal_list for inspection.",
+    description: "Create, update, change lifecycle, or change the Space/Thread links of a goal (initiative). Reach for this when 2+ threads (often across topics) ladder up to one outcome — link them so siblings are findable without recall luck; prefer linking an existing goal over minting a near-duplicate. Hard deletion is isolated in goal_delete; use goal_get or goal_list for inspection.",
     inputSchema: {
       verb: exports_external.enum([
         "create",
@@ -19506,6 +19595,11 @@ function parseErrorDetails(value) {
       };
     }
   }
+  if (typeof raw.compatibilityState === "string") {
+    details.compatibilityState = raw.compatibilityState;
+  }
+  if (typeof raw.suggestedAction === "string")
+    details.suggestedAction = raw.suggestedAction;
   return details;
 }
 function detailsForError(err) {

package/package.json

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