pi-onlyne 0.9.1 → 1.0.0

package/dist/onlyne.d.ts

@@ -1,70 +0,0 @@
-import { type ChildProcess } from "node:child_process";
-import { type Socket } from "node:net";
-import type { Workspace } from "./workspace.js";
-export interface OnlyneRequest {
-    id: string;
-    op: string;
-    op_id?: string;
-    channel_id?: string;
-    conversation_id?: string;
-    message_id?: string;
-    text?: string;
-    format?: "plain" | "markdown";
-    raw_text?: boolean;
-    limit?: number;
-    offset?: number;
-    priority?: number;
-    consume_timeout_ms?: number;
-    event_seq?: number;
-}
-export interface SendTarget {
-    channelId: string;
-}
-export interface SendResult extends SendTarget {
-    ok: boolean;
-    error?: string;
-}
-export declare function request(socketPath: string, req: OnlyneRequest): Promise<any>;
-export interface SwarmSubscription extends Socket {
-    ack: Promise<any>;
-}
-export declare function subscribe(socketPath: string, onLine: (line: any) => void, onDisconnect?: () => void, opts?: {
-    priority?: number;
-    consumeTimeoutMs?: number;
-}): SwarmSubscription;
-export declare function waitForSocket(socketPath: string, timeoutMs?: number): Promise<void>;
-export declare function connectDaemon(ws: Workspace, startIfMissing?: boolean): Promise<{
-    owner: "external" | "extension";
-    process?: ChildProcess;
-}>;
-export declare function shutdownDaemon(ws: Workspace, child?: ChildProcess): Promise<void>;
-export declare function stopProcess(child?: ChildProcess): void;
-export declare function swarmReady(socketPath: string, workspace: string, terminalHandle: string, snapshot?: unknown, opId?: string): Promise<any>;
-export declare function swarmRecycled(socketPath: string, taskId: string, terminalHandle: string, reason: string, opId?: string): Promise<any>;
-/** R4 hop activity: turn started. Fire-and-forget; the scheduler treats a
- * missing task row as race residue and drops it silently. `body` comes from
- * swarm.ts hopActivityBody (the shared, unit-tested decision). */
-export declare function swarmBusy(socketPath: string, body: {
-    workspace: string;
-    terminal_handle: string;
-    task_id: string;
-}, opId?: string): Promise<any>;
-/** R4 hop activity: turn ended with no out. `body.pending_exit` mirrors whether
- * the hop still awaits swarm_complete — the scheduler only records it. */
-export declare function swarmIdle(socketPath: string, body: {
-    workspace: string;
-    terminal_handle: string;
-    task_id: string;
-    pending_exit?: boolean;
-}, opId?: string): Promise<any>;
-export declare function consumeEvent(socket: Socket, eventSeq: number): Promise<void>;
-export declare function loopback(socketPath: string, text: string, rawText?: boolean, opId?: string): Promise<any>;
-/** Versioned lifecycle evidence for the scheduler reducer. The frame travels as
- * a raw-text loopback inbound: the daemon stores `text` verbatim and publishes
- * it on the same event stream the report consumer reads. `raw_text` keeps the
- * frame out of Markdown processing, and `opId` makes a socket-level retry
- * return the stored receipt. */
-export declare function sendSwarmReport(socketPath: string, frame: string, opId?: string): Promise<any>;
-export declare function markConsumed(socketPath: string, messageId: string): Promise<any>;
-export declare function sendWithRetry(socketPath: string, target: SendTarget, text: string, attempts: number, rawText?: boolean, opId?: string): Promise<SendResult>;
-export declare function broadcast(socketPath: string, targets: SendTarget[], text: string, attempts: number, concurrency: number, rawText?: boolean): Promise<SendResult[]>;

package/dist/onlyne.js

