@axiom-lattice/cli-a2a 0.1.5 → 0.1.6

package/dist/index.js

@@ -34,16 +34,19 @@ __export(index_exports, {
   CodexExecutor: () => CodexExecutor,
   LogLevel: () => LogLevel,
   OpenCodeExecutor: () => OpenCodeExecutor,
+  SessionBindingStore: () => SessionBindingStore,
   createA2AServer: () => createA2AServer,
   createClaudeExecutor: () => createClaudeExecutor,
   createCodexExecutor: () => createCodexExecutor,
   createExecutor: () => createExecutor,
   createOpenCodeExecutor: () => createOpenCodeExecutor,
+  generateContextId: () => generateContextId,
   getExecutor: () => getExecutor,
   loadConfigFile: () => loadConfigFile,
   logger: () => logger,
   registerExecutor: () => registerExecutor,
-  resolveConfig: () => resolveConfig
+  resolveConfig: () => resolveConfig,
+  resolveSessionStorePath: () => resolveSessionStorePath
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -91,6 +94,8 @@ var DEFAULTS = Object.freeze({
   session: {
     titlePrefix: "A2A Session",
     reuseByContext: true,
+    persist: true,
+    storePath: "",
     ttl: 36e5,
     cleanupInterval: 3e5
   },
@@ -109,7 +114,7 @@ var DEFAULTS = Object.freeze({
     level: "info"
   },
   opencode: {
-    baseUrl: "http://localhost:4096",
+    baseUrl: "",
     projectDirectory: "",
     model: "",
     agent: "",
@@ -284,7 +289,8 @@ function buildAgentCard(config) {
     skills,
     capabilities: {
       streaming: agentCard.streaming ?? true,
-      pushNotifications: agentCard.pushNotifications ?? false
+      pushNotifications: agentCard.pushNotifications ?? false,
+      stateTransitionHistory: true
     },
     // Additional interfaces advertised to orchestrators
     additionalInterfaces: [
@@ -306,24 +312,219 @@ function registerExecutor(provider, factory) {
 function getExecutor(provider) {
   return registry.get(provider);
 }
-function createExecutor(config) {
+function createExecutor(config, sessionStore) {
   const factory = registry.get(config.provider);
   if (!factory) {
     const available = Array.from(registry.keys()).join(", ");
     throw new Error(`Unknown provider: ${config.provider}. Available: ${available}`);
   }
-  return factory(config);
+  return factory(config, sessionStore);
+}
+
+// src/session-store.ts
+var import_node_path2 = require("path");
+var import_node_os = require("os");
+var import_node_fs2 = require("fs");
+var import_node_crypto = require("crypto");
+var log3 = logger.child("session-store");
+var DEFAULT_STORE_DIR = (0, import_node_path2.join)(
+  (0, import_node_os.homedir)(),
+  "Library",
+  "Application Support",
+  "axiom-lattice",
+  "cli-a2a"
+);
+var DEFAULT_STORE_PATH = (0, import_node_path2.join)(DEFAULT_STORE_DIR, "sessions.json");
+var DEFAULT_CLEANUP_INTERVAL_MS = 60 * 60 * 1e3;
+function resolveSessionStorePath(options) {
+  if (options.configuredPath && options.configuredPath.length > 0) {
+    return options.configuredPath;
+  }
+  return (0, import_node_path2.join)(
+    options.storeDir ?? DEFAULT_STORE_DIR,
+    `sessions-${options.provider}-${options.port}.json`
+  );
+}
+var SessionBindingStore = class {
+  constructor(opts) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.cleanupTimer = null;
+    this.dirty = false;
+    this.flushTimeout = null;
+    this.storePath = opts?.storePath && opts.storePath.length > 0 ? opts.storePath : DEFAULT_STORE_PATH;
+    this.persist = opts?.persist ?? true;
+    this.loadFromFile();
+    this.startCleanup(opts?.cleanupIntervalMs ?? DEFAULT_CLEANUP_INTERVAL_MS);
+  }
+  // ── Public API ────────────────────────────────────────────────────────
+  get(contextId, provider) {
+    const key = this.makeKey(contextId, provider);
+    const binding = this.cache.get(key);
+    if (!binding) return null;
+    if (this.isExpired(binding)) {
+      this.cache.delete(key);
+      this.markDirty();
+      return null;
+    }
+    return binding;
+  }
+  set(binding) {
+    const key = this.makeKey(binding.contextId, binding.provider);
+    this.cache.set(key, binding);
+    this.markDirty();
+  }
+  delete(contextId, provider) {
+    const key = this.makeKey(contextId, provider);
+    const existed = this.cache.delete(key);
+    if (existed) this.markDirty();
+    return existed;
+  }
+  clearActiveTask(contextId, provider) {
+    const binding = this.get(contextId, provider);
+    if (binding) {
+      binding.activeTaskId = void 0;
+      binding.activeTaskState = void 0;
+      binding.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.markDirty();
+    }
+  }
+  /**
+   * Remove all expired entries.
+   * Called automatically on the cleanup interval; call manually before shutdown.
+   */
+  cleanup() {
+    let removed = 0;
+    for (const [key, binding] of this.cache) {
+      if (this.isExpired(binding)) {
+        this.cache.delete(key);
+        removed++;
+      }
+    }
+    if (removed > 0) {
+      this.markDirty();
+      log3.info("TTL cleanup completed", { removed, remaining: this.cache.size });
+    }
+    return removed;
+  }
+  /**
+   * Graceful shutdown: stop cleanup timer, flush pending writes.
+   */
+  shutdown() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    if (this.flushTimeout) {
+      clearTimeout(this.flushTimeout);
+      this.flushTimeout = null;
+    }
+    this.flushToFile();
+    log3.info("Session store shut down", { bindings: this.cache.size });
+  }
+  /** For testing: return the number of cached bindings. */
+  get size() {
+    return this.cache.size;
+  }
+  // ── Internal ──────────────────────────────────────────────────────────
+  makeKey(contextId, provider) {
+    return `${provider}:${contextId}`;
+  }
+  isExpired(binding) {
+    if (!binding.expiresAt) return false;
+    return Date.now() >= new Date(binding.expiresAt).getTime();
+  }
+  startCleanup(intervalMs) {
+    this.cleanupTimer = setInterval(() => this.cleanup(), intervalMs);
+    this.cleanupTimer.unref();
+  }
+  // ── Persistence ───────────────────────────────────────────────────────
+  markDirty() {
+    if (!this.persist) return;
+    this.dirty = true;
+    if (!this.flushTimeout) {
+      this.flushTimeout = setTimeout(() => {
+        this.flushToFile();
+      }, 1e3);
+    }
+  }
+  flushToFile() {
+    this.flushTimeout = null;
+    if (!this.persist || !this.dirty) return;
+    this.dirty = false;
+    this.writeAtomically();
+  }
+  writeAtomically() {
+    const tmpPath = this.storePath + ".tmp";
+    const data = {
+      version: 1,
+      bindings: Array.from(this.cache.values())
+    };
+    try {
+      (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(this.storePath), { recursive: true });
+      (0, import_node_fs2.writeFileSync)(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+      (0, import_node_fs2.renameSync)(tmpPath, this.storePath);
+    } catch (err) {
+      log3.error("Failed to write session store", { error: err.message });
+      try {
+        (0, import_node_fs2.unlinkSync)(tmpPath);
+      } catch {
+      }
+    }
+  }
+  loadFromFile() {
+    if (!this.persist || !(0, import_node_fs2.existsSync)(this.storePath)) return;
+    try {
+      const raw = (0, import_node_fs2.readFileSync)(this.storePath, "utf-8");
+      const data = JSON.parse(raw);
+      if (!data || !Array.isArray(data.bindings)) {
+        throw new Error("Invalid store format: bindings array missing");
+      }
+      let loaded = 0;
+      let expired = 0;
+      for (const b of data.bindings) {
+        if (!b.provider || !b.contextId || !b.sessionId) continue;
+        if (this.isExpired(b)) {
+          expired++;
+          continue;
+        }
+        const key = this.makeKey(b.contextId, b.provider);
+        this.cache.set(key, b);
+        loaded++;
+      }
+      log3.info("Session store loaded", { path: this.storePath, loaded, expired });
+    } catch (err) {
+      log3.error("Failed to load session store \u2014 starting fresh", {
+        path: this.storePath,
+        error: err.message
+      });
+      this.cache.clear();
+      this.writeAtomically();
+    }
+  }
+};
+function generateContextId() {
+  return (0, import_node_crypto.randomUUID)();
 }
 
 // src/server/index.ts
-var log3 = logger.child("server");
+var log4 = logger.child("server");
 async function createA2AServer(config) {
   const srv = config.server;
   const port = srv.port ?? 3e3;
   const hostname = srv.hostname ?? "0.0.0.0";
   const advertiseHost = srv.advertiseHost ?? "localhost";
   const advertiseProto = srv.advertiseProtocol ?? "http";
-  const executor = createExecutor(config);
+  const sessionConf = config.session;
+  const sessionStore = new SessionBindingStore({
+    persist: sessionConf.persist ?? true,
+    storePath: resolveSessionStorePath({
+      configuredPath: sessionConf.storePath,
+      provider: config.provider,
+      port
+    }),
+    cleanupIntervalMs: sessionConf.cleanupInterval
+  });
+  const executor = createExecutor(config, sessionStore);
   await executor.initialize();
   const agentCard = buildAgentCard(config);
   const taskStore = new import_server.InMemoryTaskStore();
@@ -355,7 +556,7 @@ async function createA2AServer(config) {
   app.use("/a2a/jsonrpc", (0, import_express2.jsonRpcHandler)({ requestHandler, userBuilder: import_express2.UserBuilder.noAuthentication }));
   app.use("/a2a/rest", (0, import_express2.restHandler)({ requestHandler, userBuilder: import_express2.UserBuilder.noAuthentication }));
   const httpServer = app.listen(port, hostname, () => {
-    log3.info("A2A server started", { bind: hostname, port, proto: advertiseProto });
+    log4.info("A2A server started", { bind: hostname, port, proto: advertiseProto });
     const banner = [
       "",
       "\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557",
@@ -379,20 +580,20 @@ async function createA2AServer(config) {
     async shutdown() {
       httpServer.close();
       await executor.shutdown();
-      log3.info("Server shut down");
+      sessionStore.shutdown();
+      log4.info("Server shut down");
     }
   };
 }
 
 // src/executors/opencode/client.ts
 var import_node_child_process = require("child_process");
-var log4 = logger.child("opencode:client");
+var log5 = logger.child("opencode:client");
 var OpenCodeClient = class {
   constructor(config) {
     this.config = config;
     this.currentChild = null;
   }
-  /** Abort the currently running child process (if any). */
   abort() {
     if (this.currentChild) {
       this.currentChild.kill("SIGTERM");
@@ -405,14 +606,32 @@ var OpenCodeClient = class {
     }
   }
   /**
-   * Execute a prompt via the OpenCode CLI and return the response text.
+   * Execute a prompt via the OpenCode CLI.
+   *
+   * @param prompt - The user prompt text.
+   * @param sessionId - If provided, continues the session with `--session`.
+   *   Otherwise creates a new session using `--format json` to capture the
+   *   session ID.
+   * @param workingDirectory - Optional per-request working directory override.
+   *   Falls back to config.workdir if not provided.
    */
-  async execute(prompt) {
+  async execute(prompt, sessionId, workingDirectory) {
+    if (sessionId) {
+      const text = await this.runResume(prompt, sessionId, workingDirectory);
+      return { text, sessionId };
+    }
+    return this.runNew(prompt, workingDirectory);
+  }
+  resolveWorkdir(override) {
+    return override || this.config.workdir || process.cwd();
+  }
+  // ── New session (first turn) ──────────────────────────────────────────
+  async runNew(prompt, workingDirectory) {
     const cliPath = this.config.cliPath || "opencode";
     const timeout = this.config.timeout ?? 6e5;
     const MAX_PROMPT = 1e5;
     if (prompt.length > MAX_PROMPT) {
-      throw new Error(`Prompt too large (${prompt.length} chars, max ${MAX_PROMPT}). Split into smaller messages or use a provider with HTTP API transport.`);
+      throw new Error(`Prompt too large (${prompt.length} chars, max ${MAX_PROMPT}).`);
     }
     const env = {
       PATH: process.env.PATH ?? "",
@@ -424,7 +643,7 @@ var OpenCodeClient = class {
     for (const key of ["OPENAI_API_KEY", "ANTHROPIC_API_KEY", "OPENCODE_SERVER_PASSWORD", "OPENCODE_SERVER_USERNAME"]) {
       if (process.env[key]) env[key] = process.env[key];
     }
-    const args = ["run", prompt];
+    const args = ["run", "--format", "json"];
     if (this.config.model) {
       args.push("--model", this.config.model);
     }
@@ -434,12 +653,12 @@ var OpenCodeClient = class {
     if (this.config.attachUrl) {
       args.push("--attach", this.config.attachUrl);
     }
-    args.push("--format", "default");
-    args.push("--dangerously-skip-permissions");
-    log4.info("Spawning opencode", { cliPath, workdir: this.config.workdir, model: this.config.model });
+    args.push("--dangerously-skip-permissions", prompt);
+    const workdir = this.resolveWorkdir(workingDirectory);
+    log5.info("Spawning opencode (new session, json)", { cliPath, workdir });
     return new Promise((resolve2, reject) => {
       const child = (0, import_node_child_process.spawn)(cliPath, args, {
-        cwd: this.config.workdir || process.cwd(),
+        cwd: workdir,
         env,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -466,7 +685,92 @@ var OpenCodeClient = class {
       });
       child.stderr?.on("data", (chunk) => {
         stderr += chunk.toString();
-        log4.debug("OpenCode stderr", { text: chunk.toString().trim() });
+        log5.debug("OpenCode stderr", { text: chunk.toString().trim() });
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        this.currentChild = null;
+        if (code !== 0) {
+          const errMsg = stderr.trim() || stdout.trim() || `OpenCode exited with code ${code}`;
+          log5.warn("OpenCode non-zero exit", { code, stderr: errMsg });
+          reject(new Error(errMsg));
+          return;
+        }
+        try {
+          const { text, sessionId } = this.parseJsonEvents(stdout);
+          resolve2({ text, sessionId });
+        } catch (err) {
+          reject(new Error(`Failed to parse OpenCode JSON output: ${err.message}`));
+        }
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        log5.error("OpenCode spawn failed", { error: err.message });
+        reject(new Error(`Failed to start opencode: ${err.message}. Is it installed?`));
+      });
+    });
+  }
+  // ── Resume session ────────────────────────────────────────────────────
+  async runResume(prompt, sessionId, workingDirectory) {
+    const cliPath = this.config.cliPath || "opencode";
+    const timeout = this.config.timeout ?? 6e5;
+    const MAX_PROMPT = 1e5;
+    if (prompt.length > MAX_PROMPT) {
+      throw new Error(`Prompt too large (${prompt.length} chars, max ${MAX_PROMPT}).`);
+    }
+    const env = {
+      PATH: process.env.PATH ?? "",
+      HOME: process.env.HOME ?? ""
+    };
+    for (const key of ["HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "no_proxy"]) {
+      if (process.env[key]) env[key] = process.env[key];
+    }
+    for (const key of ["OPENAI_API_KEY", "ANTHROPIC_API_KEY", "OPENCODE_SERVER_PASSWORD", "OPENCODE_SERVER_USERNAME"]) {
+      if (process.env[key]) env[key] = process.env[key];
+    }
+    const args = ["run", "--session", sessionId];
+    if (this.config.model) {
+      args.push("--model", this.config.model);
+    }
+    if (this.config.agent) {
+      args.push("--agent", this.config.agent);
+    }
+    if (this.config.attachUrl) {
+      args.push("--attach", this.config.attachUrl);
+    }
+    args.push("--format", "default", "--dangerously-skip-permissions", prompt);
+    const workdir = this.resolveWorkdir(workingDirectory);
+    log5.info("Spawning opencode (resume)", { sessionId, workdir });
+    return new Promise((resolve2, reject) => {
+      const child = (0, import_node_child_process.spawn)(cliPath, args, {
+        cwd: workdir,
+        env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      this.currentChild = child;
+      let stdout = "";
+      let stderr = "";
+      const MAX_OUTPUT = 1e7;
+      const timer = setTimeout(() => {
+        child.kill("SIGTERM");
+        const forceTimer = setTimeout(() => {
+          if (child.exitCode === null) child.kill("SIGKILL");
+        }, 5e3);
+        child.on("close", () => clearTimeout(forceTimer));
+        reject(new Error(`OpenCode execution timed out after ${timeout}ms`));
+      }, timeout);
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+        if (stdout.length > MAX_OUTPUT) {
+          child.kill("SIGTERM");
+          setTimeout(() => {
+            if (child.exitCode === null) child.kill("SIGKILL");
+          }, 5e3);
+        }
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+        log5.debug("OpenCode stderr", { text: chunk.toString().trim() });
       });
       child.on("close", (code) => {
         clearTimeout(timer);
@@ -475,21 +779,65 @@ var OpenCodeClient = class {
           resolve2(stdout.trim());
         } else {
           const errMsg = stderr.trim() || stdout.trim() || `OpenCode exited with code ${code}`;
-          log4.warn("OpenCode non-zero exit", { code, stderr: errMsg });
+          log5.warn("OpenCode non-zero exit", { code, stderr: errMsg });
           reject(new Error(errMsg));
         }
       });
       child.on("error", (err) => {
         clearTimeout(timer);
-        log4.error("OpenCode spawn failed", { error: err.message });
+        log5.error("OpenCode spawn failed", { error: err.message });
         reject(new Error(`Failed to start opencode: ${err.message}. Is it installed?`));
       });
     });
   }
+  // ── Parser ────────────────────────────────────────────────────────────
+  /**
+   * Parse newline-delimited JSON events from OpenCode's `--format json` output.
+   * Extracts the sessionID from the first event that contains it, and
+   * accumulates text content from relevant events.
+   */
+  parseJsonEvents(stdout) {
+    const lines = stdout.split("\n").filter((l) => l.trim());
+    let sessionId = "";
+    const textParts = [];
+    for (const line of lines) {
+      let event;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!sessionId && event.sessionID) {
+        sessionId = event.sessionID;
+      }
+      if (event.type === "error") continue;
+      const text = event.text || event.content || event.message;
+      if (text) {
+        textParts.push(text);
+      }
+    }
+    if (!sessionId) {
+      return {
+        text: textParts.join("\n").trim() || stdout.trim(),
+        sessionId: ""
+      };
+    }
+    return {
+      text: textParts.join("\n").trim() || "No response from OpenCode.",
+      sessionId
+    };
+  }
 };
 
 // src/executors/events.ts
 var import_uuid2 = require("uuid");
+function extractText(message) {
+  return message.parts.filter((p) => {
+    const part = p;
+    const text = part.text;
+    return text !== void 0 && text !== null;
+  }).map((p) => p.text).join("\n");
+}
 function publishTask(bus, taskId, contextId) {
   bus.publish({
     kind: "task",
@@ -526,12 +874,13 @@ function publishFinalArtifact(bus, taskId, contextId, text) {
 }
 
 // src/executors/opencode/executor.ts
-var log5 = logger.child("opencode:executor");
+var log6 = logger.child("opencode:executor");
 var OpenCodeExecutor = class {
-  constructor(config) {
+  constructor(config, sessionStore) {
     this.client = null;
     this.initialized = false;
     this.config = config;
+    this.sessionStore = sessionStore;
   }
   async initialize() {
     if (this.initialized) return;
@@ -545,58 +894,77 @@ var OpenCodeExecutor = class {
       timeout: this.config.timeouts.prompt ?? 6e5
     });
     this.initialized = true;
-    log5.info("Executor initialized", { workdir: oc.projectDirectory, model: oc.model });
+    log6.info("Executor initialized", { workdir: oc.projectDirectory, model: oc.model });
   }
   async shutdown() {
     this.client = null;
     this.initialized = false;
-    log5.info("Executor shut down");
+    log6.info("Executor shut down");
   }
   async execute(ctx, bus) {
-    const { taskId, contextId, userMessage, task } = ctx;
+    const { taskId, userMessage } = ctx;
     await this.initialize();
+    const reuseByContext = this.config.session?.reuseByContext ?? true;
+    let contextId = ctx.contextId;
+    if (!contextId) {
+      contextId = generateContextId();
+      log6.info("Generated new contextId", { contextId, taskId });
+    }
+    const binding = reuseByContext ? this.sessionStore.get(contextId, "opencode") : null;
+    const sessionId = binding?.sessionId;
     try {
-      if (!task) {
+      const existingTask = ctx.task;
+      if (!existingTask) {
         publishTask(bus, taskId, contextId);
         publishStatus(bus, taskId, contextId, "submitted");
       }
-      publishStatus(bus, taskId, contextId, "working", "Processing request...");
-      const promptText = this.extractText(userMessage);
-      log5.info("Sending prompt to OpenCode", { taskId, len: promptText.length });
-      const response = await this.client.execute(promptText);
-      const finalText = response || "No response from OpenCode.";
-      publishFinalArtifact(bus, taskId, contextId, finalText);
+      publishStatus(bus, taskId, contextId, "working");
+      const promptText = extractText(userMessage);
+      const userMsg = userMessage;
+      const workingDirectory = userMsg.metadata && typeof userMsg.metadata === "object" ? userMsg.metadata.workingDirectory : void 0;
+      log6.info("Sending prompt to OpenCode", {
+        taskId,
+        contextId,
+        sessionId: sessionId || "(new)",
+        len: promptText.length,
+        workingDirectory: workingDirectory || "(default)"
+      });
+      const result = await this.client.execute(promptText, sessionId, workingDirectory);
+      this.sessionStore.set({
+        provider: "opencode",
+        contextId,
+        sessionId: result.sessionId,
+        activeTaskId: void 0,
+        activeTaskState: void 0,
+        createdAt: binding?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        expiresAt: new Date(Date.now() + (this.config.session?.ttl ?? 24 * 60 * 60 * 1e3)).toISOString()
+      });
+      publishFinalArtifact(bus, taskId, contextId, result.text || "No response from OpenCode.");
       publishStatus(bus, taskId, contextId, "completed", void 0, true);
       bus.finished();
-      log5.info("Task completed", { taskId, len: finalText.length });
+      log6.info("Task completed", { taskId, contextId, sessionId: result.sessionId });
     } catch (error) {
       const msg = error.message ?? String(error);
-      log5.error("Execution failed", { taskId, error: msg });
+      log6.error("Execution failed", { taskId, contextId, error: msg });
       publishStatus(bus, taskId, contextId, "failed", `Error: ${msg}`, true);
       bus.finished();
     }
   }
   async cancelTask(taskId, bus) {
-    log5.info("Cancel requested for OpenCode task", { taskId });
+    log6.info("Cancel requested for OpenCode task", { taskId });
     this.client?.abort();
     publishStatus(bus, taskId, "", "canceled", "OpenCode task cancelled", true);
     bus.finished();
   }
-  extractText(message) {
-    return message.parts.filter((p) => {
-      const part = p;
-      const text = part.text;
-      return text !== void 0 && text !== null;
-    }).map((p) => p.text).join("\n");
-  }
 };
-function createOpenCodeExecutor(config) {
-  return new OpenCodeExecutor(config);
+function createOpenCodeExecutor(config, sessionStore) {
+  return new OpenCodeExecutor(config, sessionStore);
 }
 
 // src/executors/codex/client.ts
 var import_node_child_process2 = require("child_process");
-var log6 = logger.child("codex:client");
+var log7 = logger.child("codex:client");
 var CodexClient = class {
   constructor(config) {
     this.config = config;
@@ -614,9 +982,24 @@ var CodexClient = class {
     }
   }
   /**
-   * Execute a prompt via the Codex CLI and return the response text.
+   * Execute a prompt via the Codex CLI.
+   *
+   * @param prompt - The user prompt text.
+   * @param sessionId - If provided, resumes an existing session.
+   *   Otherwise creates a new session and extracts the thread_id from JSONL.
+   * @param workingDirectory - Optional per-request working directory override.
    */
-  async execute(prompt) {
+  async execute(prompt, sessionId, workingDirectory) {
+    if (sessionId) {
+      return this.executeResume(prompt, sessionId, workingDirectory);
+    }
+    return this.executeNew(prompt, workingDirectory);
+  }
+  resolveWorkdir(override) {
+    return override || this.config.workdir || process.cwd();
+  }
+  // ── New session (first turn) ──────────────────────────────────────────
+  async executeNew(prompt, workingDirectory) {
     const cliPath = this.config.cliPath || "codex";
     const timeout = this.config.timeout ?? 3e5;
     const MAX_PROMPT = 1e5;
@@ -633,15 +1016,20 @@ var CodexClient = class {
     if (this.config.apiKey) {
       env["OPENAI_API_KEY"] = this.config.apiKey;
     }
-    const args = [];
+    const args = ["exec", "--json"];
     if (this.config.model) {
       args.push("--model", this.config.model);
     }
-    args.push(prompt);
-    log6.info("Spawning codex", { cliPath, workdir: this.config.workdir, model: this.config.model });
+    args.push(
+      "--dangerously-bypass-approvals-and-sandbox",
+      "--skip-git-repo-check",
+      prompt
+    );
+    const workdir = this.resolveWorkdir(workingDirectory);
+    log7.info("Spawning codex (new session)", { cliPath, workdir, model: this.config.model });
     return new Promise((resolve2, reject) => {
       const child = (0, import_node_child_process2.spawn)(cliPath, args, {
-        cwd: this.config.workdir || process.cwd(),
+        cwd: workdir,
         env,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -668,35 +1056,192 @@ var CodexClient = class {
       });
       child.stderr?.on("data", (chunk) => {
         stderr += chunk.toString();
-        log6.debug("Codex stderr", { text: chunk.toString().trim() });
+        log7.debug("Codex stderr", { text: chunk.toString().trim() });
       });
       child.on("close", (code) => {
         clearTimeout(timer);
         this.currentChild = null;
-        if (code === 0) {
-          resolve2(stdout.trim());
-        } else {
+        if (code !== 0) {
+          const errMsg = stderr.trim() || stdout.trim() || `Codex exited with code ${code}`;
+          log7.warn("Codex non-zero exit", { code, stderr: errMsg });
+          reject(new Error(errMsg));
+          return;
+        }
+        try {
+          const { text, sessionId } = this.parseJsonl(stdout);
+          resolve2({ text, sessionId });
+        } catch (err) {
+          reject(new Error(`Failed to parse Codex JSONL output: ${err.message}`));
+        }
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        log7.error("Codex spawn failed", { error: err.message });
+        reject(new Error(`Failed to start codex: ${err.message}. Is it installed? (npm i -g @openai/codex)`));
+      });
+    });
+  }
+  // ── Resume session (subsequent turns) ─────────────────────────────────
+  async executeResume(prompt, sessionId, workingDirectory) {
+    const cliPath = this.config.cliPath || "codex";
+    const timeout = this.config.timeout ?? 3e5;
+    const MAX_PROMPT = 1e5;
+    if (prompt.length > MAX_PROMPT) {
+      throw new Error(`Prompt too large (${prompt.length} chars, max ${MAX_PROMPT}). Split into smaller messages.`);
+    }
+    const env = {
+      PATH: process.env.PATH ?? "",
+      HOME: process.env.HOME ?? ""
+    };
+    for (const key of ["HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "no_proxy"]) {
+      if (process.env[key]) env[key] = process.env[key];
+    }
+    if (this.config.apiKey) {
+      env["OPENAI_API_KEY"] = this.config.apiKey;
+    }
+    const args = ["exec", "resume", sessionId];
+    if (this.config.model) {
+      args.push("--model", this.config.model);
+    }
+    args.push(
+      "--dangerously-bypass-approvals-and-sandbox",
+      "--skip-git-repo-check",
+      prompt
+    );
+    const workdir = this.resolveWorkdir(workingDirectory);
+    log7.info("Spawning codex (resume)", { sessionId, workdir });
+    return new Promise((resolve2, reject) => {
+      const child = (0, import_node_child_process2.spawn)(cliPath, args, {
+        cwd: workdir,
+        env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      this.currentChild = child;
+      let stdout = "";
+      let stderr = "";
+      const MAX_OUTPUT = 1e7;
+      const timer = setTimeout(() => {
+        child.kill("SIGTERM");
+        const forceTimer = setTimeout(() => {
+          if (child.exitCode === null) child.kill("SIGKILL");
+        }, 5e3);
+        child.on("close", () => clearTimeout(forceTimer));
+        reject(new Error(`Codex execution timed out after ${timeout}ms`));
+      }, timeout);
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+        if (stdout.length > MAX_OUTPUT) {
+          child.kill("SIGTERM");
+          setTimeout(() => {
+            if (child.exitCode === null) child.kill("SIGKILL");
+          }, 5e3);
+        }
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+        log7.debug("Codex stderr", { text: chunk.toString().trim() });
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        this.currentChild = null;
+        if (code !== 0) {
           const errMsg = stderr.trim() || stdout.trim() || `Codex exited with code ${code}`;
-          log6.warn("Codex non-zero exit", { code, stderr: errMsg });
+          log7.warn("Codex non-zero exit", { code, stderr: errMsg });
           reject(new Error(errMsg));
+          return;
         }
+        const text = this.extractResumeText(stdout);
+        resolve2({ text, sessionId });
       });
       child.on("error", (err) => {
         clearTimeout(timer);
-        log6.error("Codex spawn failed", { error: err.message });
+        log7.error("Codex spawn failed", { error: err.message });
         reject(new Error(`Failed to start codex: ${err.message}. Is it installed? (npm i -g @openai/codex)`));
       });
     });
   }
+  // ── Parsers ───────────────────────────────────────────────────────────
+  /**
+   * Parse JSONL output to extract session thread_id and agent response text.
+   */
+  parseJsonl(stdout) {
+    const lines = stdout.split("\n").filter((l) => l.trim());
+    let sessionId = "";
+    const textParts = [];
+    for (const line of lines) {
+      let event;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (event.type === "thread.started" && event.thread_id) {
+        sessionId = event.thread_id;
+      }
+      if (event.type === "item.completed") {
+        const item = event.item;
+        if (item && item.type === "agent_message" && item.text) {
+          textParts.push(item.text);
+        }
+      }
+    }
+    if (!sessionId) {
+      throw new Error("No thread_id found in Codex JSONL output");
+    }
+    return {
+      text: textParts.join("\n").trim() || "No response from Codex.",
+      sessionId
+    };
+  }
+  /**
+   * Extract the agent response text from the resume mode output.
+   *
+   * The resume output includes a CLI header followed by the conversation.
+   * We extract everything after the last "codex" marker line as the
+   * latest agent response.
+   */
+  extractResumeText(stdout) {
+    const lines = stdout.split("\n");
+    let responseStart = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].trim() === "codex") {
+        responseStart = i;
+      }
+    }
+    if (responseStart >= 0 && responseStart + 1 < lines.length) {
+      return lines.slice(responseStart + 1).join("\n").trim();
+    }
+    let skipHeader = true;
+    const resultLines = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (skipHeader) {
+        if (trimmed === "--------" || trimmed === "codex") {
+          skipHeader = false;
+        }
+        continue;
+      }
+      if (trimmed === "user" || trimmed === "codex") {
+        continue;
+      }
+      if (trimmed.startsWith("tokens used")) {
+        if (resultLines.length > 0) resultLines.pop();
+        break;
+      }
+      resultLines.push(line);
+    }
+    return resultLines.join("\n").trim() || stdout.trim();
+  }
 };
 
 // src/executors/codex/executor.ts
-var log7 = logger.child("codex:executor");
+var log8 = logger.child("codex:executor");
 var CodexExecutor = class {
-  constructor(config) {
+  constructor(config, sessionStore) {
     this.client = null;
     this.initialized = false;
     this.config = config;
+    this.sessionStore = sessionStore;
   }
   async initialize() {
     if (this.initialized) return;
@@ -709,59 +1254,78 @@ var CodexExecutor = class {
       timeout: this.config.timeouts.prompt ?? 6e5
     });
     this.initialized = true;
-    log7.info("Executor initialized", { cliPath: cx.cliPath, workdir: cx.workdir });
+    log8.info("Executor initialized", { cliPath: cx.cliPath, workdir: cx.workdir });
   }
   async shutdown() {
     this.client = null;
     this.initialized = false;
-    log7.info("Executor shut down");
+    log8.info("Executor shut down");
   }
   async execute(ctx, bus) {
-    const { taskId, contextId, userMessage, task } = ctx;
+    const { taskId, userMessage } = ctx;
     await this.initialize();
+    const reuseByContext = this.config.session?.reuseByContext ?? true;
+    let contextId = ctx.contextId;
+    if (!contextId) {
+      contextId = generateContextId();
+      log8.info("Generated new contextId", { contextId, taskId });
+    }
+    const binding = reuseByContext ? this.sessionStore.get(contextId, "codex") : null;
+    const sessionId = binding?.sessionId;
     try {
-      if (!task) {
+      const existingTask = ctx.task;
+      if (!existingTask) {
         publishTask(bus, taskId, contextId);
         publishStatus(bus, taskId, contextId, "submitted");
       }
-      publishStatus(bus, taskId, contextId, "working", "Processing request...");
-      const promptText = this.extractText(userMessage);
-      log7.info("Sending prompt to Codex", { taskId, len: promptText.length });
-      const response = await this.client.execute(promptText);
-      const finalText = response || "No response from Codex.";
-      publishFinalArtifact(bus, taskId, contextId, finalText);
+      publishStatus(bus, taskId, contextId, "working");
+      const promptText = extractText(userMessage);
+      const userMsg = userMessage;
+      const workingDirectory = userMsg.metadata && typeof userMsg.metadata === "object" ? userMsg.metadata.workingDirectory : void 0;
+      log8.info("Sending prompt to Codex", {
+        taskId,
+        contextId,
+        sessionId: sessionId || "(new)",
+        len: promptText.length,
+        workingDirectory: workingDirectory || "(default)"
+      });
+      const result = await this.client.execute(promptText, sessionId, workingDirectory);
+      this.sessionStore.set({
+        provider: "codex",
+        contextId,
+        sessionId: result.sessionId,
+        activeTaskId: void 0,
+        activeTaskState: void 0,
+        createdAt: binding?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        expiresAt: new Date(Date.now() + (this.config.session?.ttl ?? 24 * 60 * 60 * 1e3)).toISOString()
+      });
+      publishFinalArtifact(bus, taskId, contextId, result.text || "No response from Codex.");
       publishStatus(bus, taskId, contextId, "completed", void 0, true);
       bus.finished();
-      log7.info("Task completed", { taskId, len: finalText.length });
+      log8.info("Task completed", { taskId, contextId, sessionId: result.sessionId });
     } catch (error) {
       const msg = error.message ?? String(error);
-      log7.error("Execution failed", { taskId, error: msg });
+      log8.error("Execution failed", { taskId, contextId, error: msg });
       publishStatus(bus, taskId, contextId, "failed", `Error: ${msg}`, true);
       bus.finished();
     }
   }
   async cancelTask(taskId, bus) {
-    log7.info("Cancel requested for Codex task", { taskId });
+    log8.info("Cancel requested for Codex task", { taskId });
     this.client?.abort();
     publishStatus(bus, taskId, "", "canceled", "Codex task cancelled", true);
     bus.finished();
   }
-  // ── Helpers ─────────────────────────────────────────────────────────────
-  extractText(message) {
-    return message.parts.filter((p) => {
-      const part = p;
-      const text = part.text;
-      return text !== void 0 && text !== null;
-    }).map((p) => p.text).join("\n");
-  }
 };
-function createCodexExecutor(config) {
-  return new CodexExecutor(config);
+function createCodexExecutor(config, sessionStore) {
+  return new CodexExecutor(config, sessionStore);
 }
 
 // src/executors/claude/client.ts
 var import_node_child_process3 = require("child_process");
-var log8 = logger.child("claude:client");
+var import_uuid3 = require("uuid");
+var log9 = logger.child("claude:client");
 var ClaudeClient = class {
   constructor(config) {
     this.config = config;
@@ -779,14 +1343,31 @@ var ClaudeClient = class {
     }
   }
   /**
-   * Execute a prompt via the Claude Code CLI and return the response text.
+   * Execute a prompt via the Claude Code CLI.
+   *
+   * @param prompt - The user prompt text.
+   * @param sessionId - If provided, resumes the session with `--resume`.
+   *   Otherwise creates a new session with `--session-id <new-uuid>`.
+   * @param workingDirectory - Optional per-request working directory override.
+   * @returns The response text and the session ID (new or existing).
    */
-  async execute(prompt) {
+  async execute(prompt, sessionId, workingDirectory) {
+    if (sessionId) {
+      const text2 = await this.run(["-p", "--resume", sessionId, prompt], workingDirectory);
+      return { text: text2, sessionId };
+    }
+    const newSessionId = (0, import_uuid3.v4)();
+    const text = await this.run(["-p", "--session-id", newSessionId, prompt], workingDirectory);
+    return { text, sessionId: newSessionId };
+  }
+  // ── Internal ──────────────────────────────────────────────────────────
+  async run(args, workingDirectory) {
     const cliPath = this.config.cliPath || "claude";
     const timeout = this.config.timeout ?? 3e5;
     const MAX_PROMPT = 1e5;
-    if (prompt.length > MAX_PROMPT) {
-      throw new Error(`Prompt too large (${prompt.length} chars, max ${MAX_PROMPT}). Split into smaller messages.`);
+    const promptArg = args[args.length - 1];
+    if (promptArg && promptArg.length > MAX_PROMPT) {
+      throw new Error(`Prompt too large (${promptArg.length} chars, max ${MAX_PROMPT}). Split into smaller messages.`);
     }
     const env = {
       PATH: process.env.PATH ?? "",
@@ -798,15 +1379,19 @@ var ClaudeClient = class {
     if (this.config.apiKey) {
       env["ANTHROPIC_API_KEY"] = this.config.apiKey;
     }
-    const args = ["-p"];
+    const fullArgs = [];
+    for (const arg of args.slice(0, -1)) {
+      fullArgs.push(arg);
+    }
     if (this.config.model) {
-      args.push("--model", this.config.model);
+      fullArgs.push("--model", this.config.model);
     }
-    args.push(prompt);
-    log8.info("Spawning claude", { cliPath, workdir: this.config.workdir, model: this.config.model });
+    fullArgs.push(promptArg);
+    const workdir = workingDirectory || this.config.workdir || process.cwd();
+    log9.info("Spawning claude", { cliPath, workdir, model: this.config.model });
     return new Promise((resolve2, reject) => {
-      const child = (0, import_node_child_process3.spawn)(cliPath, args, {
-        cwd: this.config.workdir || process.cwd(),
+      const child = (0, import_node_child_process3.spawn)(cliPath, fullArgs, {
+        cwd: workdir,
         env,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -833,7 +1418,7 @@ var ClaudeClient = class {
       });
       child.stderr?.on("data", (chunk) => {
         stderr += chunk.toString();
-        log8.debug("Claude stderr", { text: chunk.toString().trim() });
+        log9.debug("Claude stderr", { text: chunk.toString().trim() });
       });
       child.on("close", (code) => {
         clearTimeout(timer);
@@ -842,13 +1427,13 @@ var ClaudeClient = class {
           resolve2(stdout.trim());
         } else {
           const errMsg = stderr.trim() || stdout.trim() || `Claude Code exited with code ${code}`;
-          log8.warn("Claude non-zero exit", { code, stderr: errMsg });
+          log9.warn("Claude non-zero exit", { code, stderr: errMsg });
           reject(new Error(errMsg));
         }
       });
       child.on("error", (err) => {
         clearTimeout(timer);
-        log8.error("Claude spawn failed", { error: err.message });
+        log9.error("Claude spawn failed", { error: err.message });
         reject(new Error(`Failed to start claude: ${err.message}. Install: npm i -g @anthropic-ai/claude-code`));
       });
     });
@@ -856,12 +1441,13 @@ var ClaudeClient = class {
 };
 
 // src/executors/claude/executor.ts
-var log9 = logger.child("claude:executor");
+var log10 = logger.child("claude:executor");
 var ClaudeExecutor = class {
-  constructor(config) {
+  constructor(config, sessionStore) {
     this.client = null;
     this.initialized = false;
     this.config = config;
+    this.sessionStore = sessionStore;
   }
   async initialize() {
     if (this.initialized) return;
@@ -874,53 +1460,72 @@ var ClaudeExecutor = class {
       timeout: this.config.timeouts.prompt ?? 6e5
     });
     this.initialized = true;
-    log9.info("Executor initialized", { cliPath: cc.cliPath, workdir: cc.workdir });
+    log10.info("Executor initialized", { cliPath: cc.cliPath, workdir: cc.workdir });
   }
   async shutdown() {
     this.client = null;
     this.initialized = false;
-    log9.info("Executor shut down");
+    log10.info("Executor shut down");
   }
   async execute(ctx, bus) {
-    const { taskId, contextId, userMessage, task } = ctx;
+    const { taskId, userMessage } = ctx;
     await this.initialize();
+    const reuseByContext = this.config.session?.reuseByContext ?? true;
+    let contextId = ctx.contextId;
+    if (!contextId) {
+      contextId = generateContextId();
+      log10.info("Generated new contextId", { contextId, taskId });
+    }
+    const binding = reuseByContext ? this.sessionStore.get(contextId, "claude") : null;
+    const sessionId = binding?.sessionId;
     try {
-      if (!task) {
+      const existingTask = ctx.task;
+      if (!existingTask) {
         publishTask(bus, taskId, contextId);
         publishStatus(bus, taskId, contextId, "submitted");
       }
-      publishStatus(bus, taskId, contextId, "working", "Processing request...");
-      const promptText = this.extractText(userMessage);
-      log9.info("Sending prompt to Claude Code", { taskId, len: promptText.length });
-      const response = await this.client.execute(promptText);
-      const finalText = response || "No response from Claude Code.";
-      publishFinalArtifact(bus, taskId, contextId, finalText);
+      publishStatus(bus, taskId, contextId, "working");
+      const promptText = extractText(userMessage);
+      const userMsg = userMessage;
+      const workingDirectory = userMsg.metadata && typeof userMsg.metadata === "object" ? userMsg.metadata.workingDirectory : void 0;
+      log10.info("Sending prompt to Claude Code", {
+        taskId,
+        contextId,
+        sessionId: sessionId || "(new)",
+        len: promptText.length,
+        workingDirectory: workingDirectory || "(default)"
+      });
+      const result = await this.client.execute(promptText, sessionId, workingDirectory);
+      this.sessionStore.set({
+        provider: "claude",
+        contextId,
+        sessionId: result.sessionId,
+        activeTaskId: void 0,
+        activeTaskState: void 0,
+        createdAt: binding?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        expiresAt: new Date(Date.now() + (this.config.session?.ttl ?? 24 * 60 * 60 * 1e3)).toISOString()
+      });
+      publishFinalArtifact(bus, taskId, contextId, result.text || "No response from Claude Code.");
       publishStatus(bus, taskId, contextId, "completed", void 0, true);
       bus.finished();
-      log9.info("Task completed", { taskId, len: finalText.length });
+      log10.info("Task completed", { taskId, contextId, sessionId: result.sessionId });
     } catch (error) {
       const msg = error.message ?? String(error);
-      log9.error("Execution failed", { taskId, error: msg });
+      log10.error("Execution failed", { taskId, contextId, error: msg });
       publishStatus(bus, taskId, contextId, "failed", `Error: ${msg}`, true);
       bus.finished();
     }
   }
   async cancelTask(taskId, bus) {
-    log9.info("Cancel requested for Claude Code task", { taskId });
+    log10.info("Cancel requested for Claude Code task", { taskId });
     this.client?.abort();
     publishStatus(bus, taskId, "", "canceled", "Claude Code task cancelled", true);
     bus.finished();
   }
-  extractText(message) {
-    return message.parts.filter((p) => {
-      const part = p;
-      const text = part.text;
-      return text !== void 0 && text !== null;
-    }).map((p) => p.text).join("\n");
-  }
 };
-function createClaudeExecutor(config) {
-  return new ClaudeExecutor(config);
+function createClaudeExecutor(config, sessionStore) {
+  return new ClaudeExecutor(config, sessionStore);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -928,15 +1533,18 @@ function createClaudeExecutor(config) {
   CodexExecutor,
   LogLevel,
   OpenCodeExecutor,
+  SessionBindingStore,
   createA2AServer,
   createClaudeExecutor,
   createCodexExecutor,
   createExecutor,
   createOpenCodeExecutor,
+  generateContextId,
   getExecutor,
   loadConfigFile,
   logger,
   registerExecutor,
-  resolveConfig
+  resolveConfig,
+  resolveSessionStorePath
 });
 //# sourceMappingURL=index.js.map