@melihmucuk/pi-crew 1.0.13 → 1.0.14

package/dist/runtime/crew-runtime.js

@@ -1,285 +0,0 @@
-import { bootstrapSession } from "../bootstrap-session.js";
-import { DeliveryCoordinator } from "./delivery-coordinator.js";
-import { runPromptWithOverflowRecovery } from "./overflow-recovery.js";
-import { SubagentRegistry } from "./subagent-registry.js";
-import { isAbortableStatus, isAborted, } from "./subagent-state.js";
-function toBootstrapContext(ctx) {
-    return {
-        model: ctx.model,
-        modelRegistry: ctx.modelRegistry,
-        agentDir: ctx.agentDir,
-        parentSessionFile: ctx.parentSessionFile,
-    };
-}
-function getLastAssistantMessage(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i];
-        if (msg.role === "assistant") {
-            return msg;
-        }
-    }
-    return undefined;
-}
-function getAssistantText(message) {
-    if (!message)
-        return undefined;
-    const texts = [];
-    for (const part of message.content) {
-        if (part.type === "text") {
-            texts.push(part.text);
-        }
-    }
-    return texts.length > 0 ? texts.join("\n") : undefined;
-}
-function getPromptOutcome(state) {
-    const lastAssistant = getLastAssistantMessage(state.session.messages);
-    const text = getAssistantText(lastAssistant);
-    if (lastAssistant?.stopReason === "error") {
-        return {
-            status: "error",
-            error: lastAssistant.errorMessage ?? text ?? "(no output)",
-        };
-    }
-    if (lastAssistant?.stopReason === "aborted") {
-        return {
-            status: "aborted",
-            error: lastAssistant.errorMessage ?? text ?? "(no output)",
-        };
-    }
-    return {
-        status: state.agentConfig.interactive ? "waiting" : "done",
-        result: text ?? "(no output)",
-    };
-}
-/**
- * Process-level singleton that owns all durable subagent state.
- *
- * This survives extension instance replacement caused by runtime
- * teardown/recreation on /resume, /new, /fork (pi 0.65.0+).
- * Each new extension instance rebinds delivery and widget hooks
- * via activateSession/deactivateSession.
- */
-class CrewRuntime {
-    registry = new SubagentRegistry();
-    delivery = new DeliveryCoordinator();
-    // Per-session refresh callbacks, keyed by ownerSessionId
-    refreshCallbacks = new Map();
-    refreshWidgetFor(sessionId) {
-        this.refreshCallbacks.get(sessionId)?.();
-    }
-    activateSession(binding, refreshWidget) {
-        if (refreshWidget) {
-            this.refreshCallbacks.set(binding.sessionId, refreshWidget);
-        }
-        this.delivery.activateSession(binding, (ownerSessionId, excludeId) => this.registry.countRunningForOwner(ownerSessionId, excludeId));
-        refreshWidget?.();
-    }
-    deactivateSession(sessionId) {
-        this.delivery.deactivateSession(sessionId);
-        this.refreshCallbacks.delete(sessionId);
-    }
-    spawn(agentConfig, task, cwd, ownerSessionId, ctx, extensionResolvedPath) {
-        const state = this.registry.create(agentConfig, task, ownerSessionId);
-        this.refreshWidgetFor(ownerSessionId);
-        void this.spawnSession(state, cwd, ctx, extensionResolvedPath);
-        return state.id;
-    }
-    attachSessionListeners(state, session) {
-        state.unsubscribe = session.subscribe((event) => {
-            if (event.type !== "turn_end")
-                return;
-            state.turns++;
-            const msg = event.message;
-            if (msg.role === "assistant") {
-                const assistantMsg = msg;
-                state.contextTokens = assistantMsg.usage.totalTokens;
-                state.model = assistantMsg.model;
-            }
-            this.refreshWidgetFor(state.ownerSessionId);
-        });
-    }
-    attachSpawnedSession(state, session) {
-        if (!this.registry.hasState(state)) {
-            session.dispose();
-            return false;
-        }
-        state.session = session;
-        return true;
-    }
-    settleAgent(state, nextStatus, opts) {
-        state.status = nextStatus;
-        state.result = opts.result;
-        state.error = opts.error;
-        this.delivery.deliver(state.ownerSessionId, {
-            id: state.id,
-            agentName: state.agentConfig.name,
-            sessionFile: state.session?.sessionFile,
-            status: state.status,
-            result: state.result,
-            error: state.error,
-        }, (ownerSessionId, excludeId) => this.registry.countRunningForOwner(ownerSessionId, excludeId));
-        if (state.status !== "waiting") {
-            this.disposeAgent(state);
-        }
-        else {
-            this.refreshWidgetFor(state.ownerSessionId);
-        }
-    }
-    disposeAgent(state) {
-        state.unsubscribe?.();
-        state.promptAbortController = undefined;
-        state.session?.dispose();
-        this.registry.delete(state.id);
-        this.refreshWidgetFor(state.ownerSessionId);
-    }
-    async runPromptCycle(state, prompt) {
-        if (isAborted(state))
-            return;
-        const abortController = new AbortController();
-        state.promptAbortController = abortController;
-        try {
-            const recovery = await runPromptWithOverflowRecovery(state.session, prompt, abortController.signal);
-            if (isAborted(state))
-                return;
-            const outcome = getPromptOutcome(state);
-            if (recovery === "failed" && outcome.status !== "error") {
-                this.settleAgent(state, "error", {
-                    error: "Context overflow recovery failed",
-                });
-                return;
-            }
-            this.settleAgent(state, outcome.status, outcome);
-        }
-        catch (err) {
-            if (isAborted(state))
-                return;
-            const error = err instanceof Error ? err.message : String(err);
-            this.settleAgent(state, "error", { error });
-        }
-        finally {
-            state.promptAbortController = undefined;
-        }
-    }
-    async spawnSession(state, cwd, ctx, extensionResolvedPath) {
-        try {
-            if (isAborted(state))
-                return;
-            const { session, warnings } = await bootstrapSession({
-                agentConfig: state.agentConfig,
-                cwd,
-                ctx: toBootstrapContext(ctx),
-                extensionResolvedPath,
-            });
-            // Emit bootstrap warnings to UI
-            for (const warning of warnings) {
-                ctx.onWarning?.(warning);
-            }
-            if (!this.attachSpawnedSession(state, session))
-                return;
-            this.attachSessionListeners(state, session);
-            await this.runPromptCycle(state, state.task);
-        }
-        catch (err) {
-            if (isAborted(state))
-                return;
-            if (state.status === "running") {
-                const error = err instanceof Error ? err.message : String(err);
-                this.settleAgent(state, "error", { error });
-            }
-        }
-    }
-    respond(id, message, callerSessionId) {
-        const state = this.registry.get(id);
-        if (!state)
-            return { error: `No subagent with id "${id}"` };
-        if (state.ownerSessionId !== callerSessionId) {
-            return { error: `Subagent "${id}" belongs to a different session` };
-        }
-        if (state.status !== "waiting") {
-            return {
-                error: `Subagent "${id}" is not waiting for a response (status: ${state.status})`,
-            };
-        }
-        if (!state.session)
-            return { error: `Subagent "${id}" has no active session` };
-        state.status = "running";
-        this.refreshWidgetFor(state.ownerSessionId);
-        void this.runPromptCycle(state, message);
-        return {};
-    }
-    done(id, callerSessionId) {
-        const state = this.registry.get(id);
-        if (!state)
-            return { error: `No active subagent with id "${id}"` };
-        if (state.ownerSessionId !== callerSessionId) {
-            return { error: `Subagent "${id}" belongs to a different session` };
-        }
-        if (state.status !== "waiting") {
-            return { error: `Subagent "${id}" is not in waiting state` };
-        }
-        this.disposeAgent(state);
-        return {};
-    }
-    abort(id, opts) {
-        const state = this.registry.get(id);
-        if (!state || !isAbortableStatus(state.status))
-            return false;
-        state.promptAbortController?.abort();
-        state.promptAbortController = undefined;
-        state.session?.abortCompaction();
-        state.session?.abortRetry();
-        state.session?.abort().catch(() => { });
-        this.settleAgent(state, "aborted", { error: opts.reason });
-        return true;
-    }
-    abortOwned(ids, callerSessionId, opts) {
-        const uniqueIds = Array.from(new Set(ids.map((id) => id.trim()).filter(Boolean)));
-        const result = {
-            abortedIds: [],
-            missingIds: [],
-            foreignIds: [],
-        };
-        for (const id of uniqueIds) {
-            const state = this.registry.get(id);
-            if (!state || !isAbortableStatus(state.status)) {
-                result.missingIds.push(id);
-                continue;
-            }
-            if (state.ownerSessionId !== callerSessionId) {
-                result.foreignIds.push(id);
-                continue;
-            }
-            if (this.abort(id, opts)) {
-                result.abortedIds.push(id);
-            }
-            else {
-                result.missingIds.push(id);
-            }
-        }
-        return result;
-    }
-    abortAllOwned(callerSessionId, opts) {
-        const ids = this.registry.getOwnedAbortableIds(callerSessionId);
-        for (const id of ids) {
-            this.abort(id, opts);
-        }
-        return ids;
-    }
-    /**
-     * Abort all running subagents during shutdown cleanup.
-     * Called from SIGINT, session_shutdown(reason="quit"), and beforeExit fallback paths.
-     */
-    abortAll() {
-        const allAgents = this.registry.getAllRunning();
-        for (const state of allAgents) {
-            this.abort(state.id, { reason: "Aborted during shutdown" });
-        }
-    }
-    getAbortableAgents() {
-        return this.registry.getAbortableAgents();
-    }
-    getActiveSummariesForOwner(ownerSessionId) {
-        return this.registry.getActiveSummariesForOwner(ownerSessionId);
-    }
-}
-export const crewRuntime = new CrewRuntime();

