@axiom-lattice/cli-a2a 0.1.4 → 0.1.6

package/dist/cli.js

@@ -102,13 +102,13 @@ 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);
 }
 var import_sdk, import_uuid, registry;
 var init_executors = __esm({
@@ -120,20 +120,211 @@ var init_executors = __esm({
   }
 });
 
+// src/session-store.ts
+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`
+  );
+}
+function generateContextId() {
+  return (0, import_node_crypto.randomUUID)();
+}
+var import_node_path2, import_node_os, import_node_fs2, import_node_crypto, log3, DEFAULT_STORE_DIR, DEFAULT_STORE_PATH, DEFAULT_CLEANUP_INTERVAL_MS, SessionBindingStore;
+var init_session_store = __esm({
+  "src/session-store.ts"() {
+    "use strict";
+    import_node_path2 = require("path");
+    import_node_os = require("os");
+    import_node_fs2 = require("fs");
+    import_node_crypto = require("crypto");
+    init_logger();
+    log3 = logger.child("session-store");
+    DEFAULT_STORE_DIR = (0, import_node_path2.join)(
+      (0, import_node_os.homedir)(),
+      "Library",
+      "Application Support",
+      "axiom-lattice",
+      "cli-a2a"
+    );
+    DEFAULT_STORE_PATH = (0, import_node_path2.join)(DEFAULT_STORE_DIR, "sessions.json");
+    DEFAULT_CLEANUP_INTERVAL_MS = 60 * 60 * 1e3;
+    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();
+        }
+      }
+    };
+  }
+});
+
 // src/executors/opencode/client.ts
-var import_node_child_process, log4, OpenCodeClient;
+var import_node_child_process, log5, OpenCodeClient;
 var init_client = __esm({
   "src/executors/opencode/client.ts"() {
     "use strict";
     import_node_child_process = require("child_process");
     init_logger();
-    log4 = logger.child("opencode:client");
+    log5 = logger.child("opencode:client");
     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");
@@ -146,14 +337,117 @@ var init_client = __esm({
         }
       }
       /**
-       * 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}).`);
+        }
+        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", "--format", "json"];
+        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("--dangerously-skip-permissions", prompt);
+        const workdir = this.resolveWorkdir(workingDirectory);
+        log5.info("Spawning opencode (new session, json)", { cliPath, workdir });
+        return new Promise((resolve3, 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);
+            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);
+              resolve3({ 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}). 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 ?? "",
@@ -165,7 +459,7 @@ var init_client = __esm({
         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", "--session", sessionId];
         if (this.config.model) {
           args.push("--model", this.config.model);
         }
@@ -175,12 +469,12 @@ var init_client = __esm({
         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("--format", "default", "--dangerously-skip-permissions", prompt);
+        const workdir = this.resolveWorkdir(workingDirectory);
+        log5.info("Spawning opencode (resume)", { sessionId, workdir });
         return new Promise((resolve3, reject) => {
           const child = (0, import_node_child_process.spawn)(cliPath, args, {
-            cwd: this.config.workdir || process.cwd(),
+            cwd: workdir,
             env,
             stdio: ["ignore", "pipe", "pipe"]
           });
@@ -207,7 +501,7 @@ var init_client = __esm({
           });
           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);
@@ -216,22 +510,66 @@ var init_client = __esm({
               resolve3(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
+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",
@@ -280,22 +618,24 @@ __export(executor_exports, {
   OpenCodeExecutor: () => OpenCodeExecutor,
   createOpenCodeExecutor: () => createOpenCodeExecutor
 });
-function createOpenCodeExecutor(config) {
-  return new OpenCodeExecutor(config);
+function createOpenCodeExecutor(config, sessionStore) {
+  return new OpenCodeExecutor(config, sessionStore);
 }
-var log5, OpenCodeExecutor;
+var log6, OpenCodeExecutor;
 var init_executor = __esm({
   "src/executors/opencode/executor.ts"() {
     "use strict";
+    init_session_store();
     init_logger();
     init_client();
     init_events();
-    log5 = logger.child("opencode:executor");
+    log6 = logger.child("opencode:executor");
     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;
@@ -309,62 +649,81 @@ var init_executor = __esm({
           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");
-      }
     };
   }
 });
 
 // src/executors/codex/client.ts
-var import_node_child_process2, log6, CodexClient;
+var import_node_child_process2, log7, CodexClient;
 var init_client2 = __esm({
   "src/executors/codex/client.ts"() {
     "use strict";
     import_node_child_process2 = require("child_process");
     init_logger();
-    log6 = logger.child("codex:client");
+    log7 = logger.child("codex:client");
     CodexClient = class {
       constructor(config) {
         this.config = config;
@@ -382,9 +741,24 @@ var init_client2 = __esm({
         }
       }
       /**
-       * 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;
@@ -401,15 +775,20 @@ var init_client2 = __esm({
         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((resolve3, reject) => {
           const child = (0, import_node_child_process2.spawn)(cliPath, args, {
-            cwd: this.config.workdir || process.cwd(),
+            cwd: workdir,
             env,
             stdio: ["ignore", "pipe", "pipe"]
           });
@@ -436,26 +815,182 @@ var init_client2 = __esm({
           });
           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) {
-              resolve3(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);
+              resolve3({ 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((resolve3, 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);
+            resolve3({ 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();
+      }
     };
   }
 });
@@ -466,22 +1001,24 @@ __export(executor_exports2, {
   CodexExecutor: () => CodexExecutor,
   createCodexExecutor: () => createCodexExecutor
 });
-function createCodexExecutor(config) {
-  return new CodexExecutor(config);
+function createCodexExecutor(config, sessionStore) {
+  return new CodexExecutor(config, sessionStore);
 }
-var log7, CodexExecutor;
+var log8, CodexExecutor;
 var init_executor2 = __esm({
   "src/executors/codex/executor.ts"() {
     "use strict";
+    init_session_store();
     init_logger();
     init_client2();
     init_events();
-    log7 = logger.child("codex:executor");
+    log8 = logger.child("codex:executor");
     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;
@@ -494,63 +1031,82 @@ var init_executor2 = __esm({
           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");
-      }
     };
   }
 });
 
 // src/executors/claude/client.ts
-var import_node_child_process3, log8, ClaudeClient;
+var import_node_child_process3, import_uuid3, log9, ClaudeClient;
 var init_client3 = __esm({
   "src/executors/claude/client.ts"() {
     "use strict";
     import_node_child_process3 = require("child_process");
+    import_uuid3 = require("uuid");
     init_logger();
-    log8 = logger.child("claude:client");
+    log9 = logger.child("claude:client");
     ClaudeClient = class {
       constructor(config) {
         this.config = config;
@@ -568,14 +1124,31 @@ var init_client3 = __esm({
         }
       }
       /**
-       * 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 ?? "",
@@ -587,15 +1160,19 @@ var init_client3 = __esm({
         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((resolve3, 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"]
           });
@@ -622,7 +1199,7 @@ var init_client3 = __esm({
           });
           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);
@@ -631,13 +1208,13 @@ var init_client3 = __esm({
               resolve3(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`));
           });
         });
@@ -652,22 +1229,24 @@ __export(executor_exports3, {
   ClaudeExecutor: () => ClaudeExecutor,
   createClaudeExecutor: () => createClaudeExecutor
 });
-function createClaudeExecutor(config) {
-  return new ClaudeExecutor(config);
+function createClaudeExecutor(config, sessionStore) {
+  return new ClaudeExecutor(config, sessionStore);
 }
-var log9, ClaudeExecutor;
+var log10, ClaudeExecutor;
 var init_executor3 = __esm({
   "src/executors/claude/executor.ts"() {
     "use strict";
+    init_session_store();
     init_logger();
     init_client3();
     init_events();
-    log9 = logger.child("claude:executor");
+    log10 = logger.child("claude:executor");
     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;
@@ -680,50 +1259,69 @@ var init_executor3 = __esm({
           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");
-      }
     };
   }
 });
@@ -733,14 +1331,14 @@ var bridge_exports = {};
 __export(bridge_exports, {
   BridgeClient: () => BridgeClient
 });
-var import_node_net, import_node_crypto, log10, SimpleWs, BridgeClient;
+var import_node_net, import_node_crypto2, log11, SimpleWs, BridgeClient;
 var init_bridge = __esm({
   "src/bridge.ts"() {
     "use strict";
     import_node_net = require("net");
-    import_node_crypto = require("crypto");
+    import_node_crypto2 = require("crypto");
     init_logger();
-    log10 = logger.child("bridge");
+    log11 = logger.child("bridge");
     SimpleWs = class {
       constructor() {
         this.socket = null;
@@ -753,7 +1351,7 @@ var init_bridge = __esm({
         const host = url.hostname;
         const port = parseInt(url.port) || (url.protocol === "wss:" ? 443 : 80);
         const path = url.pathname + url.search;
-        const key = (0, import_node_crypto.randomBytes)(16).toString("base64");
+        const key = (0, import_node_crypto2.randomBytes)(16).toString("base64");
         const req = (0, import_node_net.connect)({ host, port }, () => {
           const headers = [
             `GET ${path} HTTP/1.1`,
@@ -847,7 +1445,7 @@ var init_bridge = __esm({
         if (!this.socket) return;
         const payload = Buffer.from(data, "utf-8");
         const len = payload.length;
-        const maskKey = (0, import_node_crypto.randomBytes)(4);
+        const maskKey = (0, import_node_crypto2.randomBytes)(4);
         const masked = Buffer.alloc(len);
         for (let i = 0; i < len; i++) {
           masked[i] = payload[i] ^ maskKey[i % 4];
@@ -899,7 +1497,7 @@ var init_bridge = __esm({
           this.ws = new SimpleWs();
           let firstConnect = true;
           this.ws.onopen = () => {
-            log10.info("Bridge connected");
+            log11.info("Bridge connected");
             this.ws.send(JSON.stringify({
               type: "agent:register",
               agentId: this.config.agentId,
@@ -914,7 +1512,7 @@ var init_bridge = __esm({
               return;
             }
             if (msg.type === "agent:registered") {
-              log10.info("Agent registered via bridge", { agentId: this.config.agentId });
+              log11.info("Agent registered via bridge", { agentId: this.config.agentId });
               if (firstConnect) {
                 firstConnect = false;
                 resolve3();
@@ -926,7 +1524,7 @@ var init_bridge = __esm({
             }
           };
           this.ws.onclose = () => {
-            log10.warn("Bridge disconnected, reconnecting...");
+            log11.warn("Bridge disconnected, reconnecting...");
             if (this.running) {
               this.reconnectTimer = setTimeout(
                 () => this.start().catch(() => {
@@ -936,13 +1534,13 @@ var init_bridge = __esm({
             }
           };
           this.ws.onerror = (err) => {
-            log10.error("Bridge error", { error: err.message });
+            log11.error("Bridge error", { error: err.message });
             if (firstConnect) {
               firstConnect = false;
               reject(err);
             }
           };
-          log10.info("Connecting bridge", { url: this.config.bridgeUrl });
+          log11.info("Connecting bridge", { url: this.config.bridgeUrl });
           this.ws.connect(this.config.bridgeUrl, this.config.apiKey);
         });
       }
@@ -957,7 +1555,7 @@ var init_bridge = __esm({
         }
         this.ws?.close();
         this.ws = null;
-        log10.info("Bridge stopped");
+        log11.info("Bridge stopped");
       }
       // ── Internal ────────────────────────────────────────────────────────────
       async handleHttpRequest(msg) {
@@ -991,7 +1589,7 @@ var init_bridge = __esm({
             body: responseBody
           }));
         } catch (err) {
-          log10.error("Proxy request failed", { url, error: err.message });
+          log11.error("Proxy request failed", { url, error: err.message });
           this.ws?.send(JSON.stringify({
             type: "http:error",
             requestId,
@@ -1005,7 +1603,7 @@ var init_bridge = __esm({
 
 // src/cli.ts
 var import_node_util = require("util");
-var import_node_path2 = require("path");
+var import_node_path3 = require("path");
 
 // src/config/loader.ts
 var import_node_fs = require("fs");
@@ -1051,6 +1649,8 @@ var DEFAULTS = Object.freeze({
   session: {
     titlePrefix: "A2A Session",
     reuseByContext: true,
+    persist: true,
+    storePath: "",
     ttl: 36e5,
     cleanupInterval: 3e5
   },
@@ -1069,7 +1669,7 @@ var DEFAULTS = Object.freeze({
     level: "info"
   },
   opencode: {
-    baseUrl: "http://localhost:4096",
+    baseUrl: "",
     projectDirectory: "",
     model: "",
     agent: "",
@@ -1195,7 +1795,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: [
@@ -1209,15 +1810,26 @@ function buildAgentCard(config) {
 
 // src/server/index.ts
 init_executors();
+init_session_store();
 init_logger();
-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();
@@ -1249,7 +1861,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",
@@ -1273,14 +1885,15 @@ async function createA2AServer(config) {
     async shutdown() {
       httpServer.close();
       await executor.shutdown();
-      log3.info("Server shut down");
+      sessionStore.shutdown();
+      log4.info("Server shut down");
     }
   };
 }
 
 // src/cli.ts
 init_logger();
-var log11 = logger.child("cli");
+var log12 = logger.child("cli");
 var PKG_VERSION = "0.1.0";
 function printUsage() {
   console.log(`
@@ -1431,7 +2044,7 @@ async function registerWithGateway(registerUrl, registerKey, config, agentCardUr
   };
   try {
     const url = registerUrl.replace(/\/$/, "") + "/api/assistants";
-    log11.info("Registering with gateway", { url, agentCardUrl });
+    log12.info("Registering with gateway", { url, agentCardUrl });
     const resp = await fetch(url, {
       method: "POST",
       headers: {
@@ -1442,24 +2055,24 @@ async function registerWithGateway(registerUrl, registerKey, config, agentCardUr
     });
     if (!resp.ok) {
       const text = await resp.text().catch(() => "");
-      log11.error("Gateway registration failed", { status: resp.status, body: text });
+      log12.error("Gateway registration failed", { status: resp.status, body: text });
       return null;
     }
     const result = await resp.json();
     const assistantId = result.data?.id ?? body.graphDefinition.key;
-    log11.info("Registered with gateway", { assistantId, agentCardUrl });
+    log12.info("Registered with gateway", { assistantId, agentCardUrl });
     console.log(`Registered as agent: ${assistantId}`);
     console.log(`Agent card:        ${agentCardUrl}`);
     return { assistantId, agentCardUrl };
   } catch (err) {
-    log11.error("Gateway registration error", { error: err.message });
+    log12.error("Gateway registration error", { error: err.message });
     return null;
   }
 }
 async function unregisterFromGateway(registerUrl, registerKey, assistantId) {
   try {
     const url = `${registerUrl.replace(/\/$/, "")}/api/assistants/${assistantId}`;
-    log11.info("Unregistering from gateway", { assistantId });
+    log12.info("Unregistering from gateway", { assistantId });
     const resp = await fetch(url, {
       method: "DELETE",
       headers: {
@@ -1467,19 +2080,19 @@ async function unregisterFromGateway(registerUrl, registerKey, assistantId) {
       }
     });
     if (!resp.ok && resp.status !== 404) {
-      log11.warn("Gateway unregistration failed", { status: resp.status });
+      log12.warn("Gateway unregistration failed", { status: resp.status });
     } else {
-      log11.info("Unregistered from gateway", { assistantId });
+      log12.info("Unregistered from gateway", { assistantId });
     }
   } catch (err) {
-    log11.warn("Gateway unregistration error", { error: err.message });
+    log12.warn("Gateway unregistration error", { error: err.message });
   }
 }
 async function main() {
   const { configPath, overrides, registerUrl, registerKey, unregisterOnShutdown, bridgeUrl, bridgeKey } = parseCliArgs();
   const config = resolveConfig(configPath, overrides);
   if (configPath) {
-    config.configDir = (0, import_node_path2.dirname)((0, import_node_path2.resolve)(configPath));
+    config.configDir = (0, import_node_path3.dirname)((0, import_node_path3.resolve)(configPath));
   }
   const levelStr = config.logging.level ?? "info";
   const levelMap = {
@@ -1490,9 +2103,9 @@ async function main() {
   };
   logger.setLevel(levelMap[levelStr] ?? 20 /* INFO */);
   if (!configPath) {
-    log11.info("No --config provided \u2014 running with defaults + CLI args.");
+    log12.info("No --config provided \u2014 running with defaults + CLI args.");
   }
-  log11.info("Starting CLI A2A Gateway", {
+  log12.info("Starting CLI A2A Gateway", {
     provider: config.provider,
     config: configPath ?? "(defaults)",
     agent: config.agentCard.name,
@@ -1524,10 +2137,10 @@ async function main() {
       localBaseUrl: `http://localhost:${listenPort}`
     });
     bridgeClient.start().then(() => {
-      log11.info("Bridge connected \u2014 agent reachable via gateway proxy");
+      log12.info("Bridge connected \u2014 agent reachable via gateway proxy");
       console.log(`Bridge: ws://gateway \u2192 localhost:${listenPort}`);
     }).catch((err) => {
-      log11.error("Bridge connection failed", { error: err.message });
+      log12.error("Bridge connection failed", { error: err.message });
     });
   }
   let registeredAssistantId = null;
@@ -1544,7 +2157,7 @@ async function main() {
     }
   }
   const shutdown = async (signal) => {
-    log11.info(`${signal} received, shutting down...`);
+    log12.info(`${signal} received, shutting down...`);
     bridgeClient?.stop();
     if (registeredAssistantId && registerUrl && registerKey && unregisterOnShutdown) {
       await unregisterFromGateway(registerUrl, registerKey, registeredAssistantId);
@@ -1556,7 +2169,7 @@ async function main() {
   process.on("SIGTERM", () => shutdown("SIGTERM"));
 }
 main().catch((err) => {
-  log11.error("Fatal error", { error: err.message, stack: err.stack });
+  log12.error("Fatal error", { error: err.message, stack: err.stack });
   process.exit(1);
 });
 //# sourceMappingURL=cli.js.map