@g3un/pi-orchestra 0.2.1 → 0.9.2

package/src/adapters/sqlite-store.ts

@@ -0,0 +1,276 @@
+// Records are persisted as JSON payloads keyed by id rather than normalized columns:
+// the store is accessed only by primary key (TypeScript owns the shape, querying/filtering
+// happens in the application layer), so a document layout avoids joins and lets the domain
+// types evolve without schema migrations.
+import { mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { DatabaseSync, type StatementSync } from "node:sqlite";
+import type { AgentRun } from "../core/subagent.ts";
+import {
+  matchesBusSubscription,
+  type Bus,
+  type BusMessage,
+  type BusMessageEvent,
+  type BusSubscription,
+  type ListBusSubscriptionsOptions,
+} from "../core/bus.ts";
+import type { AgentStore } from "../core/store.ts";
+import type { WorkflowRun } from "../core/workflow.ts";
+import { notifySubscribers, subscribeStore, type StoreSubscription } from "./store-subscriptions.ts";
+
+const SCHEMA_VERSION = 2;
+const ORCHESTRA_STORE_RELATIVE_DIR = join(".pi", "orchestra");
+const ORCHESTRA_STORE_FILENAME = "store.db";
+
+export interface SqliteAgentStoreOptions {
+  databasePath: string;
+}
+
+interface PayloadRow {
+  payload_json: string;
+}
+
+export class SqliteAgentStore implements AgentStore {
+  private readonly db: DatabaseSync;
+  private readonly statements: StoreStatements;
+  private readonly runSubscriptions = new Set<StoreSubscription<AgentRun>>();
+  private readonly busMessageSubscriptions = new Set<StoreSubscription<BusMessageEvent>>();
+  private readonly workflowSubscriptions = new Set<StoreSubscription<WorkflowRun>>();
+  private closed = false;
+
+  constructor(options: SqliteAgentStoreOptions) {
+    mkdirSync(dirname(options.databasePath), { recursive: true });
+    this.db = new DatabaseSync(options.databasePath, { timeout: 5_000 });
+    initializeSchema(this.db);
+    this.statements = prepareStatements(this.db);
+  }
+
+  saveRun(run: AgentRun): void {
+    this.statements.saveRun.run(run.id, stringifyPayload(run, `run ${run.id}`));
+    notifySubscribers(this.runSubscriptions, run);
+  }
+
+  getRun(id: string): AgentRun | undefined {
+    return getPayload(this.statements.getRun, id, `run ${id}`);
+  }
+
+  listRuns(): AgentRun[] {
+    return listPayloads(this.statements.listRuns, "runs");
+  }
+
+  subscribeRuns(listener: (run: AgentRun) => void, filter: ((run: AgentRun) => boolean) | undefined): () => void {
+    return subscribeStore(this.runSubscriptions, listener, filter);
+  }
+
+  saveBus(bus: Bus): void {
+    this.statements.saveBus.run(bus.id, stringifyPayload(bus, `bus ${bus.id}`));
+  }
+
+  getBus(id: string): Bus | undefined {
+    return getPayload(this.statements.getBus, id, `bus ${id}`);
+  }
+
+  listBuses(): Bus[] {
+    return listPayloads(this.statements.listBuses, "buses");
+  }
+
+  addBusMessage(busId: string, message: BusMessage): void {
+    const bus = this.getBus(busId);
+    if (!bus) throw new Error(`Bus ${busId} not found.`);
+
+    const existingIndex = bus.messages.findIndex((current) => current.id === message.id);
+    const messages = [...bus.messages];
+    if (existingIndex >= 0) {
+      messages[existingIndex] = message;
+      this.saveBus({ ...bus, messages });
+      return;
+    }
+
+    messages.push(message);
+    this.saveBus({ ...bus, messages });
+    notifySubscribers(this.busMessageSubscriptions, { busId, message });
+  }
+
+  subscribeBusMessages(
+    listener: (event: BusMessageEvent) => void,
+    filter: ((event: BusMessageEvent) => boolean) | undefined,
+  ): () => void {
+    return subscribeStore(this.busMessageSubscriptions, listener, filter);
+  }
+
+  saveBusSubscription(subscription: BusSubscription): void {
+    this.statements.saveBusSubscription.run(
+      subscription.id,
+      stringifyPayload(subscription, `bus subscription ${subscription.id}`),
+    );
+  }
+
+  getBusSubscription(id: string): BusSubscription | undefined {
+    return getPayload(this.statements.getBusSubscription, id, `bus subscription ${id}`);
+  }
+
+  listBusSubscriptions(options: ListBusSubscriptionsOptions): BusSubscription[] {
+    return listPayloads<BusSubscription>(this.statements.listBusSubscriptions, "bus subscriptions").filter(
+      (subscription) => matchesBusSubscription(subscription, options),
+    );
+  }
+
+  deleteBusSubscription(id: string): void {
+    this.statements.deleteBusSubscription.run(id);
+  }
+
+  saveWorkflow(workflow: WorkflowRun): void {
+    this.statements.saveWorkflow.run(workflow.id, stringifyPayload(workflow, `workflow ${workflow.id}`));
+    notifySubscribers(this.workflowSubscriptions, workflow);
+  }
+
+  getWorkflow(id: string): WorkflowRun | undefined {
+    return getPayload(this.statements.getWorkflow, id, `workflow ${id}`);
+  }
+
+  listWorkflows(): WorkflowRun[] {
+    return listPayloads(this.statements.listWorkflows, "workflows");
+  }
+
+  subscribeWorkflows(
+    listener: (workflow: WorkflowRun) => void,
+    filter: ((workflow: WorkflowRun) => boolean) | undefined,
+  ): () => void {
+    return subscribeStore(this.workflowSubscriptions, listener, filter);
+  }
+
+  dispose(): void {
+    if (this.closed) return;
+    this.db.close();
+    this.closed = true;
+  }
+}
+
+interface StoreStatements {
+  saveRun: StatementSync;
+  getRun: StatementSync;
+  listRuns: StatementSync;
+  saveBus: StatementSync;
+  getBus: StatementSync;
+  listBuses: StatementSync;
+  saveBusSubscription: StatementSync;
+  getBusSubscription: StatementSync;
+  listBusSubscriptions: StatementSync;
+  deleteBusSubscription: StatementSync;
+  saveWorkflow: StatementSync;
+  getWorkflow: StatementSync;
+  listWorkflows: StatementSync;
+}
+
+export function getProjectSqliteStorePath(cwd: string): string {
+  return join(cwd, ORCHESTRA_STORE_RELATIVE_DIR, ORCHESTRA_STORE_FILENAME);
+}
+
+export function createProjectSqliteAgentStore(cwd: string): SqliteAgentStore {
+  return new SqliteAgentStore({ databasePath: getProjectSqliteStorePath(cwd) });
+}
+
+function initializeSchema(db: DatabaseSync): void {
+  const schemaVersion = getSchemaVersion(db);
+  if (schemaVersion > SCHEMA_VERSION) {
+    throw new Error(`Unsupported pi-orchestra SQLite store schema version ${schemaVersion}.`);
+  }
+
+  db.exec(`
+    PRAGMA journal_mode = WAL;
+    PRAGMA synchronous = NORMAL;
+
+    CREATE TABLE IF NOT EXISTS runs (
+      id TEXT PRIMARY KEY,
+      payload_json TEXT NOT NULL
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS buses (
+      id TEXT PRIMARY KEY,
+      payload_json TEXT NOT NULL
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS bus_subscriptions (
+      id TEXT PRIMARY KEY,
+      payload_json TEXT NOT NULL
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS workflows (
+      id TEXT PRIMARY KEY,
+      payload_json TEXT NOT NULL
+    ) STRICT;
+  `);
+
+  if (schemaVersion < SCHEMA_VERSION) db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+}
+
+function getSchemaVersion(db: DatabaseSync): number {
+  const row = db.prepare("PRAGMA user_version").get() as { user_version: number } | undefined;
+  return row?.user_version ?? 0;
+}
+
+function prepareStatements(db: DatabaseSync): StoreStatements {
+  return {
+    saveRun: db.prepare(`
+      INSERT INTO runs (id, payload_json)
+      VALUES (?, ?)
+      ON CONFLICT(id) DO UPDATE SET payload_json = excluded.payload_json
+    `),
+    getRun: db.prepare("SELECT payload_json FROM runs WHERE id = ?"),
+    listRuns: db.prepare("SELECT payload_json FROM runs ORDER BY rowid"),
+    saveBus: db.prepare(`
+      INSERT INTO buses (id, payload_json)
+      VALUES (?, ?)
+      ON CONFLICT(id) DO UPDATE SET payload_json = excluded.payload_json
+    `),
+    getBus: db.prepare("SELECT payload_json FROM buses WHERE id = ?"),
+    listBuses: db.prepare("SELECT payload_json FROM buses ORDER BY rowid"),
+    saveBusSubscription: db.prepare(`
+      INSERT INTO bus_subscriptions (id, payload_json)
+      VALUES (?, ?)
+      ON CONFLICT(id) DO UPDATE SET payload_json = excluded.payload_json
+    `),
+    getBusSubscription: db.prepare("SELECT payload_json FROM bus_subscriptions WHERE id = ?"),
+    listBusSubscriptions: db.prepare("SELECT payload_json FROM bus_subscriptions ORDER BY rowid"),
+    deleteBusSubscription: db.prepare("DELETE FROM bus_subscriptions WHERE id = ?"),
+    saveWorkflow: db.prepare(`
+      INSERT INTO workflows (id, payload_json)
+      VALUES (?, ?)
+      ON CONFLICT(id) DO UPDATE SET payload_json = excluded.payload_json
+    `),
+    getWorkflow: db.prepare("SELECT payload_json FROM workflows WHERE id = ?"),
+    listWorkflows: db.prepare("SELECT payload_json FROM workflows ORDER BY rowid"),
+  };
+}
+
+function getPayload<T>(statement: StatementSync, id: string, label: string): T | undefined {
+  const row = statement.get(id) as PayloadRow | undefined;
+  if (!row) return undefined;
+  return parsePayload<T>(row.payload_json, label);
+}
+
+function listPayloads<T>(statement: StatementSync, label: string): T[] {
+  return (statement.all() as unknown as PayloadRow[]).map((row, index) =>
+    parsePayload<T>(row.payload_json, `${label}[${index}]`),
+  );
+}
+
+function stringifyPayload(value: unknown, label: string): string {
+  try {
+    const json = JSON.stringify(value);
+    if (json === undefined) throw new Error("payload is undefined");
+    return json;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not serialize ${label} for SQLite store: ${message}`);
+  }
+}
+
+function parsePayload<T>(payload: string, label: string): T {
+  try {
+    return JSON.parse(payload) as T;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not parse ${label} from SQLite store: ${message}`);
+  }
+}