@@ -1,194 +0,0 @@
-import { spawn } from "node:child_process";
-import { createConnection } from "node:net";
-import { SWARM_REPORT_PREFIX } from "./swarm.js";
-export function request(socketPath, req) {
-    return new Promise((resolve, reject) => {
-        const socket = createConnection(socketPath);
-        let data = "";
-        socket.setEncoding("utf8");
-        socket.on("error", reject);
-        socket.on("connect", () => socket.write(`${JSON.stringify(req)}\n`));
-        socket.on("data", (chunk) => { data += chunk; const idx = data.indexOf("\n"); if (idx >= 0) {
-            socket.end();
-            try {
-                const response = JSON.parse(data.slice(0, idx));
-                if (response && response.ok === false)
-                    reject(new Error(response.error?.message ?? JSON.stringify(response.error ?? response)));
-                else
-                    resolve(response);
-            }
-            catch (e) {
-                reject(e);
-            }
-        } });
-    });
-}
-export function subscribe(socketPath, onLine, onDisconnect, opts) {
-    const socket = createConnection(socketPath);
-    let buf = "";
-    let closed = false;
-    socket.setEncoding("utf8");
-    let resolveAck;
-    let rejectAck;
-    socket.ack = new Promise((resolve, reject) => { resolveAck = resolve; rejectAck = reject; });
-    const disconnect = () => { if (closed)
-        return; closed = true; rejectAck(new Error("onlyne subscription disconnected")); onDisconnect?.(); };
-    socket.on("error", disconnect);
-    socket.on("close", disconnect);
-    socket.on("connect", () => { if (!socket.destroyed)
-        socket.write(`${JSON.stringify({ id: "sub", op: "subscribe_events", ...(opts?.priority !== undefined ? { priority: opts.priority } : {}), ...(opts?.consumeTimeoutMs !== undefined ? { consume_timeout_ms: opts.consumeTimeoutMs } : {}) })}\n`, () => { }); });
-    socket.on("data", (chunk) => { buf += chunk; for (;;) {
-        const idx = buf.indexOf("\n");
-        if (idx < 0)
-            break;
-        const raw = buf.slice(0, idx);
-        buf = buf.slice(idx + 1);
-        if (!raw.trim())
-            continue;
-        try {
-            const line = JSON.parse(raw);
-            if (line.id === "sub") {
-                if (line.ok)
-                    resolveAck(line);
-                else
-                    rejectAck(new Error(line.error?.message ?? "subscribe_events rejected"));
-            }
-            onLine(line);
-        }
-        catch { /* malformed event lines stay outside the lifecycle protocol */ }
-    } });
-    return socket;
-}
-export async function waitForSocket(socketPath, timeoutMs = 5000) {
-    const deadline = Date.now() + timeoutMs;
-    let last;
-    while (Date.now() < deadline) {
-        try {
-            await request(socketPath, { id: "ping", op: "ping" });
-            return;
-        }
-        catch (e) {
-            last = e;
-        }
-        await new Promise((r) => setTimeout(r, 100));
-    }
-    throw last instanceof Error ? last : new Error("onlyne socket not ready");
-}
-function spawnManagedDaemon(ws) {
-    const bin = process.env.ONLYNE_BIN || "onlyne";
-    const script = `
-parent="$1"; shift
-"$@" &
-child=$!
-trap 'kill "$child" 2>/dev/null; wait "$child" 2>/dev/null' INT TERM HUP EXIT
-while kill -0 "$parent" 2>/dev/null; do
-  kill -0 "$child" 2>/dev/null || { wait "$child"; exit $?; }
-  sleep 1
-done
-kill "$child" 2>/dev/null
-wait "$child" 2>/dev/null
-`;
-    return spawn("sh", ["-c", script, "onlyne-supervisor", String(process.pid), bin, "--workspace", ws.root, "run"], { stdio: "ignore" });
-}
-export async function connectDaemon(ws, startIfMissing = true) {
-    try {
-        await request(ws.socketPath, { id: "ping", op: "ping" });
-        return { owner: "external" };
-    }
-    catch (e) {
-        if (!startIfMissing)
-            throw new Error(`onlyne daemon is not running for ${ws.root}; start it with /onlyne daemon start`, { cause: e });
-        const child = spawnManagedDaemon(ws);
-        try {
-            await waitForSocket(ws.socketPath);
-            // 自己 spawn 的 daemon 已退出:竞态中输给了其他启动方,socket 归对方所有,降级为 external(只订阅、不 shutdown)。
-            if (child.exitCode !== null || child.signalCode !== null)
-                return { owner: "external" };
-            return { owner: "extension", process: child };
-        }
-        catch (err) {
-            stopProcess(child);
-            throw err;
-        }
-    }
-}
-export async function shutdownDaemon(ws, child) {
-    try {
-        await request(ws.socketPath, { id: `shutdown-${Date.now()}`, op: "shutdown" });
-    }
-    catch { /* may already be down */ }
-    stopProcess(child);
-}
-export function stopProcess(child) { if (!child || child.killed)
-    return; try {
-    child.kill("SIGTERM");
-}
-catch { /* ignore */ } }
-export async function swarmReady(socketPath, workspace, terminalHandle, snapshot, opId) {
-    return request(socketPath, { id: `swarm-ready-${Date.now()}`, op: "swarm_ready", op_id: opId, text: JSON.stringify({ protocol: 2, workspace, terminal_handle: terminalHandle, snapshot }) });
-}
-export async function swarmRecycled(socketPath, taskId, terminalHandle, reason, opId) {
-    return request(socketPath, { id: `swarm-recycled-${Date.now()}`, op: "swarm_recycled", op_id: opId, text: JSON.stringify({ task_id: taskId, terminal_handle: terminalHandle, reason }) });
-}
-/** R4 hop activity: turn started. Fire-and-forget; the scheduler treats a
- * missing task row as race residue and drops it silently. `body` comes from
- * swarm.ts hopActivityBody (the shared, unit-tested decision). */
-export async function swarmBusy(socketPath, body, opId) {
-    return request(socketPath, { id: `swarm-busy-${Date.now()}`, op: "swarm_busy", op_id: opId, text: JSON.stringify(body) });
-}
-/** R4 hop activity: turn ended with no out. `body.pending_exit` mirrors whether
- * the hop still awaits swarm_complete — the scheduler only records it. */
-export async function swarmIdle(socketPath, body, opId) {
-    return request(socketPath, { id: `swarm-idle-${Date.now()}`, op: "swarm_idle", op_id: opId, text: JSON.stringify(body) });
-}
-export async function consumeEvent(socket, eventSeq) {
-    return new Promise((resolve) => { try {
-        socket.write(`${JSON.stringify({ id: `consume-${Date.now()}`, op: "consume", event_seq: eventSeq })}\n`, () => resolve());
-    }
-    catch {
-        resolve();
-    } });
-}
-export async function loopback(socketPath, text, rawText = true, opId) {
-    return request(socketPath, { id: `loopback-${Date.now()}`, op: "loopback", op_id: opId, text, raw_text: rawText });
-}
-/** Versioned lifecycle evidence for the scheduler reducer. The frame travels as
- * a raw-text loopback inbound: the daemon stores `text` verbatim and publishes
- * it on the same event stream the report consumer reads. `raw_text` keeps the
- * frame out of Markdown processing, and `opId` makes a socket-level retry
- * return the stored receipt. */
-export async function sendSwarmReport(socketPath, frame, opId) {
-    if (!frame.startsWith(SWARM_REPORT_PREFIX))
-        throw new Error("swarm report frame needs the ---swarm-report header");
-    return loopback(socketPath, frame, true, opId);
-}
-export async function markConsumed(socketPath, messageId) {
-    return request(socketPath, { id: `consume-${Date.now()}`, op: "mark_io_consumed", message_id: messageId });
-}
-export async function sendWithRetry(socketPath, target, text, attempts, rawText = false, opId) {
-    let error = "unknown error";
-    for (let i = 0; i < Math.max(1, attempts); i++) {
-        try {
-            const res = await request(socketPath, { id: `send-${Date.now()}-${i}`, op: "send_message", op_id: opId, channel_id: target.channelId, text, raw_text: rawText });
-            if (res.ok)
-                return { ...target, ok: true };
-            error = res.error?.message ?? JSON.stringify(res.error ?? res);
-        }
-        catch (e) {
-            error = e instanceof Error ? e.message : String(e);
-        }
-    }
-    return { ...target, ok: false, error };
-}
-export async function broadcast(socketPath, targets, text, attempts, concurrency, rawText = false) {
-    const out = [];
-    let next = 0;
-    async function worker() { for (;;) {
-        const i = next++;
-        if (i >= targets.length)
-            return;
-        out[i] = await sendWithRetry(socketPath, targets[i], text, attempts, rawText);
-    } }
-    await Promise.all(Array.from({ length: Math.max(1, Math.min(concurrency, targets.length)) }, worker));
-    return out;
-}

