@bud.sh/app 0.5.1 → 0.6.0

package/dist/types/assets/{config-DIC2cf_S.d.ts → config-CvcYmE2s.d.ts}

@@ -1,4 +1,4 @@
-import { n as ResolvedPicker, t as BudPicker } from "./picker-D1Bw3ndx.js";
+import { t as ResolvedPicker } from "./picker-Be5Gx4WR.js";
 import { RouteMap } from "remix/routes";
 //#region ../project/src/lib/flows.d.ts
 /**
@@ -55,6 +55,82 @@ interface ResolvedFiles {
   edit: boolean;
 }
 //#endregion
+//#region ../project/src/lib/factory.d.ts
+/** The steps of a factory task, each a status in the project's task store. */
+declare const FACTORY_STATUS_ROLES: readonly ["open", "inProgress", "needsApproval", "readyToMerge", "merged"];
+/** One step of a factory task. */
+type FactoryStatusRole = (typeof FACTORY_STATUS_ROLES)[number];
+/** The project's dev server inside a sandbox: `$PORT` in the command is replaced by `port`. */
+interface BudFactoryDev {
+  command: string;
+  port: number;
+  /** Where Open live preview lands, such as a locale's home page; `/` by default. */
+  path?: string;
+  /** Values the dev server needs, such as a gateway URL; never secrets, which the server adds. */
+  env?: Record<string, string>;
+}
+/** The software factory: comments become tasks that agents finish in sandboxes. */
+interface BudFactory {
+  /** The task store's status for each step; the defaults are Beads' names. */
+  statuses?: Partial<Record<FactoryStatusRole, string>>;
+  /** Moved into plugins: `local()` or `boat()` from `@bud.sh/app/plugins`. */
+  sandbox?: never;
+  /** Moved into plugins: `opencode({ model, keys })` from `@bud.sh/app/plugins`. */
+  agent?: never;
+  /** A shell command run once in a new sandbox's checkout, such as `bun install`. */
+  setup?: string;
+  dev?: BudFactoryDev;
+  /** The prefix of every run's branch; `dev/` by default. */
+  branchPrefix?: string;
+  /**
+   * Minutes a sandbox stays up while its run waits for people (review, a question, a failure);
+   * then it sleeps with its disk kept and wakes when needed. 5 by default; 0 keeps it up.
+   */
+  sleepAfter?: number;
+  /** A `./` Markdown file with project instructions for the agent. */
+  instructions?: string;
+  /**
+   * Where approved branches go: the Git remote (`origin`), and the server environment variable
+   * holding a token that may push them, with the user name its Git host expects (`x-access-token`
+   * for GitHub, `x-token-auth` for Bitbucket). Without a token, Git's own credentials push.
+   */
+  push?: {
+    remote?: string;
+    credential?: string;
+    username?: string;
+  };
+}
+/** The factory as Bud runs it, or null when it is off. */
+interface ResolvedFactory {
+  statuses: Record<FactoryStatusRole, string>;
+  /** The name of the plugin providing the sandboxes, such as `bud:local`. */
+  sandbox: string | null;
+  /**
+   * The agent harness's plugin, its model and the server variables the model needs, from the
+   * harness plugin; OpenCode with DeepSeek V4.1 Flash on its free tier by default.
+   */
+  agent: {
+    harness: string;
+    model: string;
+    keys: string[];
+  };
+  setup: string | null;
+  dev: {
+    command: string;
+    port: number;
+    path: string;
+    env: Record<string, string>;
+  } | null;
+  branchPrefix: string;
+  sleepAfter: number;
+  instructions: string | null;
+  push: {
+    remote: string;
+    credential: string | null;
+    username: string;
+  };
+}
+//#endregion
 //#region ../project/src/lib/theme.d.ts
 /** Token values by name, such as `{ primary: '#f5b700' }`. */
 type BudThemeColors = Readonly<Record<string, string>>;
@@ -99,6 +175,100 @@ interface ResolvedBranches {
   serve: string | null;
 }
 //#endregion
