pi-onlyne 0.4.0 → 0.7.0

package/README.md

@@ -1,72 +1,107 @@
 # pi-onlyne
 
-**Give pi agents a real IM inbox/outbox through [Onlyne](https://github.com/dbydd/onlyne).**
+`pi-onlyne` gives [Pi](https://github.com/badlogic/pi-mono) agents a local IM inbox and outbox through [Onlyne](https://github.com/dbydd/onlyne). The extension connects Pi to an Onlyne workspace, exposes message tools, and delivers subscribed events as Pi follow-ups.
 
-`pi-onlyne` is the Pi extension for Onlyne. It adds tools and commands to pi so an agent can receive messages from IM channels and send replies without pretending that a chat platform is a terminal, a browser tab, or a custom workflow engine.
+## Runtime requirements
 
-## What is Onlyne?
+- Node.js 20 or newer
+- Pi 0.84 or newer with the `pi` command available in `PATH`
+- `onlyne` 0.4.x installed with `cargo install onlyne`, or a compatible local build
+- An initialized Onlyne workspace with `.onlyne/config.toml`
+- A configured model/provider for Pi agent replies
+- Unix domain socket support on the host
 
-[Onlyne](https://github.com/dbydd/onlyne) is a small workspace-local IM channel daemon. It runs in your project directory, keeps its config/state under `.onlyne/`, and brokers local agent calls to real messaging adapters such as Telegram, Feishu/Lark, QQ Bot, and WeChat.
+The extension supports macOS and Linux. Each workspace keeps daemon state, channel credentials, history, sockets, and logs under its own `.onlyne/` directory.
 
-Onlyne is deliberately narrow:
+## Install
 
-- local workspace daemon, not a global cloud service
-- channel broker, not an agent runtime
-- Unix socket / stdio friendly, not a web dashboard
-- local history and event stream, not a heavy message platform
+Install the published Pi package:
 
-## What does this extension do?
+```bash
+pi install npm:pi-onlyne
+```
 
-`pi-onlyne` connects pi to an existing Onlyne workspace and exposes Onlyne as native pi tools.
+Run it for one Pi process:
+
+```bash
+pi -e npm:pi-onlyne
+```
 
-Onlyne channels are singleton-routed: each enabled channel has one `bind_conversation_id` set in config or by sending `/handshake` from the desired conversation, so pi tools take `channelId` only.
+Install the package from a local checkout during development:
 
-With this extension, a pi agent can:
+```bash
+cd path/to/pi-onlyne
+npm install
+npm run check
+pi install .
+```
 
-- watch an Onlyne workspace for inbound IM messages
-- surface inbound messages into the current pi session
-- reply to the current inbound message
-- send a message to a channel's configured conversation
-- broadcast the same message to multiple conversations
-- inject a local loopback activation so background scripts can wake the session
-- share Onlyne's FIFO consume cursor so `.onlyne/channels/<channel>/out` does not re-read messages already surfaced to pi
-- mark an inbound message as intentionally not replied
+The package publishes `dist/`, `README.md`, `SPEC.md`, and `LICENSE`. `prepublishOnly` runs the build and test suite.
 
-Messages are Markdown by default, matching normal agent output. Use `rawText: true` only when the message must be sent literally. Onlyne can also expose FIFO IO under `.onlyne/channels/<channel>/in|out`; pi-onlyne stays on the socket/event API and advances the shared consume cursor after delivering inbound follow-ups.
+## Prepare an Onlyne workspace
 
-## Install
+Run these commands from the project that should receive the messages:
 
 ```bash
-pi install npm:pi-onlyne
+cargo install onlyne
+onlyne init
+onlyne export-skill
 ```
 
-For a one-off run without installing:
+Configure a channel in `.onlyne/config.toml` and place secrets in `.onlyne/.env`. Examples:
 
-```bash
-pi -e npm:pi-onlyne
+```toml
+[adapters.telegram]
+enabled = true
+
+[adapters.feishu]
+enabled = true
+
+[adapters.qqbot]
+enabled = true
+
+[adapters.wechat]
+enabled = true
 ```
 
-You also need an initialized Onlyne workspace:
+Use the matching `onlyne auth` command for Feishu, QQ Bot, or WeChat. Telegram uses `TELEGRAM_BOT_TOKEN` in `.onlyne/.env`. Bind a target conversation with `bind_conversation_id`, or send `/handshake` from the desired conversation after the adapter starts.
+
+Start the daemon from the project root:
 
 ```bash
-onlyne init
-# Optional: refresh the workspace-local agent skill
-onlyne export-skill
+onlyne run
 ```
 
-`pi-onlyne` can manage a workspace-local daemon for the current Pi session. Prefer `/onlyne daemon start|stop|restart` or `/onlyne watch on` over shelling out `onlyne run` manually. Do not combine plugin-managed daemons with ad-hoc `nohup onlyne run`, `pkill -f 'onlyne run'`, or global launchd/systemd jobs for the same workspace.
-
-## Typical workflow
+A Pi session can start or connect to the daemon through `/onlyne daemon start`.
+
+## Configure Pi behavior
+
+The extension reads `.pi/onlyne.json` from the current Pi project. The default configuration is:
+
+```json
+{
+  "watch": { "autoStart": false },
+  "inbound": { "defaultMode": "auto-handle", "rules": [] },
+  "outbound": {
+    "defaultReplyMode": "guarded-explicit",
+    "guardedExplicit": {
+      "reminders": 2,
+      "noOutputFallbackText": "Onlyne/Pi error: no valid reply was produced."
+    },
+    "retry": { "attempts": 2, "concurrency": 8 }
+  }
+}
+```
 
-1. Initialize/configure Onlyne in your project.
-2. Install this Pi extension.
-3. Start the workspace daemon and watch from pi:
+Enable automatic subscription when Pi starts:
 
-```text
-/onlyne watch on
+```json
+{
+  "watch": { "autoStart": true }
+}
 ```
 
-When a normal user message arrives through Onlyne, pi receives it as a follow-up message. Onlyne control messages such as `/handshake` are consumed silently. The agent can then call `onlyne_reply`, or deliberately call `onlyne_mark_no_reply`.
+The extension merges partial JSON with the defaults. `inbound.rules` accepts channel and optional conversation selectors with `auto-handle`, `queue-only`, or `muted` modes. `outbound.defaultReplyMode` accepts `guarded-explicit`, `explicit-only`, or `implicit-final`.
 
 ## Commands
 
@@ -78,12 +113,17 @@ When a normal user message arrives through Onlyne, pi receives it as a follow-up
 /onlyne watch on
 /onlyne watch off
 /onlyne config auto-start
+/onlyne swarm on
+/onlyne swarm off
+/onlyne swarm status
 ```
 
-`/onlyne` supports argument completions for `status`, `daemon start|stop|restart`, `watch on`, `watch off`, and `config auto-start`.
+`watch on` subscribes to the current workspace event stream. Incoming channel messages become Pi follow-ups. A normal inbound message receives `onlyne_reply`, and an intentional omission receives `onlyne_mark_no_reply`.
 
 ## Agent tools
 
+Normal mode:
+
 ```text
 onlyne_daemon_start()
 onlyne_daemon_stop()
@@ -95,22 +135,30 @@ onlyne_loopback({ text, rawText? })
 onlyne_mark_no_reply({ reason? })
 ```
 
-### Send one message
+Swarm mode (`[swarm] enabled`):
 
-```ts
-onlyne_send({
-  channelId: "telegram",
-  text: "# Build report\n\nAll checks passed."
-})
+```text
+onlyne_daemon_start()
+onlyne_daemon_stop()
+onlyne_daemon_restart()
+swarm_complete({ text })
+swarm_quit({ reason? })
+swarm_send({ to, text })
+swarm_status()
 ```
 
-### Send literal text
+One session sees one toolset, chosen at session start. Generic send/reply
+tools stay out of the swarm surface so unheaded writes cannot pollute the
+protocol.
+
+Messages use Markdown by default. `rawText: true` preserves literal text for scripts and protocol payloads.
+
+### Send one message
 
 ```ts
 onlyne_send({
   channelId: "telegram",
-  text: "# not a heading",
-  rawText: true
+  text: "# Build report\n\nAll checks passed."
 })
 ```
 
@@ -118,43 +166,72 @@ onlyne_send({
 
 ```ts
 onlyne_broadcast({
-  targets: [
-    { channelId: "telegram" },
-    { channelId: "feishu" }
-  ],
-  text: "# Release shipped\n\nVersion 0.3.4 is live."
+  targets: [{ channelId: "telegram" }, { channelId: "feishu" }],
+  text: "# Release shipped\n\nVersion 0.6.0 is live."
 })
 ```
 
 ### Loopback wake-up
 
-From any local script, inject an inbound message into the current Onlyne daemon:
+A local script can wake the current Pi session through the daemon socket:
 
 ```bash
 onlyne client '{"id":"wake","op":"loopback","text":"background job finished","raw_text":true}'
-# or, with FIFO IO enabled by the daemon:
-printf 'background job finished\n' > .onlyne/channels/loopback/in
 ```
 
-Pi treats channel `loopback` as wake-up-only: it sends a follow-up to the session, but does not expect `onlyne_reply`.
+The extension also supports `.onlyne/channels/loopback/in` when FIFO IO is enabled.
 
-## Local state
+## Swarm mode
 
-This extension stores its own pi-side config at:
+Swarm mode lets `onlyne-swarm` own task routing for a generated agent workspace. Enable it in `.onlyne/config.toml`:
 
-```text
-.pi/onlyne.json
+```toml
+[swarm]
+enabled = true
 ```
 
-Onlyne itself stores workspace state under:
+A swarm Pi session subscribes to loopback events, reports `swarm_ready`, accepts one hop atomically, spawns continuations with `swarm_send` (fire-and-forget), and exits with `swarm_complete` (done signal) or `swarm_quit` (silent, scheduler records failed). Downstream results travel through files and the ledger; nothing waits.
 
-```text
-.onlyne/
+For automatic startup in a generated workspace, add `.pi/onlyne.json`:
+
+```json
+{
+  "watch": { "autoStart": true },
+  "outbound": {
+    "defaultReplyMode": "explicit-only",
+    "retry": { "attempts": 4, "concurrency": 8 }
+  }
+}
 ```
 
-That keeps each project isolated: different workspaces can run different Onlyne daemons, channels, histories, and policies.
+The swarm scheduler starts Pi with normal extension discovery. The configured retry extension remains available in swarm sessions. See the [onlyne-swarm README](https://github.com/dbydd/onlyne-swarm) for the graph template, scheduler commands, Orca requirements, and test runner.
+
+## Local state and security
+
+Pi-side settings live at `.pi/onlyne.json`. Onlyne stores credentials, history, sockets, logs, and adapter state under `.onlyne/`. Keep `.onlyne/.env` private. Review package source before installing third-party extensions because Pi extensions run with the permissions of the Pi process.
+
+## Release notes
+
+This checkout is version 0.6.0 with swarm support already merged into the `dev` branch. npm currently publishes 0.4.0 as the latest tag. Run `npm run check` before any release so the build and tests regenerate `dist/`. Publish with `npm publish` after reviewing the generated tarball.
+
+## Development
+
+```bash
+npm install
+npm run check
+npm pack --dry-run
+```
+
+`npm run check` compiles TypeScript and runs the Node test suite. The tests cover configuration, workspace discovery, daemon connection, swarm header parsing, and the atomic swarm task slot.
 
 ## Links
 
-- Onlyne main repository: https://github.com/dbydd/onlyne
-- pi-onlyne package: https://www.npmjs.com/package/pi-onlyne
+- Onlyne: https://github.com/dbydd/onlyne
+- Onlyne documentation: https://github.com/dbydd/onlyne/tree/dev/docs
+- npm package: https://www.npmjs.com/package/pi-onlyne
+- pi-onlyne source: https://github.com/dbydd/pi-onlyne
+- onlyne-swarm: https://github.com/dbydd/onlyne-swarm
+
+## License
+
+MIT

package/SPEC.md

@@ -8,7 +8,7 @@ Pi extension for Onlyne. Onlyne remains a workspace-local IM broker; this extens
 
 - Watch is configurable; default manual.
 - `/onlyne` provides argument completions for its supported subcommands, including daemon lifecycle commands.
-- `watch on` connects to the workspace-local `.onlyne/run/onlyne.sock`; if unavailable, it starts a Pi-owned workspace daemon.
+- `watch on` connects to the workspace-local `.onlyne/run/s`; if unavailable, it starts a Pi-owned workspace daemon.
 - `/onlyne daemon start|stop|restart` is the preferred lifecycle surface. Agents must not use ad-hoc `nohup onlyne run`, `pkill -f 'onlyne run'`, or global launchd/systemd jobs when pi-onlyne owns the daemon.
 - Inbound events come from Onlyne `subscribe_events`; no polling.
 - Inbound mode is rule-based: `auto-handle`, `queue-only`, or `muted`.
@@ -38,11 +38,25 @@ Stored in project `.pi/onlyne.json`:
 
 ## Tools
 
+Normal mode (default):
+
 - `onlyne_reply({ text })`
 - `onlyne_send({ channelId, text, rawText? })`
 - `onlyne_broadcast({ targets, text, rawText? })`
 - `onlyne_loopback({ text, rawText? })`
 - `onlyne_mark_no_reply({ reason? })`
+- `onlyne_daemon_start/stop/restart`
+
+Swarm mode (`[swarm] enabled`, see below):
+
+- `swarm_complete({ text })`
+- `swarm_quit({ reason? })`
+- `swarm_send({ to, text })`
+- `swarm_status()`
+- `onlyne_daemon_start/stop/restart`
+
+One session sees one toolset. The surface is chosen at `session_start` from
+`[swarm]` and applied with `setActiveTools` when the Pi API exists.
 
 ## Deferred
 
@@ -50,3 +64,35 @@ Stored in project `.pi/onlyne.json`:
 - Auth QR/secret editing TUI.
 - Schedules.
 - Target groups.
+
+## Swarm mode (v2, amendment-1)
+
+- Switch: `/onlyne swarm on|off|status`. On/off persists to the workspace
+  `.onlyne/config.toml` `[swarm] enabled` flag and restarts watch. Status line
+  and `session_start` banner report `swarm` vs `ready`.
+- When swarm is on, generic in/out auto-handling is disabled: the scheduler owns
+  input/output. Only loopback messages carrying a `---swarm` body header enter
+  the session, via the `followUp` task queue.
+- Session model: one session carries exactly one hop, no exceptions. A new
+  header claims the slot; any further header while claimed is ignored
+  (the scheduler always opens a new session, so this guard never fires
+  on the normal path). No waiting, no callbacks, no parent bookkeeping.
+- Startup handshake: swarm watch sends the `swarm_ready` op
+  (`{workspace, terminal_handle}`) so the scheduler can match a pending task.
+  `ONLYNE_SWARM_TASK` env and `ORCA_TERMINAL_HANDLE`/`ONLYNE_TERMINAL_HANDLE`
+  provide fallback correlation.
+- Tools: `swarm_complete({text})` writes the out message carrying this hop's
+  header (the scheduler's done signal). `swarm_quit({reason?})` exits silently
+  (scheduler records failed). `swarm_send({to, text})` spawns a downstream
+  task with `transfer_send_to` set to the current task and returns the child
+  id without waiting. `swarm_status()` reports the current task and spawned
+  ids. Daemon lifecycle tools stay available in both modes.
+- Generic send/reply tools are not registered in the swarm surface: unheaded
+  or misheaded writes would pollute the protocol. All swarm IO goes through
+  the `swarm_*` tools, whose headers are constructed inside the plugin
+  (`renderSwarmHeader`).
+- Exit guard: at `agent_end` with an unfinished hop, one followUp reminder
+  fires; a second quiet window auto-runs `swarm_quit` (failed ledger row).
+- Body protocol lives in `src/swarm.ts` (`parseSwarmHeader`,
+  `renderSwarmHeader`, `readSwarmEnabled`); covered by `test/swarm.test.mjs`.
+  Old `reply_to` headers parse as ordinary (non-swarm) messages.

package/dist/index.js

@@ -1,11 +1,15 @@
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { broadcast, connectDaemon, loopback, markConsumed, sendWithRetry, shutdownDaemon, stopProcess, subscribe } from "./onlyne.js";
+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";
-const state = { cwd: process.cwd(), workspace: null, watching: false, owner: "stopped" };
+import { envTaskId, parseSwarmHeader, readSwarmEnabled, terminalHandle } 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 };
 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(() => { }); }
@@ -49,10 +53,28 @@ function scheduleReconnect(pi) {
         }
     }, 1000);
 }
+/** Swarm-mode inbound path: claim one hop, inject via followUp, never wait. */
+function handleSwarmInbound(pi, text, eventSeq) {
+    const parsed = parseSwarmHeader(text);
+    if (!parsed)
+        return false;
+    if (state.socket && eventSeq !== undefined)
+        void 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 = swarmSlot.handle(pi, text);
+    if (outcome === "claimed") {
+        const cur = swarmSlot.task();
+        state.swarmTask = { taskId: cur.taskId, from: cur.from, transferSendTo: cur.transferSendTo, attempt: cur.attempt };
+    }
+    return outcome === "claimed";
+}
 async function startWatch(pi) {
     state.workspace = findWorkspace(state.cwd);
     if (!state.workspace)
         throw new Error("current workspace has no .onlyne configuration");
+    refreshSwarmFlag();
     if (state.reconnectTimer)
         clearTimeout(state.reconnectTimer);
     state.reconnectTimer = undefined;
@@ -61,6 +83,32 @@ async function startWatch(pi) {
     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;
+        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;
+            handleSwarmInbound(pi, inbound.text, line.event_seq);
+        }, () => { if (state.socket === socket)
+            scheduleReconnect(pi); });
+        state.socket = socket;
+        state.watching = true;
+        const task = envTaskId();
+        try {
+            await swarmReady(ws.socketPath, ws.root, terminalHandle());
+        }
+        catch { /* scheduler may read env fallback */ }
+        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")
@@ -82,9 +130,9 @@ async function startWatch(pi) {
     return `watching ${state.workspace.root} (${state.owner})`;
 }
 function stopWatch() { if (state.reconnectTimer)
-    clearTimeout(state.reconnectTimer); state.reconnectTimer = undefined; clearReminder(); state.socket?.destroy(); state.socket = undefined; stopProcess(state.child); state.child = undefined; state.watching = false; state.owner = "stopped"; return "watch stopped"; }
+    clearTimeout(state.reconnectTimer); state.reconnectTimer = undefined; clearReminder(); state.socket?.destroy(); state.socket = undefined; stopProcess(state.child); state.child = undefined; 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"); 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}`; }
+    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}`; }
@@ -95,11 +143,77 @@ 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 ".". */
+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);
+}
+/** swarm_complete: hand over. Writes the out message carrying this hop's header (done signal). */
+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 res = await sendWithRetry(state.workspace.socketPath, { channelId: "loopback" }, wire, currentConfig().outbound.retry.attempts);
+    if (res.ok) {
+        state.swarmTask = undefined;
+        swarmSlot.clear();
+    }
+    return { ...res, taskId: task.taskId };
+}
+/** swarm_quit: silent exit. No out written; the scheduler records failed. */
+async function swarmQuit(reason) {
+    const task = state.swarmTask;
+    state.swarmTask = undefined;
+    swarmSlot.clear();
+    return { quit: true, taskId: task?.taskId, reason: reason ?? "" };
+}
+/** swarm_send: spawn downstream. New UUID, transfer_send_to = current task, fire-and-forget. */
+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 { 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).
+    const wsRoot = state.workspace.root;
+    const linkPath = to === "." || to === "_root"
+        ? join(wsRoot, "onlyne_in", "_root")
+        : join(wsRoot, "onlyne_in", ...to.split("/").filter(Boolean));
+    const resolved = resolve(wsRoot);
+    const linkDir = resolve(linkPath);
+    if (!linkDir.startsWith(resolved))
+        throw new Error(`invalid swarm_send target: ${to}`);
+    if (!existsSync(linkPath))
+        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);
+    }
+    catch (e) {
+        throw new Error(`swarm_send failed for ${to}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    swarmSlot.noteSpawned(childId);
+    return { childId, to };
+}
 export default function onlyne(pi) {
     pi.on("session_start", async (_event, 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; ctx.ui.setStatus("onlyne", state.workspace ? "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); 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");
         }
@@ -116,11 +230,14 @@ 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 () => scheduleReminder(pi));
+    pi.on("agent_end", async () => { if (state.swarm)
+        scheduleSwarmExitReminder(pi);
+    else
+        scheduleReminder(pi); });
     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"];
+            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;
@@ -139,7 +256,14 @@ export default function onlyne(pi) {
                 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}; workspace=${state.workspace?.root ?? "none"}`, "info");
+                    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;
@@ -147,13 +271,35 @@ export default function onlyne(pi) {
                     ctx.ui.notify(`autoStart=${cfg.watch.autoStart}`, "info");
                 }
                 else
-                    ctx.ui.notify("usage: /onlyne status | watch on|off | daemon start|stop|restart | config auto-start", "info");
+                    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 when pi-onlyne manages it, without shelling out to pkill/nohup.", 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 }); } }));
@@ -169,3 +315,63 @@ export default function onlyne(pi) {
             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: write a new task to onlyne_in/<to>/ with transfer_send_to set to the current task. Fire-and-forget; 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 })); } }));
+}
+/** 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) {
+            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 { 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]")) {
+        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)`;
+}