package/dist/session.d.ts

@@ -1,82 +0,0 @@
-export declare const SWARM_STATE_ENTRY = "pi-onlyne:swarm-state";
-export declare const SWARM_PROTOCOL = 2;
-export type AgentState = "booting" | "ready" | "running" | "idle" | "gone";
-export type DeliveryState = "none" | "pending" | "retrying" | "accepted" | "exhausted";
-export type ResourceState = "detached" | "attached" | "closing" | "closed";
-export type Lifecycle = "created" | "working" | "idle" | "exited";
-export type RecoveryState = "idle_waiting" | "idle_fault" | "draining";
-export interface SwarmSnapshot {
-    protocol: 2;
-    task_id: string;
-    generation: number;
-    seq: number;
-    agent: AgentState;
-    delivery: DeliveryState;
-    resource: ResourceState;
-    lifecycle: Lifecycle;
-    recovery: RecoveryState;
-    pending_intents: string[];
-    at: string;
-}
-export interface SwarmIntent {
-    op_id: string;
-    kind: string;
-    payload: unknown;
-    attempts: number;
-    status: "pending" | "retrying" | "accepted" | "exhausted";
-    receipt?: unknown;
-    last_error?: string;
-}
-export interface SwarmStateData {
-    protocol: 2;
-    task_id: string;
-    generation: number;
-    seq: number;
-    snapshot: SwarmSnapshot;
-    intents: SwarmIntent[];
-}
-export interface SessionEntry {
-    type?: string;
-    customType?: string;
-    data?: unknown;
-}
-export interface StateContext {
-    appendEntry: (customType: string, data?: unknown) => void;
-    sessionManager?: {
-        getEntries(): readonly SessionEntry[];
-    };
-}
-export declare function restoreSwarmState(ctx: StateContext, taskId: string): SwarmStateData | undefined;
-export declare class SwarmSessionState {
-    readonly taskId: string;
-    private append;
-    private _generation;
-    private _seq;
-    private _snapshot;
-    private _intents;
-    private timers;
-    private heartbeatTimer?;
-    constructor(ctx: StateContext, taskId: string, restored?: SwarmStateData);
-    startSession(): SwarmSnapshot;
-    get generation(): number;
-    get seq(): number;
-    get intents(): SwarmIntent[];
-    snapshot(): SwarmSnapshot;
-    private makeSnapshot;
-    private persist;
-    transition(patch: Partial<SwarmSnapshot>, kind?: string): SwarmSnapshot;
-    heartbeat(): SwarmSnapshot;
-    recordIntent(kind: string, payload: unknown, opId: string): SwarmIntent;
-    receipt(opId: string, receipt: unknown): boolean;
-    retry(opId: string, send: (intent: SwarmIntent) => Promise<unknown>, maxAttempts?: number): Promise<SwarmIntent>;
-    startHeartbeat(intervalMs?: number, run?: () => void): void;
-    stopHeartbeat(): void;
-    shutdown(): void;
-}
-export declare function compareSwarmVersion(a: {
-    generation: number;
-    seq: number;
-}, b: {
-    generation: number;
-    seq: number;
-}): "stale" | "duplicate" | "new";

