@paradow/ledge 0.12.1 → 0.13.0

package/dist/cli/{attach-UWADG6NX.js → attach-PJHKOS4N.js}

@@ -1,13 +1,14 @@
 import {
   attachEnv
-} from "./chunk-ZNRXLDSH.js";
+} from "./chunk-ZSKCV73V.js";
 import {
   connect
-} from "./chunk-XXFUYME7.js";
-import "./chunk-X34LPKG7.js";
+} from "./chunk-SVVQ5KPJ.js";
+import "./chunk-5XFBRTKO.js";
 import {
-  PROTOCOL_PORT
-} from "./chunk-VY45MACP.js";
+  PROTOCOL_PORT,
+  backendOf
+} from "./chunk-PPRB4XIX.js";
 import {
   realTmux
 } from "./chunk-ZEHTNFPV.js";
@@ -24,6 +25,17 @@ function attachInherit(args, env) {
     child.on("exit", (c) => resolve(c ?? 1));
   });
 }
+async function nativeSession(id, port) {
+  try {
+    const c = await connect({ port, timeoutMs: 800 });
+    const snap = await c.next("snapshot");
+    await Promise.race([c.close(), new Promise((r) => setTimeout(r, 500))]);
+    const s = snap.sessions.find((x) => x.id === id);
+    return s && backendOf(s) === "omp-rpc" ? s.name : null;
+  } catch {
+    return null;
+  }
+}
 async function attach(id, opts = {}) {
   if (!id) {
     console.error("ledge attach: missing session id");
@@ -32,7 +44,8 @@ async function attach(id, opts = {}) {
   const tmux = realTmux(opts.tmuxSocket ?? TMUX_SOCKET);
   const tmuxName = `ledge-${id}`;
   if (!await tmux.hasSession(tmuxName)) {
-    console.error(`ledge attach: no session ${id}`);
+    const native = await nativeSession(id, opts.port ?? PROTOCOL_PORT);
+    console.error(native ? `ledge attach: ${native} is driven by Ledge over OMP's own protocol: there is no terminal to attach to (open a shell from the app)` : `ledge attach: no session ${id}`);
     return 1;
   }
   let title = tmuxName;

package/dist/cli/{bridge-53ZTDSST.js → bridge-VQZCDSQE.js}

@@ -7,7 +7,7 @@ import {
   parseClientMessage,
   parseServerMessage,
   readDaemonToken
-} from "./chunk-VY45MACP.js";
+} from "./chunk-PPRB4XIX.js";
 import "./chunk-FGOFRWIB.js";
 
 // src/cli/bridge.ts

package/dist/cli/{chunk-X34LPKG7.js → chunk-5XFBRTKO.js}

@@ -1,6 +1,6 @@
 import {
   pickName
-} from "./chunk-VY45MACP.js";
+} from "./chunk-PPRB4XIX.js";
 import {
   paths
 } from "./chunk-FGOFRWIB.js";
@@ -126,7 +126,7 @@ function claudeToolAnswered(path, id) {
 // src/spawn.ts
 import { basename, join as join2 } from "path";
 import { randomBytes, randomUUID } from "crypto";
-var AGENT_BIN = { claude: "claude", codex: "codex", cursor: "cursor-agent" };
+var AGENT_BIN = { claude: "claude", codex: "codex", cursor: "cursor-agent", omp: "omp" };
 var CODEX_ENV_VAR = "LEDGE_CODEX_SESSION";
 var CODEX_HOOK_VAR = "LEDGE_CODEX_HOOK_SESSION";
 function agentIdArgs(tool, id) {
@@ -190,6 +190,7 @@ export {
   CODEX_ENV_VAR,
   CODEX_HOOK_VAR,
   exitFile,
+  PARENT_AGENT_VARS,
   agentEnv,
   spawnSession
 };

package/dist/cli/{chunk-FRGNPUDO.js → chunk-7XZNRFWJ.js}

@@ -1,9 +1,9 @@
 import {
   connect
-} from "./chunk-XXFUYME7.js";
+} from "./chunk-SVVQ5KPJ.js";
 import {
   isArchived
-} from "./chunk-VY45MACP.js";
+} from "./chunk-PPRB4XIX.js";
 
 // src/cli/who.ts
 import { basename } from "path";

package/dist/cli/{chunk-A7YEHYLY.js → chunk-FXI2EE52.js}

@@ -1,10 +1,10 @@
 import {
   connect,
   sendMessageAndAwaitAck
-} from "./chunk-XXFUYME7.js";
+} from "./chunk-SVVQ5KPJ.js";
 import {
   CODEX_HOOK_VAR
-} from "./chunk-X34LPKG7.js";
+} from "./chunk-5XFBRTKO.js";
 
 // src/cli/send.ts
 import { randomUUID } from "crypto";