package/dist/onlyne.d.ts

@@ -10,6 +10,9 @@ export interface OnlyneRequest {
     format?: "plain" | "markdown";
     raw_text?: boolean;
     limit?: number;
+    priority?: number;
+    consume_timeout_ms?: number;
+    event_seq?: number;
 }
 export interface SendTarget {
     channelId: string;
@@ -19,7 +22,10 @@ export interface SendResult extends SendTarget {
     error?: string;
 }
 export declare function request(socketPath: string, req: OnlyneRequest): Promise<any>;
-export declare function subscribe(socketPath: string, onLine: (line: any) => void, onDisconnect?: () => void): Socket;
+export declare function subscribe(socketPath: string, onLine: (line: any) => void, onDisconnect?: () => void, opts?: {
+    priority?: number;
+    consumeTimeoutMs?: number;
+}): Socket;
 export declare function waitForSocket(socketPath: string, timeoutMs?: number): Promise<void>;
 export declare function connectDaemon(ws: Workspace, startIfMissing?: boolean): Promise<{
     owner: "external" | "extension";
@@ -27,6 +33,8 @@ export declare function connectDaemon(ws: Workspace, startIfMissing?: boolean):
 }>;
 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): Promise<any>;
+export declare function consumeEvent(socket: Socket, eventSeq: number): Promise<void>;
 export declare function loopback(socketPath: string, text: string, rawText?: boolean): 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): Promise<SendResult>;