package/dist/session.js

@@ -1,91 +0,0 @@
-export const SWARM_STATE_ENTRY = "pi-onlyne:swarm-state";
-export const SWARM_PROTOCOL = 2;
-function isObject(v) { return !!v && typeof v === "object" && !Array.isArray(v); }
-function validState(v) {
-    if (!isObject(v) || v.protocol !== 2 || typeof v.task_id !== "string" || typeof v.generation !== "number" || typeof v.seq !== "number" || !isObject(v.snapshot) || !Array.isArray(v.intents))
-        return false;
-    return v.snapshot.protocol === 2 && v.snapshot.task_id === v.task_id && v.snapshot.generation === v.generation && typeof v.snapshot.seq === "number";
-}
-export function restoreSwarmState(ctx, taskId) {
-    let found;
-    for (const entry of ctx.sessionManager?.getEntries() ?? []) {
-        if (entry.type !== "custom" || entry.customType !== SWARM_STATE_ENTRY)
-            continue;
-        if (!validState(entry.data))
-            throw new Error("malformed swarm v2 state entry");
-        if (entry.data.task_id !== taskId)
-            continue;
-        if (!found || entry.data.seq > found.seq || entry.data.generation > found.generation)
-            found = entry.data;
-    }
-    return found;
-}
-export class SwarmSessionState {
-    taskId;
-    append;
-    _generation = 0;
-    _seq = 0;
-    _snapshot;
-    _intents = new Map();
-    timers = new Set();
-    heartbeatTimer;
-    constructor(ctx, taskId, restored) {
-        this.taskId = taskId;
-        this.append = ctx.appendEntry;
-        if (restored) {
-            this._generation = restored.generation;
-            this._seq = restored.seq;
-            this._snapshot = structuredClone(restored.snapshot);
-            for (const i of restored.intents)
-                this._intents.set(i.op_id, structuredClone(i));
-        }
-        else
-            this._snapshot = this.makeSnapshot();
-    }
-    startSession() { this._generation++; return this.persist("session_start", { generation: this._generation }); }
-    get generation() { return this._generation; }
-    get seq() { return this._seq; }
-    get intents() { return [...this._intents.values()].map((x) => structuredClone(x)); }
-    snapshot() { return structuredClone(this._snapshot); }
-    makeSnapshot() { return { protocol: 2, task_id: this.taskId, generation: this._generation, seq: this._seq, agent: "booting", delivery: "none", resource: "detached", lifecycle: "created", recovery: "idle_waiting", pending_intents: [...this._intents.keys()], at: new Date().toISOString() }; }
-    persist(kind, patch) { this._seq++; this._snapshot = { ...this._snapshot, ...patch, protocol: 2, task_id: this.taskId, generation: this._generation, seq: this._seq, pending_intents: [...this._intents.values()].filter((i) => i.status !== "accepted").map((i) => i.op_id), at: new Date().toISOString() }; this.append(SWARM_STATE_ENTRY, { protocol: 2, task_id: this.taskId, generation: this._generation, seq: this._seq, snapshot: this._snapshot, intents: this.intents, kind }); return this.snapshot(); }
-    transition(patch, kind = "snapshot") { return this.persist(kind, patch); }
-    heartbeat() { return this.persist("swarm_heartbeat"); }
-    recordIntent(kind, payload, opId) { if (this._intents.has(opId))
-        return structuredClone(this._intents.get(opId)); const intent = { op_id: opId, kind, payload, attempts: 0, status: "pending" }; this._intents.set(opId, intent); this.persist(kind, { delivery: "pending" }); return structuredClone(intent); }
-    receipt(opId, receipt) { const i = this._intents.get(opId); if (!i)
-        return false; i.status = "accepted"; i.receipt = receipt; this.persist("intent_receipt", { delivery: "accepted", lifecycle: i.kind === "swarm_complete" ? "exited" : this._snapshot.lifecycle }); return true; }
-    async retry(opId, send, maxAttempts = 3) { const i = this._intents.get(opId); if (!i)
-        throw new Error(`unknown intent ${opId}`); for (let n = i.attempts; n < maxAttempts && i.status !== "accepted"; n++) {
-        i.attempts++;
-        i.status = "retrying";
-        this.persist("intent_attempt", { delivery: "retrying" });
-        try {
-            const receipt = await send(structuredClone(i));
-            this.receipt(opId, receipt);
-        }
-        catch (e) {
-            i.last_error = e instanceof Error ? e.message : String(e);
-            if (i.attempts >= maxAttempts) {
-                i.status = "exhausted";
-                this.persist("intent_exhausted", { delivery: "exhausted", recovery: "idle_fault" });
-            }
-            else {
-                const delay = 1000 * 2 ** (i.attempts - 1);
-                await new Promise((resolve) => { const t = setTimeout(() => { this.timers.delete(t); resolve(); }, delay); this.timers.add(t); });
-            }
-        }
-    } return structuredClone(i); }
-    startHeartbeat(intervalMs = 10_000, run = () => this.heartbeat()) {
-        this.stopHeartbeat();
-        this.heartbeatTimer = setInterval(() => run(), Math.max(1, intervalMs));
-        this.heartbeatTimer.unref?.();
-    }
-    stopHeartbeat() { if (this.heartbeatTimer)
-        clearInterval(this.heartbeatTimer); this.heartbeatTimer = undefined; }
-    shutdown() { this.stopHeartbeat(); for (const t of this.timers)
-        clearTimeout(t); this.timers.clear(); }
-}
-export function compareSwarmVersion(a, b) { if (a.generation < b.generation || (a.generation === b.generation && a.seq < b.seq))
-    return "stale"; if (a.generation === b.generation && a.seq === b.seq)
-    return "duplicate"; return "new"; }