package/dist/runtime/delivery-coordinator.d.ts

@@ -1,26 +0,0 @@
-import { type SteeringPayload, type SendMessageFn } from "../subagent-messages.js";
-export interface ActiveRuntimeBinding {
-    sessionId: string;
-    isIdle: () => boolean;
-    sendMessage: SendMessageFn;
-}
-export declare class DeliveryCoordinator {
-    private binding;
-    private pendingMessages;
-    private flushScheduled;
-    activateSession(binding: ActiveRuntimeBinding, countRunningForOwner: (ownerSessionId: string, excludeId: string) => number): void;
-    deactivateSession(sessionId: string): void;
-    deliver(ownerSessionId: string, payload: SteeringPayload, countRunningForOwner: (ownerSessionId: string, excludeId: string) => number): void;
-    /**
-     * Remove pending messages older than the TTL.
-     * Called during activateSession to prevent unbounded memory growth.
-     */
-    private cleanStaleMessages;
-    private flushPending;
-    /**
-     * Result messages always go first. If more subagents are still running and the
-     * owner is idle, queue the result without triggering, then queue the separate
-     * remaining note with triggerTurn so the next turn sees both in order.
-     */
-    private send;
-}

package/dist/runtime/delivery-coordinator.js

@@ -1,86 +0,0 @@
-import { sendRemainingNote, sendSteeringMessage, } from "../subagent-messages.js";
-export class DeliveryCoordinator {
-    binding;
-    pendingMessages = [];
-    flushScheduled = false;
-    activateSession(binding, countRunningForOwner) {
-        this.binding = binding;
-        // Delay flush to next macrotask. session_start fires before pi-core
-        // calls _reconnectToAgent(), so synchronous delivery would emit agent
-        // events while the session listener is disconnected, losing JSONL persistence.
-        if (this.pendingMessages.some((entry) => entry.ownerSessionId === binding.sessionId)) {
-            this.flushScheduled = true;
-            setTimeout(() => {
-                this.flushScheduled = false;
-                this.flushPending(countRunningForOwner);
-            }, 0);
-        }
-    }
-    deactivateSession(sessionId) {
-        if (this.binding?.sessionId === sessionId) {
-            this.binding = undefined;
-        }
-    }
-    deliver(ownerSessionId, payload, countRunningForOwner) {
-        if (!this.binding || ownerSessionId !== this.binding.sessionId || this.flushScheduled) {
-            this.pendingMessages.push({ ownerSessionId, payload, queuedAt: Date.now() });
-            return;
-        }
-        this.send(ownerSessionId, payload, countRunningForOwner);
-    }
-    /**
-     * Remove pending messages older than the TTL.
-     * Called during activateSession to prevent unbounded memory growth.
-     */
-    cleanStaleMessages() {
-        const maxAgeMs = 86_400_000; // 24 hours
-        const cutoff = Date.now() - maxAgeMs;
-        this.pendingMessages = this.pendingMessages.filter((entry) => entry.queuedAt >= cutoff);
-    }
-    flushPending(countRunningForOwner) {
-        if (!this.binding)
-            return;
-        const targetSessionId = this.binding.sessionId;
-        // Clean up stale messages first (older than TTL)
-        this.cleanStaleMessages();
-        const toDeliver = [];
-        const remaining = [];
-        for (const entry of this.pendingMessages) {
-            if (entry.ownerSessionId === targetSessionId) {
-                toDeliver.push(entry);
-            }
-            else {
-                // Keep all other messages - they may be for sessions that will be reactivated later
-                remaining.push(entry);
-            }
-        }
-        // Keep messages for other sessions
-        this.pendingMessages = remaining;
-        // Deliver messages for the active session
-        for (const entry of toDeliver) {
-            this.send(entry.ownerSessionId, entry.payload, countRunningForOwner);
-        }
-    }
-    /**
-     * Result messages always go first. If more subagents are still running and the
-     * owner is idle, queue the result without triggering, then queue the separate
-     * remaining note with triggerTurn so the next turn sees both in order.
-     */
-    send(ownerSessionId, payload, countRunningForOwner) {
-        if (!this.binding || this.binding.sessionId !== ownerSessionId) {
-            this.pendingMessages.push({ ownerSessionId, payload, queuedAt: Date.now() });
-            return;
-        }
-        const remaining = countRunningForOwner(ownerSessionId, payload.id);
-        const isIdle = this.binding.isIdle();
-        const triggerResultTurn = !(isIdle && remaining > 0);
-        sendSteeringMessage(payload, this.binding.sendMessage, {
-            isIdle,
-            triggerTurn: triggerResultTurn,
-        });
-        sendRemainingNote(remaining, this.binding.sendMessage, {
-            isIdle,
-            triggerTurn: isIdle && remaining > 0,
-        });
-    }
-}