+//#region ../project/src/lib/screens.d.ts
+/** One destination in Bud's navigation: a built-in or a Remix component module in the project. */
+interface BudScreen {
+  id: string;
+  label: string;
+  /** A Bud icon name; defaults to `layers`. */
+  icon?: string;
+  /** One static segment such as `/metrics`; defaults to `/${id}`. */
+  path?: string;
+  /** `./`-relative to the project root (`.ts`, `.tsx`, `.js`, `.jsx`), or a `bud:` built-in. */
+  module: string;
+  /** Optional route metadata shared with defineScreen; checked before the server listens. */
+  routes?: RouteMap;
+}
+/** A validated screen with every field filled in. */
+type ResolvedScreen = Required<Omit<BudScreen, "routes">> & {
+  routes?: RouteMap;
+};
+/**
+ * Bud's browser of your live pages, with their comments.
+ * @returns The built-in screen, ready to relabel by spreading.
+ */
+declare function pages(): ResolvedScreen;
+/**
+ * Bud's canvas of every route's screenshot.
+ * @returns The built-in screen, ready to relabel by spreading.
+ */
+declare function canvas(): ResolvedScreen;
+/**
+ * Bud's Beads task board.
+ * @returns The built-in screen, ready to relabel by spreading.
+ */
+declare function tasks(): ResolvedScreen;
+/**
+ * Bud's file browser and review.
+ * @returns The built-in screen, ready to relabel by spreading.
+ */
+declare function files(): ResolvedScreen;
+//#endregion
+//#region ../project/src/lib/plugins.d.ts
+/**
+ * A Bud plugin as the config sees it: a name, an optional `config` hook and what it contributes.
+ * `@bud.sh/plugin` types the server contributions (stores, sandbox, harness); here they are only
+ * found, so the config knows which plugin provides what.
+ */
+interface BudPluginBase {
+  /** Unique among the project's plugins, such as `bud:beads`. */
+  name: string;
+  /** A human name for what it provides, such as `Beads`. */
+  label?: string;
+  /** `pre` plugins run their hooks first, `post` ones last, as Vite's do. */
+  enforce?: "pre" | "post";
+  /** Adjusts the config before Bud resolves it; return the settings to merge in. */
+  config?(config: BudConfig): Partial<BudConfig> | null | void;
+  /** The task store: an Effect layer providing WorkAdapter, or a function making one. */
+  work?: unknown;
+  /** The discussion store: an Effect layer providing ThreadAdapter, or a function making one. */
+  threads?: unknown;
+  /**
+   * The picker: null for one Bud knows by the plugin's name (`bud:react-grab`), or a `./` browser
+   * module in the project whose default export is a picker adapter.
+   */
+  picker?: string | null;
+  /** A `./` browser module in the project designing the Tasks screen. */
+  taskDesign?: string;
+  /** Screens added to Bud's navigation. */
+  screens?: BudScreen[];
+  /** The factory's sandboxes: a function making a SandboxAdapter. */
+  sandbox?: unknown;
+  /** The factory's agent harness: how its server starts in a sandbox, its model and keys. */
+  harness?: unknown;
+}
+/** What `plugins` takes: plugins, and nothing or nested lists of them, as Vite's does. */
+type BudPluginOption = BudPluginBase | false | null | undefined | readonly BudPluginOption[];
+/**
+ * A task design from the project: a `./` browser module whose default export designs the Tasks
+ * screen.
+ * @param module - The module, such as `./designs/compact-card.tsx`.
+ * @returns The plugin.
+ */
+declare function taskDesign(module: string): {
+  name: string;
+  taskDesign: string;
+};
+/**
+ * A picker from the project: a `./` browser module whose default export is a picker adapter.
+ * @param module - The module, such as `./bud/picker.ts`.
+ * @returns The plugin.
+ */
+declare function picker(module: string): {
+  name: string;
+  picker: string;
+};
+//#endregion
 //#region ../project/src/lib/logo.d.ts
 /**
  * An image in your project, relative to the config, that replaces Bud's mark in the navigation
@@ -192,54 +362,14 @@ interface ResolvedPreviews {
   css: string;
 }
 //#endregion
-//#region ../project/src/lib/screens.d.ts
-/** One destination in Bud's navigation: a built-in or a Remix component module in the project. */
-interface BudScreen {
-  id: string;
-  label: string;
-  /** A Bud icon name; defaults to `layers`. */
-  icon?: string;
-  /** One static segment such as `/metrics`; defaults to `/${id}`. */
-  path?: string;
-  /** `./`-relative to the project root (`.ts`, `.tsx`, `.js`, `.jsx`), or a `bud:` built-in. */
-  module: string;
-  /** Optional route metadata shared with defineScreen; checked before the server listens. */
-  routes?: RouteMap;
-}
-/** A validated screen with every field filled in. */
-type ResolvedScreen = Required<Omit<BudScreen, "routes">> & {
-  routes?: RouteMap;
-};
-/**
- * Bud's browser of your live pages, with their comments.
- * @returns The built-in screen, ready to relabel by spreading.
- */
-declare function pages(): ResolvedScreen;
-/**
- * Bud's canvas of every route's screenshot.
- * @returns The built-in screen, ready to relabel by spreading.
- */
-declare function canvas(): ResolvedScreen;
-/**
- * Bud's Beads task board.
- * @returns The built-in screen, ready to relabel by spreading.
- */
-declare function tasks(): ResolvedScreen;
-/**
- * Bud's file browser and review.
- * @returns The built-in screen, ready to relabel by spreading.
- */
-declare function files(): ResolvedScreen;
-//#endregion
 //#region ../project/src/lib/storage.d.ts