package/dist/swarm-prompt.d.ts

@@ -1,12 +0,0 @@
-export interface SwarmPromptConfig {
-    enabled: boolean;
-    template?: string;
-    fallback?: string;
-}
-export declare function readSwarmPromptConfig(workspaceRoot: string): SwarmPromptConfig;
-export declare function resolveSwarmPrompt(workspaceRoot: string, header: {
-    task_id: string;
-    from: string;
-    transfer_send_to: string;
-    attempt: number;
-}, payload: string): string | null;

package/dist/swarm-prompt.js

@@ -1,45 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-const DEFAULT_PROMPT = `Onlyne swarm task {task_id} (from {from}):
-
-{payload}
-
-This session carries this one task only. Restore context from files, work, spawn continuations with swarm_send when another unit must continue, then exit with swarm_complete. Downstream results travel through files and the ledger; nothing waits here.`;
-export function readSwarmPromptConfig(workspaceRoot) {
-    const cfgPath = join(workspaceRoot, ".pi", "onlyne.json");
-    if (!existsSync(cfgPath)) {
-        return { enabled: true, fallback: DEFAULT_PROMPT };
-    }
-    try {
-        const parsed = JSON.parse(readFileSync(cfgPath, "utf8"));
-        const sw = parsed?.swarm_prompt;
-        if (sw === false || (sw && sw.enabled === false))
-            return { enabled: false, fallback: DEFAULT_PROMPT };
-        return {
-            enabled: sw?.enabled !== false,
-            template: sw?.template,
-            fallback: sw?.fallback ?? DEFAULT_PROMPT,
-        };
-    }
-    catch {
-        return { enabled: true, fallback: DEFAULT_PROMPT };
-    }
-}
-export function resolveSwarmPrompt(workspaceRoot, header, payload) {
-    const cfg = readSwarmPromptConfig(workspaceRoot);
-    if (!cfg.enabled)
-        return null;
-    let tmpl = cfg.fallback ?? DEFAULT_PROMPT;
-    if (cfg.template) {
-        const abs = join(workspaceRoot, cfg.template);
-        if (existsSync(abs)) {
-            tmpl = readFileSync(abs, "utf8");
-        }
-    }
-    return tmpl
-        .replace(/{task_id}/g, header.task_id)
-        .replace(/{from}/g, header.from)
-        .replace(/{transfer_send_to}/g, header.transfer_send_to)
-        .replace(/{attempt}/g, String(header.attempt))
-        .replace(/{payload}/g, payload);
-}