package/dist/onlyne.js

@@ -18,7 +18,7 @@ export function request(socketPath, req) {
         } });
     });
 }
-export function subscribe(socketPath, onLine, onDisconnect) {
+export function subscribe(socketPath, onLine, onDisconnect, opts) {
     const socket = createConnection(socketPath);
     let buf = "";
     let closed = false;
@@ -28,7 +28,7 @@ export function subscribe(socketPath, onLine, onDisconnect) {
     socket.on("error", disconnect);
     socket.on("close", disconnect);
     socket.on("connect", () => { if (!socket.destroyed)
-        socket.write('{"id":"sub","op":"subscribe_events"}\n', () => { }); });
+        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)
@@ -109,6 +109,17 @@ export function stopProcess(child) { if (!child || child.killed)
     child.kill("SIGTERM");
 }
 catch { /* ignore */ } }
+export async function swarmReady(socketPath, workspace, terminalHandle) {
+    return request(socketPath, { id: `swarm-ready-${Date.now()}`, op: "swarm_ready", text: JSON.stringify({ workspace, terminal_handle: terminalHandle }) });
+}
+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) {
     return request(socketPath, { id: `loopback-${Date.now()}`, op: "loopback", text, raw_text: rawText });
 }

package/dist/swarm-slot.d.ts