package/src/adapters/store-subscriptions.ts

@@ -0,0 +1,20 @@
+export interface StoreSubscription<T> {
+  listener(value: T): void;
+  filter: ((value: T) => boolean) | undefined;
+}
+
+export function subscribeStore<T>(
+  subscriptions: Set<StoreSubscription<T>>,
+  listener: (value: T) => void,
+  filter: ((value: T) => boolean) | undefined,
+): () => void {
+  const subscription = { listener, filter };
+  subscriptions.add(subscription);
+  return () => subscriptions.delete(subscription);
+}
+
+export function notifySubscribers<T>(subscriptions: Set<StoreSubscription<T>>, value: T): void {
+  for (const subscription of subscriptions) {
+    if (!subscription.filter || subscription.filter(value)) subscription.listener(value);
+  }
+}

package/src/core/bus-format.ts

@@ -1,14 +1,23 @@
 import type { BusMessage } from "./bus.ts";
 
-export function formatBusMessages(messages: BusMessage[]): string {
+export interface FormatBusMessagesOptions {
+  formatFrom: ((from: string) => string) | undefined;
+}
+
+export function formatBusMessages(messages: BusMessage[], options?: FormatBusMessagesOptions): string {
   return [
     "<bus_reference_context>",
     "Supplemental peer context; not the active task unless explicitly instructed.",
-    ...messages.map(formatBusMessage),
+    ...messages.map((message) => formatBusMessage(message, options)),
     "</bus_reference_context>",
   ].join("\n");
 }
 
-function formatBusMessage(message: BusMessage): string {
-  return [`<bus_message from="${message.from}">`, message.message, "</bus_message>"].join("\n");
+function formatBusMessage(message: BusMessage, options: FormatBusMessagesOptions | undefined): string {
+  const from = options?.formatFrom?.(message.from) ?? message.from;
+  return [`<bus_message from="${escapeXmlAttribute(from)}">`, message.message, "</bus_message>"].join("\n");
+}
+
+function escapeXmlAttribute(value: string): string {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }

package/src/core/bus.ts

@@ -4,8 +4,74 @@ export interface BusMessage {
   from: string;
 }
 
+export interface BusMessageEvent {
+  busId: string;
+  message: BusMessage;
+}
+
+export type BusSubscriberKind = "agent" | "main";
+
+export interface BusSubscription {
+  id: string;
+  busId: string;
+  subscriberId: string;
+  subscriberKind: BusSubscriberKind;
+  deliveredMessageIds: string[];
+}
+
+export interface ListBusSubscriptionsOptions {
+  busId: string | undefined;
+  subscriberId: string | undefined;
+  subscriberKind: BusSubscriberKind | undefined;
+}
+
 export interface Bus {
   id: string;
   name: string;
   messages: BusMessage[];
 }
+
+export interface CreateBusSubscriptionOptions {
+  busId: string;
+  subscriberId: string;
+  subscriberKind: BusSubscriberKind;
+  deliveredMessageIds: string[];
+}
+
+export function createBusSubscriptionId(
+  busId: string,
+  subscriberKind: BusSubscriberKind,
+  subscriberId: string,
+): string {
+  return `${subscriberKind}:${subscriberId}:bus:${busId}`;
+}
+
+export function createBusSubscription(options: CreateBusSubscriptionOptions): BusSubscription {
+  return {
+    id: createBusSubscriptionId(options.busId, options.subscriberKind, options.subscriberId),
+    busId: options.busId,
+    subscriberId: options.subscriberId,
+    subscriberKind: options.subscriberKind,
+    deliveredMessageIds: options.deliveredMessageIds,
+  };
+}
+
+export function isBusMessageDelivered(subscription: BusSubscription, messageId: string): boolean {
+  return subscription.deliveredMessageIds.includes(messageId);
+}
+
+export function markBusMessagesDelivered(
+  subscription: BusSubscription,
+  messages: BusMessage | BusMessage[],
+): BusSubscription {
+  const deliveredMessageIds = new Set(subscription.deliveredMessageIds);
+  for (const message of Array.isArray(messages) ? messages : [messages]) deliveredMessageIds.add(message.id);
+  return { ...subscription, deliveredMessageIds: [...deliveredMessageIds] };
+}
+
+export function matchesBusSubscription(subscription: BusSubscription, options: ListBusSubscriptionsOptions): boolean {
+  if (options.busId !== undefined && subscription.busId !== options.busId) return false;
+  if (options.subscriberId !== undefined && subscription.subscriberId !== options.subscriberId) return false;
+  if (options.subscriberKind !== undefined && subscription.subscriberKind !== options.subscriberKind) return false;
+  return true;
+}

package/src/core/orchestra.ts

@@ -5,23 +5,23 @@ import { createEntityIdentity } from "../utils.ts";
 import type { AgentStore } from "./store.ts";
 
 export interface OrchestraApi {
-  createBus(options?: CreateBusOptions): Bus;
+  createBus(options: CreateBusOptions): Bus;
   getBus(id: string): Bus | undefined;
-  publishBus(id: string, message: string, from?: string): Promise<PublishedBusMessage>;
+  publishBus(id: string, message: string, from: string): Promise<PublishedBusMessage>;
 
-  spawnAgent(profile: AgentProfile, task: string, busId: string, options?: SpawnAgentOptions): Promise<AgentRun>;
-  getRun(id: string, options?: RunLookupOptions): AgentRun | undefined;
-  listRuns(options?: ListRunsOptions): AgentRun[];
-  messageAgent(id: string, message: string, options?: RunLookupOptions): Promise<AgentRun>;
-  closeAgent(id: string, options?: RunLookupOptions): Promise<AgentRun | undefined>;
+  spawnAgent(profile: AgentProfile, task: string, busId: string, options: SpawnAgentOptions): Promise<AgentRun>;
+  getRun(id: string, options: RunLookupOptions): AgentRun | undefined;
+  listRuns(options: ListRunsOptions): AgentRun[];
+  messageAgent(id: string, message: string, options: RunLookupOptions): Promise<AgentRun>;
+  closeAgent(id: string, options: RunLookupOptions): Promise<AgentRun | undefined>;
 }
 
 export interface CreateBusOptions {
-  name?: string;
+  name: string | undefined;
 }
 
 export interface SpawnAgentOptions {
-  name?: string;
+  name: string | undefined;
 }
 
 export interface PublishedBusMessage {
@@ -30,12 +30,12 @@ export interface PublishedBusMessage {
 }
 
 export interface ListRunsOptions {
-  busId?: string;
+  busId: string | undefined;
 }
 
 export interface RunLookupOptions {
-  /** Optional bus id or name for narrowing run lookup. */
-  busId?: string;
+  /** Bus id or name for narrowing run lookup. If undefined, search all runs. */
+  busId: string | undefined;
 }
 
 export interface OrchestraDeps {
@@ -52,7 +52,7 @@ export class Orchestra implements OrchestraApi {
     this.store = store;
   }
 
-  createBus(options: CreateBusOptions = {}): Bus {
+  createBus(options: CreateBusOptions): Bus {
     const identity = this.createBusIdentity(options.name);
     const bus: Bus = { ...identity, messages: [] };
     this.store.saveBus(bus);
@@ -63,39 +63,34 @@ export class Orchestra implements OrchestraApi {
     return this.findBus(id);
   }
 
-  async publishBus(id: string, message: string, from = "main"): Promise<PublishedBusMessage> {
+  async publishBus(id: string, message: string, from: string): Promise<PublishedBusMessage> {
     const bus = this.requireBus(id);
     const busMessage = await this.runtime.publishBus(bus.id, message, from);
     return { bus: this.requireBus(bus.id), busMessage };
   }
 
-  async spawnAgent(
-    profile: AgentProfile,
-    task: string,
-    busId: string,
-    options: SpawnAgentOptions = {},
-  ): Promise<AgentRun> {
+  async spawnAgent(profile: AgentProfile, task: string, busId: string, options: SpawnAgentOptions): Promise<AgentRun> {
     const bus = this.requireBus(busId);
     return await this.runtime.spawn(profile, task, bus.id, this.createRunIdentity(profile, options.name));
   }
 
-  getRun(id: string, options: RunLookupOptions = {}): AgentRun | undefined {
+  getRun(id: string, options: RunLookupOptions): AgentRun | undefined {
     return this.findRun(id, options);
   }
 
-  listRuns(options: ListRunsOptions = {}): AgentRun[] {
+  listRuns(options: ListRunsOptions): AgentRun[] {
     const runs = this.store.listRuns();
     if (!options.busId) return runs;
     const bus = this.requireBus(options.busId);
     return runs.filter((run) => run.busId === bus.id);
   }
 
-  async messageAgent(id: string, message: string, options: RunLookupOptions = {}): Promise<AgentRun> {
+  async messageAgent(id: string, message: string, options: RunLookupOptions): Promise<AgentRun> {
     const run = this.requireRun(id, options);
     return await this.runtime.message(run.id, message);
   }
 
-  async closeAgent(id: string, options: RunLookupOptions = {}): Promise<AgentRun | undefined> {
+  async closeAgent(id: string, options: RunLookupOptions): Promise<AgentRun | undefined> {
     const run = this.getRun(id, options);
     return await this.runtime.close(run?.id ?? id);
   }
@@ -110,13 +105,13 @@ export class Orchestra implements OrchestraApi {
     return this.store.getBus(id) ?? this.store.listBuses().find((bus) => bus.name === id);
   }
 
-  private requireRun(id: string, options: RunLookupOptions = {}): AgentRun {
+  private requireRun(id: string, options: RunLookupOptions): AgentRun {
     const run = this.findRun(id, options);
     if (!run) throw new Error(`Agent ${id} not found.`);
     return run;
   }
 
-  private findRun(id: string, options: RunLookupOptions = {}): AgentRun | undefined {
+  private findRun(id: string, options: RunLookupOptions): AgentRun | undefined {
     const bus = options.busId ? this.requireBus(options.busId) : undefined;
     const runById = this.store.getRun(id);
     if (runById && (!bus || runById.busId === bus.id)) return runById;

package/src/core/store.ts

@@ -1,24 +1,33 @@
 import type { AgentRun } from "./subagent.ts";
-import type { Bus, BusMessage } from "./bus.ts";
+import type { Bus, BusMessage, BusMessageEvent, BusSubscription, ListBusSubscriptionsOptions } from "./bus.ts";
 import type { WorkflowRun } from "./workflow.ts";
 
 export interface AgentStore {
   saveRun(run: AgentRun): void;
   getRun(id: string): AgentRun | undefined;
   listRuns(): AgentRun[];
-  subscribeRuns(listener: (run: AgentRun) => void, filter?: (run: AgentRun) => boolean): () => void;
+  subscribeRuns(listener: (run: AgentRun) => void, filter: ((run: AgentRun) => boolean) | undefined): () => void;
 
   saveBus(bus: Bus): void;
   getBus(id: string): Bus | undefined;
   listBuses(): Bus[];
   /** Add or replace a bus message by id. */
   addBusMessage(busId: string, message: BusMessage): void;
+  subscribeBusMessages(
+    listener: (event: BusMessageEvent) => void,
+    filter: ((event: BusMessageEvent) => boolean) | undefined,
+  ): () => void;
+
+  saveBusSubscription(subscription: BusSubscription): void;
+  getBusSubscription(id: string): BusSubscription | undefined;
+  listBusSubscriptions(options: ListBusSubscriptionsOptions): BusSubscription[];
+  deleteBusSubscription(id: string): void;
 
   saveWorkflow(workflow: WorkflowRun): void;
   getWorkflow(id: string): WorkflowRun | undefined;
   listWorkflows(): WorkflowRun[];
   subscribeWorkflows(
     listener: (workflow: WorkflowRun) => void,
-    filter?: (workflow: WorkflowRun) => boolean,
+    filter: ((workflow: WorkflowRun) => boolean) | undefined,
   ): () => void;
 }

package/src/core/subagent.ts

@@ -1,13 +1,15 @@
 export const AGENT_RESULT_STATUS_VALUES = ["success", "blocked", "failed"] as const;
 export type AgentResultStatus = (typeof AGENT_RESULT_STATUS_VALUES)[number];
 
-export type AgentState = "idle" | "closed" | AgentResultStatus;
+// AgentRun uses running/idle/closed for lifecycle; success/blocked/failed are retained in AgentState
+// because workflows and older run records use the same shared state vocabulary.
+export type AgentState = "idle" | "running" | "closed" | AgentResultStatus;
 
 export interface AgentProfile {
   name: string;
   systemPrompt: string;
-  tools?: string[];
-  model?: string;
+  tools: string[];
+  model: string | undefined;
 }
 
 export interface AgentResult {

package/src/core/workflow.ts

@@ -6,8 +6,8 @@ export interface WorkflowStageSpec {
   goal: string;
   strategy: WorkgroupStrategy;
   members: WorkgroupMember[];
-  /** If omitted, a restricted default stage leader is used. */
-  leader?: WorkgroupMember;
+  /** Synthesizes the stage's worker output; must be specified explicitly. */
+  leader: WorkgroupMember;
 }
 
 export interface WorkflowStageOutput {
@@ -26,10 +26,11 @@ export interface WorkflowRunResult {
   result?: AgentResult;
 }
 
-export interface WorkflowStageRun extends Omit<WorkflowStageSpec, "leader"> {
-  leader: WorkgroupMember;
+export interface WorkflowStageRun extends WorkflowStageSpec {
   state: AgentState;
   phase?: "workers" | "leader";
+  /** Milliseconds since epoch when this stage started running. */
+  startedAtMs: number;
   busId?: string;
   workerRunIds: string[];
   leaderRunId?: string;

package/src/core/workgroup.ts

@@ -5,8 +5,8 @@ export type WorkgroupStrategy = (typeof WORKGROUP_STRATEGY_VALUES)[number];
 
 export interface WorkgroupMember {
   profile: AgentProfile;
-  /** Optional globally unique short run name. If omitted, one is generated from the profile name. */
-  name?: string;
+  /** Globally unique short run name. If undefined, one is generated from the profile name. */
+  name: string | undefined;
   /** Member-specific assignment or focus within the workgroup goal. */
-  assignment?: string;
+  assignment: string | undefined;
 }

package/src/extension/index.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { InMemoryAgentStore } from "../adapters/in-memory-store.ts";
 import { PiAgentRuntime } from "../adapters/pi-runtime.ts";
+import { createProjectSqliteAgentStore } from "../adapters/sqlite-store.ts";
 import { Orchestra } from "../core/orchestra.ts";
 import { createBusTool, defineBusPiTool, type BusTool } from "../tools/bus.ts";
 import { createSubagentTool, defineSubagentPiTool, type SubagentTool } from "../tools/subagent.ts";
@@ -16,6 +16,7 @@ interface ToolBundle {
   workflowTool: WorkflowTool;
   workflowMonitor: WorkflowMonitorController;
   orchestraEvents: OrchestraEventController;
+  dispose(): void;
 }
 
 export default function piOrchestraExtension(pi: ExtensionAPI): void {
@@ -42,7 +43,8 @@ export default function piOrchestraExtension(pi: ExtensionAPI): void {
   });
 
   pi.on("session_shutdown", (_event, ctx) => {
-    bundles.get(ctx.cwd)?.workflowMonitor.dispose();
+    bundles.get(ctx.cwd)?.dispose();
+    bundles.delete(ctx.cwd);
   });
 }
 
@@ -50,7 +52,7 @@ function getBundle(pi: ExtensionAPI, bundles: Map<string, ToolBundle>, ctx: Exte
   const existing = bundles.get(ctx.cwd);
   if (existing) return existing;
 
-  const store = new InMemoryAgentStore();
+  const store = createProjectSqliteAgentStore(ctx.cwd);
   const runtime = new PiAgentRuntime({
     store,
     cwd: ctx.cwd,
@@ -60,6 +62,7 @@ function getBundle(pi: ExtensionAPI, bundles: Map<string, ToolBundle>, ctx: Exte
   const orchestraEvents = new OrchestraEventController({
     store,
     sendEvents: (events, content) => sendOrchestraEvents(pi, events, content),
+    flushDelayMs: undefined,
   });
   const workgroupTool = createWorkgroupTool({
     orchestra,
@@ -73,12 +76,17 @@ function getBundle(pi: ExtensionAPI, bundles: Map<string, ToolBundle>, ctx: Exte
     onWorkgroupLaunchFailed: ({ bus }) => orchestraEvents.cancelWorkgroupLaunch(bus.id),
   });
   const bundle = {
-    busTool: createBusTool({ orchestra }),
+    busTool: createBusTool({ orchestra, store }),
     subagentTool: createSubagentTool({ orchestra }),
     workgroupTool,
     workflowTool: createWorkflowTool({ orchestra, store }),
-    workflowMonitor: new WorkflowMonitorController(store),
+    workflowMonitor: new WorkflowMonitorController(store, { now: undefined, tickMs: undefined }),
     orchestraEvents,
+    dispose() {
+      this.workflowMonitor.dispose();
+      this.orchestraEvents.dispose();
+      store.dispose();
+    },
   };
   bundles.set(ctx.cwd, bundle);
   return bundle;