package/dist/swarm-slot.d.ts

@@ -1,43 +0,0 @@
-export type SwarmHandleResult = "claimed" | "yielded" | "not-swarm";
-export interface SwarmPi {
-    sendUserMessage: (content: string, opts: {
-        deliverAs: "followUp";
-    }) => void;
-}
-/**
- * Single atomic task slot for swarm mode, extracted for unit testing.
- * index.ts delegates its state transitions here; the only coupling is the
- * followUp injection callback.
- */
-export declare class SwarmSlot {
-    private taskId?;
-    private from;
-    private transfer;
-    private attempt;
-    private sentChildIds;
-    handle(pi: SwarmPi, text: string, preferredTaskId?: string, workspaceRoot?: string): SwarmHandleResult;
-    task(): {
-        taskId?: string;
-        from: string;
-        transferSendTo: string;
-        attempt: number;
-        sentChildIds: string[];
-    };
-    noteSpawned(childId: string): void;
-    taskIdOf(): string | undefined;
-    clear(): void;
-}
-/** Test seam: fresh slot without touching module-global pi-onlyne state. */
-export declare function __swarmSlotForTest(): {
-    handle: (pi: SwarmPi, text: string, preferredTaskId?: string, workspaceRoot?: string) => SwarmHandleResult;
-    task: () => {
-        taskId?: string;
-        from: string;
-        transferSendTo: string;
-        attempt: number;
-        sentChildIds: string[];
-    };
-    taskId: () => string | undefined;
-    noteSpawned: (childId: string) => void;
-    clear: () => void;
-};