package/dist/runtime/overflow-recovery.d.ts

@@ -1,3 +0,0 @@
-import type { AgentSession } from "@mariozechner/pi-coding-agent";
-export type OverflowRecoveryResult = "none" | "recovered" | "failed";
-export declare function runPromptWithOverflowRecovery(session: AgentSession, text: string, signal: AbortSignal): Promise<OverflowRecoveryResult>;

package/dist/runtime/overflow-recovery.js

@@ -1,155 +0,0 @@
-const OVERFLOW_RECOVERY_TIMEOUT_MS = 120_000;
-/**
- * Short grace period for the first terminal agent_end after prompt() resolves.
- * If this window expires, we still wait the full recovery timeout.
- */
-const INITIAL_AGENT_END_WAIT_MS = 5_000;
-function createDeferredPhase() {
-    let done = false;
-    let resolveFn;
-    const promise = new Promise((resolve) => {
-        resolveFn = () => {
-            if (done)
-                return;
-            done = true;
-            resolve();
-        };
-    });
-    return {
-        promise,
-        resolve: () => resolveFn?.(),
-        isDone: () => done,
-    };
-}
-class OverflowRecoveryTracker {
-    overflowDetected = false;
-    compactionWillRetry = false;
-    autoRetryActive = false;
-    initialAgentEnd = createDeferredPhase();
-    compactionEnd;
-    retryAgentEnd;
-    overflowAutoRetryEnd;
-    timers = [];
-    handleEvent(event) {
-        switch (event.type) {
-            case "agent_end":
-                this.onAgentEnd();
-                break;
-            case "compaction_start":
-                this.onCompactionStart(event.reason);
-                break;
-            case "compaction_end":
-                this.onCompactionEnd(event.reason, event.willRetry);
-                break;
-            case "auto_retry_start":
-                this.onAutoRetryStart();
-                break;
-            case "auto_retry_end":
-                this.onAutoRetryEnd();
-                break;
-            default:
-                break;
-        }
-    }
-    async awaitCompletion(signal) {
-        const cancelPromise = new Promise((resolve) => {
-            if (signal.aborted) {
-                resolve();
-                return;
-            }
-            signal.addEventListener("abort", () => resolve(), { once: true });
-        });
-        try {
-            let initialEnd = await this.waitForPhase(this.initialAgentEnd.promise, INITIAL_AGENT_END_WAIT_MS, cancelPromise);
-            if (initialEnd === "timeout") {
-                initialEnd = await this.waitForPhase(this.initialAgentEnd.promise, OVERFLOW_RECOVERY_TIMEOUT_MS, cancelPromise);
-            }
-            if (initialEnd !== "done") {
-                return this.overflowDetected ? "failed" : "none";
-            }
-            if (!this.overflowDetected)
-                return "none";
-            if (this.compactionEnd) {
-                const compactionEnd = await this.waitForPhase(this.compactionEnd.promise, OVERFLOW_RECOVERY_TIMEOUT_MS, cancelPromise);
-                if (compactionEnd !== "done")
-                    return "failed";
-            }
-            if (!this.compactionWillRetry)
-                return "failed";
-            if (this.retryAgentEnd) {
-                const retryEnd = await this.waitForPhase(this.retryAgentEnd.promise, OVERFLOW_RECOVERY_TIMEOUT_MS, cancelPromise);
-                if (retryEnd !== "done")
-                    return "failed";
-            }
-            if (this.overflowAutoRetryEnd) {
-                const autoRetryEnd = await this.waitForPhase(this.overflowAutoRetryEnd.promise, OVERFLOW_RECOVERY_TIMEOUT_MS, cancelPromise);
-                if (autoRetryEnd !== "done")
-                    return "failed";
-            }
-            return "recovered";
-        }
-        finally {
-            for (const timer of this.timers)
-                clearTimeout(timer);
-        }
-    }
-    async waitForPhase(phasePromise, timeoutMs, cancelPromise) {
-        return Promise.race([
-            phasePromise.then(() => "done"),
-            cancelPromise.then(() => "cancelled"),
-            new Promise((resolve) => {
-                this.timers.push(setTimeout(() => resolve("timeout"), timeoutMs));
-            }),
-        ]);
-    }
-    // agent_end can be followed immediately by auto_retry_start in the same
-    // _processAgentEvent tick. Resolve on microtask so we can ignore retrying
-    // attempts and only accept terminal agent_end events.
-    onAgentEnd() {
-        queueMicrotask(() => {
-            if (this.autoRetryActive)
-                return;
-            if (!this.initialAgentEnd.isDone()) {
-                this.initialAgentEnd.resolve();
-                return;
-            }
-            this.retryAgentEnd?.resolve();
-        });
-    }
-    onCompactionStart(reason) {
-        if (reason !== "overflow")
-            return;
-        this.overflowDetected = true;
-        this.compactionEnd ??= createDeferredPhase();
-    }
-    onCompactionEnd(reason, willRetry) {
-        if (reason !== "overflow")
-            return;
-        this.compactionWillRetry = willRetry;
-        if (willRetry) {
-            this.retryAgentEnd ??= createDeferredPhase();
-        }
-        this.compactionEnd?.resolve();
-    }
-    onAutoRetryStart() {
-        this.autoRetryActive = true;
-        if (this.overflowDetected) {
-            this.overflowAutoRetryEnd ??= createDeferredPhase();
-        }
-    }
-    onAutoRetryEnd() {
-        this.autoRetryActive = false;
-        this.overflowAutoRetryEnd?.resolve();
-    }
-}
-export async function runPromptWithOverflowRecovery(session, text, signal) {
-    const tracker = new OverflowRecoveryTracker();
-    const unsubscribe = session.subscribe((event) => tracker.handleEvent(event));
-    try {
-        await session.prompt(text);
-        return await tracker.awaitCompletion(signal);
-    }
-    finally {
-        unsubscribe();
-    }
-}

