pi-fabric 0.8.2 → 0.9.1

package/dist/actors/manager.d.ts

@@ -33,6 +33,19 @@ export declare class ActorManager {
      * actor inherits the Fabric default (subagents.thinking, default "medium").
      */
     setThinking(id: string, thinking: string | undefined): Promise<FabricActorInfo>;
+    /**
+     * Replace an existing actor's host-event subscriptions. Already-queued work
+     * for a removed event still runs, but future dispatches respect the new set.
+     * Pass an empty array to pause host-event reactivity while keeping the actor
+     * alive and reachable by direct messages and mesh topics.
+     */
+    setEvents(id: string, events: FabricActorHostEvent[]): Promise<FabricActorInfo>;
+    /**
+     * Clear an actor's recorded inbox/outbox history. The actor keeps running;
+     * only its bounded message log is reset — useful to declutter a long mailbox
+     * from the dashboard without stopping the actor.
+     */
+    clearMessages(id: string): Promise<FabricActorInfo>;
     tell(id: string, message: string, data?: unknown): {
         queued: true;
         messageId: string;
@@ -46,6 +59,14 @@ export declare class ActorManager {
     }): FabricActorLog;
     dispatchHostEvent(event: FabricActorHostEvent, payload: unknown): number;
     stop(id: string): Promise<FabricActorInfo>;
+    /**
+     * Whether the stop-the-world gate is currently armed. haltAll() arms it
+     * (ESC stop-the-world) and the "input" host event lifts it when the user
+     * resumes with a new message. Read-only view of the private gate so the
+     * ESC handler can treat a repeated lone Esc while already halted as a
+     * no-op rather than re-arming and re-notifying.
+     */
+    get halted(): boolean;
     /**
      * Interrupt every non-stopped actor: abort its in-flight run (if any) and
      * reject every queued message so subsequent execution is cancelled. Unlike

package/dist/actors/manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/actors/manager.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAA2B,MAAM,cAAc,CAAC;AAC9E,OAAO,EAAE,SAAS,EAAkB,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,OAAO,KAAK,EAEV,0BAA0B,EAE1B,oBAAoB,EACpB,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAGnB,MAAM,YAAY,CAAC;AAqIpB,qBAAa,YAAY;;IAYrB,QAAQ,CAAC,SAAS,EAAE,MAAM;IAC1B,QAAQ,CAAC,QAAQ,EAAE,YAAY;IAC/B,QAAQ,CAAC,IAAI,EAAE,SAAS;IACxB,QAAQ,CAAC,UAAU,EAAE,gBAAgB;IACrC,QAAQ,CAAC,SAAS,EAAE,eAAe;IACnC,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,0BAA0B,KAAK,IAAI;gBALxD,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,SAAS,EACf,UAAU,EAAE,gBAAgB,EAC5B,SAAS,EAAE,eAAe,EAC1B,SAAS,EAAE,CAAC,OAAO,EAAE,0BAA0B,KAAK,IAAI,EACjE,OAAO,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAO;IAetD,MAAM,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,eAAe,CAAC;IA4DnE,IAAI,IAAI,eAAe,EAAE;IAIzB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe;IAInC;;;;;;OAMG;IACG,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,eAAe,CAAC;IAU/E;;;;;;OAMG;IACG,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,eAAe,CAAC;IAerF,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG;QAAE,MAAM,EAAE,IAAI,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IAmBtF,GAAG,CACD,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,OAAO,EACd,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,kBAAkB,CAAC;IA4C9B,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,kBAAkB,EAAE;IAMtD,OAAO,CACL,EAAE,EAAE,MAAM,EACV,IAAI,GAAE;QAAE,IAAI,CAAC,EAAE,SAAS,GAAG,KAAK,GAAG,KAAK,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO,GAC9E,cAAc;IAkCjB,iBAAiB,CAAC,KAAK,EAAE,oBAAoB,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM;IAuBlE,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAmBhD;;;;;;;;OAQG;IACH,OAAO,IAAI;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE;IA2BvB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IAajD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAyiB7B"}
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/actors/manager.ts"],"names":[],"mappings":"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"}

package/dist/actors/manager.js

@@ -15,10 +15,6 @@ const HOST_EVENTS = new Set([
     "session_compact",
 ]);
 const MESSAGE_HISTORY_LIMIT = 100;
-// After a user-triggered halt (ESC), ignore host-event dispatches for a short
-// window so the interrupt's own turn_end / agent_settled events do not
-// immediately re-arm the actors that were just stopped.
-const HOST_EVENT_HALT_COOLDOWN_MS = 1_000;
 const atomicWrite = (filePath, value) => {
     fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
     const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
@@ -108,7 +104,11 @@ export class ActorManager {
     #meshOffset;
     #polling = false;
     #closing = false;
-    #haltedAt = 0;
+    // Stop-the-world gate armed by haltAll() (ESC): while true, host-event and
+    // mesh dispatch are frozen so interrupted actors are not re-armed by the
+    // interrupt's own turn_end / agent_settled events. Lifted when the user
+    // resumes by sending a new message (the "input" host event).
+    #halted = false;
     constructor(sessionId, identity, mesh, meshConfig, subagents, onDeliver, options = {}) {
         this.sessionId = sessionId;
         this.identity = identity;
@@ -174,6 +174,7 @@ export class ActorManager {
             ...(request.timeoutMs ? { timeoutMs: request.timeoutMs } : {}),
             sessionFile: path.join(actorDirectory, "session.jsonl"),
             queue: [],
+            draining: false,
             messages: [],
             createdAt: Date.now(),
             updatedAt: Date.now(),
@@ -239,6 +240,38 @@ export class ActorManager {
         await this.#publishPresence(actor);
         return this.#publicInfo(actor);
     }
+    /**
+     * Replace an existing actor's host-event subscriptions. Already-queued work
+     * for a removed event still runs, but future dispatches respect the new set.
+     * Pass an empty array to pause host-event reactivity while keeping the actor
+     * alive and reachable by direct messages and mesh topics.
+     */
+    async setEvents(id, events) {
+        const actor = this.#requireActor(id);
+        const next = [...new Set(events)];
+        for (const event of next) {
+            if (!HOST_EVENTS.has(event))
+                throw new Error(`Unsupported Fabric actor event: ${event}`);
+        }
+        actor.events = next;
+        actor.updatedAt = Date.now();
+        this.#saveActors();
+        await this.#publishPresence(actor);
+        return this.#publicInfo(actor);
+    }
+    /**
+     * Clear an actor's recorded inbox/outbox history. The actor keeps running;
+     * only its bounded message log is reset — useful to declutter a long mailbox
+     * from the dashboard without stopping the actor.
+     */
+    async clearMessages(id) {
+        const actor = this.#requireActor(id);
+        actor.messages = [];
+        actor.updatedAt = Date.now();
+        this.#saveActors();
+        await this.#publishPresence(actor);
+        return this.#publicInfo(actor);
+    }
     tell(id, message, data) {
         this.#validateDirectMessage(message, data);
         const actor = this.#requireActiveActor(id);
@@ -337,9 +370,12 @@ export class ActorManager {
     dispatchHostEvent(event, payload) {
         if (this.#closing || !this.meshConfig.enabled)
             return 0;
-        if (this.#haltedAt > 0 && Date.now() - this.#haltedAt < HOST_EVENT_HALT_COOLDOWN_MS) {
+        // The user sending a new message ends a stop-the-world halt: lift the gate
+        // before dispatching so input-subscribed actors receive this event.
+        if (event === "input")
+            this.#halted = false;
+        if (this.#halted)
             return 0;
-        }
         let delivered = 0;
         for (const actor of this.#actors.values()) {
             if (actor.status === "stopped" || !actor.events.includes(event))
@@ -374,6 +410,16 @@ export class ActorManager {
             .catch(() => undefined);
         return this.#publicInfo(actor);
     }
+    /**
+     * Whether the stop-the-world gate is currently armed. haltAll() arms it
+     * (ESC stop-the-world) and the "input" host event lifts it when the user
+     * resumes with a new message. Read-only view of the private gate so the
+     * ESC handler can treat a repeated lone Esc while already halted as a
+     * no-op rather than re-arming and re-notifying.
+     */
+    get halted() {
+        return this.#halted;
+    }
     /**
      * Interrupt every non-stopped actor: abort its in-flight run (if any) and
      * reject every queued message so subsequent execution is cancelled. Unlike
@@ -387,7 +433,11 @@ export class ActorManager {
         if (!this.meshConfig.enabled)
             return { halted: 0 };
         let halted = 0;
-        this.#haltedAt = Date.now();
+        // Arm stop-the-world: freeze host-event and mesh dispatch until the user
+        // resumes with a new message. Always arm the gate (even with no active
+        // work) so an idle-but-subscribed actor is not re-armed by the interrupt's
+        // own settle events.
+        this.#halted = true;
         for (const actor of this.#actors.values()) {
             if (actor.status === "stopped")
                 continue;
@@ -458,6 +508,7 @@ export class ActorManager {
             if (existing) {
                 existing.payload = payload;
                 existing.createdAt = Date.now();
+                this.#ensureDrain(actor);
                 return existing;
             }
         }
@@ -486,123 +537,149 @@ export class ActorManager {
             data: structuredClone(payload),
         });
         void this.#publishPresence(actor);
-        actor.drain ??= this.#drain(actor).finally(() => {
-            delete actor.drain;
-        });
+        this.#ensureDrain(actor);
         return item;
     }
+    /**
+     * Ensure exactly one drain loop is processing the actor's queue. The loop
+     * clears `actor.draining` synchronously when it exits, so a host-event
+     * enqueue that lands in the microtask window between the loop exiting and
+     * this drain's promise settling still observes `draining === false` and
+     * starts a fresh drain — preventing a queued item from being stranded with
+     * no drain to process it (the "stuck at queue:1" race).
+     */
+    #ensureDrain(actor) {
+        if (actor.draining || actor.status === "stopped" || this.#closing)
+            return;
+        actor.draining = true;
+        const drain = this.#drain(actor);
+        actor.drain = drain;
+        const release = () => {
+            if (actor.drain === drain)
+                delete actor.drain;
+        };
+        drain.then(release, release);
+    }
     async #drain(actor) {
-        while (actor.queue.length > 0 && actor.status !== "stopped" && !this.#closing) {
-            const item = actor.queue.shift();
-            if (!item)
-                break;
-            actor.status = "running";
-            actor.updatedAt = Date.now();
-            delete actor.lastError;
-            const abortController = new AbortController();
-            actor.abortController = abortController;
-            await this.#publishPresence(actor);
-            let runId;
-            const previousRunId = actor.lastRunId;
-            let runCompleted = false;
-            try {
-                const result = await this.subagents.run(this.#runRequest(actor, item), abortController.signal);
-                runId = result.id;
-                actor.lastRunId = result.id;
-                runCompleted = result.status === "completed";
-                if (result.status !== "completed") {
-                    if (actor.responseMode === "directive") {
-                        // A failed directive run is non-fatal: stay silent and keep the
-                        // actor ambient instead of erroring out. Record the run error for
-                        // debugging; the failed run itself is retained (see finally) so
-                        // agents.status(actor.lastRunId) can inspect the full output.
-                        const silent = {
-                            id: randomUUID(),
-                            actorId: actor.id,
-                            actorName: actor.name,
-                            direction: "out",
-                            source: item.source,
-                            createdAt: Date.now(),
-                            action: "silent",
-                            data: { runError: result.error || `Actor run ${result.status}`, runId: result.id },
-                            runId: result.id,
-                            usage: result.usage,
-                        };
-                        this.#recordMessage(actor, silent);
-                        item.resolve?.(structuredClone(silent));
-                        continue;
+        try {
+            while (actor.queue.length > 0 && actor.status !== "stopped" && !this.#closing) {
+                const item = actor.queue.shift();
+                if (!item)
+                    break;
+                actor.status = "running";
+                actor.updatedAt = Date.now();
+                delete actor.lastError;
+                const abortController = new AbortController();
+                actor.abortController = abortController;
+                await this.#publishPresence(actor);
+                let runId;
+                const previousRunId = actor.lastRunId;
+                let runCompleted = false;
+                try {
+                    const result = await this.subagents.run(this.#runRequest(actor, item), abortController.signal);
+                    runId = result.id;
+                    actor.lastRunId = result.id;
+                    runCompleted = result.status === "completed";
+                    if (result.status !== "completed") {
+                        if (actor.responseMode === "directive") {
+                            // A failed directive run is non-fatal: stay silent and keep the
+                            // actor ambient instead of erroring out. Record the run error for
+                            // debugging; the failed run itself is retained (see finally) so
+                            // agents.status(actor.lastRunId) can inspect the full output.
+                            const silent = {
+                                id: randomUUID(),
+                                actorId: actor.id,
+                                actorName: actor.name,
+                                direction: "out",
+                                source: item.source,
+                                createdAt: Date.now(),
+                                action: "silent",
+                                data: { runError: result.error || `Actor run ${result.status}`, runId: result.id },
+                                runId: result.id,
+                                usage: result.usage,
+                            };
+                            this.#recordMessage(actor, silent);
+                            item.resolve?.(structuredClone(silent));
+                            continue;
+                        }
+                        throw new Error(result.error || `Actor run ${result.status}`);
                     }
-                    throw new Error(result.error || `Actor run ${result.status}`);
-                }
-                const message = this.#outgoingMessage(actor, item, result);
-                this.#recordMessage(actor, message);
-                await this.mesh
-                    .publish({
-                    topic: "fabric.actor.output",
-                    kind: message.action ?? "message",
-                    from: { id: actor.id, name: actor.name, kind: "actor", sessionId: this.sessionId },
-                    ...(message.text ? { text: message.text } : {}),
-                    ...(message.data !== undefined ? { data: message.data } : {}),
-                })
-                    .catch(() => undefined);
-                if ((message.action === "message" || message.action === "stop") &&
-                    message.text &&
-                    actor.delivery !== "mailbox") {
-                    try {
-                        this.onDeliver({
-                            actor: this.#publicInfo(actor),
-                            message: structuredClone(message),
-                            delivery: actor.delivery,
-                            triggerTurn: actor.triggerTurn,
-                        });
+                    const message = this.#outgoingMessage(actor, item, result);
+                    this.#recordMessage(actor, message);
+                    await this.mesh
+                        .publish({
+                        topic: "fabric.actor.output",
+                        kind: message.action ?? "message",
+                        from: { id: actor.id, name: actor.name, kind: "actor", sessionId: this.sessionId },
+                        ...(message.text ? { text: message.text } : {}),
+                        ...(message.data !== undefined ? { data: message.data } : {}),
+                    })
+                        .catch(() => undefined);
+                    if ((message.action === "message" || message.action === "stop") &&
+                        message.text &&
+                        actor.delivery !== "mailbox") {
+                        try {
+                            this.onDeliver({
+                                actor: this.#publicInfo(actor),
+                                message: structuredClone(message),
+                                delivery: actor.delivery,
+                                triggerTurn: actor.triggerTurn,
+                            });
+                        }
+                        catch { /* skip non-cloneable or undeliverable message */ }
+                    }
+                    item.resolve?.(structuredClone(message));
+                    if (message.action === "stop") {
+                        actor.status = "stopped";
+                        actor.queue.splice(0).forEach((queued) => queued.reject?.(new Error("Actor stopped")));
                     }
-                    catch { /* skip non-cloneable or undeliverable message */ }
-                }
-                item.resolve?.(structuredClone(message));
-                if (message.action === "stop") {
-                    actor.status = "stopped";
-                    actor.queue.splice(0).forEach((queued) => queued.reject?.(new Error("Actor stopped")));
-                }
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                actor.lastError = message;
-                const failed = {
-                    id: randomUUID(),
-                    actorId: actor.id,
-                    actorName: actor.name,
-                    direction: "out",
-                    source: item.source,
-                    createdAt: Date.now(),
-                    error: message,
-                };
-                this.#recordMessage(actor, failed);
-                item.reject?.(new Error(message));
-            }
-            finally {
-                // Retain a durable copy of the run's event log + status in the
-                // actor's directory so agents.log / /fabric log can inspect what the
-                // actor sent to and received from its model, even after a successful
-                // run cleans up the in-memory handle and tmp run directory. Failed
-                // runs stay in the subagent registry for agents.status(lastRunId).
-                if (runId) {
-                    await this.#retainRunLog(actor, runId).catch(() => undefined);
                 }
-                // Release the in-memory handle and tmp run dir for completed runs;
-                // failed runs are retained for agents.status(actor.lastRunId).
-                if (previousRunId && previousRunId !== runId) {
-                    await this.subagents.cleanup(previousRunId).catch(() => ({ cleaned: false }));
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    actor.lastError = message;
+                    const failed = {
+                        id: randomUUID(),
+                        actorId: actor.id,
+                        actorName: actor.name,
+                        direction: "out",
+                        source: item.source,
+                        createdAt: Date.now(),
+                        error: message,
+                    };
+                    this.#recordMessage(actor, failed);
+                    item.reject?.(new Error(message));
                 }
-                if (runId && runCompleted) {
-                    await this.subagents.cleanup(runId).catch(() => ({ cleaned: false }));
+                finally {
+                    // Retain a durable copy of the run's event log + status in the
+                    // actor's directory so agents.log / /fabric log can inspect what the
+                    // actor sent to and received from its model, even after a successful
+                    // run cleans up the in-memory handle and tmp run directory. Failed
+                    // runs stay in the subagent registry for agents.status(lastRunId).
+                    if (runId) {
+                        await this.#retainRunLog(actor, runId).catch(() => undefined);
+                    }
+                    // Release the in-memory handle and tmp run dir for completed runs;
+                    // failed runs are retained for agents.status(actor.lastRunId).
+                    if (previousRunId && previousRunId !== runId) {
+                        await this.subagents.cleanup(previousRunId).catch(() => ({ cleaned: false }));
+                    }
+                    if (runId && runCompleted) {
+                        await this.subagents.cleanup(runId).catch(() => ({ cleaned: false }));
+                    }
+                    delete actor.abortController;
+                    actor.updatedAt = Date.now();
+                    if (actor.status !== "stopped")
+                        actor.status = actor.queue.length > 0 ? "queued" : "idle";
+                    await this.#publishPresence(actor);
                 }
-                delete actor.abortController;
-                actor.updatedAt = Date.now();
-                if (actor.status !== "stopped")
-                    actor.status = actor.queue.length > 0 ? "queued" : "idle";
-                await this.#publishPresence(actor);
             }
         }
+        finally {
+            // Mark the drain inactive the moment its loop exits (or throws) so a
+            // concurrent #ensureDrain observes `draining === false` and starts a
+            // fresh drain instead of stranding a just-enqueued item.
+            actor.draining = false;
+        }
     }
     #runRequest(actor, item) {
         return {
@@ -678,6 +755,10 @@ export class ActorManager {
     async #pollMesh() {
         if (this.#polling || this.#closing || !this.meshConfig.enabled)
             return;
+        // Stop-the-world: do not consume mesh events while halted, so deferred
+        // events are preserved and dispatched after the user resumes.
+        if (this.#halted)
+            return;
         this.#polling = true;
         try {
             const tail = this.mesh.tail(this.#meshOffset, this.meshConfig.maxReadEvents);
@@ -888,6 +969,7 @@ export class ActorManager {
                 ...(typeof record.timeoutMs === "number" ? { timeoutMs: record.timeoutMs } : {}),
                 sessionFile: path.join(this.#actorRoot, record.id, "session.jsonl"),
                 queue: [],
+                draining: false,
                 messages: [],
                 createdAt: record.createdAt,
                 updatedAt: Date.now(),