package/dist/swarm-slot.js

@@ -1,76 +0,0 @@
-import { parseSwarmHeader } from "./swarm.js";
-import { resolveSwarmPrompt } from "./swarm-prompt.js";
-/**
- * Single atomic task slot for swarm mode, extracted for unit testing.
- * index.ts delegates its state transitions here; the only coupling is the
- * followUp injection callback.
- */
-export class SwarmSlot {
-    taskId;
-    from = ".";
-    transfer = "";
-    attempt = 1;
-    sentChildIds = [];
-    handle(pi, text, preferredTaskId, workspaceRoot) {
-        const parsed = parseSwarmHeader(text);
-        if (!parsed)
-            return "not-swarm";
-        const { header, delivery, payload } = parsed;
-        // A scheduler-created terminal carries ONLYNE_SWARM_TASK. Its task id
-        // is a hard delivery binding: history replay or a stale live event for
-        // another task must never claim this session. Without this guard a
-        // freshly spawned pane can run an expired workspace-local payload
-        // before its assigned FIFO write reaches history.
-        if (preferredTaskId && header.task_id !== preferredTaskId)
-            return "not-swarm";
-        // Only the scheduler's second delivery is claimable. A worker's raw
-        // swarm_send relay and every out wire omit this structured field, so
-        // history catchup cannot claim either one as an executable task.
-        if (delivery !== "scheduler")
-            return "not-swarm";
-        if (!this.taskId) {
-            this.taskId = header.task_id;
-            this.from = header.from;
-            this.transfer = header.transfer_send_to;
-            this.attempt = header.attempt;
-            this.sentChildIds = [];
-            // A scheduler delivery is a real user task. `sendUserMessage` always
-            // triggers a turn, including during a fresh Pi session; custom
-            // `sendMessage` follow-ups can remain queued until a later event while
-            // the session_start hook is still settling.
-            pi.sendUserMessage(resolveSwarmPrompt(workspaceRoot ?? process.cwd(), header, payload) ?? payload, { deliverAs: "followUp" });
-            return "claimed";
-        }
-        // A claimed session normally receives no further delivery. The
-        // preferred-id guard above already protected an env-bound pane, so this
-        // branch only applies to manual ready-pool sessions with no env task.
-        return "not-swarm";
-    }
-    task() {
-        return { taskId: this.taskId, from: this.from, transferSendTo: this.transfer, attempt: this.attempt, sentChildIds: [...this.sentChildIds] };
-    }
-    noteSpawned(childId) {
-        this.sentChildIds.push(childId);
-    }
-    taskIdOf() {
-        return this.taskId;
-    }
-    clear() {
-        this.taskId = undefined;
-        this.from = ".";
-        this.transfer = "";
-        this.attempt = 1;
-        this.sentChildIds = [];
-    }
-}
-/** Test seam: fresh slot without touching module-global pi-onlyne state. */
-export function __swarmSlotForTest() {
-    const slot = new SwarmSlot();
-    return {
-        handle: (pi, text, preferredTaskId, workspaceRoot) => slot.handle(pi, text, preferredTaskId, workspaceRoot),
-        task: () => slot.task(),
-        taskId: () => slot.taskIdOf(),
-        noteSpawned: (childId) => slot.noteSpawned(childId),
-        clear: () => slot.clear(),
-    };
-}