@@ -0,0 +1,47 @@
+export type SwarmHandleResult = "claimed" | "not-swarm";
+export interface SwarmSlotMessage {
+    text: string;
+    deliverAs: "followUp";
+}
+export interface SwarmPi {
+    sendUserMessage: (text: 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): 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) => 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

@@ -0,0 +1,56 @@
+import { parseSwarmHeader } from "./swarm.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) {
+        const parsed = parseSwarmHeader(text);
+        if (!parsed)
+            return "not-swarm";
+        const { header, payload } = parsed;
+        if (!this.taskId) {
+            this.taskId = header.task_id;
+            this.from = header.from;
+            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" });
+            return "claimed";
+        }
+        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) => slot.handle(pi, text),
+        task: () => slot.task(),
+        taskId: () => slot.taskIdOf(),
+        noteSpawned: (childId) => slot.noteSpawned(childId),
+        clear: () => slot.clear(),
+    };
+}

package/dist/swarm.d.ts

@@ -0,0 +1,21 @@
+/** Swarm header carried in the message body (upper-layer protocol, see PROTOCOL.md). */
+export interface SwarmHeader {
+    task_id: string;
+    from: string;
+    transfer_send_to: string;
+    attempt: number;
+}
+export interface SwarmMessage {
+    header: SwarmHeader;
+    payload: string;
+}
+/** Parse a `---swarm` body header. Returns null for non-swarm messages. */
+export declare function parseSwarmHeader(text: string): SwarmMessage | null;
+/** Render a swarm body header in front of a Markdown payload. */
+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;
+/** 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). */
+export declare function envTaskId(): string;