package/dist/cli/{chunk-QAEH5TJB.js → chunk-IOASI5FF.js}

@@ -1,7 +1,7 @@
 import {
   cleanTopic,
   sessionTitle
-} from "./chunk-VY45MACP.js";
+} from "./chunk-PPRB4XIX.js";
 
 // src/daemon/crossSession.ts
 var FIRST_LINE = /^Another Claude session sent a message:\s*\n/;
@@ -101,6 +101,9 @@ function pendingFor(ev) {
   if (ev.name === "Notification" && ev.kind === "permission") {
     return { kind: "permission", text: ev.text ?? "", source: "hook" };
   }
+  if (ev.name === "NativeRequest") {
+    return { kind: "question", text: ev.text ?? "", ...ev.options?.length ? { options: ev.options } : {}, ...ev.questions ? { questions: ev.questions } : {}, ...ev.requestId ? { requestId: ev.requestId } : {}, source: "rpc", tool: "omp" };
+  }
   if (ev.name === "PanePrompt") {
     return { kind: ev.kind ?? "permission", text: ev.text ?? "", ...ev.body ? { body: ev.body } : {}, options: ev.options, ...details(ev), source: "pane" };
   }
@@ -295,6 +298,16 @@ function reduceEvent(s, ev) {
       const state = pending.kind === "question" ? "waiting_input" : "waiting_permission";
       return { ...s, state, pending, lastActivityAt: at };
     }
+    case "QueueUpdate": {
+      const { queue: _q, ...rest } = s;
+      return ev.queue?.length ? { ...rest, queue: ev.queue } : s.queue ? rest : s;
+    }
+    case "AgentMessage":
+      return s.lastActivityAt === at ? s : { ...s, lastActivityAt: at };
+    case "NativeRequest": {
+      if (s.pending) return s;
+      return { ...s, state: "waiting_input", pending: pendingFor(ev), lastActivityAt: at };
+    }
     case "SessionStart":
     case "UserPromptSubmit":
     case "PreToolUse":
@@ -302,6 +315,7 @@ function reduceEvent(s, ev) {
     case "Notification": {
       const notice2 = ev.name === "UserPromptSubmit" && !!ev.text && !!crossSessionNotices(ev.text);
       if (ev.name === "UserPromptSubmit" && ev.text && !s.topic && !notice2 && !crossSession(ev.text)) s = withTopic(s, ev.text, "prompt");
+      if (s.pending?.source === "rpc" && ev.name === "PreToolUse") return { ...s, lastHookAt: at, lastActivityAt: at };
       const incoming = pendingFor(ev);
       if (incoming) {
         if (ev.name === "Notification" && s.pending) return { ...s, lastHookAt: at, lastActivityAt: at };

package/dist/cli/chunk-LMQADKT7.js

@@ -0,0 +1,6 @@
+// src/version.ts
+var LEDGE_VERSION = true ? "0.13.0" : "0.0.0-dev";
+
+export {
+  LEDGE_VERSION
+};

package/dist/cli/{chunk-VY45MACP.js → chunk-PPRB4XIX.js}

@@ -4,8 +4,16 @@ import {
 
 // ../protocol/src/session.ts
 import { z } from "zod";
-var ToolSchema = z.enum(["claude", "codex", "cursor"]);
+var ToolSchema = z.enum(["claude", "codex", "cursor", "omp"]);
+var BackendSchema = z.enum(["tmux", "omp-rpc"]);
 var SessionStateSchema = z.enum(["starting", "working", "waiting_input", "waiting_permission", "idle", "exited", "error"]);
+var AskQuestionSchema = z.object({
+  id: z.string(),
+  question: z.string(),
+  header: z.string().optional(),
+  multi: z.boolean().optional(),
+  options: z.array(z.object({ label: z.string(), description: z.string().optional() }))
+});
 var PendingSchema = z.object({
   kind: z.enum(["question", "permission", "plan", "diff"]),
   text: z.string(),
@@ -15,7 +23,11 @@ var PendingSchema = z.object({
   options: z.array(z.string()).optional(),
   /** Each option's description, by index ('' when it has none); left out when no option has one. */
   optionDetails: z.array(z.string()).optional(),
-  source: z.enum(["hook", "pane"]),
+  /** `rpc`: the harness's own protocol asked (OMP): answered on its request id, never by typing. */
+  source: z.enum(["hook", "pane", "rpc"]),
+  /** OMP: every question of one `ask` call, answered together with `session.answer`; `requestId` is the dialog it answers. */
+  questions: z.array(AskQuestionSchema).optional(),
+  requestId: z.string().optional(),
   /** Set when the request comes from a helper (subagent): it is routed through its parent. */
   helperId: z.string().optional(),
   /** For a helper-routed request: the state the parent returns to once it is answered (main thread may stop meanwhile). */
@@ -60,9 +72,13 @@ var SessionSchema = z.object({
   /** The folder the agent works in now, as its last hook reported it: `cwd` stays where it started, this follows a worktree it entered. */
   workdir: z.string().optional(),
   tmuxSession: z.string().nullable(),
+  /** Left out for a tmux session. `omp-rpc`: no pane, nothing to attach to; the daemon holds the process (see `agentSessionFile`). */
+  backend: BackendSchema.optional(),
   state: SessionStateSchema,
   pending: PendingSchema.optional(),
   helpers: z.array(HelperSchema).default([]),
+  /** OMP: the instructions waiting in its own queue (typed while it works), as it reports them; left out when none. */
+  queue: z.array(z.object({ text: z.string(), mode: z.enum(["steer", "follow_up"]) })).optional(),
   lastReply: ReplySchema.optional(),
   /** The last message this session sent to another agent: its tool_use_id, the address, the peer's Ledge session id, a one-line summary. */
   lastMessage: z.object({ id: z.string(), to: z.string(), peer: z.string().optional(), summary: z.string(), at: z.string().datetime() }).optional(),
@@ -72,8 +88,12 @@ var SessionSchema = z.object({
   /** The model and effort Ledge launched the agent with (#58); left out, the agent's own default. */
   model: z.string().optional(),
   effort: z.string().optional(),
+  /** A model change asked while the agent worked (`session.model`), applied at its next free moment; a field left out is the agent's default. */
+  modelNext: z.object({ model: z.string().optional(), effort: z.string().optional() }).optional(),
   /** The agent's own session id when Ledge chose it at launch (Claude Code `--session-id`). */
   agentSessionId: z.string().optional(),
+  /** OMP: the exact journal file of the conversation, what a resume names (never "the latest of the folder"). */
+  agentSessionFile: z.string().optional(),
   /** The agent's transcript: the latest one a hook named (it follows /clear and --resume), else the one the launch implies. */
   transcriptPath: z.string().optional(),
   exitCode: z.number().int().nullable().optional(),
@@ -85,6 +105,9 @@ var SessionSchema = z.object({
   /** When the session was last taken out of the archive: the poller's retirement clock restarts from it, not from `exitedAt`. */
   restoredAt: z.string().datetime().optional()
 });
+function backendOf(s) {
+  return s.backend ?? "tmux";
+}
 function isArchived(s) {
   return s.archivedAt !== void 0;
 }
@@ -279,8 +302,9 @@ var IslandScaleSchema = z10.union([z10.literal("auto"), z10.literal(1), z10.lite
 var IslandPrefsSchema = z10.object({
   /** Shown at the top of the screen; hidden, Desktop still notifies. */
   visible: z10.boolean(),
-  /** The primary screen, or the first other one. */
-  screen: z10.enum(["primary", "second"]),
+  /** `primary` (whichever it is after a reconfiguration), or a monitor's id as the shell lists it (`list_monitors`: the OS
+   *  name, `#index` without one). `second`, written by older fronts, is the first monitor that is not the primary. */
+  screen: z10.string().trim().min(1).max(200),
   position: z10.enum(["center", "left", "right"]),
   /** A strip under a maximised window. */
   discreet: z10.boolean(),
@@ -406,7 +430,9 @@ var NOTE_NOT_TYPED = "note_not_typed";
 var DECISION_OFFERS = {
   claude: { always: ["permission", "diff", "plan"], note: ["permission", "diff", "plan"] },
   codex: { always: ["permission", "diff"], note: ["permission", "diff", "plan"] },
-  cursor: { always: [], note: ["permission", "plan"] }
+  cursor: { always: [], note: ["permission", "plan"] },
+  /** OMP answers its own native requests (spec 2026-10-20 §3.3): no « always », no note until those are typed. */
+  omp: { always: [], note: [] }
 };
 function offers(tool, kind, what) {
   return DECISION_OFFERS[tool][what].includes(kind);
@@ -430,7 +456,7 @@ function pendingKey(p) {
 // ../protocol/src/messages.ts
 var PROTOCOL_PORT = 47831;
 var SessionEventSchema = z14.object({
-  name: z14.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed"]),
+  name: z14.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed", "NativeRequest", "AgentMessage", "QueueUpdate"]),
   at: z14.string().datetime(),
   source: z14.enum(["hook", "pane", "daemon"]),
   tool: z14.string().optional(),
@@ -447,6 +473,16 @@ var SessionEventSchema = z14.object({
   task: z14.string().optional(),
   /** PostToolUseFailure: the user interrupted the turn (Esc); Claude then waits for input with no Stop. */
   interrupt: z14.boolean().optional(),
+  /** QueueUpdate: OMP's queue as it stands. */
+  queue: z14.array(z14.object({ text: z14.string(), mode: z14.enum(["steer", "follow_up"]) })).optional(),
+  /** AgentMessage: the harness's own message, its text so far (`streaming`) or whole. `messageId` is unique for the session's life. */
+  messageId: z14.string().optional(),
+  streaming: z14.boolean().optional(),
+  /** NativeRequest: the dialog's id, and OMP's `ask` questions when it is one. */
+  requestId: z14.string().optional(),
+  questions: z14.array(AskQuestionSchema).optional(),
+  /** Stop: its text is already in the thread as AgentMessage cards, which the reply card must not repeat. */
+  streamed: z14.boolean().optional(),
   /** Native tracking (spec 2026-10-13 §2): the harness's id of the tool call, so its result lands on the same row. */
   toolUseId: z14.string().optional(),
   /** The tool's input as the harness gave it, every string capped by the hook. */
@@ -474,6 +510,10 @@ var DaemonInfoSchema = z14.object({
   archive: z14.boolean().optional(),
   /** Takes `model` and `effort` on `session.launch` and answers `models.list` (#58). */
   models: z14.boolean().optional(),
+  /** Drives OMP over its RPC: launching `omp` sessions is possible when the binary is there (`models.list` says so). */
+  omp: z14.boolean().optional(),
+  /** Takes `session.model`: a live session's model and effort changed (#58, lot 2). */
+  modelSwitch: z14.boolean().optional(),
   /** Its home folder, so a client shows the folders under it as `~` (absent from older daemons). */
   home: z14.string().optional()
 });
@@ -490,6 +530,8 @@ var ServerMessageSchema = z14.discriminatedUnion("type", [
    *  from daemons older than the auto-update. */
   z14.object({ type: z14.literal("snapshot"), sessions: z14.array(SessionSchema), recents: z14.array(RecentSchema).optional(), launcher: z14.array(z14.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
   z14.object({ type: z14.literal("session.updated"), session: SessionSchema }),
+  /** OMP: the instructions taken back from its queue by an interrupt that restores it; the asker puts them back in its draft. */
+  z14.object({ type: z14.literal("session.queue.restored"), id: z14.string(), texts: z14.array(z14.string()) }),
   z14.object({ type: z14.literal("session.removed"), id: z14.string() }),
   z14.object({ type: z14.literal("session.preview"), id: z14.string(), lines: z14.array(z14.string()) }),
   /** A session's thread, on request (spec 2026-10-13 §5); then each created or updated item, broadcast. */
@@ -588,7 +630,10 @@ var ClientMessageSchema = z14.discriminatedUnion("type", [
     machineId: z14.string().optional(),
     requestId: z14.string().min(1).max(100).optional()
   }),
-  z14.object({ type: z14.literal("session.reply"), id: z14.string(), text: z14.string().min(1) }),
+  /** `steer`: OMP only, redirect the turn running now instead of queueing the text after it. */
+  /** OMP's `ask`: the answers to every question of the dialog `requestId`, in order (`selected` labels, and/or free `text`); `cancel` declines it. */
+  z14.object({ type: z14.literal("session.answer"), id: z14.string(), requestId: z14.string().min(1).max(200), answers: z14.array(z14.object({ id: z14.string(), selected: z14.array(z14.string().max(2e3)).max(100), text: z14.string().max(2e4).optional() })).max(50), cancel: z14.boolean().optional() }),
+  z14.object({ type: z14.literal("session.reply"), id: z14.string(), text: z14.string().min(1), steer: z14.boolean().optional() }),
   /** The chat card's instruction (spec 2026-10-12 relay §4): sent now if the session is free, else queued until it is. */
   z14.object({ type: z14.literal("session.relay"), qid: z14.string().min(1) }),
   /** Takes the card's queued instruction back out of the queue. */
@@ -605,7 +650,8 @@ var ClientMessageSchema = z14.discriminatedUnion("type", [
   }),
   z14.object({ type: z14.literal("session.focus"), id: z14.string() }),
   z14.object({ type: z14.literal("session.kill"), id: z14.string() }),
-  z14.object({ type: z14.literal("session.interrupt"), id: z14.string() }),
+  /** `restoreQueue` (OMP): also take back what waits in its queue, returned as `session.queue.restored` to put in the draft. */
+  z14.object({ type: z14.literal("session.interrupt"), id: z14.string(), restoreQueue: z14.boolean().optional() }),
   /** Removes a finished (exited) or read-only (hook_only) session from the list; refused for a live launcher session. */
   z14.object({ type: z14.literal("session.dismiss"), id: z14.string() }),
   /** Puts a session in the archive: it leaves the live list but is kept. */
@@ -614,6 +660,9 @@ var ClientMessageSchema = z14.discriminatedUnion("type", [
   z14.object({ type: z14.literal("session.restore"), id: z14.string() }),
   /** Starts the agent again on an archived session's conversation. */
   z14.object({ type: z14.literal("session.resume"), id: z14.string() }),
+  /** Changes a live session's model and effort (#58, lot 2), `null` for the agent's own default: the daemon restarts the
+   *  agent on the same conversation with them, at once when the session is free, else at its next free moment. */
+  z14.object({ type: z14.literal("session.model"), id: z14.string(), model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
   /** Deletes a session for good, archived or not. */
   z14.object({ type: z14.literal("session.delete"), id: z14.string() }),
   /** The user names the session's topic from the overlay (500 characters at most, the hook's prompt cap); an empty topic hands back to the automatic sources. */
@@ -905,6 +954,7 @@ function readDaemonToken() {
 
 export {
   SessionSchema,
+  backendOf,
   isArchived,
   MAX_PROPOSALS,
   proposalRows,

package/dist/cli/{chunk-XXFUYME7.js → chunk-SVVQ5KPJ.js}

@@ -4,7 +4,7 @@ import {
   SUMMARY_MAX,
   parseServerMessage,
   readDaemonToken
-} from "./chunk-VY45MACP.js";
+} from "./chunk-PPRB4XIX.js";
 
 // src/client.ts
 import WebSocket from "ws";

package/dist/cli/{chunk-ZNRXLDSH.js → chunk-ZSKCV73V.js}

@@ -1,14 +1,14 @@
 import {
   DaemonRefusedError,
   connect
-} from "./chunk-XXFUYME7.js";
+} from "./chunk-SVVQ5KPJ.js";
 import {
   exitFile,
   spawnSession
-} from "./chunk-X34LPKG7.js";
+} from "./chunk-5XFBRTKO.js";
 import {
   PROTOCOL_PORT
-} from "./chunk-VY45MACP.js";
+} from "./chunk-PPRB4XIX.js";
 import {
   realTmux
 } from "./chunk-ZEHTNFPV.js";