-/** A built-in store, a project-owned server module, or an explicitly disabled store. */
+/** Turns stores off; the stores themselves come from plugins. */
 interface BudStorage {
-  work?: string | false;
-  threads?: string | false;
+  work?: false;
+  threads?: false;
 }
 /** Presentation modules are separate from the server modules that own storage. */
 interface BudDesigns {
-  tasks?: string;
   /**
    * How the Pages sidebar names a page: by its path alone (`path`, the default) or by its title
    * with its path beside it (`title`).
@@ -329,9 +459,14 @@ interface BudConfig {
    * disable it.
    */
   screens?: BudScreen[];
-  /** Storage is server-only. bud:memory is intended for tests and examples. */
+  /**
+   * What extends Bud, as in Vite: stores, a picker, a task design, screens, the factory's sandbox
+   * and agent, each from its package, such as `beads()` from `@bud.sh/beads`.
+   */
+  plugins?: BudPluginOption[];
+  /** Turns a store off: `{ work: false }` hides Tasks' data, `{ threads: false }` comments. */
   storage?: BudStorage;
-  /** Browser presentation modules, independent of storage. */
+  /** How the Pages sidebar names pages; the task design comes from a plugin. */
   designs?: BudDesigns;
   /** Screenshot density and color schemes for the canvas. */
   previews?: BudPreviews;
@@ -350,10 +485,12 @@ interface BudConfig {
   /** The language of Bud's interface: `en` (the default) or `de`. */
   locale?: "en" | "de";
   /**
-   * What finds the element under a comment: `bud:dom` (the default), `bud:react-grab` for React
-   * projects with React Grab installed, or a ./ module in your project exporting a picker adapter.
+   * The software factory, off by default: `{}` turns it on with Beads' status names, and
+   * `statuses` maps its steps to your task store's statuses.
    */
-  picker?: BudPicker;
+  factory?: BudFactory | false;
+  /** Moved into plugins, such as `reactGrab()` from `@bud.sh/picker-react-grab`. */
+  picker?: never;
   /**
    * Branches the canvas captures beside the working tree: main always, others once activated in
    * its sidebar, each built from its latest commit outside your checkout.
@@ -410,8 +547,9 @@ interface ResolvedBudConfig {
   logo: ResolvedLogo | null;
   theme: ResolvedTheme;
   locale: "en" | "de";
+  factory: ResolvedFactory | null;
   picker: ResolvedPicker;
   branches: ResolvedBranches;
 }
 //#endregion
-export { defineConfig as a, files as c, BudTheme as d, ResolvedBudConfig as i, pages as l, BudRoute as n, BudScreen as o, ProjectInfo as r, canvas as s, BudConfig as t, tasks as u };
+export { defineConfig as a, taskDesign as c, files as d, pages as f, ResolvedBudConfig as i, BudScreen as l, BudTheme as m, BudRoute as n, BudPluginBase as o, tasks as p, ProjectInfo as r, picker as s, BudConfig as t, canvas as u };

package/dist/types/assets/{contract-CAT-XFNq.d.ts → contract-B7yuuqSn.d.ts}

@@ -1,4 +1,4 @@
-import { i as ResolvedBudConfig } from "./config-DIC2cf_S.js";
+import { i as ResolvedBudConfig } from "./config-CvcYmE2s.js";
 //#region app/server/hosted/contract.d.ts
 /** How a hosted Bud's captures stand, as its host reports them. */
 interface RemoteBranchState {
@@ -74,6 +74,43 @@ interface HostedAppOptions {
    * restarts its server keeps it, so open pages keep working.
    */
   token?: string;
+  /** What the factory's runs need from the host; without it, tasks can't be started. */
+  factory?: HostedFactory;
+}
+/**
+ * The host's part in factory runs on boat.dev: keys from its secrets, where the project is cloned
+ * from, and how to tell a merge. The host calls `tick` regularly while runs are going.
+ */
+interface HostedFactory {
+  /** The boat.dev API key. */
+  boatToken: string;
+  /** The project's HTTPS clone URL, without credentials. */
+  repository: string;
+  /** Git credentials for cloning; they reach only the clone command. */
+  clone?: {
+    username: string;
+    token: string;
+  } | null;
+  /** A token that may push the runs' branches, with `factory.push.username`; or none yet. */
+  pushToken?: string | null;
+  /** The secret agents' per-run passwords are derived from; the same across restarts. */
+  secret: string;
+  /** Values the model needs in the sandbox, such as its key, by name. */
+  keys?: Record<string, string>;
+  /** Whether the project's main branch contains a commit, through the Git host. */
+  merged?(commit: string): Promise<boolean>;
+  /**
+   * This Bud's public origin, such as its workers.dev URL, where agents in sandboxes read the
+   * task database; without it, agents go without.
+   */
+  tools?: string;
+}
+/** Where a hosted Bud's runs stand after a tick, so the host knows when to tick again. */
+interface HostedFactoryTick {
+  /** A run is setting up, working or pushing: tick again soon. */
+  busy: boolean;
+  /** A pushed run waits for its merge: tick again in a while. */
+  waiting: boolean;
 }
 /** The part of a D1 database the Beads store uses. */
 interface HostedDatabase {
@@ -99,6 +136,11 @@ interface HostedRequestContext {
 interface HostedApp {
   /** Answers one request to Bud, already authenticated by the host. */
   fetch(request: Request, context?: HostedRequestContext): Promise<Response>;
+  /**
+   * Carries the factory's runs on: picks up runs a restart left, follows agents and checks pushed
+   * runs for a merge. Safe to call at any time.
+   */
+  tick(): Promise<HostedFactoryTick>;
   /** Stops its services. */
   dispose(): Promise<void>;
 }
@@ -110,4 +152,4 @@ type CreateHostedApp = (options: HostedAppOptions) => HostedApp;
  */
 declare const hostedScreenModules: readonly string[];
 //#endregion
-export { HostedAuthor as a, HostedStorage as c, HostedAppOptions as i, RemoteBranchState as l, CreateHostedApp as n, HostedDatabase as o, HostedApp as r, HostedRequestContext as s, BranchRemote as t, hostedScreenModules as u };
+export { HostedAuthor as a, HostedFactoryTick as c, RemoteBranchState as d, hostedScreenModules as f, HostedAppOptions as i, HostedRequestContext as l, CreateHostedApp as n, HostedDatabase as o, HostedApp as r, HostedFactory as s, BranchRemote as t, HostedStorage as u };

package/dist/types/assets/{items-CaVkByHk.d.ts → items-BQdaVksf.d.ts}

@@ -126,6 +126,16 @@ interface WorkItemRef {
 }
 /** A field's value: JSON, or the people or items a person or relation field holds. */
 type WorkValue = JsonValue | WorkPerson | WorkPerson[] | WorkItemRef | WorkItemRef[];
+/**
+ * Where a factory run on the item is, for a board badge: its state, and its error when it failed.
+ * The run itself is read through the factory API.
+ */
+interface WorkRunSummary {
+  state: string;
+  error: string | null;
+  /** Whether the run's sandbox sleeps while the run waits. */
+  asleep?: boolean;
+}
 /** One task, with values keyed by its adapter's declared fields. */
 interface WorkItem {
   id: string;
@@ -145,6 +155,7 @@ interface WorkItem {
   };
   ready?: boolean;
   closeable?: boolean;
+  run?: WorkRunSummary;
   /** False for a brief item, which may leave out long Markdown fields. */
   contentLoaded: boolean;
   /** Adapter data outside the declared fields. */
@@ -265,4 +276,4 @@ interface WorkSyncResult extends WorkSync {
  */
 declare function valueByRole(item: WorkItem, schema: WorkSchema, role: FieldRole): WorkValue | undefined;
 //#endregion
-export { JsonValue as C, fieldByRole as S, MessageAuthor as _, WorkDetail as a, StatusSchema as b, WorkPatch as c, WorkSync as d, WorkSyncResult as f, Message as g, valueByRole as h, WorkCreate as i, WorkQuery as l, WorkValue as m, WorkActionInput as n, WorkItem as o, WorkUpdate as p, WorkConnection as r, WorkMutationResult as s, SectionData as t, WorkSnapshot as u, FieldKind as v, WorkSchema as x, FieldSchema as y };
+export { fieldByRole as C, WorkSchema as S, MessageAuthor as _, WorkDetail as a, StatusCategory as b, WorkPatch as c, WorkSync as d, WorkSyncResult as f, Message as g, valueByRole as h, WorkCreate as i, WorkQuery as l, WorkValue as m, WorkActionInput as n, WorkItem as o, WorkUpdate as p, WorkConnection as r, WorkMutationResult as s, SectionData as t, WorkSnapshot as u, FieldKind as v, JsonValue as w, StatusSchema as x, FieldSchema as y };

package/dist/types/assets/memory-state-BBW-FAVA.d.ts

@@ -0,0 +1,236 @@
+import { S as WorkSchema, _ as MessageAuthor, a as WorkDetail, b as StatusCategory, c as WorkPatch, d as WorkSync, f as WorkSyncResult, g as Message, i as WorkCreate, l as WorkQuery, o as WorkItem, r as WorkConnection, s as WorkMutationResult, t as SectionData, u as WorkSnapshot, w as JsonValue } from "./items-BQdaVksf.js";
+import { t as CanvasAnchor } from "./canvas-anchor-CYU3qBPx.js";
+import * as Effect from "effect/Effect";
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Stream from "effect/Stream";
+//#region ../work/src/lib/code-anchor.d.ts
+/**
+ * A code comment's place: an inclusive line range of one file version, with the selected lines and
+ * up to three lines on each side, so it can be found again after the file changes.
+ */
+interface CodeAnchor {
+  readonly type: "code";
+  readonly version: 1;
+  readonly path: string;
+  /** Complete-byte SHA-256 supplied by the Files service, not a mutable branch name. */
+  readonly revision: string;
+  /** The commit the lines come from, or `null` for uncommitted changes. */
+  readonly commit: string | null;
+  /** Which side of a diff the lines are on. */
+  readonly side: "old" | "new";
+  readonly startLine: number;
+  readonly endLine: number;
+  readonly context: {
+    readonly before: readonly string[];
+    readonly selected: readonly string[];
+    readonly after: readonly string[];
+  };
+}
+//#endregion
+//#region ../work/src/lib/threads.d.ts
+declare const threadStatuses: readonly ["open", "in_progress", "needs_approval", "resolved"];
+/** Where a discussion is in its lifecycle. */
+type ThreadStatus = (typeof threadStatuses)[number];
+/** Where a discussion is attached: a page capture or a code capture. */
+type Anchor = CanvasAnchor | CodeAnchor;
+/** A discussion shared by page captures, code captures and linked work items. */
+interface Thread {
+  id: string;
+  status: ThreadStatus;
+  anchor: Anchor | null;
+  itemIds: string[];
+  messages: Message[];
+  messageCount: number;
+  messagesLoaded: boolean;
+  messagesTruncated: boolean;
+  createdAt: string;
+  updatedAt: string;
+  revision: string | null;
+  /** Adapter metadata, including stable source identity for imported discussions. */
+  metadata?: JsonValue;
+}
+/** Which discussion operations an adapter supports. */
+interface ThreadCapabilities {
+  create: boolean;
+  reply: boolean;
+  status: boolean;
+  link: boolean;
+  sync: boolean;
+  edit: boolean;
+  delete: boolean;
+}
+/** The discussions an adapter lists, with its connection and capabilities. */
+interface ThreadSnapshot {
+  connection: WorkConnection;
+  capabilities: ThreadCapabilities;
+  threads: Thread[];
+  truncated: boolean;
+}
+/** A new discussion: its first message and where it is attached. */
+interface ThreadInput {
+  anchor: Anchor | null;
+  itemIds: string[];
+  body: string;
+}
+/** A reply, posted only while the discussion is still at `expectedRevision`. */
+interface ThreadReplyInput {
+  body: string;
+  parentId: string | null;
+  expectedRevision: string;
+}
+/** A message to delete, deleted only while the discussion is still at `expectedRevision`. */
+interface ThreadDeleteInput {
+  messageId: string;
+  expectedRevision: string;
+}
+/** Which discussions a list returns: by anchor kind, page or linked item. */
+interface ThreadFilter {
+  anchorKind?: "canvas" | "code";
+  pagePath?: string;
+  itemId?: string;
+}
+//#endregion
+//#region ../work/src/server/errors.d.ts
+/**
+ * Why a work or thread operation failed. `uncertain` means a write may have applied; callers must
+ * not retry it automatically.
+ */
+type WorkFailureReason = "input" | "unavailable" | "not-found" | "conflict" | "refused" | "timeout" | "uncertain" | "storage";
+interface WorkErrorFields {
+  readonly reason: WorkFailureReason;
+  readonly message: string;
+  readonly operation?: string;
+  readonly currentRevision?: string | null;
+  readonly cause?: unknown;
+}
+declare const WorkErrorBase: new (fields: WorkErrorFields) => Cause.YieldableError & WorkErrorFields & {
+  readonly _tag: "WorkError";
+};
+/** Safe messages cross the HTTP boundary; diagnostics and credentials do not. */
+declare class WorkError extends WorkErrorBase {}
+//#endregion
+//#region ../work/src/server/import.d.ts
+/**
+ * Trusted history from another store, keyed by its source identity; never part of a browser create
+ * or reply request.
+ */
+interface ThreadImportInput {
+  source: string;
+  sourceId: string;
+  thread: Thread;
+}
+/** The imported discussion, and whether this import created it or found it already there. */
+interface ThreadImportResult {
+  outcome: "created" | "existing";
+  thread: Thread;
+}
+/**
+ * Validates complete source history before a server-side migration writes anything.
+ * @param value - The source identity and fully loaded discussion.
+ * @returns Complete, byte-bounded history, independent of the browser's message-count limit.
+ */
+declare function parseThreadImport(value: unknown): ThreadImportInput;
+//#endregion
+//#region ../work/src/server/services.d.ts
+/** Read-only operations bound to one request's project and resource lifetime. */
+interface WorkReader {
+  readonly describe: Effect.Effect<WorkConnection, WorkError>;
+  readonly schema: Effect.Effect<WorkSchema, WorkError>;
+  readonly list: (query: WorkQuery) => Effect.Effect<WorkSnapshot, WorkError>;
+  readonly get: (id: string) => Effect.Effect<WorkDetail, WorkError>;
+  readonly section: (id: string, sectionId: string) => Effect.Effect<SectionData, WorkError>;
+}
+/** Keys under which Bud keeps its own records on a work item, such as the factory's run. */
+type ItemDataKey = "budRun" | "budContext";
+interface WorkAdapterOperations {
+  /** Optional request composition; readers cannot write or outlive the callback. */
+  readonly read?: <A, E>(root: string, operation: (reader: WorkReader) => Effect.Effect<A, E>) => Effect.Effect<A, E | WorkError>;
+  readonly describe: (root: string) => Effect.Effect<WorkConnection, WorkError>;
+  readonly schema: (root: string) => Effect.Effect<WorkSchema, WorkError>;
+  readonly list: (root: string, query: WorkQuery) => Effect.Effect<WorkSnapshot, WorkError>;
+  readonly get: (root: string, id: string) => Effect.Effect<WorkDetail, WorkError>;
+  readonly section: (root: string, id: string, sectionId: string) => Effect.Effect<SectionData, WorkError>;
+  readonly create: (root: string, input: WorkCreate) => Effect.Effect<WorkMutationResult, WorkError>;
+  /**
+   * Reads a record Bud keeps on an item under a reserved key, with the item's revision. A store
+   * that implements it also implements `writeItemData`; the record is hidden from the item's
+   * own fields and kept when they're edited.
+   */
+  readonly readItemData?: (root: string, id: string, key: ItemDataKey) => Effect.Effect<{
+    value: JsonValue | null;
+    revision: string | null;
+  }, WorkError>;
+  /** Replaces (or, with null, removes) such a record while the item is at `expectedRevision`. */
+  readonly writeItemData?: (root: string, id: string, key: ItemDataKey, value: JsonValue | null, expectedRevision: string) => Effect.Effect<{
+    revision: string | null;
+  }, WorkError>;
+  /**
+   * Adds lifecycle statuses the store doesn't have yet, keeping its own and their order; a
+   * status it already has stays as it is. Stores whose statuses are fixed leave it out.
+   */
+  readonly addStatuses?: (root: string, statuses: readonly {
+    readonly value: string;
+    readonly category: StatusCategory;
+  }[]) => Effect.Effect<void, WorkError>;
+  readonly update: (root: string, id: string, patch: WorkPatch, expectedRevision: string) => Effect.Effect<WorkMutationResult, WorkError>;
+  readonly act: (root: string, id: string, actionId: string, input: WorkPatch, expectedRevision: string) => Effect.Effect<WorkMutationResult, WorkError>;
+  readonly sync?: (root: string, direction: WorkSync["direction"]) => Effect.Effect<WorkSyncResult, WorkError>;
+  /**
+   * Signals stored changes, including ones made outside Bud such as an agent using the
+   * store's CLI. Without it, open views follow only Bud's own writes.
+   */
+  readonly watch?: (root: string) => Stream.Stream<void, WorkError>;
+}
+declare const WorkAdapterBase: Context.ServiceClass<WorkAdapter, "@bud.sh/work/WorkAdapter", WorkAdapterOperations>;
+/** A backend's work items. Run programs at a request boundary with its AbortSignal. */
+declare class WorkAdapter extends WorkAdapterBase {}
+interface ThreadAdapterOperations {
+  /** Server-only migration; browser requests cannot supply stored authors or timestamps. */
+  readonly import?: (root: string, input: ThreadImportInput) => Effect.Effect<ThreadImportResult, WorkError>;
+  readonly list: (root: string, filter: ThreadFilter) => Effect.Effect<ThreadSnapshot, WorkError>;
+  readonly get: (root: string, id: string) => Effect.Effect<Thread, WorkError>;
+  readonly create: (root: string, input: ThreadInput, author: MessageAuthor) => Effect.Effect<Thread, WorkError>;
+  readonly reply: (root: string, id: string, input: ThreadReplyInput, author: MessageAuthor) => Effect.Effect<Thread, WorkError>;
+  readonly setStatus: (root: string, id: string, status: ThreadStatus, expectedRevision: string) => Effect.Effect<Thread, WorkError>;
+  readonly link: (root: string, id: string, itemIds: string[], expectedRevision: string) => Effect.Effect<Thread, WorkError>;
+  readonly unlink: (root: string, id: string, itemIds: string[], expectedRevision: string) => Effect.Effect<Thread, WorkError>;
+  readonly sync?: (root: string, direction?: WorkSync["direction"]) => Effect.Effect<ThreadSnapshot, WorkError>;
+  /**
+   * Deletes one of `author`'s messages; null when it was the first and the discussion is gone.
+   * Adapters that implement it report the `delete` capability.
+   */
+  readonly deleteMessage?: (root: string, id: string, input: ThreadDeleteInput, author: MessageAuthor) => Effect.Effect<Thread | null, WorkError>;
+  /** Signals stored discussion changes, including ones made outside Bud. */
+  readonly watch?: (root: string) => Stream.Stream<void, WorkError>;
+}
+declare const ThreadAdapterBase: Context.ServiceClass<ThreadAdapter, "@bud.sh/work/ThreadAdapter", ThreadAdapterOperations>;
+/** Discussions receive trusted server attribution separately from browser input. */
+declare class ThreadAdapter extends ThreadAdapterBase {}
+//#endregion
+//#region ../work/src/server/memory-state.d.ts
+/** A pure action computes a replacement; the memory adapter validates and commits it. */
+type MemoryAction = (context: {
+  item: WorkItem;
+  input: WorkPatch;
+  schema: WorkSchema;
+  author: MessageAuthor;
+}) => {
+  values?: WorkPatch;
+  relations?: WorkItem["relations"];
+};
+/** The schema, seed records and action and section implementations of an in-memory store. */
+interface MemoryAdapterOptions {
+  schema: WorkSchema;
+  items?: readonly WorkItem[];
+  threads?: readonly Thread[];
+  /** Defaults can supply required server-owned fields without making them editable. */
+  defaults?: WorkPatch;
+  actions?: Readonly<Record<string, MemoryAction>>;
+  sections?: Readonly<Record<string, (item: WorkItem) => SectionData>>;
+  /** Trusted attribution for work-item history; thread writes supply it separately. */
+  author?: MessageAuthor;
+  threadCapabilities?: Partial<Omit<ThreadCapabilities, "edit" | "sync">>;
+}
+//#endregion
+export { ThreadImportInput as a, WorkError as c, WorkReader as i, WorkFailureReason as l, ThreadAdapter as n, ThreadImportResult as o, WorkAdapter as r, parseThreadImport as s, MemoryAdapterOptions as t };

package/dist/types/assets/picker-Be5Gx4WR.d.ts

@@ -0,0 +1,9 @@
+//#region ../project/src/lib/picker.d.ts
+/** The picker, with the project module to serve when it is the project's own. */
+interface ResolvedPicker {
+  name: string;
+  /** The project's own picker module, as a ./ path; null for a built-in picker. */
+  module: string | null;
+}
+//#endregion
+export { ResolvedPicker as t };

package/dist/types/assets/{task-design-xJOhRNWh.d.ts → task-design-BDHKFHpp.d.ts}

@@ -1,4 +1,4 @@
-import { a as WorkDetail, b as StatusSchema, d as WorkSync, f as WorkSyncResult, i as WorkCreate, m as WorkValue, n as WorkActionInput, o as WorkItem, p as WorkUpdate, t as SectionData, u as WorkSnapshot, x as WorkSchema, y as FieldSchema } from "./items-CaVkByHk.js";
+import { S as WorkSchema, a as WorkDetail, d as WorkSync, f as WorkSyncResult, i as WorkCreate, m as WorkValue, n as WorkActionInput, o as WorkItem, p as WorkUpdate, t as SectionData, u as WorkSnapshot, x as StatusSchema, y as FieldSchema } from "./items-BQdaVksf.js";
 import { Handle, RemixNode } from "remix/component";
 //#region ../ui/src/lib/tasks/task-card.d.ts
 /** A task's board state and optional selection behavior. */
@@ -59,6 +59,8 @@ interface TaskDetailsProps {
   operations?: TaskOperations;
   draft?: TaskDraft;
   onDraft?: (draft: TaskDraft) => void;
+  /** The consumer's buttons in the page's toolbar, such as opening Agent view. */
+  actions?: RemixNode;
 }
 /**
  * Renders primary and secondary fields using the default properties card.

package/dist/types/bridge.d.ts

@@ -1,4 +1,4 @@
-import { n as ResolvedPicker } from "./assets/picker-D1Bw3ndx.js";
+import { t as ResolvedPicker } from "./assets/picker-Be5Gx4WR.js";
 //#region ../picker/src/lib/module.d.ts
 /** The picker module's ID in the project's dev server, served by Bud's Vite plugin. */
 export declare const PICKER_MODULE_ID = "\0bud-picker";

package/dist/types/companion.d.ts

@@ -1,8 +1,8 @@
-import { i as ResolvedBudConfig } from "./assets/config-DIC2cf_S.js";
+import { i as ResolvedBudConfig } from "./assets/config-CvcYmE2s.js";
 //#region src/companion.d.ts
 /**
- * The contract between a host, such as `@bud.sh/app-vite-plugin` and its CLI, and the companion
- * server the app builds separately as `@bud.sh/app/companion`.
+ * The contract between a host, such as the `bud()` Vite plugin and the `bud` CLI, and the
+ * companion server the app builds separately as `@bud.sh/app/companion`.
  */
 export interface StartBudOptions {
   root: string;