package/dist/runtime/subagent-registry.d.ts

@@ -1,14 +0,0 @@
-import type { AgentConfig } from "../agent-discovery.js";
-import type { AbortableAgentSummary, ActiveAgentSummary, SubagentState } from "./subagent-state.js";
-export declare class SubagentRegistry {
-    private activeAgents;
-    create(agentConfig: AgentConfig, task: string, ownerSessionId: string): SubagentState;
-    get(id: string): SubagentState | undefined;
-    hasState(state: SubagentState): boolean;
-    delete(id: string): void;
-    countRunningForOwner(ownerSessionId: string, excludeId: string): number;
-    getAbortableAgents(): AbortableAgentSummary[];
-    getActiveSummariesForOwner(ownerSessionId: string): ActiveAgentSummary[];
-    getOwnedAbortableIds(ownerSessionId: string): string[];
-    getAllRunning(): SubagentState[];
-}

package/dist/runtime/subagent-registry.js

@@ -1,58 +0,0 @@
-import { buildAbortableAgentSummary, buildActiveAgentSummary, generateId, isAbortableStatus, } from "./subagent-state.js";
-export class SubagentRegistry {
-    activeAgents = new Map();
-    create(agentConfig, task, ownerSessionId) {
-        const id = generateId(agentConfig.name, new Set(this.activeAgents.keys()));
-        const state = {
-            id,
-            agentConfig,
-            task,
-            status: "running",
-            ownerSessionId,
-            session: null,
-            turns: 0,
-            contextTokens: 0,
-            model: undefined,
-        };
-        this.activeAgents.set(id, state);
-        return state;
-    }
-    get(id) {
-        return this.activeAgents.get(id);
-    }
-    hasState(state) {
-        return this.activeAgents.get(state.id) === state;
-    }
-    delete(id) {
-        this.activeAgents.delete(id);
-    }
-    countRunningForOwner(ownerSessionId, excludeId) {
-        let count = 0;
-        for (const state of this.activeAgents.values()) {
-            if (state.id !== excludeId &&
-                state.ownerSessionId === ownerSessionId &&
-                state.status === "running") {
-                count++;
-            }
-        }
-        return count;
-    }
-    getAbortableAgents() {
-        return Array.from(this.activeAgents.values())
-            .filter((state) => isAbortableStatus(state.status))
-            .map(buildAbortableAgentSummary);
-    }
-    getActiveSummariesForOwner(ownerSessionId) {
-        return Array.from(this.activeAgents.values())
-            .filter((state) => isAbortableStatus(state.status) && state.ownerSessionId === ownerSessionId)
-            .map(buildActiveAgentSummary);
-    }
-    getOwnedAbortableIds(ownerSessionId) {
-        return Array.from(this.activeAgents.values())
-            .filter((state) => state.ownerSessionId === ownerSessionId && isAbortableStatus(state.status))
-            .map((state) => state.id);
-    }
-    getAllRunning() {
-        return Array.from(this.activeAgents.values()).filter((state) => isAbortableStatus(state.status));
-    }
-}

