pi-onlyne 0.7.0 → 0.7.3

package/dist/index.js

@@ -1,12 +1,16 @@
 import { defineTool } from "@earendil-works/pi-coding-agent";
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
 import { Type } from "typebox";
 import { broadcast, connectDaemon, consumeEvent, loopback, markConsumed, sendWithRetry, shutdownDaemon, stopProcess, subscribe, swarmReady } from "./onlyne.js";
 import { inboundModeFor, loadConfig, saveConfig } from "./config.js";
 import { findWorkspace } from "./workspace.js";
-import { envTaskId, parseSwarmHeader, readSwarmEnabled, terminalHandle } from "./swarm.js";
+import { envTaskId, parseSwarmHeader, readSwarmEnabled, readSwarmModel, terminalHandle, treePathForWorkspace } from "./swarm.js";
 import { SwarmSlot } from "./swarm-slot.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; }
@@ -53,8 +57,104 @@ function 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 (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;
+    try {
+        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;
+            const p = parseSwarmHeader(text);
+            if (!p)
+                continue;
+            if (m?.direction === "outbound")
+                outs.add(p.header.task_id);
+            else
+                inbounds.push(text);
+        }
+        // Env task first: exact task_id match on inbound, even if an out exists
+        // (out may belong to a previous generation; scheduler owns the truth).
+        if (env) {
+            for (const text of inbounds) {
+                const p = parseSwarmHeader(text);
+                if (p.header.task_id === env) {
+                    if (handleSwarmInbound(pi, text, undefined, ctx))
+                        return;
+                }
+            }
+        }
+        // Fallback: newest inbound with no out yet.
+        for (let i = inbounds.length - 1; i >= 0; i--) {
+            const p = parseSwarmHeader(inbounds[i]);
+            if (outs.has(p.header.task_id))
+                continue;
+            if (p.header.task_id === env)
+                continue; // already tried above
+            if (handleSwarmInbound(pi, inbounds[i]))
+                return;
+        }
+    }
+    catch { /* best effort; live events still arrive */ }
+}
+/** 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) {
+function handleSwarmInbound(pi, text, eventSeq, ctx) {
     const parsed = parseSwarmHeader(text);
     if (!parsed)
         return false;
@@ -63,12 +163,14 @@ function handleSwarmInbound(pi, text, eventSeq) {
     // 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 = swarmSlot.handle(pi, text);
-    if (outcome === "claimed") {
+    const outcome = swarmSlot.handle(pi, text, envTaskId() || undefined);
+    if (outcome === "claimed" || outcome === "yielded") {
         const cur = swarmSlot.task();
         state.swarmTask = { taskId: cur.taskId, from: cur.from, transferSendTo: cur.transferSendTo, attempt: cur.attempt };
+        if (ctx)
+            void pinSwarmTitle(ctx, cur.taskId);
     }
-    return outcome === "claimed";
+    return outcome === "claimed" || outcome === "yielded";
 }
 async function startWatch(pi) {
     state.workspace = findWorkspace(state.cwd);
@@ -89,6 +191,9 @@ async function startWatch(pi) {
         // 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;
@@ -97,9 +202,14 @@ async function startWatch(pi) {
             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.
+            void catchUpSwarmHistory(pi);
             handleSwarmInbound(pi, inbound.text, line.event_seq);
         }, () => { if (state.socket === socket)
-            scheduleReconnect(pi); });
+            scheduleReconnect(pi); }, { priority: 1 });
         state.socket = socket;
         state.watching = true;
         const task = envTaskId();
@@ -107,6 +217,10 @@ async function startWatch(pi) {
             await swarmReady(ws.socketPath, ws.root, terminalHandle());
         }
         catch { /* scheduler may read env fallback */ }
+        // 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")
@@ -143,12 +257,11 @@ async function reply(text) { if (!state.workspace)
     inbound.replied = true;
     clearReminder();
 } return res; }
