macro-agent 0.0.17 → 0.1.1

package/src/store/event-store.ts

@@ -23,6 +23,7 @@ import type {
   EventFilter,
   Agent,
   AgentState,
+  AgentMetadataUpdate,
   Task,
   TaskStatus,
   QueuedMessage,
@@ -131,8 +132,8 @@ function createTabularBetterSqlite3Persister(
     undefined,
     // onIgnoredError
     (error: any) => console.warn('[EventStore] Persister error:', error),
-    // destroy
-    () => db.close(),
+    // destroy — do NOT close DB here; close() handles it after the persister drains
+    () => {},
     // persist mode (1 = StoreOnly)
     1 as any,
     // thing (the db instance)
@@ -203,6 +204,8 @@ export interface EventStore {
   // Agent view
   getAgent(agentId: AgentId): Agent | null;
   listAgents(filter?: { state?: AgentState; parent?: AgentId | null }): Agent[];
+  updateAgentPlan(agentId: AgentId, plan: Array<{ content: string; priority: string; status: string }>): void;
+  updateAgentMetadata(agentId: AgentId, updates: AgentMetadataUpdate): void;
 
   // Task view
   getTask(taskId: TaskId): Task | null;
@@ -519,6 +522,51 @@ export async function createEventStore(config: StoreConfig = {}): Promise<EventS
     return agents;
   }
 
+  /**
+   * Update agent metadata fields (name, plan, metadata).
+   * Only provided fields are updated. Metadata is shallow-merged with existing.
+   */
+  function updateAgentMetadata(
+    agentId: AgentId,
+    updates: AgentMetadataUpdate,
+  ): void {
+    const row = store.getRow('agents', agentId);
+    if (!row.id) return;
+
+    const partial: Record<string, string | number | boolean> = {
+      last_activity_at: Date.now(),
+    };
+
+    if (updates.name !== undefined) {
+      partial.name = updates.name;
+    }
+    if (updates.plan !== undefined) {
+      partial.plan = JSON.stringify(updates.plan);
+    }
+    if (updates.metadata !== undefined) {
+      // Shallow merge with existing metadata
+      const existing = row.metadata ? JSON.parse(row.metadata as string) : {};
+      partial.metadata = JSON.stringify({ ...existing, ...updates.metadata });
+    }
+
+    store.setPartialRow('agents', agentId, partial);
+
+    const agent = rowToAgent(store.getRow('agents', agentId));
+    notifyAgentChange(agentId, agent);
+  }
+
+  /**
+   * Update an agent's plan entries (persisted to SQLite via TinyBase).
+   * Convenience wrapper around updateAgentMetadata.
+   */
+  function updateAgentPlan(
+    agentId: AgentId,
+    plan: Array<{ content: string; priority: string; status: string }>,
+  ): void {
+    updateAgentMetadata(agentId, { plan });
+  }
+
+
   /**
    * Get task by ID
    */
@@ -927,8 +975,18 @@ export async function createEventStore(config: StoreConfig = {}): Promise<EventS
    */
   async function close(): Promise<void> {
     if (persister) {
+      // Stop auto-save first to prevent race conditions between
+      // auto-save callbacks and the explicit save/destroy sequence.
+      await persister.stopAutoSave();
       await persister.save();
+      // Destroy the persister (removes store listeners) BEFORE closing the DB.
+      // The destroy callback is a no-op — we close the DB ourselves below
+      // after giving TinyBase's internal async queues time to drain.
       persister.destroy();
+      // Allow any in-flight TinyBase microtasks to settle before closing
+      // the database connection. Without this, pending writes from store
+      // change listeners can race against db.close().
+      await new Promise(resolve => setTimeout(resolve, 50));
     }
     if (db) {
       db.close();
@@ -1203,6 +1261,8 @@ export async function createEventStore(config: StoreConfig = {}): Promise<EventS
     // Views
     getAgent,
     listAgents,
+    updateAgentPlan,
+    updateAgentMetadata,
     getTask,
     listTasks,
     getMessages,
@@ -1269,6 +1329,25 @@ function initializeTables(store: Store): void {
  * Rebuild materialized views from the event log
  */
 function rebuildViews(store: Store): void {
+  // Preserve out-of-band agent fields that aren't derived from events.
+  // These fields are written directly (not through events),
+  // so they would be lost when we clear and replay.
+  const OUT_OF_BAND_FIELDS = ['plan', 'name', 'metadata'] as const;
+  const savedOutOfBand = new Map<string, Record<string, string>>();
+  for (const rowId of store.getRowIds('agents')) {
+    const row = store.getRow('agents', rowId);
+    const saved: Record<string, string> = {};
+    for (const field of OUT_OF_BAND_FIELDS) {
+      const val = row[field] as string | undefined;
+      if (val && val !== '' && val !== '[]') {
+        saved[field] = val;
+      }
+    }
+    if (Object.keys(saved).length > 0) {
+      savedOutOfBand.set(rowId, saved);
+    }
+  }
+
   // Clear existing views
   for (const rowId of store.getRowIds('agents')) {
     store.delRow('agents', rowId);
@@ -1324,6 +1403,14 @@ function rebuildViews(store: Store): void {
   for (const event of events) {
     applyEventToViews(store, event, noop, noop, noop, noop, noop, noop);
   }
+
+  // Restore out-of-band agent fields preserved before the wipe
+  for (const [agentId, fields] of savedOutOfBand) {
+    const row = store.getRow('agents', agentId);
+    if (row.id) {
+      store.setPartialRow('agents', agentId, fields);
+    }
+  }
 }
 
 /**
@@ -1343,8 +1430,8 @@ function applyEventToViews(
     case 'spawn':
       applySpawnEvent(store, event, notifyAgentChange);
       break;
-    case 'terminate':
-      applyTerminateEvent(store, event, notifyAgentChange);
+    case 'stop':
+      applyStopEvent(store, event, notifyAgentChange);
       break;
     case 'status':
       applyStatusEvent(store, event, notifyAgentChange);
@@ -1411,6 +1498,7 @@ function applySpawnEvent(
 
   store.setRow('agents', agentId, {
     id: agentId,
+    name: '',
     session_id: payload.session_id,
     provider_session_id: '',
     parent: parent ?? '',
@@ -1422,6 +1510,8 @@ function applySpawnEvent(
     role: payload.role ?? '',
     config: JSON.stringify(payload.config ?? {}),
     cwd: payload.cwd ?? process.cwd(),
+    plan: '[]',
+    metadata: '',
     created_at: event.timestamp,
     started_at: 0,
     stopped_at: 0,
@@ -1433,9 +1523,9 @@ function applySpawnEvent(
 }
 
 /**
- * Apply terminate event to agents view
+ * Apply stop event to agents view
  */
-function applyTerminateEvent(
+function applyStopEvent(
   store: Store,
   event: Event,
   notify: (agentId: AgentId, agent: Agent | null) => void,
@@ -1577,6 +1667,7 @@ function applyTaskEvent(
         description: string;
         parent_task?: TaskId;
         inputs?: Record<string, unknown>;
+        tags?: string[];
         retryPolicy?: unknown;
       };
       store.setRow('tasks', taskId, {
@@ -1587,6 +1678,7 @@ function applyTaskEvent(
         parent_task: details.parent_task ?? '',
         subtasks: JSON.stringify([]),
         blockers: JSON.stringify([]),
+        tags: details.tags ? JSON.stringify(details.tags) : '',
         created_at: event.timestamp,
         started_at: 0,
         completed_at: 0,
@@ -1633,10 +1725,15 @@ function applyTaskEvent(
           break;
         }
       }
-      store.setPartialRow('tasks', taskId, {
+      const updates: Record<string, string | number | boolean> = {
         assigned_agent: '',
         agent_history: JSON.stringify(history),
-      });
+      };
+      // Reset to pending if task was only assigned (not yet started)
+      if (existing.status === 'assigned') {
+        updates.status = 'pending';
+      }
+      store.setPartialRow('tasks', taskId, updates);
       break;
     }
     case 'status_change': {
@@ -1759,6 +1856,7 @@ function rowToAgent(row: Record<string, unknown>): Agent {
   const stopReason = row.stop_reason as string;
   return {
     id: row.id as AgentId,
+    name: (row.name as string) || undefined,
     session_id: row.session_id as string,
     provider_session_id: (row.provider_session_id as string) || undefined,
     parent: (row.parent as string) || null,
@@ -1770,6 +1868,8 @@ function rowToAgent(row: Record<string, unknown>): Agent {
     role: (row.role as string) || undefined,
     config: row.config ? JSON.parse(row.config as string) : {},
     cwd: (row.cwd as string) || process.cwd(),
+    plan: row.plan ? JSON.parse(row.plan as string) : [],
+    metadata: row.metadata ? JSON.parse(row.metadata as string) : undefined,
     created_at: row.created_at as Timestamp,
     started_at: (row.started_at as number) || undefined,
     stopped_at: (row.stopped_at as number) || undefined,
@@ -1797,6 +1897,7 @@ function rowToTask(row: Record<string, unknown>): Task {
     outputs: row.outputs ? JSON.parse(row.outputs as string) : undefined,
     artifacts: row.artifacts ? JSON.parse(row.artifacts as string) : undefined,
     agent_history: row.agent_history ? JSON.parse(row.agent_history as string) : undefined,
+    tags: row.tags ? JSON.parse(row.tags as string) : undefined,
     retryPolicy: row.retry_policy ? JSON.parse(row.retry_policy as string) : undefined,
     retryState: row.retry_state ? JSON.parse(row.retry_state as string) : undefined,
   };

package/src/store/types/agents.ts

@@ -28,6 +28,8 @@ export interface AgentConfig {
 // Agent record in materialized view
 export interface Agent {
   id: AgentId;
+  /** Optional display name (set via rename, not derived from events) */
+  name?: string;
   session_id: SessionId;
   /** Session ID from the underlying agent provider (e.g., Claude Code UUID for --resume) */
   provider_session_id?: string;
@@ -40,9 +42,23 @@ export interface Agent {
   role?: string;
   config: AgentConfig;
   cwd: string;
+  plan: Array<{ content: string; priority: string; status: string }>;
+  /** Arbitrary metadata (persisted out-of-band, not derived from events) */
+  metadata?: Record<string, unknown>;
   created_at: Timestamp;
   started_at?: Timestamp;
   stopped_at?: Timestamp;
   /** Last time this agent emitted an event (for health monitoring) */
   last_activity_at?: Timestamp;
 }
+
+/**
+ * Partial update for agent metadata fields.
+ * All fields are optional — only provided fields are updated.
+ * `metadata` is merged (shallow) with existing metadata.
+ */
+export interface AgentMetadataUpdate {
+  name?: string;
+  plan?: Array<{ content: string; priority: string; status: string }>;
+  metadata?: Record<string, unknown>;
+}

package/src/store/types/events.ts

@@ -11,7 +11,7 @@ export const CURRENT_EVENT_VERSION = 1;
 // Event types
 export type EventType =
   | "spawn"
-  | "terminate"
+  | "stop"
   | "status"
   | "message"
   | "task"

package/src/task/backend/__tests__/create-task-backend.test.ts

@@ -0,0 +1,225 @@
+/**
+ * Tests for createTaskBackend factory function
+ *
+ * Covers:
+ * - Memory backend returns no socketPath
+ * - OpenTasks backend with explicit socketPath returns it
+ * - OpenTasks backend with autoStart returns daemon's socketPath
+ * - Unknown backend type throws
+ *
+ * @module task/backend/__tests__/create-task-backend.test
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { createEventStore, type EventStore } from "../../../store/event-store.js";
+
+// Mock opentasks to avoid real daemon operations
+vi.mock("opentasks", () => ({
+  checkExistingDaemon: vi.fn(),
+  createDaemonWithStore: vi.fn(),
+  OpenTasksClient: vi.fn(),
+}));
+
+// Mock the opentasks client module
+vi.mock("../opentasks/client.js", () => ({
+  IPCOpenTasksClient: vi.fn().mockImplementation(() => ({
+    connect: vi.fn().mockResolvedValue(undefined),
+    disconnect: vi.fn(),
+    isConnected: vi.fn().mockReturnValue(true),
+    call: vi.fn().mockResolvedValue({}),
+    createIssue: vi.fn(),
+    getIssue: vi.fn(),
+    updateIssue: vi.fn(),
+    deleteIssue: vi.fn(),
+    listIssues: vi.fn(),
+    getReadyIssues: vi.fn(),
+    createEdge: vi.fn(),
+    removeEdge: vi.fn(),
+    getBlockers: vi.fn(),
+    getBlocking: vi.fn(),
+    task: vi.fn(),
+    taskTransition: vi.fn(),
+    taskReady: vi.fn(),
+    taskAssign: vi.fn(),
+    taskValidActions: vi.fn(),
+    listProviders: vi.fn(),
+  })),
+  createOpenTasksClient: vi.fn().mockImplementation(async () => ({
+    connect: vi.fn().mockResolvedValue(undefined),
+    disconnect: vi.fn(),
+    isConnected: vi.fn().mockReturnValue(true),
+    call: vi.fn().mockResolvedValue({}),
+    createIssue: vi.fn(),
+    getIssue: vi.fn(),
+    updateIssue: vi.fn(),
+    deleteIssue: vi.fn(),
+    listIssues: vi.fn(),
+    getReadyIssues: vi.fn(),
+    createEdge: vi.fn(),
+    removeEdge: vi.fn(),
+    getBlockers: vi.fn(),
+    getBlocking: vi.fn(),
+    task: vi.fn(),
+    taskTransition: vi.fn(),
+    taskReady: vi.fn(),
+    taskAssign: vi.fn(),
+    taskValidActions: vi.fn(),
+    listProviders: vi.fn(),
+  })),
+  OpenTasksClientError: class extends Error {
+    code: string;
+    constructor(msg: string, code: string) {
+      super(msg);
+      this.code = code;
+    }
+  },
+}));
+
+// Mock the opentasks backend
+vi.mock("../opentasks/backend.js", () => ({
+  OpenTasksTaskBackend: vi.fn().mockImplementation(() => ({
+    create: vi.fn(),
+    get: vi.fn(),
+    update: vi.fn(),
+    list: vi.fn(),
+    delete: vi.fn(),
+    onChange: vi.fn(),
+  })),
+}));
+
+// Mock daemon-manager
+vi.mock("../opentasks/daemon-manager.js", () => ({
+  DaemonManager: vi.fn().mockImplementation(() => ({
+    ensureDaemon: vi.fn().mockResolvedValue({
+      client: {
+        connect: vi.fn(),
+        disconnect: vi.fn(),
+        isConnected: vi.fn().mockReturnValue(true),
+      },
+      socketPath: "/tmp/auto-daemon.sock",
+      ownsDaemon: true,
+    }),
+    shutdown: vi.fn().mockResolvedValue(undefined),
+    connectProject: vi.fn().mockResolvedValue(undefined),
+    getConnectedProjects: vi.fn().mockReturnValue([]),
+  })),
+}));
+
+describe("createTaskBackend", () => {
+  let eventStore: EventStore;
+
+  beforeEach(async () => {
+    eventStore = await createEventStore({ inMemory: true });
+    vi.clearAllMocks();
+  });
+
+  afterEach(async () => {
+    await eventStore.close();
+  });
+
+  it("should return no socketPath for memory backend", async () => {
+    const { createTaskBackend } = await import("../index.js");
+
+    const result = await createTaskBackend(
+      { backend: { type: "memory" } },
+      eventStore
+    );
+
+    expect(result.backend).toBeDefined();
+    expect(result.socketPath).toBeUndefined();
+    expect(result.shutdown).toBeUndefined();
+  });
+
+  it("should return explicit socketPath for opentasks with socketPath config", async () => {
+    const { createTaskBackend } = await import("../index.js");
+
+    const result = await createTaskBackend(
+      { backend: { type: "opentasks", socketPath: "/tmp/explicit.sock" } },
+      eventStore
+    );
+
+    expect(result.backend).toBeDefined();
+    expect(result.socketPath).toBe("/tmp/explicit.sock");
+    expect(result.openTasksClient).toBeDefined();
+    expect(result.shutdown).toBeDefined();
+    // No connectProject when using direct socket (no DaemonManager)
+    expect(result.connectProject).toBeUndefined();
+  });
+
+  it("should return daemon socketPath for opentasks with autoStart", async () => {
+    const { createTaskBackend } = await import("../index.js");
+
+    const result = await createTaskBackend(
+      { backend: { type: "opentasks" } }, // autoStart defaults to true
+      eventStore
+    );
+
+    expect(result.backend).toBeDefined();
+    expect(result.socketPath).toBe("/tmp/auto-daemon.sock");
+    expect(result.openTasksClient).toBeDefined();
+    expect(result.shutdown).toBeDefined();
+    expect(result.connectProject).toBeDefined();
+    expect(result.getConnectedProjects).toBeDefined();
+  });
+
+  it("should return no socketPath for opentasks with autoStart disabled", async () => {
+    const { createTaskBackend } = await import("../index.js");
+
+    const result = await createTaskBackend(
+      { backend: { type: "opentasks", autoStart: false } },
+      eventStore
+    );
+
+    expect(result.backend).toBeDefined();
+    // autoStart=false, no socketPath in config → socket path unknown
+    expect(result.socketPath).toBeUndefined();
+    expect(result.openTasksClient).toBeDefined();
+    expect(result.shutdown).toBeDefined();
+    // No DaemonManager when autoStart is false
+    expect(result.connectProject).toBeUndefined();
+  });
+
+  it("should throw for unknown backend type", async () => {
+    const { createTaskBackend } = await import("../index.js");
+
+    await expect(
+      createTaskBackend(
+        { backend: { type: "unknown" as any } },
+        eventStore
+      )
+    ).rejects.toThrow("Unknown backend type");
+  });
+
+  it("should call backend.close() before daemon shutdown", async () => {
+    const { createTaskBackend } = await import("../index.js");
+
+    const result = await createTaskBackend(
+      { backend: { type: "opentasks" } }, // autoStart defaults to true
+      eventStore
+    );
+
+    expect(result.shutdown).toBeDefined();
+
+    // Track call order
+    const callOrder: string[] = [];
+    const { DaemonManager } = await import("../opentasks/daemon-manager.js");
+    const mockInstance = vi.mocked(DaemonManager).mock.results[0]?.value;
+    if (mockInstance) {
+      mockInstance.shutdown.mockImplementation(async () => {
+        callOrder.push("daemon_shutdown");
+      });
+    }
+
+    // backend.close() is called within the shutdown wrapper
+    const backend = result.backend as any;
+    const originalClose = backend.close?.bind(backend);
+    backend.close = vi.fn(async () => {
+      callOrder.push("backend_close");
+      if (originalClose) await originalClose();
+    });
+
+    await result.shutdown!();
+
+    expect(callOrder).toEqual(["backend_close", "daemon_shutdown"]);
+  });
+});