package/dist/swarm.js

@@ -0,0 +1,99 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Parse a `---swarm` body header. Returns null for non-swarm messages. */
+export function parseSwarmHeader(text) {
+    const rest = text.startsWith("---swarm\n") ? text.slice("---swarm\n".length) : null;
+    if (rest === null)
+        return null;
+    let end = rest.indexOf("\n---\n");
+    let payload;
+    let headRaw;
+    if (end >= 0) {
+        headRaw = rest.slice(0, end);
+        payload = rest.slice(end + "\n---\n".length);
+    }
+    else if (rest.endsWith("\n---")) {
+        headRaw = rest.slice(0, rest.length - "\n---".length);
+        payload = "";
+    }
+    else {
+        const alt = rest.indexOf("\n---");
+        if (alt < 0)
+            return null;
+        headRaw = rest.slice(0, alt);
+        payload = rest.slice(alt + "\n---".length).replace(/^\n/, "");
+    }
+    let task_id;
+    let from = ".";
+    let transfer_send_to = "";
+    let attempt = 1;
+    let sawTransfer = false;
+    for (const line of headRaw.split("\n")) {
+        const t = line.trim();
+        if (!t || t.startsWith("#"))
+            continue;
+        const i = t.indexOf(":");
+        if (i < 0)
+            continue;
+        const k = t.slice(0, i).trim();
+        const v = t.slice(i + 1).trim().replace(/^["']|["']$/g, "");
+        if (k === "task_id")
+            task_id = v;
+        else if (k === "from")
+            from = v || ".";
+        else if (k === "transfer_send_to") {
+            transfer_send_to = v;
+            sawTransfer = true;
+        }
+        else if (k === "reply_to")
+            return null;
+        else if (k === "attempt")
+            attempt = Number.parseInt(v, 10) || 1;
+    }
+    if (!sawTransfer)
+        return null;
+    if (!task_id || !UUID_RE.test(task_id.trim()))
+        return null;
+    return { header: { task_id: task_id.trim(), from, transfer_send_to, attempt }, payload };
+}
+/** Render a swarm body header in front of a Markdown payload. */
+export function renderSwarmHeader(header, role, payloadMarkdown) {
+    let s = `---swarm\ntask_id: ${header.task_id}\nfrom: ${header.from}\ntransfer_send_to: ${header.transfer_send_to}\nattempt: ${header.attempt}\n---\n`;
+    if (role)
+        s += `## role: ${role}\n\n${role}\n`;
+    s += payloadMarkdown;
+    if (!s.endsWith("\n"))
+        s += "\n";
+    return s;
+}
+/** Read the `[swarm] enabled` flag from the workspace .onlyne/config.toml. */
+export function readSwarmEnabled(onlyneDir) {
+    const path = join(onlyneDir, "config.toml");
+    if (!existsSync(path))
+        return false;
+    try {
+        const text = readFileSync(path, "utf8");
+        let inSwarm = false;
+        for (const line of text.split("\n")) {
+            const t = line.trim();
+            if (t.startsWith("[")) {
+                inSwarm = t === "[swarm]";
+                continue;
+            }
+            if (inSwarm && t.startsWith("enabled")) {
+                return /=?\s*true\b/.test(t);
+            }
+        }
+    }
+    catch { /* unreadable -> disabled */ }
+    return false;
+}
+/** Terminal handle for swarm_ready correlation (injected by the scheduler). */
+export function terminalHandle() {
+    return process.env.ORCA_TERMINAL_HANDLE || process.env.ONLYNE_TERMINAL_HANDLE || "";
+}
+/** Task id injected by the scheduler via env (fallback before swarm_ready handshake). */
+export function envTaskId() {
+    return process.env.ONLYNE_SWARM_TASK || "";
+}

package/dist/workspace.js

@@ -5,7 +5,7 @@ export function findWorkspace(start) {
     for (;;) {
         const onlyneDir = join(dir, ".onlyne");
         if (existsSync(onlyneDir))
-            return { root: dir, onlyneDir, socketPath: join(onlyneDir, "run", "onlyne.sock") };
+            return { root: dir, onlyneDir, socketPath: join(onlyneDir, "run", "s") };
         const parent = dirname(dir);
         if (parent === dir)
             return null;

package/package.json

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