-/** Resolve the current workspace tree path from the workspace root dir name. Root itself is ".". */
+/** Resolve the current workspace tree path: segment after /.ws/, root is ".". */
 function swarmTreePath() {
     if (!state.workspace)
         throw new Error("onlyne workspace not found");
-    const { basename } = require("node:path");
-    return state.workspace.root === process.cwd() ? "." : basename(state.workspace.root);
+    return treePathForWorkspace(state.workspace.root);
 }
 /** swarm_complete: hand over. Writes the out message carrying this hop's header (done signal). */
 async function swarmComplete(text) {
@@ -180,10 +293,7 @@ async function swarmSend(to, text) {
     const task = state.swarmTask;
     if (!task)
         throw new Error("no active swarm task");
-    const { randomUUID } = await import("node:crypto");
     const { renderSwarmHeader } = await import("./swarm.js");
-    const { existsSync } = await import("node:fs");
-    const { join, resolve } = await import("node:path");
     // Resolve the target workspace dir: root "." or a tree path under the swarm tree.
     // The scheduler owns the tree; here we only verify the send-side symlink exists
     // (missing target = dangling link = error, never a blind FIFO write).
@@ -199,7 +309,6 @@ async function swarmSend(to, text) {
         throw new Error(`unknown swarm_send target (missing onlyne_in link): ${to}`);
     const childId = randomUUID();
     const wire = renderSwarmHeader({ task_id: childId, from: swarmTreePath(), transfer_send_to: task.taskId, attempt: 1 }, "", text);
-    const { writeFileSync } = await import("node:fs");
     try {
         writeFileSync(linkPath, wire);
     }
@@ -209,11 +318,42 @@ async function swarmSend(to, text) {
     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) => { const resumeWatch = state.watching; if (state.owner === "extension")
+    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); ctx.ui.setStatus("onlyne", state.workspace ? (state.swarm ? "onlyne: swarm" : "onlyne: ready") : "onlyne: no .onlyne"); if ((currentConfig().watch.autoStart || resumeWatch) && state.workspace) {
+        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");
         }
@@ -230,8 +370,12 @@ export default function onlyne(pi) {
     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());
-    pi.on("agent_end", async () => { if (state.swarm)
+    pi.on("agent_end", async () => { if (state.swarm) {
+        const cur = swarmSlot.task();
+        if (cur.taskId && cachedCtx)
+            void pinSwarmTitle(cachedCtx, cur.taskId);
         scheduleSwarmExitReminder(pi);
+    }
     else
         scheduleReminder(pi); });
     pi.registerCommand("onlyne", {
@@ -331,7 +475,13 @@ function scheduleSwarmExitReminder(pi, delayMs = 30_000) {
         if (!state.swarmTask)
             return;
         if (state.swarmTask) {
-            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" });
+            {
+                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)
@@ -344,8 +494,6 @@ function scheduleSwarmExitReminder(pi, delayMs = 30_000) {
 async function setSwarm(pi, enabled) {
     if (!state.workspace)
         throw new Error("onlyne workspace not found");
-    const { readFileSync, writeFileSync, existsSync } = await import("node:fs");
-    const { join } = await import("node:path");
     const cfgPath = join(state.workspace.onlyneDir, "config.toml");
     let text = existsSync(cfgPath) ? readFileSync(cfgPath, "utf8") : "";
     if (text.includes("[swarm]")) {

package/dist/swarm-slot.d.ts

@@ -1,10 +1,12 @@
-export type SwarmHandleResult = "claimed" | "not-swarm";
-export interface SwarmSlotMessage {
-    text: string;
-    deliverAs: "followUp";
-}
+export type SwarmHandleResult = "claimed" | "yielded" | "not-swarm";
 export interface SwarmPi {
-    sendUserMessage: (text: string, opts: {
+    sendMessage: (message: {
+        customType: string;
+        content: string;
+        display: boolean;
+        details?: unknown;
+    }, opts: {
+        triggerTurn: true;
         deliverAs: "followUp";
     }) => void;
 }
@@ -19,7 +21,7 @@ export declare class SwarmSlot {
     private transfer;
     private attempt;
     private sentChildIds;
-    handle(pi: SwarmPi, text: string): SwarmHandleResult;
+    handle(pi: SwarmPi, text: string, preferredTaskId?: string): SwarmHandleResult;
     task(): {
         taskId?: string;
         from: string;
@@ -33,7 +35,7 @@ export declare class SwarmSlot {
 }
 /** Test seam: fresh slot without touching module-global pi-onlyne state. */
 export declare function __swarmSlotForTest(): {
-    handle: (pi: SwarmPi, text: string) => SwarmHandleResult;
+    handle: (pi: SwarmPi, text: string, preferredTaskId?: string) => SwarmHandleResult;
     task: () => {
         taskId?: string;
         from: string;

package/dist/swarm-slot.js

@@ -10,7 +10,7 @@ export class SwarmSlot {
     transfer = "";
     attempt = 1;
     sentChildIds = [];
-    handle(pi, text) {
+    handle(pi, text, preferredTaskId) {
         const parsed = parseSwarmHeader(text);
         if (!parsed)
             return "not-swarm";
@@ -21,9 +21,25 @@ export class SwarmSlot {
             this.transfer = header.transfer_send_to;
             this.attempt = header.attempt;
             this.sentChildIds = [];
-            pi.sendUserMessage(`Onlyne swarm task ${header.task_id} (from ${header.from}):\n\n${payload}\n\nThis 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.`, { deliverAs: "followUp" });
+            // Cold start needs triggerTurn: followUp alone only queues behind an
+            // active turn, and a fresh session has none. sendMessage with
+            // triggerTurn starts the model turn immediately.
+            pi.sendMessage({ customType: "onlyne-swarm-task", content: `Onlyne swarm task ${header.task_id} (from ${header.from}):\n\n${payload}\n\nThis 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.`, display: true }, { triggerTurn: true, deliverAs: "followUp" });
             return "claimed";
         }
+        // Env-task preemption: the scheduler injected ONLYNE_SWARM_TASK for
+        // this terminal. If the slot holds a stale claim (history catchup
+        // grabbed an already-done task) and the env task arrives, yield the
+        // slot silently — the stale claim never did work, so nothing is lost.
+        if (preferredTaskId && header.task_id === preferredTaskId && this.taskId !== preferredTaskId) {
+            this.taskId = header.task_id;
+            this.from = header.from;
+            this.transfer = header.transfer_send_to;
+            this.attempt = header.attempt;
+            this.sentChildIds = [];
+            pi.sendMessage({ customType: "onlyne-swarm-task", content: `Onlyne swarm task ${header.task_id} (from ${header.from}):\n\n${payload}\n\nThis 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.`, display: true }, { triggerTurn: true, deliverAs: "followUp" });
+            return "yielded";
+        }
         return "not-swarm";
     }
     task() {
@@ -47,7 +63,7 @@ export class SwarmSlot {
 export function __swarmSlotForTest() {
     const slot = new SwarmSlot();
     return {
-        handle: (pi, text) => slot.handle(pi, text),
+        handle: (pi, text, preferredTaskId) => slot.handle(pi, text, preferredTaskId),
         task: () => slot.task(),
         taskId: () => slot.taskIdOf(),
         noteSpawned: (childId) => slot.noteSpawned(childId),

package/dist/swarm.d.ts

@@ -15,6 +15,18 @@ export declare function parseSwarmHeader(text: string): SwarmMessage | null;
 export declare function renderSwarmHeader(header: SwarmHeader, role: string, payloadMarkdown: string): string;
 /** Read the `[swarm] enabled` flag from the workspace .onlyne/config.toml. */
 export declare function readSwarmEnabled(onlyneDir: string): boolean;
+/** Strip // line comments and trailing commas so jsonc parses as JSON. */
+export declare function stripJsonc(text: string): string;
+/** Read the model triple from the workspace .onlyne/swarm.workspace.jsonc snapshot. */
+export declare function readSwarmModel(onlyneDir: string): {
+    provider?: string;
+    model?: string;
+    effort?: string;
+} | null;
+/** Tree path of a workspace inside the swarm tree: the segment after the
+ * nearest `/.ws/` marker; the swarm root itself is "." .
+ * Pure function so quoting/edge cases are unit-tested without a live session. */
+export declare function treePathForWorkspace(workspaceRoot: string): string;
 /** Terminal handle for swarm_ready correlation (injected by the scheduler). */
 export declare function terminalHandle(): string;
 /** Task id injected by the scheduler via env (fallback before swarm_ready handshake). */

package/dist/swarm.js

@@ -89,6 +89,67 @@ export function readSwarmEnabled(onlyneDir) {
     catch { /* unreadable -> disabled */ }
     return false;
 }
+/** Strip // line comments and trailing commas so jsonc parses as JSON. */
+export function stripJsonc(text) {
+    const out = [];
+    let inStr = false;
+    let esc = false;
+    for (const line of text.split("\n")) {
+        let res = "";
+        for (let i = 0; i < line.length; i++) {
+            const c = line[i];
+            if (inStr) {
+                res += c;
+                if (esc)
+                    esc = false;
+                else if (c === "\\")
+                    esc = true;
+                else if (c === '"')
+                    inStr = false;
+                continue;
+            }
+            if (c === '"') {
+                inStr = true;
+                res += c;
+                continue;
+            }
+            if (c === "/" && line[i + 1] === "/")
+                break;
+            res += c;
+        }
+        out.push(res);
+    }
+    return out.join("\n").replace(/,(\s*[}\]])/g, "$1");
+}
+/** Read the model triple from the workspace .onlyne/swarm.workspace.jsonc snapshot. */
+export function readSwarmModel(onlyneDir) {
+    const path = join(onlyneDir, "swarm.workspace.jsonc");
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(stripJsonc(readFileSync(path, "utf8")));
+        const m = parsed?.model;
+        if (!m || typeof m !== "object")
+            return null;
+        const provider = typeof m.provider === "string" && m.provider ? m.provider : undefined;
+        const model = typeof m.model === "string" && m.model ? m.model : undefined;
+        const effort = typeof m.effort === "string" && m.effort ? m.effort : undefined;
+        if (!provider && !model)
+            return null;
+        return { provider, model, effort };
+    }
+    catch { /* malformed -> no model override */ }
+    return null;
+}
+/** Tree path of a workspace inside the swarm tree: the segment after the
+ * nearest `/.ws/` marker; the swarm root itself is "." .
+ * Pure function so quoting/edge cases are unit-tested without a live session. */
+export function treePathForWorkspace(workspaceRoot) {
+    const i = workspaceRoot.lastIndexOf("/.ws/");
+    if (i >= 0)
+        return workspaceRoot.slice(i + "/.ws/".length) || ".";
+    return ".";
+}
 /** Terminal handle for swarm_ready correlation (injected by the scheduler). */
 export function terminalHandle() {
     return process.env.ORCA_TERMINAL_HANDLE || process.env.ONLYNE_TERMINAL_HANDLE || "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-onlyne",
-  "version": "0.7.0",
+  "version": "0.7.3",
   "description": "Pi extension tools for sending messages through Onlyne.",
   "type": "module",
   "main": "./dist/index.js",