@lambdacurry/arbor 0.21.0 → 0.21.2

package/dist/arbor.js

@@ -2072,6 +2072,9 @@ var computerRuns = sqliteTable("computer_runs", {
   execution: text("isolation").$type().notNull(),
   workspaceDir: text("workspace_dir").notNull(),
   baseSnapshotId: text("base_snapshot_id"),
+  currentSnapshotId: text("current_snapshot_id"),
+  runtimeState: text("runtime_state").$type().notNull().default("shared"),
+  runtimeUpdatedAt: ts("runtime_updated_at"),
   gitStart: text("git_start", { mode: "json" }).$type(),
   status: text("status").$type().notNull().default("active"),
   label: text("label"),
@@ -2082,13 +2085,15 @@ var computerRuns = sqliteTable("computer_runs", {
   computerIdx: index("computer_runs_computer_idx").on(t.computerId, t.startedAt),
   threadIdx: index("computer_runs_thread_idx").on(t.threadId, t.startedAt),
   sessionIdx: index("computer_runs_session_idx").on(t.computerSessionId, t.startedAt),
-  statusIdx: index("computer_runs_status_idx").on(t.computerId, t.status)
+  statusIdx: index("computer_runs_status_idx").on(t.computerId, t.status),
+  runtimeIdx: index("computer_runs_runtime_idx").on(t.computerId, t.runtimeState)
 }));
 var computerSnapshots = sqliteTable("computer_snapshots", {
   id: text("id").primaryKey(),
   ownerScope: text("owner_scope").$type().notNull(),
   topicId: text("topic_id").notNull().references(() => topics.id),
   computerId: text("computer_id").references(() => threadComputers.id),
+  runId: text("run_id").references(() => computerRuns.id),
   parentSnapshotId: text("parent_snapshot_id"),
   lineageKey: text("lineage_key"),
   configKey: text("config_key"),
@@ -2104,6 +2109,7 @@ var computerSnapshots = sqliteTable("computer_snapshots", {
   topicBaseIdx: uniqueIndex("computer_snapshots_topic_base_idx").on(t.topicId, t.configKey),
   lineageIdx: uniqueIndex("computer_snapshots_lineage_idx").on(t.lineageKey),
   computerIdx: index("computer_snapshots_computer_idx").on(t.computerId, t.createdAt),
+  runIdx: index("computer_snapshots_run_idx").on(t.runId, t.createdAt),
   parentIdx: index("computer_snapshots_parent_idx").on(t.parentSnapshotId)
 }));
 var previews = sqliteTable("previews", {
@@ -17249,6 +17255,11 @@ var computerRunPublication = exports_external.looseObject({
   reasonCode: exports_external.string(),
   remoteRef: exports_external.string().optional()
 });
+var computerRunRuntime = exports_external.looseObject({
+  state: exports_external.enum(["shared", "live", "suspended", "released"]),
+  currentSnapshotId: id.nullable(),
+  updatedAt: exports_external.string().nullable()
+});
 var computerRunDurability = exports_external.looseObject({
   workspace: exports_external.enum(["shared", "isolated"]),
   parentMutation: exports_external.enum(["direct", "none"]),
@@ -17330,6 +17341,8 @@ var computerRun = exports_external.looseObject({
   execution: exports_external.enum(["shared", "isolated"]),
   workspaceDir: exports_external.string(),
   baseSnapshotId: id.nullable(),
+  currentSnapshotId: id.nullable().optional(),
+  runtime: computerRunRuntime,
   gitStart: computerRunGitStart.nullable().optional(),
   durability: computerRunDurability,
   status: exports_external.enum(["active", "finished", "failed", "cancelled"]),
@@ -17353,6 +17366,7 @@ var computerRunReceipt = exports_external.looseObject({
   execution: exports_external.enum(["shared", "isolated"]),
   workspace: exports_external.looseObject({ dir: exports_external.string() }),
   baseSnapshotId: id.nullable(),
+  runtime: computerRunRuntime,
   gitStart: computerRunGitStart.nullable().optional(),
   durability: computerRunDurability,
   finishAssessment: computerRunFinishAssessment.nullable(),
@@ -17717,6 +17731,18 @@ var MCP_OUTPUT_SCHEMAS = {
     association: jsonObject.nullable(),
     message: exports_external.string()
   }),
+  feedback_status: exports_external.object({
+    feedbackId: id,
+    type: exports_external.enum(ARBOR_FEEDBACK_TYPES),
+    status: exports_external.enum(ARBOR_FEEDBACK_STATUSES),
+    private: exports_external.literal(true),
+    associatedWithSharedKnowledge: exports_external.boolean(),
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    reviewedAt: timestamp.nullable(),
+    resolvedAt: timestamp.nullable(),
+    message: exports_external.string()
+  }),
   admin_feedback_capability: jsonObject,
   admin_feedback_evidence: jsonObject,
   admin_feedback_topic: jsonObject,
@@ -18081,6 +18107,12 @@ var MCP_OUTPUT_SCHEMAS = {
     durability: computerRunDurabilitySummary,
     status: exports_external.string()
   }),
+  computer_run_suspend: exports_external.looseObject({
+    runId: id,
+    runtime: computerRunRuntime,
+    replayed: exports_external.boolean(),
+    snapshotId: id.nullable()
+  }),
   computer_run_finish: exports_external.looseObject({
     status: exports_external.string(),
     replayed: exports_external.boolean(),
@@ -18464,6 +18496,15 @@ var OUTPUT_SHAPERS = {
       ["status", run.status]
     ]);
   },
+  computer_run_suspend: (result) => {
+    const run = record2(result.run) ?? {};
+    return defined([
+      ["runId", run.runId],
+      ["runtime", selected(run.runtime, ["state", "currentSnapshotId", "updatedAt"])],
+      ["replayed", result.replayed],
+      ["snapshotId", result.snapshotId]
+    ]);
+  },
   computer_run_finish: (result) => {
     const run = record2(result.run) ?? {};
     return defined([
@@ -18565,6 +18606,7 @@ var MCP_TOOL_ANNOTATIONS = {
   feedback_recall: readOnly,
   feedback_thread_get: readOnly,
   contribute_arbor_feedback: additive,
+  feedback_status: readOnly,
   admin_feedback_capability: destructiveIdempotent,
   admin_feedback_evidence: destructive,
   admin_feedback_topic: destructive,
@@ -18642,6 +18684,7 @@ var MCP_TOOL_ANNOTATIONS = {
   computer_open: additive,
   computer_reprovision: destructiveIdempotent,
   computer_run_start: additive,
+  computer_run_suspend: idempotent,
   computer_repo_work_status: readOnly,
   computer_run_finish: idempotent,
   computer_run_receipt: readOnly,
@@ -18679,9 +18722,10 @@ var CONTRIBUTION_ADD_LINK_RELS = [
   "tracked-as",
   "delivered-by"
 ];
+var ARBOR_FEEDBACK_GUIDANCE = `ARBOR-SPECIFIC FEEDBACK — Privately capture ONE bounded report through \`contribute_arbor_feedback\` when Arbor itself caused meaningful friction: confusing semantics; surprising Arbor UI/MCP/CLI behavior; a missing Arbor capability; repeated Arbor retries; an Arbor-specific workaround; or misleading state, recovery guidance, or ergonomics. Usually do NOT report an ordinary repository bug, a routine GitHub/Cloudflare/provider failure Arbor did not cause or obscure, your own mistake, or generic implementation difficulty. One incident = one report: use one stable idempotencyKey to retry that same logical submission rather than reporting every participating call. Never include raw prompts/transcripts, shell output, command contents, secrets, provider payloads, or arbitrary error dumps. The raw body remains private; \`feedback_status\` reads only a receipt you own, while \`feedback_tree\` → \`feedback_recall\` → \`feedback_thread_get\` browses deliberately shared, sanitized knowledge.`;
 var ORIENTATION = `Arbor is your team's deliberation room and shared memory — people and agents settle typed work here, and Arbor remembers what's decided. To work well:
 
-Meaningful friction with Arbor itself can be privately contributed through \`contribute_arbor_feedback\`; the raw body is never posted into the current Thread or the shared Arbor Feedback forum. Browse the curated shared forum with \`feedback_tree\` → \`feedback_recall\` → \`feedback_thread_get\`.
+${ARBOR_FEEDBACK_GUIDANCE}
 
 Arbor's MCP is the collaboration and durable-knowledge surface. Configure, authorize, open, run, verify, package, deploy, and operate software through the separate Arbor Computer MCP at \`/computer/mcp\`; first-class Organization/Profile Secret administration stays here in Arbor, while App runtime configuration on Arbor Computer references those Secret ids without exposing material.
 
@@ -18696,6 +18740,19 @@ Arbor's MCP is the collaboration and durable-knowledge surface. Configure, autho
 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.
 
 Run \`arbor help\` (or read the MCP tool list) for the exact command/flags — those stay generated from the live action surface, so they're always current.`;
+var COMPUTER_ORIENTATION = `Arbor Computer is the complete software execution platform attached to Arbor's durable collaboration graph. It configures project environments, executes and verifies work, packages and releases Apps, and preserves reviewable evidence; it does not schedule agents or replace Arbor collaboration.
+
+${ARBOR_FEEDBACK_GUIDANCE}
+
+1. ORIENT, CONFIGURE, AND AUTHORIZE. Start with get_computer(threadId) to inspect the effective inherited recipe, repository authorization, compatibility, and durable lineage. 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_repositories then github_connect_repository to authorize repositories at the narrowest scope that should inherit them. attach_computer mints durable protocol identity without starting a runtime; computer_open attaches as needed and starts or resumes the project environment. 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. computer_open and computer_status describe the live PARENT Thread Computer and return the exact computerSessionId for parent filesystem, command, checkpoint, Preview, bundle, and stop operations. computer_status does not establish isolated Run activity; 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. Once every operation is settled, computer_run_suspend publishes the exact workspace and releases the provider during an external wait; the next Run-aware operation restores that checkpoint under the same runId automatically. Suspension refuses active processes or unsettled outcomes and never replays unknown work, so reconcile process and Git/publication evidence first. 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 is the explicit choice to destroy proven non-durable work.
+4. CHECKPOINT COMPLETE PARENT UNITS. computer_checkpoint advances immutable parent lineage after an intermediate complete unit; computer_stop performs the final checkpoint before teardown. 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; 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. Then 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.
+8. FINISH WHAT YOU START. Stop the parent after its final complete unit, finish every Run, and preserve evidence before teardown. When reporting collaboration conclusions through Arbor, pass the producing computerSessionId and attachmentIds to contribute or respond.
+9. CLOSE OUT ARBOR DOGFOOD. When developing Arbor through Arbor, ask: “Did Arbor itself create meaningful friction or require an Arbor-specific workaround?” If yes, apply the classifier above and privately capture one bounded report before closing the development loop; keep unrelated product friction out of the implementation Thread. If no, close normally without manufacturing feedback.`;
 var PROSE_LISTS = exports_external.registry();
 function proseList(description) {
   const schema = exports_external.array(exports_external.string()).describe(description);
@@ -18845,7 +18902,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "contribute_arbor_feedback",
     title: "Privately contribute feedback about Arbor",
-    description: "Privately contribute feedback about using Arbor, including friction, evidence, critiques, questions, risks, or improvement proposals. The submitted body is not posted into the current Thread or shared Arbor Feedback forum; optional Topic/Thread ids only associate the private evidence with sanitized shared knowledge.",
+    description: "Privately capture one bounded report when Arbor itself caused meaningful product or ergonomics friction; do not use this for ordinary repository bugs, routine un-obscured provider failures, agent mistakes, or generic implementation difficulty. The body is never posted into the current Thread or shared forum; one incident should produce one report, with a stable idempotencyKey used only to retry that same submission.",
     inputSchema: {
       type: exports_external.enum(ARBOR_FEEDBACK_TYPES).optional().describe("the contribution move (default comment); decision is reserved for shared forum curation"),
       body: exports_external.string().min(1).describe("the private feedback body"),
@@ -18860,6 +18917,17 @@ var ACTION_DEFINITIONS = [
     toolset: "feedback",
     run: forward("feedback.contribute")
   },
+  {
+    name: "feedback_status",
+    title: "Check your private Arbor feedback receipt",
+    description: "READ ONLY: Check the useful lifecycle of one private Arbor feedback receipt you own. Missing and not-owned receipts look identical, and this returns no raw body, identities, moderator diagnostics, or shared association targets.",
+    inputSchema: {
+      feedbackId: exports_external.string().describe("your private Arbor feedback receipt id, fbk_…")
+    },
+    surfaces: ["mcp", "cli"],
+    toolset: "feedback",
+    run: forward("feedback.status")
+  },
   {
     name: "admin_feedback_capability",
     title: "Manage Arbor Feedback capabilities",
@@ -19242,6 +19310,17 @@ var ACTION_DEFINITIONS = [
     toolset: "loop",
     run: forward("computer_runtime.run_start")
   },
+  {
+    name: "computer_run_suspend",
+    title: "Suspend a run",
+    description: "Checkpoint an active isolated WRITE Run's exact workspace, publish that Run-owned restore point, and release its provider Sandbox during an external wait; the same runId resumes automatically on its next operation. Refuses active processes or unsettled mutations and never replays unknown work.",
+    inputSchema: {
+      runId: exports_external.string().describe("the active isolated WRITE Run to suspend, run_…")
+    },
+    surfaces: ["computer-mcp", "computer-cli"],
+    toolset: "loop",
+    run: forward("computer_runtime.run_suspend")
+  },
   {
     name: "computer_repo_work_status",
     title: "Inspect repository finish state",
@@ -20138,7 +20217,7 @@ var ACTION_DEFINITIONS = [
   {
     name: "service_register",
     title: "Register a Computer lifecycle service",
-    description: "Register a persistent service identity for Currybox Computer lifecycle maintenance and mint its API key (shown ONCE). Human owner/admin CLI setup only. The credential is restricted to computer.get + computer.lifecycle_runs + computer.checkpoint + computer.reconcile_runs and to the Spaces listed here; store it as the Currybox control plane's Arbor credential.",
+    description: "Register a persistent service identity for Currybox Computer lifecycle maintenance and mint its API key (shown ONCE). Human owner/admin CLI setup only. The credential is restricted to computer.get + computer.lifecycle_runs + computer.checkpoint + computer.suspend_run + computer.resume_run + computer.reconcile_runs and to the Spaces listed here; store it as the Currybox control plane's Arbor credential.",
     inputSchema: {
       displayName: exports_external.string().min(1).describe("the service display name, e.g. Currybox lifecycle service"),
       spaceIds: exports_external.array(exports_external.string().min(1)).min(1).describe("Spaces whose Thread computers the service may maintain")
@@ -21536,7 +21615,8 @@ function buildInput(inputSchema, flags, command) {
 var COMMAND_WORD_OVERRIDES = {
   contribute_arbor_feedback: "feedback",
   feedback_recall: "feedback find",
-  feedback_thread_get: "feedback thread"
+  feedback_thread_get: "feedback thread",
+  feedback_status: "feedback status"
 };
 function commandWords(action) {
   return COMMAND_WORD_OVERRIDES[action.name] ?? action.name.replace(/_/g, " ");
@@ -21548,6 +21628,7 @@ var POSITIONAL_FIELDS = {
   contribute_arbor_feedback: ["body"],
   feedback_recall: ["query"],
   feedback_thread_get: ["threadId"],
+  feedback_status: ["feedbackId"],
   admin_feedback_capability: ["verb"],
   admin_feedback_evidence: ["verb"],
   admin_feedback_topic: ["action"],
@@ -21557,6 +21638,7 @@ var POSITIONAL_FIELDS = {
   app_fetch: ["appId", "path"],
   app_request: ["appId", "path"],
   computer_run_start: ["computerSessionId", "mode"],
+  computer_run_suspend: ["runId"],
   code_symbols: ["path"],
   code_find_symbol: ["namePath", "path"],
   code_references: ["namePath", "path"],

package/package.json

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