jeo-code 0.12.6 → 0.12.8

package/src/agent/notify/session-endpoint.ts

@@ -44,6 +44,7 @@ import * as fs from "node:fs/promises";
 import type { Server, ServerWebSocket } from "bun";
 import { readGlobalConfig } from "../state";
 import { notifySessionEndpointPath, notifySessionsDir } from "./paths";
+import { resolveDiscordArtifactStage, type DiscordArtifactPaths } from "./discord-artifacts";
 import type { SubagentRecord, SubagentRegistry } from "../subagent-registry";
 
 const SNAPSHOT_POLL_MS = 1_200;
@@ -75,6 +76,13 @@ export class SessionNotifyEndpoint {
   private server: Server<undefined> | undefined;
 
   private readonly sockets = new Set<ServerWebSocket<undefined>>();
+  private readonly relaySockets = new Set<ServerWebSocket<undefined>>();
+  private readonly pendingRelay = new Map<ServerWebSocket<undefined>, number>();
+  private relayRequestGeneration = 0;
+  private readonly remoteControllers = new Map<ServerWebSocket<undefined>, { reqId: string; controller: AbortController }>();
+  private relayGeneration = 0;
+  private discordControlEnabled = false;
+  private discordControlGeneration = 0;
   private pollTimer: ReturnType<typeof setInterval> | undefined;
   private lastSnapshotJson = "";
   /** `undefined` between turns — subagent requests report an empty registry. */
@@ -85,6 +93,8 @@ export class SessionNotifyEndpoint {
 
   /** Registered by launch.ts; absent or rejected handlers return a failed ACK. */
   onUserMessage: ((msg: RemoteUserMessage) => void | boolean | Promise<void | boolean>) | undefined;
+  onRemoteRequest: ((text: string, finish: (text?: string, artifactsAllowed?: boolean) => void, signal: AbortSignal, stage?: DiscordArtifactPaths) => boolean) | undefined;
+  onRegistryMutation: (() => void) | undefined;
   onConfigCommand: ((cmd: RemoteConfigCommand) => void) | undefined;
 
   constructor(
@@ -153,6 +163,61 @@ export class SessionNotifyEndpoint {
     this.broadcast(JSON.stringify({ type: "turn_stream", sessionId: this.sessionId, phase: "finalized", text }));
   }
 
+  /** Revoke current subscriptions before asking a daemon to change destination. */
+  requestLocalRelay(destination: string): number {
+    this.relaySockets.clear();
+    this.relayGeneration++;
+    this.pendingRelay.clear();
+    const generation = ++this.relayRequestGeneration;
+    const json = JSON.stringify({ type: "local_relay_control", sessionId: this.sessionId, destination, generation });
+    let sent = 0;
+    for (const ws of this.sockets) {
+      try { if (ws.send(json) > 0) { if (destination !== "off") this.pendingRelay.set(ws, generation); sent++; continue; } } catch {}
+      this.sockets.delete(ws);
+      this.remoteControllers.get(ws)?.controller.abort();
+      this.remoteControllers.delete(ws);
+      try { ws.terminate(); } catch { try { ws.close(); } catch {} }
+    }
+    return sent;
+  }
+
+  /** Snapshot eligibility before a turn; changes invalidate its relay. */
+  localRelayGeneration(): number | undefined {
+    return this.relaySockets.size ? this.relayGeneration : undefined;
+  }
+
+  sendLocalFinal(text: string, generation: number): void {
+    if (generation !== this.relayGeneration) return;
+    const json = JSON.stringify({ type: "local_final", sessionId: this.sessionId, text });
+    for (const ws of this.relaySockets) {
+      try { ws.send(json); } catch {}
+    }
+  }
+
+  private sendDiscordControl(ws: ServerWebSocket<undefined>): void {
+    try {
+      const frame = JSON.stringify({ type: "discord_control", sessionId: this.sessionId, enabled: this.discordControlEnabled, generation: this.discordControlGeneration });
+      if (ws.send(frame) > 0) return;
+    } catch {}
+    this.sockets.delete(ws);
+    this.pendingRelay.delete(ws);
+    if (this.relaySockets.delete(ws)) this.relayGeneration++;
+    this.remoteControllers.get(ws)?.controller.abort();
+    this.remoteControllers.delete(ws);
+    try { ws.terminate(); } catch { try { ws.close(); } catch {} }
+  }
+
+  setDiscordControlEnabled(enabled: boolean): void {
+    if (enabled === this.discordControlEnabled) return;
+    this.discordControlEnabled = enabled;
+    this.discordControlGeneration++;
+    for (const ws of this.sockets) this.sendDiscordControl(ws);
+    if (!enabled) {
+      for (const remote of this.remoteControllers.values()) remote.controller.abort();
+      this.remoteControllers.clear();
+    }
+  }
+
   private async handleMessage(ws: ServerWebSocket<undefined>, raw: string | Buffer): Promise<void> {
     if (Buffer.byteLength(raw) > MAX_INBOUND_BYTES) return;
     let msg: Record<string, unknown>;
@@ -162,25 +227,71 @@ export class SessionNotifyEndpoint {
       return;
     }
     if (!msg || typeof msg !== "object" || Array.isArray(msg)) return;
-    if (msg.sessionId !== undefined && msg.sessionId !== this.sessionId) return;
+    if (msg.type !== "remote_request" && msg.sessionId !== undefined && msg.sessionId !== this.sessionId) return;
+    if (msg.type === "remote_request") {
+      const reqId = msg.reqId;
+      let ok = false;
+      const onlyExpectedFields = Object.keys(msg).every(key => ["type", "sessionId", "reqId", "text", "staged", "controlGeneration"].includes(key));
+      if (onlyExpectedFields && this.discordControlEnabled && msg.controlGeneration === this.discordControlGeneration && msg.sessionId === this.sessionId && typeof reqId === "string" && reqId.length > 0 && reqId.length <= 256 &&
+          typeof msg.text === "string" && !!msg.text.trim() && !msg.text.includes("\u0003") && !/^[\/!$]/.test(msg.text.trimStart()) && (msg.staged === undefined || msg.staged === true) && this.onRemoteRequest && !this.remoteControllers.has(ws)) {
+        let finished = false;
+        const controlGeneration = this.discordControlGeneration;
+        const controller = new AbortController();
+        this.remoteControllers.set(ws, { reqId, controller });
+        let stage: DiscordArtifactPaths | undefined;
+        const finish = (text?: string, artifactsAllowed = false): void => {
+          if (finished) return;
+          finished = true;
+          if (this.remoteControllers.get(ws)?.controller === controller) this.remoteControllers.delete(ws);
+          if (!this.sockets.has(ws)) return;
+          if (!this.discordControlEnabled || controller.signal.aborted || controlGeneration !== this.discordControlGeneration) text = undefined;
+          if (!stage) artifactsAllowed = false;
+          try { ws.send(JSON.stringify({ type: "remote_final", sessionId: this.sessionId, reqId, controlGeneration, ok: text !== undefined, artifactsAllowed: text !== undefined && artifactsAllowed, ...(text !== undefined ? { text } : {}) })); } catch {}
+        };
+        try {
+          if (msg.staged === true) stage = await resolveDiscordArtifactStage(this.sessionId, reqId);
+          if (this.discordControlEnabled && controlGeneration === this.discordControlGeneration && !controller.signal.aborted && this.sockets.has(ws)) {
+            ok = this.onRemoteRequest(msg.text, finish, controller.signal, stage);
+          }
+        } catch {}
+        if (!ok && this.remoteControllers.get(ws)?.controller === controller) this.remoteControllers.delete(ws);
+      }
+      try { ws.send(JSON.stringify({ type: "ack", reqId, ok })); } catch {}
+      return;
+    }
+    if (msg.type === "remote_cancel" && msg.sessionId === this.sessionId && typeof msg.reqId === "string") {
+      const remote = this.remoteControllers.get(ws);
+      if (remote?.reqId === msg.reqId) remote.controller.abort();
+      return;
+    }
+    if (msg.type === "local_relay" && msg.sessionId === this.sessionId && typeof msg.enabled === "boolean") {
+      const allowed = !msg.enabled || (typeof msg.generation === "number" && this.pendingRelay.get(ws) === msg.generation && msg.generation === this.relayRequestGeneration);
+      if (allowed && msg.enabled) this.relaySockets.add(ws);
+      else if (!msg.enabled) this.relaySockets.delete(ws);
+      if (allowed) { this.pendingRelay.delete(ws); this.relayGeneration++; }
+      try { ws.send(JSON.stringify({ type: "ack", reqId: msg.reqId, ok: allowed })); } catch {}
+      return;
+    }
     if (msg.type === "list") {
       try {
         ws.send(JSON.stringify(this.snapshot()));
       } catch {}
       return;
     }
-    if (msg.type === "steer") {
+    if (msg.type === "steer" || msg.type === "discord_steer") {
       const id = typeof msg.id === "string" ? msg.id : "";
       const message = typeof msg.message === "string" ? msg.message : "";
-      const ok = !!(id && message && this.registry?.steer(id, message));
+      const ok = !!((msg.type === "steer" || (this.discordControlEnabled && msg.sessionId === this.sessionId && msg.controlGeneration === this.discordControlGeneration)) && id && message && this.registry?.steer(id, message));
+      if (ok) this.onRegistryMutation?.();
       try {
         ws.send(JSON.stringify({ type: "ack", reqId: msg.reqId, ok }));
       } catch {}
       return;
     }
-    if (msg.type === "cancel") {
+    if (msg.type === "cancel" || msg.type === "discord_cancel") {
       const ids = Array.isArray(msg.ids) ? msg.ids.filter((x): x is string => typeof x === "string") : [];
-      const cancelled = ids.length > 0 ? (this.registry?.cancel(ids) ?? []) : [];
+      const cancelled = (msg.type === "cancel" || (this.discordControlEnabled && msg.sessionId === this.sessionId && msg.controlGeneration === this.discordControlGeneration)) && ids.length > 0 ? (this.registry?.cancel(ids) ?? []) : [];
+      if (cancelled.length) this.onRegistryMutation?.();
       try {
         ws.send(JSON.stringify({ type: "ack", reqId: msg.reqId, ok: cancelled.length > 0 }));
         ws.send(JSON.stringify(this.snapshot()));
@@ -232,10 +343,15 @@ export class SessionNotifyEndpoint {
             ws.send(JSON.stringify(this.snapshot()));
             if (this.identityFrame) ws.send(this.identityFrame);
           } catch {}
+          this.sendDiscordControl(ws);
         },
         message: (ws, raw) => { void this.handleMessage(ws, raw); },
         close: ws => {
           this.sockets.delete(ws);
+          this.pendingRelay.delete(ws);
+          this.remoteControllers.get(ws)?.controller.abort();
+          this.remoteControllers.delete(ws);
+          if (this.relaySockets.delete(ws)) this.relayGeneration++;
         },
       },
     });
@@ -279,6 +395,12 @@ export class SessionNotifyEndpoint {
       clearInterval(this.pollTimer);
       this.pollTimer = undefined;
     }
+    this.setDiscordControlEnabled(false);
+    this.relaySockets.clear();
+    this.pendingRelay.clear();
+    this.relayGeneration++;
+    for (const remote of this.remoteControllers.values()) remote.controller.abort();
+    this.remoteControllers.clear();
     for (const ws of this.sockets) {
       try {
         ws.close();

package/src/agent/session.ts

@@ -76,7 +76,7 @@ export function newSessionId(): string {
 }
 
 export function sessionsDir(cwd = process.cwd()): string {
-  return path.join(getLocalJeoDir(cwd), "sessions");
+  return process.env.JEO_SESSION_DIR || path.join(getLocalJeoDir(cwd), "sessions");
 }
 
 export function sessionPath(id: string, cwd = process.cwd()): string {
@@ -86,9 +86,11 @@ export function sessionPath(id: string, cwd = process.cwd()): string {
 export async function createSession(
   cwd = process.cwd(),
   id = newSessionId(),
-  model?: string
+  model?: string,
+  directory = sessionsDir(cwd),
+  exclusive = false,
 ): Promise<{ id: string; path: string }> {
-  const dir = sessionsDir(cwd);
+  const dir = directory;
   await fs.mkdir(dir, { recursive: true });
 
   const header: SessionHeader = {
@@ -100,8 +102,8 @@ export async function createSession(
     ...(model ? { model } : {}),
   };
 
-  const file = sessionPath(id, cwd);
-  await fs.writeFile(file, JSON.stringify(header) + "\n", "utf8");
+  const file = path.join(dir, `${id}.jsonl`);
+  await fs.writeFile(file, JSON.stringify(header) + "\n", { encoding: "utf8", ...(exclusive ? { flag: "wx", mode: 0o600 } : {}) });
 
   return { id, path: file };
 }

package/src/agent/tools.ts

@@ -22,6 +22,7 @@ async function readMutationLock(cwd: string): Promise<WorkflowState | null> {
 }
 
 export interface ToolResult {
+  images?: import("../ai/types").ImageAttachment[];
   success: boolean;
   output: string;
   error?: string;

package/src/ai/providers/anthropic.ts

@@ -240,6 +240,7 @@ export function buildAnthropicMessages(messages: Message[], model: string, think
       const blocks: AnthropicContentBlock[] = m.toolResults.map(tr => ({
         type: "tool_result", tool_use_id: tr.id, content: tr.output, is_error: tr.isError,
       }));
+      for (const img of m.images ?? []) blocks.push({ type: "image", source: { type: "base64", media_type: img.mediaType, data: img.data } });
       if (m.toolResultExtra) blocks.push({ type: "text", text: m.toolResultExtra });
       return { role: "user", content: blocks };
     }

package/src/ai/providers/openai-responses.ts

@@ -87,6 +87,7 @@ export function buildResponsesInput(messages: Message[], modelKey: string, strip
         && nonSystem[i - 1].role === "assistant" && responsesNativizable(nonSystem[i - 1], modelKey)) {
       for (const tr of m.toolResults) items.push({ type: "function_call_output", call_id: tr.id, output: tr.output });
       if (m.toolResultExtra) items.push({ role: "user", content: [{ type: "input_text", text: m.toolResultExtra }] });
+      if (m.images?.length) items.push({ role: "user", content: m.images.map(img => ({ type: "input_image", image_url: `data:${img.mediaType};base64,${img.data}` })) });
       return;
     }
     items.push(plain(m));

package/src/cli/runner.ts

@@ -119,6 +119,15 @@ export const COMMANDS: readonly CommandSpec[] = [
       return args => m.runNotifyCommand(args);
     },
   },
+  {
+    name: "messenger",
+    summary: "Run or configure the bidirectional Discord, Telegram, and Slack agent gateway.",
+    usage: "messenger [setup|check|run] --config <file> [--channel ID] [--user ID] [--tools LIST] [--artifacts] [--service]",
+    loader: async () => {
+      const m = await import("../commands/messenger");
+      return args => m.runMessengerCommand(args);
+    },
+  },
   {
     name: "daemon",
     summary: "Manage the shared Telegram/Discord/Slack notification daemon.",

package/src/cli.ts

@@ -44,6 +44,10 @@ const fatal = (err: unknown): never => {
 };
 process.on("uncaughtException", fatal);
 process.on("unhandledRejection", fatal);
+// Bun 1.4 may report a closed downstream pipe as a stream error event instead of
+// promoting it to uncaughtException. Keep both runtime shapes on the same quiet path.
+process.stdout.on("error", fatal);
+process.stderr.on("error", fatal);
 
 try {
   const code = await dispatch(process.argv.slice(2), { appName: APP_NAME, version: VERSION });

package/src/commands/computer.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import * as os from "node:os";
 import { computerSupervisor } from "../agent/computer-supervisor";
+import type { ImageAttachment } from "../ai/types";
 import { readGlobalConfig } from "../agent/state";
 
 export interface ComputerAction {
@@ -36,9 +37,11 @@ async function logAudit(action: ComputerAction, success: boolean, error?: string
 async function runCommand(cmd: string[]): Promise<{ success: boolean; stdout: string; stderr: string }> {
   try {
     const proc = Bun.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
-    await proc.exited;
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
     return {
       success: proc.exitCode === 0,
       stdout,
@@ -53,7 +56,7 @@ async function runCommand(cmd: string[]): Promise<{ success: boolean; stdout: st
   }
 }
 
-export async function executeComputerAction(action: ComputerAction, opts?: { enabledOverride?: boolean }): Promise<{ success: boolean; output: string; error?: string }> {
+export async function executeComputerAction(action: ComputerAction, opts?: { enabledOverride?: boolean }): Promise<{ success: boolean; output: string; error?: string; images?: ImageAttachment[] }> {
   let enabled = opts?.enabledOverride;
   if (enabled === undefined) {
     const config = await readGlobalConfig().catch(() => null);
@@ -68,6 +71,18 @@ export async function executeComputerAction(action: ComputerAction, opts?: { ena
   }
 
 
+  if (!action || typeof action !== "object") return { success: false, output: "", error: "Expected a computer action object." };
+  for (const field of ["x", "y", "deltaX", "deltaY", "duration"] as const) {
+    if (action[field] !== undefined && (typeof action[field] !== "number" || !Number.isFinite(action[field]))) {
+      return { success: false, output: "", error: `Invalid finite number for ${field}.` };
+    }
+  }
+  if (action.duration !== undefined && (action.duration < 0 || action.duration > 60)) {
+    return { success: false, output: "", error: "duration must be between 0 and 60 seconds." };
+  }
+  if (os.platform() !== "darwin" && os.platform() !== "linux") {
+    return { success: false, output: "", error: "Computer use supports macOS and Linux/X11 only." };
+  }
   // Read-only actions don't need supervisor inputAllowed check
   const isReadOnly = action.action === "screenshot" || action.action === "wait";
   if (!isReadOnly) {
@@ -83,7 +98,7 @@ export async function executeComputerAction(action: ComputerAction, opts?: { ena
   switch (action.action) {
     case "screenshot": {
       const tmpDir = os.tmpdir();
-      const screenPath = path.join(tmpDir, `jeo-screen-${Date.now()}.png`);
+      const screenPath = path.join(tmpDir, `jeo-screen-${crypto.randomUUID()}.png`);
       let cmd: string[];
       if (isMac) {
         cmd = ["screencapture", "-x", screenPath];
@@ -100,7 +115,7 @@ export async function executeComputerAction(action: ComputerAction, opts?: { ena
         const base64 = bytes.toString("base64");
         await fs.unlink(screenPath).catch(() => {});
         await logAudit(action, true);
-        return { success: true, output: base64 };
+        return { success: true, output: "Screenshot captured.", images: [{ mediaType: "image/png", data: base64 }] };
       } catch (err: any) {
         await logAudit(action, false, err.message);
         return { success: false, output: "", error: `Failed to read screenshot file: ${err.message}` };
@@ -164,9 +179,9 @@ export async function executeComputerAction(action: ComputerAction, opts?: { ena
       }
       let cmd: string[];
       if (isMac) {
-        cmd = ["cliclick", `dd:${action.x},${action.y}`];
+        cmd = ["cliclick", "dd:.", `dm:${action.x},${action.y}`, `du:${action.x},${action.y}`];
       } else {
-        cmd = ["xdotool", "mousemove", String(action.x), String(action.y), "mousedown", "1"];
+        cmd = ["xdotool", "mousedown", "1", "mousemove", String(action.x), String(action.y), "mouseup", "1"];
       }
       const res = await runCommand(cmd);
       await logAudit(action, res.success, res.success ? undefined : res.stderr);
@@ -179,9 +194,14 @@ export async function executeComputerAction(action: ComputerAction, opts?: { ena
       let cmd: string[];
       const dx = action.deltaX ?? 0;
       const dy = action.deltaY ?? 0;
+      if (!Number.isInteger(dx) || !Number.isInteger(dy) || Math.abs(dx) > 1000 || Math.abs(dy) > 1000) {
+        return { success: false, output: "", error: "Scroll deltas must be integers between -1000 and 1000." };
+      }
+      if (dx === 0 && dy === 0) return { success: true, output: "Scroll skipped (zero deltas)." };
       if (isMac) {
-        // cliclick scroll deltaY deltaX
-        cmd = ["cliclick", `w:${dy},${dx}`];
+        // cliclick's w: command WAITS; it cannot scroll. Use Quartz line events.
+        cmd = ["/usr/bin/osascript", "-l", "JavaScript", "-e",
+          `ObjC.import('Cocoa'); var event = $.CGEventCreateScrollWheelEvent(null, 1, 2, ${dy}, ${dx}); $.CGEventPost(0, event);`];
       } else {
         // xdotool click 4 (scroll up), 5 (scroll down), 6 (scroll left), 7 (scroll right)
         const actions: string[] = [];
@@ -212,7 +232,7 @@ export async function executeComputerAction(action: ComputerAction, opts?: { ena
       if (isMac) {
         cmd = ["cliclick", `t:${action.text}`];
       } else {
-        cmd = ["xdotool", "type", action.text];
+        cmd = ["xdotool", "type", "--clearmodifiers", "--", action.text];
       }
       const res = await runCommand(cmd);
       await logAudit(action, res.success, res.success ? undefined : res.stderr);
@@ -227,7 +247,16 @@ export async function executeComputerAction(action: ComputerAction, opts?: { ena
       }
       let cmd: string[];
       if (isMac) {
-        cmd = ["cliclick", `kp:${action.key}`];
+        const aliases: Record<string, string> = { return: "return", enter: "return", escape: "esc", backspace: "delete", arrowup: "arrow-up", arrowdown: "arrow-down", arrowleft: "arrow-left", arrowright: "arrow-right", pageup: "page-up", pagedown: "page-down" };
+        const parts = action.key.toLowerCase().split("+");
+        const key = parts.pop()!;
+        const modifiers = parts.map(p => ({ command: "cmd", meta: "cmd", control: "ctrl", option: "alt" }[p] ?? p));
+        if (modifiers.some(p => !["cmd", "ctrl", "alt", "shift", "fn"].includes(p))) {
+          return { success: false, output: "", error: "Unknown key modifier." };
+        }
+        const press = key.length === 1 ? `t:${key}` : `kp:${aliases[key] ?? key}`;
+        cmd = ["cliclick", ...(modifiers.length ? [`kd:${modifiers.join(",")}`] : []), press,
+          ...(modifiers.length ? [`ku:${modifiers.join(",")}`] : [])];
       } else {
         cmd = ["xdotool", "key", action.key];
       }
@@ -250,6 +279,7 @@ export async function executeComputerAction(action: ComputerAction, opts?: { ena
         return { success: false, output: "", error: "Missing actions array for batch action." };
       }
       const results: string[] = [];
+      const images: ImageAttachment[] = [];
       for (let i = 0; i < action.actions.length; i++) {
         const subAction = action.actions[i];
         const res = await executeComputerAction(subAction, opts);
@@ -257,12 +287,13 @@ export async function executeComputerAction(action: ComputerAction, opts?: { ena
         if (!res.success) {
           const err = `Batch failed at step ${i}: ${res.error}`;
           await logAudit(action, false, err);
-          return { success: false, output: results.join("\n"), error: err };
+          return { success: false, output: results.join("\n"), error: err, images };
         }
         results.push(`Step ${i}: ${res.output}`);
+        images.push(...(res.images ?? []));
       }
       await logAudit(action, true);
-      return { success: true, output: results.join("\n") };
+      return { success: true, output: results.join("\n"), images };
     }
 
     default:
@@ -329,7 +360,7 @@ export async function runComputerCommand(args: string[]): Promise<void> {
   const res = await executeComputerAction(action);
   if (res.success) {
     if (actionName === "screenshot") {
-      console.log(res.output); // base64 output
+      console.log(res.images?.[0]?.data ?? res.output); // preserve CLI base64 output
     } else {
       console.log(res.output);
     }

package/src/commands/launch/agy-turn.ts

@@ -9,13 +9,20 @@ export interface AgySessionTurnOptions extends Omit<AgyTurnOptions, "conversatio
 }
 
 /** An explicit full-agent turn: no raw-model loop, credential fallback, or tool replay. */
-export async function runAgySessionTurn(options: AgySessionTurnOptions): Promise<AgyTurnResult> {
+export async function runAgySessionTurn(options: AgySessionTurnOptions, deps: {
+  loadSession?: typeof loadSession;
+  appendMessage?: typeof appendMessage;
+  appendAgySession?: typeof appendAgySession;
+  runAgyTurn?: typeof runAgyTurn;
+} = {}): Promise<AgyTurnResult> {
   const { history, sessionId, images, ...turn } = options;
+  const { loadSession: load = loadSession, appendMessage: append = appendMessage, appendAgySession: appendAgy = appendAgySession, runAgyTurn: run = runAgyTurn } = deps;
   if (images?.length) throw new Error("Image attachments are not supported by the official agy bridge");
   if (turn.signal?.aborted) throw new AgyCliError("Official CLI turn cancelled", "cancelled");
 
   const previousCount = history.reduce((count, message) => count + (message.role === "system" ? 0 : 1), 0);
-  const state = sessionId ? (await loadSession(sessionId, turn.cwd)).header.agy : undefined;
+  const state = sessionId ? (await load(sessionId, turn.cwd)).header.agy : undefined;
+  turn.signal?.throwIfAborted();
   // A non-CLI turn or compaction changes the cursor. Start fresh with text context
   // rather than resume a stale agent conversation or agy's unrelated latest one.
   let conversationId = state?.messageCount === previousCount ? state.conversationId : undefined;
@@ -33,26 +40,32 @@ export async function runAgySessionTurn(options: AgySessionTurnOptions): Promise
   }
 
   const user: Message = { role: "user", content: turn.prompt };
-  if (sessionId) await appendMessage(sessionId, user, turn.cwd);
+  if (sessionId) await append(sessionId, user, turn.cwd);
+  turn.signal?.throwIfAborted();
   history.push(user);
-  const result = await runAgyTurn({
+  const result = await run({
     ...turn,
     prompt,
     conversationId,
     onConversation: async id => {
+      turn.signal?.throwIfAborted();
       conversationId = id;
-      if (sessionId) await appendAgySession(sessionId, { conversationId: id, messageCount: previousCount + 1 }, turn.cwd);
+      if (sessionId) await appendAgy(sessionId, { conversationId: id, messageCount: previousCount + 1 }, turn.cwd);
+      turn.signal?.throwIfAborted();
     },
   });
+  turn.signal?.throwIfAborted();
 
   const assistant: Message = { role: "assistant", content: result.response };
   try {
-    if (sessionId) await appendMessage(sessionId, assistant, turn.cwd);
+    if (sessionId) await append(sessionId, assistant, turn.cwd);
+    turn.signal?.throwIfAborted();
     history.push(assistant);
-    if (sessionId) await appendAgySession(sessionId, {
+    if (sessionId) await appendAgy(sessionId, {
       conversationId: result.conversationId,
       messageCount: previousCount + 2,
     }, turn.cwd);
+    turn.signal?.throwIfAborted();
   } catch (error) {
     throw new Error(`Official CLI completed, but saving its jeo session failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
   }

package/src/commands/launch/confirm.ts

@@ -0,0 +1,78 @@
+/** Confirm a sensitive action on an isolated local TTY; all other input denies. */
+export async function confirmLocalControl({
+  input,
+  output,
+  timeoutMs = 15_000,
+  warning = "Discord control grants authorized users the host session's tools and approval policy, including reading or changing files and running commands. This is not a sandbox.",
+  prompt = "Confirm Discord control: press y to allow, any other key to cancel.",
+}: {
+  input: NodeJS.ReadStream;
+  output: NodeJS.WriteStream;
+  timeoutMs?: number;
+  warning?: string;
+  prompt?: string;
+}): Promise<boolean> {
+  if (!input.isTTY || !output.isTTY || typeof input.setRawMode !== "function" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) return false;
+  const wasRaw = !!input.isRaw;
+  const wasPaused = input.isPaused();
+  const dataListeners = input.rawListeners("data");
+  const keyListeners = input.rawListeners("keypress");
+  let deadline: ReturnType<typeof setTimeout> | undefined;
+  let quiet: ReturnType<typeof setTimeout> | undefined;
+  let phase: "drain" | "ready" | "candidate" = "drain";
+  let finished = false;
+  let resolveResult: (value: boolean) => void = () => {};
+  const result = new Promise<boolean>(resolve => { resolveResult = resolve; });
+  const finish = (accepted: boolean) => {
+    if (finished) return;
+    finished = true;
+    resolveResult(accepted);
+  };
+  const startQuietDrain = () => {
+    clearTimeout(quiet);
+    quiet = setTimeout(() => {
+      if (finished) return;
+      phase = "ready";
+      try { output.write(`${prompt}\n`); }
+      catch { finish(false); }
+    }, 200);
+  };
+  const onData = (chunk: string | Uint8Array) => {
+    if (phase === "drain") { startQuietDrain(); return; }
+    if (phase !== "ready" || (typeof chunk === "string" ? chunk !== "y" : chunk.length !== 1 || chunk[0] !== 0x79)) { finish(false); return; }
+    phase = "candidate";
+    quiet = setTimeout(() => finish(true), 200);
+  };
+  const onEnd = () => finish(false);
+  try {
+    input.pause();
+    for (const listener of dataListeners) input.removeListener("data", listener);
+    for (const listener of keyListeners) input.removeListener("keypress", listener);
+    input.setRawMode(true);
+    output.write(`${warning}\n`);
+    while (input.read() !== null) { /* discard input queued before the warning */ }
+    input.on("data", onData);
+    input.once("end", onEnd);
+    input.once("close", onEnd);
+    input.once("error", onEnd);
+    deadline = setTimeout(() => finish(false), timeoutMs);
+    startQuietDrain();
+    input.resume();
+    return await result;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(deadline);
+    clearTimeout(quiet);
+    input.pause();
+    input.removeListener("data", onData);
+    input.removeListener("end", onEnd);
+    input.removeListener("close", onEnd);
+    input.removeListener("error", onEnd);
+    for (const listener of dataListeners) input.on("data", listener);
+    for (const listener of keyListeners) input.on("keypress", listener);
+    try { input.setRawMode(wasRaw); } catch {}
+    if (wasPaused) input.pause();
+    else input.resume();
+  }
+}

package/src/commands/launch/flags.ts

@@ -23,6 +23,8 @@ export interface LaunchFlags {
   thinking?: ThinkLevel;
   errors: string[];
   print?: boolean;
+  literalPrompt?: boolean;
+  literalWorker?: boolean;
   appendSystemPromptRaw?: string;
   appendSystemPrompt?: string;
   noSkills: boolean;
@@ -160,6 +162,11 @@ export function parseFlags(args: string[], cwd: string = process.cwd()): LaunchF
       if (value) flags.skills = value;
       else flags.errors.push("--skills requires a value");
       i = nextIndex;
+    } else if (a === "--literal-prompt") {
+      flags.literalPrompt = true;
+    } else if (a === "--literal-worker") {
+      flags.literalWorker = true;
+      flags.literalPrompt = true;
     } else if (a === "--no-tools") {
       flags.noTools = true;
     } else if (a === "--tools" || a.startsWith("--tools=")) {

package/src/commands/launch/input.ts

@@ -34,6 +34,9 @@ interface AbortHarnessOptions {
   onScrollKey?: (dir: -1 | 1, page: boolean) => void;
   /** Invoked with printable keyboard input received while the live turn owns stdin. */
   onBufferedInput?: (chunk: string) => void;
+  /** Emergency-only input while an aborted turn is still unwinding. */
+  onBufferedInputAfterAbort?: (chunk: string) => void;
+  pasteActiveAfterAbort?: () => boolean;
   /** True while the input queue is inside a bracketed paste (mid-paste chunks
    *  carry no marker and must keep routing to the queue, not the noise path). */
   pasteActive?: () => boolean;
@@ -46,6 +49,15 @@ interface AbortHarnessOptions {
 export const PASTE_START = "\u001b[200~";
 export const PASTE_END = "\u001b[201~";
 
+/** Conservative paste signal; one-character chunks remain indistinguishable from typing. */
+export function isPasteLikeInputChunk(chunk: string): boolean {
+  let printable = 0;
+  for (const ch of stripPasteEscapes(chunk)) {
+    if ((ch >= " " || ch === "\t") && ++printable > 1) return true;
+  }
+  return false;
+}
+
 /** True when a stdin chunk is ONLY backspace bytes (DEL 0x7f or BS 0x08) — i.e. a
  *  standalone Backspace keystroke with nothing else. A backspace on an EMPTY input
  *  line is a no-op edit, but some Bun readline builds turn it into a spurious `close`
@@ -483,8 +495,13 @@ export function createInFlightAbortHarness(opts: AbortHarnessOptions = {}): InFl
   };
 
   const handleData = (chunk: string | Uint8Array) => {
-    if (!captureEsc || controller.signal.aborted) return;
+    if (!captureEsc) return;
     const raw = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+    if (controller.signal.aborted) {
+      if (!raw.includes(PASTE_START) && !opts.pasteActiveAfterAbort?.() && chunkHasCtrlC(raw)) handleSigint();
+      else opts.onBufferedInputAfterAbort?.(raw);
+      return;
+    }
     if (raw.includes(PASTE_START) || opts.pasteActive?.()) {
       opts.onBufferedInput?.(raw);
       return;