package/dist/runtime/subagent-state.d.ts

@@ -1,35 +0,0 @@
-import type { AgentSession } from "@mariozechner/pi-coding-agent";
-import type { AgentConfig } from "../agent-discovery.js";
-import type { SubagentStatus } from "../subagent-messages.js";
-export interface SubagentState {
-    id: string;
-    agentConfig: AgentConfig;
-    task: string;
-    status: SubagentStatus;
-    ownerSessionId: string;
-    session: AgentSession | null;
-    turns: number;
-    contextTokens: number;
-    model: string | undefined;
-    error?: string;
-    result?: string;
-    promptAbortController?: AbortController;
-    unsubscribe?: () => void;
-}
-export interface ActiveAgentSummary {
-    id: string;
-    agentName: string;
-    status: SubagentStatus;
-    turns: number;
-    contextTokens: number;
-    model: string | undefined;
-}
-export interface AbortableAgentSummary {
-    id: string;
-    agentName: string;
-}
-export declare function generateId(name: string, existingIds: Set<string>): string;
-export declare function isAborted(state: SubagentState): boolean;
-export declare function isAbortableStatus(status: SubagentStatus): boolean;
-export declare function buildActiveAgentSummary(state: SubagentState): ActiveAgentSummary;
-export declare function buildAbortableAgentSummary(state: SubagentState): AbortableAgentSummary;