pi-onlyne 0.9.1 → 1.0.0

package/dist/index.js

@@ -1,780 +0,0 @@
-import { defineTool } from "@earendil-works/pi-coding-agent";
-import { randomUUID } from "node:crypto";
-import { existsSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { Type } from "typebox";
-import { broadcast, connectDaemon, consumeEvent, loopback, markConsumed, sendWithRetry, sendSwarmReport, shutdownDaemon, stopProcess, subscribe, swarmBusy, swarmIdle, swarmReady, swarmRecycled } from "./onlyne.js";
-import { inboundModeFor, loadConfig, saveConfig } from "./config.js";
-import { findWorkspace } from "./workspace.js";
-import { envTaskId, hopActivityBody, isSwarmReportFrame, isSwarmTaskId, parseSwarmCtl, parseSwarmHeader, readSwarmEnabled, readSwarmModel, renderSwarmReport, selectHistoryDelivery, terminalHandle, treePathForWorkspace } from "./swarm.js";
-import { SwarmSlot } from "./swarm-slot.js";
-import { SwarmSessionState, restoreSwarmState } from "./session.js";
-const swarmSlot = new SwarmSlot();
-const state = { cwd: process.cwd(), workspace: null, watching: false, owner: "stopped", swarm: false };
-let cachedCtx = undefined;
-const textResult = (text, details) => ({ content: [{ type: "text", text }], details });
-const currentConfig = () => loadConfig(state.cwd);
-function refreshSwarmFlag() { state.swarm = state.workspace ? readSwarmEnabled(state.workspace.onlyneDir) : false; }
-function inboundText(data) { const msg = data?.data?.data ?? data?.data ?? data; const channelId = msg.channel_id ?? msg.channelId; const conversationId = msg.conversation_id ?? msg.conversationId; const messageId = msg.message_id ?? msg.messageId; const text = msg.text ?? msg.content ?? msg.body; return channelId && conversationId && typeof text === "string" ? { channelId, conversationId, messageId, text } : null; }
-function consumeIfNotified(inbound) { if (state.workspace && inbound.messageId)
-    void markConsumed(state.workspace.socketPath, inbound.messageId).catch(() => { }); }
-function clearReminder() { if (state.reminderTimer)
-    clearTimeout(state.reminderTimer); state.reminderTimer = undefined; }
-function swarmOpId(kind, suffix) {
-    const taskId = state.swarmSession?.taskId ?? state.swarmTask?.taskId ?? state.swarmTaskKey ?? `session:${terminalHandle() || state.workspace?.root || "unknown"}`;
-    const generation = state.swarmSession?.generation ?? 0;
-    return `swarm:${taskId}:g${generation}:${kind}${suffix ? `:${suffix}` : ""}`;
-}
-async function awaitSubscriptionAck(socket, timeoutMs = 5_000) {
-    let timer;
-    try {
-        return await Promise.race([
-            socket.ack,
-            new Promise((_, reject) => { timer = setTimeout(() => reject(new Error("swarm subscribe_events ack timeout")), timeoutMs); }),
-        ]);
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
-function awaitIntent(intent) { void Promise.resolve(intent).catch(() => { }); }
-/** Task identity the scheduler owns, for lifecycle evidence. The claimed hop
- * wins; before a claim an env-assigned task is already a scheduler row. A
- * synthetic session key returns null and the report stays home: a frame the
- * ledger cannot attribute raises an unknown-session alert on that side. */
-function swarmReportTaskId() {
-    for (const candidate of [state.swarmTask?.taskId, state.swarmSession?.taskId]) {
-        if (candidate && isSwarmTaskId(candidate))
-            return candidate.trim();
-    }
-    return null;
-}
-/** A report that failed to build or reach the daemon is recorded locally. The
- * entry names the kind and the error, so a gap in the scheduler's view of this
- * session is traceable to a frame this side can show. */
-function reportFault(kind, e) {
-    const message = e instanceof Error ? e.message : String(e);
-    try {
-        state.swarmSession?.transition({}, `swarm_report_fault:${kind}:${message}`);
-    }
-    catch { /* ledger unavailable */ }
-}
-/** Send the frame for an already-persisted watermark. One attempt per point:
- * the op_id names (task, seq), and the next beat carries a fresh watermark, so
- * a dropped frame costs one step of liveness evidence. */
-async function sendSwarmReportFrame(kind, seq) {
-    const session = state.swarmSession;
-    const ws = state.workspace;
-    const taskId = swarmReportTaskId();
-    if (!session || !ws || !taskId)
-        return false;
-    let frame;
-    try {
-        frame = renderSwarmReport(kind, taskId, session.generation, seq);
-    }
-    catch (e) {
-        reportFault(kind, e);
-        return false;
-    }
-    try {
-        await sendSwarmReport(ws.socketPath, frame, swarmOpId(`report_${kind}`, `${taskId}:${seq}`));
-        return true;
-    }
-    catch (e) {
-        reportFault(kind, e);
-        return false;
-    }
-}
-/** Advance the durable watermark and carry it to the daemon. Persisting under
- * the report's own kind names the lifecycle point in the local ledger, and
- * persisting before sending gives every point its own strictly increasing seq
- * within this generation — the ordering the reducer's watermark compares
- * against. */
-async function emitSwarmReport(kind) {
-    const session = state.swarmSession;
-    if (!session)
-        return false;
-    try {
-        return await sendSwarmReportFrame(kind, session.transition({}, `swarm_report_${kind}`).seq);
-    }
-    catch (e) {
-        reportFault(kind, e);
-        return false;
-    }
-}
-function swarmHeartbeat() {
-    const session = state.swarmSession;
-    if (!session)
-        return;
-    let seq;
-    try {
-        seq = session.heartbeat().seq;
-    }
-    catch (e) {
-        session.transition({ recovery: "idle_fault" }, `swarm_heartbeat_fault:${e instanceof Error ? e.message : String(e)}`);
-        session.stopHeartbeat();
-        return;
-    }
-    awaitIntent(sendSwarmReportFrame("heartbeat", seq));
-}
-function swarmSessionTransition(patch, kind) { state.swarmSession?.transition(patch, kind); }
-async function sendSwarmIntent(kind, payload, send, maxAttempts = 3, opId = swarmOpId(kind)) {
-    const session = state.swarmSession;
-    if (!session)
-        return send(opId);
-    session.recordIntent(kind, payload, opId);
-    const intent = await session.retry(opId, async () => {
-        const receipt = await send(opId);
-        if (receipt && typeof receipt === "object" && receipt.ok === false)
-            throw new Error(JSON.stringify(receipt.error ?? receipt));
-        return receipt;
-    }, maxAttempts);
-    if (intent.status !== "accepted") {
-        session.transition({ agent: "gone", resource: "closed", recovery: "idle_fault" }, `${kind}_fault`);
-        throw new Error(`${kind} intent exhausted${intent.last_error ? `: ${intent.last_error}` : ""}`);
-    }
-    return intent.receipt;
-}
-function needsReply(inbound = state.currentInbound) { return !!inbound && !inbound.replied && !inbound.noReply && !!state.workspace; }
-function scheduleReminder(pi, delayMs = 30_000) {
-    clearReminder();
-    const inbound = state.currentInbound;
-    if (!inbound || !needsReply(inbound))
-        return;
-    state.reminderTimer = setTimeout(() => {
-        state.reminderTimer = undefined;
-        if (!needsReply(inbound) || state.currentInbound !== inbound)
-            return;
-        const cfg = currentConfig();
-        if (cfg.outbound.defaultReplyMode === "explicit-only")
-            return;
-        if (cfg.outbound.defaultReplyMode === "guarded-explicit" && inbound.reminders < cfg.outbound.guardedExplicit.reminders) {
-            if (inbound.reminders === 0)
-                inbound.fallbackText = state.lastValidOutput;
-            inbound.reminders++;
-            pi.sendUserMessage(`Onlyne reminder ${inbound.reminders}/${cfg.outbound.guardedExplicit.reminders}: reply to ${inbound.channelId}/${inbound.conversationId} with onlyne_reply, or call onlyne_mark_no_reply.`, { deliverAs: "followUp" });
-            return;
-        }
-        void reply(inbound.fallbackText || state.lastValidOutput || cfg.outbound.guardedExplicit.noOutputFallbackText).catch(() => { });
-    }, delayMs);
-}
-function scheduleReconnect(pi) {
-    if (state.reconnectTimer || !state.watching || !state.workspace)
-        return;
-    state.reconnectTimer = setTimeout(async () => {
-        state.reconnectTimer = undefined;
-        if (!state.watching)
-            return;
-        try {
-            await startWatch(pi, state.swarmContext);
-        }
-        catch {
-            scheduleReconnect(pi);
-        }
-    }, 1000);
-}
-/** Whether a history task already has an out (done) in this workspace. */
-async function historyTaskDone(taskId) {
-    try {
-        const { request } = await import("./onlyne.js");
-        if (!state.workspace)
-            return false;
-        const res = await request(state.workspace.socketPath, { id: "hist", op: "fetch_channel_history", channel_id: "loopback", limit: 30 });
-        const items = res?.data ?? res ?? [];
-        if (!Array.isArray(items))
-            return false;
-        const outs = new Set();
-        for (const m of items) {
-            const text = m?.text ?? "";
-            if (typeof text !== "string" || !text.startsWith("---swarm"))
-                continue;
-            if (text.startsWith("---swarm-ctl"))
-                continue;
-            if (m?.direction === "outbound") {
-                const p = parseSwarmHeader(text);
-                if (p)
-                    outs.add(p.header.task_id);
-            }
-        }
-        if (outs.has(taskId))
-            return true;
-        // Stale-claim guard: an inbound older than the newest outbound batch
-        // belongs to a previous hop generation. Only the scheduler-assigned
-        // env task bypasses this check.
-        return false;
-    }
-    catch {
-        return false;
-    }
-}
-/** Replay the newest unclaimed swarm task from loopback history. Idempotent.
- * Prefers the scheduler-assigned env task (ONLYNE_SWARM_TASK); never claims
- * an already-done task unless it is the env task (env wins, scheduler owns
- * the truth about what this terminal must run). */
-async function catchUpSwarmHistory(pi, ctx) {
-    if (swarmSlot.task().taskId)
-        return;
-    const { request } = await import("./onlyne.js");
-    if (!state.workspace)
-        return;
-    const env = envTaskId();
-    const res = await request(state.workspace.socketPath, { id: "hist", op: "fetch_channel_history", channel_id: "loopback", limit: 30 });
-    const items = res?.data ?? res ?? [];
-    if (!Array.isArray(items))
-        return;
-    const inbounds = [];
-    const outs = new Set();
-    for (const m of items) {
-        const text = m?.text ?? m?.content ?? "";
-        if (typeof text !== "string" || !text.startsWith("---swarm"))
-            continue;
-        if (text.startsWith("---swarm-ctl"))
-            continue;
-        // Own lifecycle evidence shares this history. A report frame carries no
-        // task header, so it must pass before the malformed-header check.
-        if (isSwarmReportFrame(text))
-            continue;
-        const p = parseSwarmHeader(text);
-        if (!p) {
-            if (text.startsWith("---swarm"))
-                state.swarmSession?.transition({ agent: "gone", resource: "closed", recovery: "idle_fault" }, "swarm_protocol_fault");
-            continue;
-        }
-        if (m?.direction === "outbound")
-            outs.add(p.header.task_id);
-        else
-            inbounds.push(text);
-    }
-    // A scheduler-created terminal has an env task id. In that case this
-    // selector returns only the matching wire or undefined: it must never
-    // fall back to an old history task while the new FIFO write races the
-    // initial catchup. Manual ready-pool sessions have no env and retain
-    // newest-unclosed fallback selection.
-    const selected = selectHistoryDelivery(env || undefined, inbounds, outs);
-    if (selected)
-        handleSwarmInbound(pi, selected, undefined, ctx);
-}
-/** Pin the tab title for a claimed hop. Pi rewrites the create-time title on
- * boot and on idle transitions, and the scheduler-side rename races those
- * writes. Last writer wins, so the session re-asserts its own title on claim
- * and again on agent_end (idle), which is pi's other rewrite point. */
-function pinSwarmTitle(ctx, taskId) {
-    try {
-        ctx?.ui?.setTitle?.(`swarm:${swarmTreePath()}:${taskId.slice(0, 8)}`);
-    }
-    catch { /* title is cosmetic */ }
-}
-/** Swarm-mode inbound path: claim one hop, inject via followUp, never wait. */
-function handleSwarmInbound(pi, text, eventSeq, ctx) {
-    // A report frame is this session's own evidence relayed back on the event
-    // stream. It is neither a task delivery nor a protocol fault.
-    if (isSwarmReportFrame(text))
-        return false;
-    let parsed;
-    try {
-        parsed = parseSwarmHeader(text);
-    }
-    catch (e) {
-        state.swarmSession?.transition({ agent: "gone", resource: "closed", recovery: "idle_fault" }, `swarm_protocol_fault:${e instanceof Error ? e.message : String(e)}`);
-        return false;
-    }
-    if (!parsed) {
-        if (text.startsWith("---swarm"))
-            state.swarmSession?.transition({ agent: "gone", resource: "closed", recovery: "idle_fault" }, "swarm_protocol_fault");
-        return false;
-    }
-    if (state.socket && eventSeq !== undefined)
-        awaitIntent(consumeEvent(state.socket, eventSeq).catch(() => { }));
-    // Slot transitions live in SwarmSlot (unit-tested); here we only mirror
-    // the claimed task into session state. A claimed session never accepts
-    // another task; downstream work spawns new tasks via swarm_send.
-    const outcome = (() => { try {
-        return swarmSlot.handle(pi, text, envTaskId() || undefined, state.workspace?.root);
-    }
-    catch (e) {
-        state.swarmSession?.transition({ agent: "gone", resource: "closed", recovery: "idle_fault" }, `swarm_slot_fault:${e instanceof Error ? e.message : String(e)}`);
-        return "fault";
-    } })();
-    if (outcome === "claimed" || outcome === "yielded") {
-        const cur = swarmSlot.task();
-        state.swarmTask = { taskId: cur.taskId, from: cur.from, transferSendTo: cur.transferSendTo, attempt: cur.attempt };
-        state.swarmTaskKey = cur.taskId;
-        const sessionCtx = state.swarmContext;
-        if (sessionCtx?.appendEntry) {
-            const restored = restoreSwarmState(sessionCtx, cur.taskId);
-            state.swarmSession?.stopHeartbeat();
-            state.swarmSession = new SwarmSessionState(sessionCtx, cur.taskId, restored);
-            state.swarmSession.startSession();
-            state.swarmSession.transition({ agent: "ready", resource: "attached", lifecycle: "working", recovery: "idle_waiting" }, "swarm_task_claimed");
-            state.swarmSession.startHeartbeat(10_000, swarmHeartbeat);
-        }
-        if (ctx)
-            void pinSwarmTitle(ctx, cur.taskId);
-    }
-    return outcome === "claimed" || outcome === "yielded";
-}
-async function startWatch(pi, ctx) {
-    state.workspace = findWorkspace(state.cwd);
-    if (!state.workspace)
-        throw new Error("current workspace has no .onlyne configuration");
-    state.swarmContext = ctx ?? state.swarmContext ?? cachedCtx;
-    refreshSwarmFlag();
-    if (state.reconnectTimer)
-        clearTimeout(state.reconnectTimer);
-    state.reconnectTimer = undefined;
-    state.socket?.destroy();
-    state.socket = undefined;
-    const conn = await connectDaemon(state.workspace);
-    state.owner = conn.owner;
-    state.child = conn.process;
-    if (state.swarm) {
-        // Swarm mode: the scheduler owns in/out. Subscribe without auto-handling generic
-        // traffic; only swarm headers enter the session, via the followUp task queue.
-        // Report readiness so the scheduler can match a pending task (fork+exec: any
-        // clean ready session on this workspace path may take it).
-        const ws = state.workspace;
-        // Priority 1 (above default 0): the scheduler consumes at MAX, then we
-        // take the event at tier 1 so it also reaches the session. A plain
-        // tier-0 subscription would starve whenever the scheduler consumes.
-        const socket = subscribe(ws.socketPath, (line) => {
-            if (!line?.event)
-                return;
-            if (line.type !== "inbound_message")
-                return;
-            const inbound = inboundText(line);
-            if (!inbound || inbound.channelId !== "loopback")
-                return;
-            // Catch up on history first: a fresh watch may subscribe after the
-            // task was already delivered (scheduler writes in before the
-            // session finishes starting). History replay is idempotent via
-            // the slot guard + scheduler task_id dedup.
-            if (parseSwarmCtl(inbound.text)) {
-                const ctl = parseSwarmCtl(inbound.text);
-                awaitIntent(handleSwarmRecycle(ctl.task_id, ctl.reason));
-                return;
-            }
-            void Promise.resolve(catchUpSwarmHistory(pi)).catch((e) => state.swarmSession?.transition({ agent: "gone", resource: "closed", recovery: "idle_fault" }, `history_catchup_fault:${e instanceof Error ? e.message : String(e)}`));
-            handleSwarmInbound(pi, inbound.text, line.event_seq);
-        }, () => { if (state.socket === socket)
-            scheduleReconnect(pi); }, { priority: 1 });
-        state.socket = socket;
-        state.watching = true;
-        try {
-            await awaitSubscriptionAck(socket);
-        }
-        catch (e) {
-            state.swarmSession?.transition({ agent: "gone", resource: "closed", recovery: "idle_fault" }, "subscribe_events_fault");
-            throw e;
-        }
-        const task = envTaskId();
-        const sessionTaskId = task || state.swarmTaskKey || `session:${terminalHandle() || randomUUID()}`;
-        state.swarmTaskKey = sessionTaskId;
-        const sessionCtx = state.swarmContext;
-        if (sessionCtx?.appendEntry) {
-            const restored = restoreSwarmState(sessionCtx, sessionTaskId);
-            state.swarmSession?.stopHeartbeat();
-            state.swarmSession = new SwarmSessionState(sessionCtx, sessionTaskId, restored);
-            state.swarmSession.startSession();
-        }
-        const readyPayload = { workspace: ws.root, terminal_handle: terminalHandle() };
-        await sendSwarmIntent("swarm_ready", readyPayload, (opId) => swarmReady(ws.socketPath, ws.root, terminalHandle(), state.swarmSession?.snapshot(), opId), currentConfig().outbound.retry.attempts);
-        if (state.swarmSession) {
-            state.swarmSession.transition({ agent: "ready", resource: "attached", lifecycle: "idle", recovery: "idle_waiting" }, "swarm_ready");
-            // Awaits the daemon receipt: the scheduler holds this session's first
-            // watermark before it reads anything else from the workspace.
-            await emitSwarmReport("ready");
-            state.swarmSession.startHeartbeat(10_000, swarmHeartbeat);
-        }
-        // The task may already sit in history (scheduler wrote in before this
-        // session finished starting). Claim it now instead of waiting for a
-        // live event that already fired.
-        await catchUpSwarmHistory(pi);
-        return `swarm watching ${ws.root} (${state.owner})${task ? ` task=${task}` : ""}`;
-    }
-    const socket = subscribe(state.workspace.socketPath, (line) => { if (!line?.event || line.type !== "inbound_message")
-        return; const inbound = inboundText(line); if (!inbound)
-        return; const mode = inboundModeFor(currentConfig(), inbound.channelId, inbound.conversationId); if (mode === "muted")
-        return; if (inbound.channelId === "loopback") {
-        if (mode === "auto-handle")
-            pi.sendUserMessage(`Onlyne loopback activation${inbound.conversationId ? ` (${inbound.conversationId})` : ""}:\n\n${inbound.text}`, { deliverAs: "followUp" });
-        consumeIfNotified(inbound);
-        return;
-    } if (inbound.text.trim() === "/handshake") {
-        consumeIfNotified(inbound);
-        return;
-    } clearReminder(); state.currentInbound = { ...inbound, replied: false, noReply: false, reminders: 0 }; if (mode === "auto-handle") {
-        pi.sendUserMessage(`Onlyne inbound message from ${inbound.channelId}/${inbound.conversationId}:\n\n${inbound.text}\n\nReply with onlyne_reply, or call onlyne_mark_no_reply if no reply is needed.`, { deliverAs: "followUp" });
-        consumeIfNotified(inbound);
-    } }, () => { if (state.socket === socket)
-        scheduleReconnect(pi); });
-    state.socket = socket;
-    state.watching = true;
-    return `watching ${state.workspace.root} (${state.owner})`;
-}
-function stopWatch(clearSession = true) { if (state.reconnectTimer)
-    clearTimeout(state.reconnectTimer); state.reconnectTimer = undefined; clearReminder(); state.socket?.destroy(); state.socket = undefined; stopProcess(state.child); state.child = undefined; if (clearSession) {
-    state.swarmSession?.shutdown();
-    state.swarmSession = undefined;
-}
-else
-    state.swarmSession?.stopHeartbeat(); state.watching = false; state.owner = "stopped"; state.swarmTask = undefined; swarmSlot.clear(); return "watch stopped"; }
-async function startDaemon() { state.workspace = findWorkspace(state.cwd); if (!state.workspace)
-    throw new Error("current workspace has no .onlyne configuration"); refreshSwarmFlag(); const conn = await connectDaemon(state.workspace, true); state.owner = conn.owner; state.child = conn.process; return `daemon ${state.owner === "extension" ? "started" : "already running"} for ${state.workspace.root}`; }
-async function stopDaemon() { if (!state.workspace)
-    state.workspace = findWorkspace(state.cwd); if (!state.workspace)
-    throw new Error("current workspace has no .onlyne configuration"); clearReminder(); state.socket?.destroy(); state.socket = undefined; await shutdownDaemon(state.workspace, state.child); state.child = undefined; state.watching = false; state.owner = "stopped"; return `daemon stopped for ${state.workspace.root}`; }
-async function restartDaemon() { await stopDaemon().catch(() => { }); return startDaemon(); }
-async function reply(text) { if (!state.workspace)
-    throw new Error("onlyne workspace not found"); const inbound = state.currentInbound; if (!inbound)
-    throw new Error("no active inbound message"); const res = await sendWithRetry(state.workspace.socketPath, { channelId: inbound.channelId }, text, currentConfig().outbound.retry.attempts); if (res.ok) {
-    inbound.replied = true;
-    clearReminder();
-} return res; }
-/** Resolve the current workspace tree path: segment after /.ws/, root is ".". */
-function swarmTreePath() {
-    if (!state.workspace)
-        throw new Error("onlyne workspace not found");
-    return treePathForWorkspace(state.workspace.root);
-}
-async function swarmComplete(text) {
-    if (!state.workspace)
-        throw new Error("onlyne workspace not found");
-    const task = state.swarmTask;
-    if (!task)
-        throw new Error("no active swarm task");
-    const { renderSwarmHeader } = await import("./swarm.js");
-    const wire = renderSwarmHeader({ task_id: task.taskId, from: swarmTreePath(), transfer_send_to: task.transferSendTo, attempt: task.attempt }, "", text);
-    const payload = { task_id: task.taskId, text: wire };
-    const result = await sendSwarmIntent("swarm_complete", payload, (opId) => sendWithRetry(state.workspace.socketPath, { channelId: "loopback" }, wire, 1, false, opId), currentConfig().outbound.retry.attempts, swarmOpId("swarm_complete", task.taskId));
-    state.swarmSession?.transition({ agent: "ready", resource: "closing", lifecycle: "exited", recovery: "draining" }, "swarm_complete");
-    // Awaits the daemon receipt on the terminal evidence for this generation.
-    await emitSwarmReport("complete");
-    state.swarmTask = undefined;
-    swarmSlot.clear();
-    clearReminder();
-    try {
-        stopWatch(false);
-    }
-    catch { /* lifecycle cleanup */ }
-    setTimeout(() => process.exit(0), 300);
-    return { ...(result && typeof result === "object" ? result : { ok: true }), taskId: task.taskId };
-}
-async function swarmQuit(reason) {
-    const task = state.swarmTask;
-    const taskId = task?.taskId ?? "";
-    const why = `quit:${reason ?? ""}`;
-    if (state.workspace && taskId) {
-        try {
-            await sendSwarmIntent("swarm_recycled", { task_id: taskId, reason: why }, (opId) => swarmRecycled(state.workspace.socketPath, taskId, terminalHandle(), why, opId), currentConfig().outbound.retry.attempts, swarmOpId("swarm_recycled", `quit:${taskId}`));
-        }
-        catch { /* fault persists; quit still exits */ }
-    }
-    // A quit writes no out, so Failed is the accurate projection of this hop.
-    // The report carries this session's own watermark next to the swarm_recycled
-    // ack above, and its receipt is collected before the exit path runs.
-    await emitSwarmReport("fault");
-    clearReminder();
-    try {
-        stopWatch(false);
-    }
-    catch { /* lifecycle cleanup */ }
-    state.swarmTask = undefined;
-    swarmSlot.clear();
-    setTimeout(() => process.exit(0), 300);
-    return { quit: true, taskId, reason: reason ?? "" };
-}
-async function handleSwarmRecycle(ctlTaskId, reason) {
-    const claimed = swarmSlot.task().taskId;
-    const taskId = ctlTaskId === "*" ? (claimed ?? "") : ctlTaskId;
-    if (claimed && ctlTaskId !== "*" && claimed !== ctlTaskId)
-        return false;
-    const why = `recycle:${reason}`;
-    // The scheduler initiated this recycle, so its own ledger already holds the
-    // truth about the hop. A report from here would restate a transition that
-    // side drove, hence no lifecycle report on this path.
-    if (state.workspace && taskId) {
-        try {
-            await sendSwarmIntent("swarm_recycled", { task_id: taskId, reason: why }, (opId) => swarmRecycled(state.workspace.socketPath, taskId, terminalHandle(), why, opId), currentConfig().outbound.retry.attempts, swarmOpId("swarm_recycled", `recycle:${taskId}`));
-        }
-        catch { /* fault persists; recycle still exits */ }
-    }
-    clearReminder();
-    try {
-        stopWatch(false);
-    }
-    catch { /* lifecycle cleanup */ }
-    state.swarmTask = undefined;
-    swarmSlot.clear();
-    setTimeout(() => process.exit(0), 300);
-    return true;
-}
-/** Resolve a scheduler target symlink to that workspace's daemon socket. */
-function swarmTargetSocket(linkPath, workspaceRoot) {
-    const targetIn = realpathSync(linkPath);
-    const root = resolve(workspaceRoot);
-    if (!targetIn.startsWith(root + "/") || !targetIn.endsWith("/.onlyne/channels/loopback/in"))
-        throw new Error(`invalid swarm_send target: ${linkPath}`);
-    const targetOnlyne = dirname(dirname(dirname(targetIn)));
-    return join(targetOnlyne, "run", "s");
-}
-/** swarm_send: spawn downstream through the target daemon's loopback RPC. */
-async function swarmSend(to, text) {
-    if (!state.workspace)
-        throw new Error("onlyne workspace not found");
-    const task = state.swarmTask;
-    if (!task)
-        throw new Error("no active swarm task");
-    const { renderSwarmHeader } = await import("./swarm.js");
-    const wsRoot = state.workspace.root;
-    const linkPath = to === "." || to === "_root" ? join(wsRoot, "onlyne_in", "_root") : join(wsRoot, "onlyne_in", ...to.split("/").filter(Boolean));
-    const childId = randomUUID();
-    const wire = renderSwarmHeader({ task_id: childId, from: swarmTreePath(), transfer_send_to: task.taskId, attempt: 1 }, "", text);
-    const targetSocket = swarmTargetSocket(linkPath, wsRoot);
-    const payload = { child_id: childId, to, task_id: task.taskId, text: wire };
-    await sendSwarmIntent("swarm_send", payload, (opId) => loopback(targetSocket, wire, true, opId), currentConfig().outbound.retry.attempts, swarmOpId("swarm_send", childId));
-    swarmSlot.noteSpawned(childId);
-    return { childId, to };
-}
-/** Swarm mode: apply the workspace snapshot model triple to this session. */
-async function applySwarmModel(pi, ctx) {
-    if (!state.swarm || !state.workspace)
-        return;
-    const m = readSwarmModel(state.workspace.onlyneDir);
-    if (!m)
-        return;
-    if (ctx?.model && m.provider && ctx.model.provider === m.provider && m.model && ctx.model.id === m.model && (!m.effort || m.effort === ctx.thinkingLevel))
-        return;
-    try {
-        if (m.provider && m.model) {
-            const found = ctx.modelRegistry?.find?.(m.provider, m.model);
-            if (found) {
-                const ok = await pi.setModel(found);
-                if (!ok) {
-                    ctx.ui?.notify(`swarm model ${m.provider}/${m.model}: no auth`, "warning");
-                    return;
-                }
-            }
-            else
-                ctx.ui?.notify(`swarm model ${m.provider}/${m.model} not in registry; keeping default`, "warning");
-        }
-        const eff = m.effort;
-        if (eff && ["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(eff))
-            pi.setThinkingLevel(eff);
-        ctx.ui?.setStatus?.("onlyne-model", `model:${m.provider ?? ""}/${m.model ?? ""}${m.effort ? ":" + m.effort : ""}`);
-    }
-    catch (e) {
-        ctx.ui?.notify(`swarm model apply failed: ${e}`, "warning");
-    }
-}
-export default function onlyne(pi) {
-    pi.on("session_start", async (_event, ctx) => { cachedCtx = ctx; const resumeWatch = state.watching; if (state.owner === "extension")
-        await stopDaemon().catch(() => { });
-    else
-        stopWatch(); state.cwd = ctx.cwd; state.workspace = findWorkspace(ctx.cwd); state.currentInbound = undefined; state.lastValidOutput = undefined; state.swarmTask = undefined; swarmSlot.clear(); refreshSwarmFlag(); applyToolSurface(pi); void applySwarmModel(pi, ctx); ctx.ui.setStatus("onlyne", state.workspace ? (state.swarm ? "onlyne: swarm" : "onlyne: ready") : "onlyne: no .onlyne"); if ((currentConfig().watch.autoStart || resumeWatch) && state.workspace) {
-        try {
-            ctx.ui.notify(await startWatch(pi), "info");
-        }
-        catch (e) {
-            ctx.ui.notify(String(e), "warning");
-        }
-    } });
-    pi.on("session_shutdown", async () => { if (state.owner === "extension")
-        await stopDaemon().catch(() => { });
-    else
-        stopWatch(); });
-    for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"])
-        process.once(sig, () => stopWatch());
-    pi.on("message_end", async (event) => { const text = typeof event.content === "string" ? event.content.trim() : ""; if (text && !text.startsWith("{") && !text.startsWith("[onlyne-internal]"))
-        state.lastValidOutput = text; });
-    pi.on("agent_start", async () => { clearReminder(); swarmSessionTransition({ agent: "running", lifecycle: "working", recovery: "idle_waiting" }, "turn_start"); awaitIntent(emitSwarmReport("turn_started")); reportHopBusy().catch(() => { }); });
-    pi.on("agent_end", async () => { if (state.swarm) {
-        const cur = swarmSlot.task();
-        if (cur.taskId && cachedCtx)
-            void pinSwarmTitle(cachedCtx, cur.taskId);
-        swarmSessionTransition({ agent: "idle", lifecycle: "idle", recovery: "idle_waiting" }, "turn_idle");
-        scheduleSwarmExitReminder(pi);
-    }
-    else
-        scheduleReminder(pi); reportHopIdle().catch(() => { }); });
-    pi.registerCommand("onlyne", {
-        description: "Onlyne watch/status/config commands",
-        getArgumentCompletions: (prefix) => {
-            const commands = ["status", "watch on", "watch off", "daemon start", "daemon stop", "daemon restart", "config auto-start", "swarm on", "swarm off", "swarm status"];
-            const p = prefix.trimStart();
-            const filtered = commands.filter((c) => c.startsWith(p));
-            return filtered.length ? filtered.map((value) => ({ value, label: value })) : null;
-        },
-        handler: async (argLine, ctx) => {
-            const [cmd, sub] = argLine.trim().split(/\s+/);
-            try {
-                if (cmd === "watch" && sub === "on")
-                    ctx.ui.notify(await startWatch(pi), "info");
-                else if (cmd === "watch" && sub === "off")
-                    ctx.ui.notify(stopWatch(), "info");
-                else if (cmd === "daemon" && sub === "start")
-                    ctx.ui.notify(await startDaemon(), "info");
-                else if (cmd === "daemon" && sub === "stop")
-                    ctx.ui.notify(await stopDaemon(), "info");
-                else if (cmd === "daemon" && sub === "restart")
-                    ctx.ui.notify(await restartDaemon(), "info");
-                else if (cmd === "status")
-                    ctx.ui.notify(`onlyne ${state.watching ? "watching" : "stopped"}; owner=${state.owner}; swarm=${state.swarm ? "on" : "off"}; workspace=${state.workspace?.root ?? "none"}`, "info");
-                else if (cmd === "swarm" && sub === "status") {
-                    const cur = swarmSlot.task();
-                    ctx.ui.notify(`swarm=${state.swarm ? "on" : "off"}; task=${cur.taskId ?? "none"}; spawned=${cur.sentChildIds.length}`, "info");
-                }
-                else if (cmd === "swarm" && (sub === "on" || sub === "off")) {
-                    ctx.ui.notify(await setSwarm(pi, sub === "on"), "info");
-                }
-                else if (cmd === "config" && sub === "auto-start") {
-                    const cfg = currentConfig();
-                    cfg.watch.autoStart = !cfg.watch.autoStart;
-                    saveConfig(state.cwd, cfg);
-                    ctx.ui.notify(`autoStart=${cfg.watch.autoStart}`, "info");
-                }
-                else
-                    ctx.ui.notify("usage: /onlyne status | watch on|off | daemon start|stop|restart | swarm on|off|status | config auto-start", "info");
-            }
-            catch (e) {
-                ctx.ui.notify(e instanceof Error ? e.message : String(e), "error");
-            }
-        },
-    });
-    registerNormalTools(pi);
-    registerSwarmTools(pi);
-    applyToolSurface(pi);
-}
-const NORMAL_TOOLS = ["onlyne_daemon_start", "onlyne_daemon_stop", "onlyne_daemon_restart", "onlyne_reply", "onlyne_send", "onlyne_broadcast", "onlyne_loopback", "onlyne_mark_no_reply"];
-const SWARM_TOOLS = ["onlyne_daemon_start", "onlyne_daemon_stop", "onlyne_daemon_restart", "swarm_complete", "swarm_quit", "swarm_send", "swarm_status"];
-/** Tool surface follows [swarm] at session start: one mode, one toolset. */
-function applyToolSurface(pi) {
-    try {
-        const active = new Set(typeof pi.getActiveTools === "function" ? pi.getActiveTools() : []);
-        const all = typeof pi.getAllTools === "function" ? pi.getAllTools().map((t) => t.name) : [];
-        const keep = state.swarm ? SWARM_TOOLS : NORMAL_TOOLS;
-        const next = [...active].filter((n) => all.includes(n) && !(NORMAL_TOOLS.includes(n) || SWARM_TOOLS.includes(n)));
-        for (const n of keep)
-            if (all.includes(n) && !next.includes(n))
-                next.push(n);
-        if (typeof pi.setActiveTools === "function")
-            pi.setActiveTools(next);
-    }
-    catch { /* older pi without tool-surface API: both sets stay registered */ }
-}
-function registerNormalTools(pi) {
-    pi.registerTool(defineTool({ name: "onlyne_daemon_start", label: "Onlyne daemon start", description: "Start or connect to the current workspace-local Onlyne daemon managed by pi-onlyne.", parameters: Type.Object({}), executionMode: "parallel", async execute() { const res = await startDaemon(); return textResult(res, { owner: state.owner, workspace: state.workspace?.root }); } }));
-    pi.registerTool(defineTool({ name: "onlyne_daemon_stop", label: "Onlyne daemon stop", description: "Stop the current workspace-local Onlyne daemon through pi-onlyne lifecycle management. The tool also sends shutdown to a daemon already running in this workspace.", parameters: Type.Object({}), executionMode: "parallel", async execute() { const res = await stopDaemon(); return textResult(res, { owner: state.owner, workspace: state.workspace?.root }); } }));
-    pi.registerTool(defineTool({ name: "onlyne_daemon_restart", label: "Onlyne daemon restart", description: "Restart the current workspace-local Onlyne daemon through pi-onlyne lifecycle management.", parameters: Type.Object({}), executionMode: "parallel", async execute() { const res = await restartDaemon(); return textResult(res, { owner: state.owner, workspace: state.workspace?.root }); } }));
-    pi.registerTool(defineTool({ name: "onlyne_reply", label: "Onlyne reply", description: "Reply with Markdown to the current Onlyne inbound message. Use Markdown by default and preserve the message as one document.", parameters: Type.Object({ text: Type.String() }), executionMode: "parallel", async execute(_id, params) { return textResult(JSON.stringify(await reply(params.text))); } }));
-    pi.registerTool(defineTool({ name: "onlyne_send", label: "Onlyne send", description: "Send Markdown to the channel's configured Onlyne conversation. Set rawText=true only for literal plain text.", parameters: Type.Object({ channelId: Type.String(), text: Type.String(), rawText: Type.Optional(Type.Boolean()) }), executionMode: "parallel", async execute(_id, params) { if (!state.workspace)
-            throw new Error("onlyne workspace not found"); const res = await sendWithRetry(state.workspace.socketPath, params, params.text, currentConfig().outbound.retry.attempts, params.rawText ?? false); return textResult(JSON.stringify(res), res); } }));
-    pi.registerTool(defineTool({ name: "onlyne_broadcast", label: "Onlyne broadcast", description: "Send Markdown to many configured Onlyne channels concurrently. Set rawText=true only for literal plain text.", parameters: Type.Object({ targets: Type.Array(Type.Object({ channelId: Type.String() })), text: Type.String(), rawText: Type.Optional(Type.Boolean()) }), executionMode: "parallel", async execute(_id, params) { if (!state.workspace)
-            throw new Error("onlyne workspace not found"); const cfg = currentConfig(); const results = await broadcast(state.workspace.socketPath, params.targets, params.text, cfg.outbound.retry.attempts, cfg.outbound.retry.concurrency, params.rawText ?? false); return textResult(JSON.stringify({ ok: results.every((r) => r.ok), results }), results); } }));
-    pi.registerTool(defineTool({ name: "onlyne_loopback", label: "Onlyne loopback", description: "Inject a local loopback activation message so scripts can wake the current Pi session. Set rawText=false for Markdown. FIFO alternative: write to .onlyne/channels/loopback/in.", parameters: Type.Object({ text: Type.String(), rawText: Type.Optional(Type.Boolean()) }), executionMode: "parallel", async execute(_id, params) { if (!state.workspace)
-            throw new Error("onlyne workspace not found"); const res = await loopback(state.workspace.socketPath, params.text, params.rawText ?? true); return textResult(JSON.stringify(res), res); } }));
-    pi.registerTool(defineTool({ name: "onlyne_mark_no_reply", label: "Onlyne no reply", description: "Mark the current Onlyne inbound message as intentionally not replied.", parameters: Type.Object({ reason: Type.Optional(Type.String()) }), executionMode: "parallel", async execute(_id, params) { if (state.currentInbound) {
-            state.currentInbound.noReply = true;
-            clearReminder();
-        } return textResult("marked no reply", params); } }));
-}
-function registerSwarmTools(pi) {
-    pi.registerTool(defineTool({ name: "swarm_complete", label: "Swarm complete", description: "Hand over this swarm hop: write the out message carrying this task header (done signal). The session becomes recyclable. Use once per swarm task.", parameters: Type.Object({ text: Type.String() }), executionMode: "parallel", async execute(_id, params) { return textResult(JSON.stringify(await swarmComplete(params.text))); } }));
-    pi.registerTool(defineTool({ name: "swarm_quit", label: "Swarm quit", description: "Quit this swarm hop silently: no out is written and the scheduler records failed. Use when the task premise does not hold or there is nothing to do.", parameters: Type.Object({ reason: Type.Optional(Type.String()) }), executionMode: "parallel", async execute(_id, params) { return textResult(JSON.stringify(await swarmQuit(params.reason))); } }));
-    pi.registerTool(defineTool({ name: "swarm_send", label: "Swarm send", description: "Spawn a downstream swarm task through the target workspace daemon loopback RPC with transfer_send_to set to the current task. Stable op_id makes retries idempotent; returns the child id without waiting. Errors on missing targets.", parameters: Type.Object({ to: Type.String(), text: Type.String() }), executionMode: "parallel", async execute(_id, params) { return textResult(JSON.stringify(await swarmSend(params.to, params.text))); } }));
-    pi.registerTool(defineTool({ name: "swarm_status", label: "Swarm status", description: "Read-only swarm state: current task id, from, workspace path, and spawned child ids.", parameters: Type.Object({}), executionMode: "parallel", async execute() { const cur = swarmSlot.task(); return textResult(JSON.stringify({ taskId: cur.taskId ?? null, from: cur.from, transferSendTo: cur.transferSendTo, workspace: state.workspace?.root ?? null, spawned: cur.sentChildIds })); } }));
-}
-/** R4 hop activity reporters: turn-granularity busy/idle over the existing
- * swarm event channel. Fire-and-forget (failures silent): the scheduler
- * treats missing rows as race residue, and its TTLs are the backstop.
- * busy fires only with a live claimed task; idle fires only when the turn
- * ended without an out (swarmTask still set). The decision (guard +
- * pending_exit) is the shared, unit-tested hopActivityBody. */
-async function reportHopBusy() {
-    const body = hopActivityBody("busy", { swarm: state.swarm, workspaceRoot: state.workspace?.root, terminal: terminalHandle(), taskId: state.swarmTask?.taskId });
-    if (!body || !state.workspace)
-        return;
-    await sendSwarmIntent("swarm_busy", body, (opId) => swarmBusy(state.workspace.socketPath, body, opId), currentConfig().outbound.retry.attempts, swarmOpId("swarm_busy", `${state.swarmTask?.taskId ?? ""}:${state.swarmSession?.seq ?? 0}`));
-}
-async function reportHopIdle() {
-    const body = hopActivityBody("idle", { swarm: state.swarm, workspaceRoot: state.workspace?.root, terminal: terminalHandle(), taskId: state.swarmTask?.taskId });
-    if (!body || !state.workspace)
-        return;
-    await sendSwarmIntent("swarm_idle", body, (opId) => swarmIdle(state.workspace.socketPath, body, opId), currentConfig().outbound.retry.attempts, swarmOpId("swarm_idle", `${state.swarmTask?.taskId ?? ""}:${state.swarmSession?.seq ?? 0}`));
-}
-/** Swarm exit guard: at agent end, an unfinished hop gets one reminder, then auto-quit. */
-function scheduleSwarmExitReminder(pi, delayMs = 30_000) {
-    clearReminder();
-    if (!state.swarmTask)
-        return;
-    state.reminderTimer = setTimeout(() => {
-        state.reminderTimer = undefined;
-        if (!state.swarmTask)
-            return;
-        if (state.swarmTask) {
-            {
-                const p = pi;
-                if (typeof p.sendMessage === "function")
-                    p.sendMessage({ customType: "onlyne-swarm-reminder", content: `Swarm hop ${state.swarmTask.taskId} has no exit yet. Call swarm_complete with the handover summary, or swarm_quit when there is nothing to do.`, display: true }, { triggerTurn: true, deliverAs: "followUp" });
-                else
-                    pi.sendUserMessage(`Swarm hop ${state.swarmTask.taskId} has no exit yet. Call swarm_complete with the handover summary, or swarm_quit when there is nothing to do.`, { deliverAs: "followUp" });
-            }
-            state.reminderTimer = setTimeout(() => {
-                state.reminderTimer = undefined;
-                if (state.swarmTask)
-                    void swarmQuit("auto-quit: no explicit exit").catch(() => { });
-            }, delayMs);
-        }
-    }, delayMs);
-}
-/** Toggle swarm mode: persists to .onlyne/config.toml [swarm] enabled, restarts watch. */
-async function setSwarm(pi, enabled) {
-    if (!state.workspace)
-        throw new Error("onlyne workspace not found");
-    const cfgPath = join(state.workspace.onlyneDir, "config.toml");
-    let text = existsSync(cfgPath) ? readFileSync(cfgPath, "utf8") : "";
-    if (text.includes("[swarm]")) {
-        const lines = text.split("\n");
-        let inSwarm = false;
-        text = lines.map((line) => {
-            const t = line.trim();
-            if (t.startsWith("[")) {
-                inSwarm = t === "[swarm]";
-                return line;
-            }
-            if (inSwarm && t.startsWith("enabled"))
-                return `enabled = ${enabled}`;
-            return line;
-        }).join("\n");
-    }
-    else {
-        if (text && !text.endsWith("\n"))
-            text += "\n";
-        text += `\n[swarm]\nenabled = ${enabled}\n`;
-    }
-    writeFileSync(cfgPath, text);
-    refreshSwarmFlag();
-    if (state.watching) {
-        stopWatch();
-        return `${enabled ? "swarm on; " : "swarm off; "}${await startWatch(pi)}`;
-    }
-    return `swarm ${enabled ? "on" : "off"} (watch not running)`;
-}
-/** Test seam: drive the lifecycle-report wiring against a stub daemon socket.
- * No live pi session and no real daemon are involved; the seam exposes the
- * same closures the hooks call. Mirrors `__swarmSlotForTest`. */
-export function __swarmReportForTest() {
-    return {
-        setWorkspace: (ws) => { state.workspace = ws; },
-        beginSession: (appendEntry, taskId) => {
-            state.swarmSession?.shutdown();
-            state.swarmSession = new SwarmSessionState({ appendEntry }, taskId);
-            state.swarmSession.startSession();
-            return { generation: state.swarmSession.generation, seq: state.swarmSession.seq };
-        },
-        setTask: (task) => { state.swarmTask = task; },
-        reportTaskId: swarmReportTaskId,
-        emit: emitSwarmReport,
-        beat: swarmHeartbeat,
-    };
-}