agent-relay 4.0.19 → 4.0.20

package/dist/index.cjs

@@ -2237,7 +2237,7 @@ var require_websocket = __commonJS({
     var http = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes10, createHash: createHash3 } = require("crypto");
+    var { randomBytes: randomBytes9, createHash: createHash3 } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2767,7 +2767,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes10(16).toString("base64");
+      const key = randomBytes9(16).toString("base64");
       const request = isSecure ? https3.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -4531,15 +4531,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path25 = [graph[toModel].parent, toModel];
+      const path24 = [graph[toModel].parent, toModel];
       let fn2 = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path25.unshift(graph[cur].parent);
+        path24.unshift(graph[cur].parent);
         fn2 = link2(conversions[graph[cur].parent][cur], fn2);
         cur = graph[cur].parent;
       }
-      fn2.conversion = path25;
+      fn2.conversion = path24;
       return fn2;
     }
     module2.exports = function(fromModel) {
@@ -5505,7 +5505,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path25, checkUnignored, mode) {
+      test(path24, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -5514,7 +5514,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path25);
+          const matched = rule[mode].test(path24);
           if (!matched) {
             return;
           }
@@ -5535,17 +5535,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path25, originalPath, doThrow) => {
-      if (!isString(path25)) {
+    var checkPath = (path24, originalPath, doThrow) => {
+      if (!isString(path24)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path25) {
+      if (!path24) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path25)) {
+      if (checkPath.isNotRelative(path24)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -5554,7 +5554,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path25) => REGEX_TEST_INVALID_PATH.test(path25);
+    var isNotRelative = (path24) => REGEX_TEST_INVALID_PATH.test(path24);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p2) => p2;
     var Ignore = class {
@@ -5584,19 +5584,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path25 = originalPath && checkPath.convert(originalPath);
+        const path24 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path25,
+          path24,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path25, cache, checkUnignored, slices);
+        return this._t(path24, cache, checkUnignored, slices);
       }
-      checkIgnore(path25) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path25)) {
-          return this.test(path25);
+      checkIgnore(path24) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path24)) {
+          return this.test(path24);
         }
-        const slices = path25.split(SLASH).filter(Boolean);
+        const slices = path24.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -5609,18 +5609,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path25, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path24, false, MODE_CHECK_IGNORE);
       }
-      _t(path25, cache, checkUnignored, slices) {
-        if (path25 in cache) {
-          return cache[path25];
+      _t(path24, cache, checkUnignored, slices) {
+        if (path24 in cache) {
+          return cache[path24];
         }
         if (!slices) {
-          slices = path25.split(SLASH).filter(Boolean);
+          slices = path24.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path25] = this._rules.test(path25, checkUnignored, MODE_IGNORE);
+          return cache[path24] = this._rules.test(path24, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -5628,29 +5628,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path25] = parent.ignored ? parent : this._rules.test(path25, checkUnignored, MODE_IGNORE);
+        return cache[path24] = parent.ignored ? parent : this._rules.test(path24, checkUnignored, MODE_IGNORE);
       }
-      ignores(path25) {
-        return this._test(path25, this._ignoreCache, false).ignored;
+      ignores(path24) {
+        return this._test(path24, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path25) => !this.ignores(path25);
+        return (path24) => !this.ignores(path24);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path25) {
-        return this._test(path25, this._testCache, true);
+      test(path24) {
+        return this._test(path24, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path25) => checkPath(path25 && checkPath.convert(path25), path25, RETURN_FALSE);
+    var isPathValid = (path24) => checkPath(path24 && checkPath.convert(path24), path24, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path25) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path25) || isNotRelative(path25);
+      checkPath.isNotRelative = (path24) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path24) || isNotRelative(path24);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -5742,17 +5742,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path25) {
-      const ctrl = callVisitor(key, node, visitor, path25);
+    function visit_(key, node, visitor, path24) {
+      const ctrl = callVisitor(key, node, visitor, path24);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path25, ctrl);
-        return visit_(key, ctrl, visitor, path25);
+        replaceNode(key, path24, ctrl);
+        return visit_(key, ctrl, visitor, path24);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path25 = Object.freeze(path25.concat(node));
+          path24 = Object.freeze(path24.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci2 = visit_(i, node.items[i], visitor, path25);
+            const ci2 = visit_(i, node.items[i], visitor, path24);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -5763,13 +5763,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path25 = Object.freeze(path25.concat(node));
-          const ck = visit_("key", node.key, visitor, path25);
+          path24 = Object.freeze(path24.concat(node));
+          const ck = visit_("key", node.key, visitor, path24);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path25);
+          const cv = visit_("value", node.value, visitor, path24);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -5790,17 +5790,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path25) {
-      const ctrl = await callVisitor(key, node, visitor, path25);
+    async function visitAsync_(key, node, visitor, path24) {
+      const ctrl = await callVisitor(key, node, visitor, path24);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path25, ctrl);
-        return visitAsync_(key, ctrl, visitor, path25);
+        replaceNode(key, path24, ctrl);
+        return visitAsync_(key, ctrl, visitor, path24);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path25 = Object.freeze(path25.concat(node));
+          path24 = Object.freeze(path24.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci2 = await visitAsync_(i, node.items[i], visitor, path25);
+            const ci2 = await visitAsync_(i, node.items[i], visitor, path24);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -5811,13 +5811,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path25 = Object.freeze(path25.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path25);
+          path24 = Object.freeze(path24.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path24);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path25);
+          const cv = await visitAsync_("value", node.value, visitor, path24);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -5844,23 +5844,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path25) {
+    function callVisitor(key, node, visitor, path24) {
       if (typeof visitor === "function")
-        return visitor(key, node, path25);
+        return visitor(key, node, path24);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path25);
+        return visitor.Map?.(key, node, path24);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path25);
+        return visitor.Seq?.(key, node, path24);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path25);
+        return visitor.Pair?.(key, node, path24);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path25);
+        return visitor.Scalar?.(key, node, path24);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path25);
+        return visitor.Alias?.(key, node, path24);
       return void 0;
     }
-    function replaceNode(key, path25, node) {
-      const parent = path25[path25.length - 1];
+    function replaceNode(key, path24, node) {
+      const parent = path24[path24.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -6468,10 +6468,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path25, value) {
+    function collectionFromPath(schema, path24, value) {
       let v2 = value;
-      for (let i = path25.length - 1; i >= 0; --i) {
-        const k2 = path25[i];
+      for (let i = path24.length - 1; i >= 0; --i) {
+        const k2 = path24[i];
         if (typeof k2 === "number" && Number.isInteger(k2) && k2 >= 0) {
           const a = [];
           a[k2] = v2;
@@ -6490,7 +6490,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path25) => path25 == null || typeof path25 === "object" && !!path25[Symbol.iterator]().next().done;
+    var isEmptyPath = (path24) => path24 == null || typeof path24 === "object" && !!path24[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -6520,11 +6520,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path25, value) {
-        if (isEmptyPath(path25))
+      addIn(path24, value) {
+        if (isEmptyPath(path24))
           this.add(value);
         else {
-          const [key, ...rest] = path25;
+          const [key, ...rest] = path24;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -6538,8 +6538,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path25) {
-        const [key, ...rest] = path25;
+      deleteIn(path24) {
+        const [key, ...rest] = path24;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -6553,8 +6553,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path25, keepScalar) {
-        const [key, ...rest] = path25;
+      getIn(path24, keepScalar) {
+        const [key, ...rest] = path24;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -6572,8 +6572,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path25) {
-        const [key, ...rest] = path25;
+      hasIn(path24) {
+        const [key, ...rest] = path24;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -6583,8 +6583,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path25, value) {
-        const [key, ...rest] = path25;
+      setIn(path24, value) {
+        const [key, ...rest] = path24;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -9096,9 +9096,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path25, value) {
+      addIn(path24, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path25, value);
+          this.contents.addIn(path24, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -9173,14 +9173,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path25) {
-        if (Collection.isEmptyPath(path25)) {
+      deleteIn(path24) {
+        if (Collection.isEmptyPath(path24)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path25) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path24) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -9195,10 +9195,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path25, keepScalar) {
-        if (Collection.isEmptyPath(path25))
+      getIn(path24, keepScalar) {
+        if (Collection.isEmptyPath(path24))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path25, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path24, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -9209,10 +9209,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path25) {
-        if (Collection.isEmptyPath(path25))
+      hasIn(path24) {
+        if (Collection.isEmptyPath(path24))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path25) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path24) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -9229,13 +9229,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path25, value) {
-        if (Collection.isEmptyPath(path25)) {
+      setIn(path24, value) {
+        if (Collection.isEmptyPath(path24)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path25), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path24), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path25, value);
+          this.contents.setIn(path24, value);
         }
       }
       /**
@@ -11192,9 +11192,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path25) => {
+    visit.itemAtPath = (cst, path24) => {
       let item = cst;
-      for (const [field, index] of path25) {
+      for (const [field, index] of path24) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -11203,23 +11203,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path25) => {
-      const parent = visit.itemAtPath(cst, path25.slice(0, -1));
-      const field = path25[path25.length - 1][0];
+    visit.parentCollection = (cst, path24) => {
+      const parent = visit.itemAtPath(cst, path24.slice(0, -1));
+      const field = path24[path24.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path25, item, visitor) {
-      let ctrl = visitor(item, path25);
+    function _visit(path24, item, visitor) {
+      let ctrl = visitor(item, path24);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci2 = _visit(Object.freeze(path25.concat([[field, i]])), token.items[i], visitor);
+            const ci2 = _visit(Object.freeze(path24.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -11230,10 +11230,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path25);
+            ctrl = ctrl(item, path24);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path25) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path24) : ctrl;
     }
     exports2.visit = visit;
   }
@@ -16708,7 +16708,7 @@ function delay2(time3) {
     setTimeout(resolve4, time3);
   });
 }
-var import_node_util3, import_util6, import_os, import_string_decoder, import_stream2, import_rfdc, import_crypto, ANSI_ESCAPE2, ANSI_ESCAPE_CODES, ListrEnvironmentVariables, ListrErrorTypes, ListrEventType, ListrRendererSelection, ListrTaskEventType, ListrTaskState, EventManager, BaseEventMap, CLEAR_LINE_REGEX, BELL_REGEX, color, FIGURES_MAIN, FIGURES_FALLBACK, figures, ListrLogLevels, LISTR_LOGGER_STYLE, LISTR_LOGGER_STDERR_LEVELS, ListrLogger, ProcessOutputBuffer, ProcessOutputStream, ProcessOutput, ListrPromptAdapter, Spinner, ListrDefaultRendererLogLevels, LISTR_DEFAULT_RENDERER_STYLE, PRESET_TIMER, PRESET_TIMESTAMP, DefaultRenderer, SilentRenderer, SimpleRenderer, TestRendererSerializer, TestRenderer, VerboseRenderer, RENDERERS, clone2, Concurrency, ListrError, ListrRendererError, PromptError, TaskWrapper, ListrTaskEventManager, Task, ListrEventManager, Listr;
+var import_node_util3, import_util6, import_os, import_string_decoder, import_stream2, import_rfdc, import_crypto2, ANSI_ESCAPE2, ANSI_ESCAPE_CODES, ListrEnvironmentVariables, ListrErrorTypes, ListrEventType, ListrRendererSelection, ListrTaskEventType, ListrTaskState, EventManager, BaseEventMap, CLEAR_LINE_REGEX, BELL_REGEX, color, FIGURES_MAIN, FIGURES_FALLBACK, figures, ListrLogLevels, LISTR_LOGGER_STYLE, LISTR_LOGGER_STDERR_LEVELS, ListrLogger, ProcessOutputBuffer, ProcessOutputStream, ProcessOutput, ListrPromptAdapter, Spinner, ListrDefaultRendererLogLevels, LISTR_DEFAULT_RENDERER_STYLE, PRESET_TIMER, PRESET_TIMESTAMP, DefaultRenderer, SilentRenderer, SimpleRenderer, TestRendererSerializer, TestRenderer, VerboseRenderer, RENDERERS, clone2, Concurrency, ListrError, ListrRendererError, PromptError, TaskWrapper, ListrTaskEventManager, Task, ListrEventManager, Listr;
 var init_dist = __esm({
   "node_modules/listr2/dist/index.mjs"() {
     init_eventemitter3();
@@ -16718,7 +16718,7 @@ var init_dist = __esm({
     import_string_decoder = require("string_decoder");
     import_stream2 = require("stream");
     import_rfdc = __toESM(require_rfdc(), 1);
-    import_crypto = require("crypto");
+    import_crypto2 = require("crypto");
     ANSI_ESCAPE2 = "\x1B[";
     ANSI_ESCAPE_CODES = {
       CURSOR_HIDE: ANSI_ESCAPE2 + "?25l",
@@ -18049,7 +18049,7 @@ var init_dist = __esm({
     };
     Task = class extends ListrTaskEventManager {
       /** Unique id per task, can be used for identifying a Task. */
-      id = (0, import_crypto.randomUUID)();
+      id = (0, import_crypto2.randomUUID)();
       /** The current state of the task. */
       state = ListrTaskState.WAITING;
       /** Subtasks of the current task. */
@@ -18810,11 +18810,11 @@ var init_types = __esm({
 });
 
 // packages/memory/dist/adapters/inmemory.js
-var import_node_crypto14, InMemoryAdapter;
+var import_node_crypto13, InMemoryAdapter;
 var init_inmemory = __esm({
   "packages/memory/dist/adapters/inmemory.js"() {
     "use strict";
-    import_node_crypto14 = require("node:crypto");
+    import_node_crypto13 = require("node:crypto");
     InMemoryAdapter = class {
       type = "inmemory";
       memories = /* @__PURE__ */ new Map();
@@ -18829,7 +18829,7 @@ var init_inmemory = __esm({
       async init() {
       }
       async add(content, options) {
-        const id = (0, import_node_crypto14.randomUUID)();
+        const id = (0, import_node_crypto13.randomUUID)();
         const now = Date.now();
         const entry = {
           id,
@@ -19260,8 +19260,8 @@ var init_supermemory = __esm({
       /**
        * Make a fetch request to the Supermemory API
        */
-      async fetch(path25, options) {
-        const url2 = `${this.endpoint}${path25}`;
+      async fetch(path24, options) {
+        const url2 = `${this.endpoint}${path24}`;
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
         try {
@@ -20388,7 +20388,7 @@ var BrokerTransport = class {
     return this.baseUrl.replace(/^http/, "ws") + "/ws";
   }
   // ── HTTP ─────────────────────────────────────────────────────────────
-  async request(path25, init) {
+  async request(path24, init) {
     const headers = new Headers(init?.headers);
     if (!headers.has("Content-Type")) {
       headers.set("Content-Type", "application/json");
@@ -20397,7 +20397,7 @@ var BrokerTransport = class {
       headers.set("X-API-Key", this.apiKey);
     }
     const signal = init?.signal ?? AbortSignal.timeout(this.requestTimeoutMs);
-    const res = await fetch(`${this.baseUrl}${path25}`, { ...init, headers, signal });
+    const res = await fetch(`${this.baseUrl}${path24}`, { ...init, headers, signal });
     if (!res.ok) {
       let body;
       try {
@@ -21650,8 +21650,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path25, errorMaps, issueData } = params;
-  const fullPath = [...path25, ...issueData.path || []];
+  const { data, path: path24, errorMaps, issueData } = params;
+  const fullPath = [...path24, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -21767,11 +21767,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path25, key) {
+  constructor(parent, value, path24, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path25;
+    this._path = path24;
     this._key = key;
   }
   get path() {
@@ -28082,10 +28082,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path25) {
-  if (!path25)
+function getElementAtPath(obj, path24) {
+  if (!path24)
     return obj;
-  return path25.reduce((acc, key) => acc?.[key], obj);
+  return path24.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -28468,11 +28468,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path25, issues) {
+function prefixIssues(path24, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path25);
+    iss.path.unshift(path24);
     return iss;
   });
 }
@@ -28655,7 +28655,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path25 = []) => {
+  const processError = (error49, path24 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -28665,7 +28665,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path25, ...issue2.path];
+        const fullpath = [...path24, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -28697,8 +28697,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path25 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path25) {
+  const path24 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path24) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -40675,13 +40675,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path25 = ref.slice(1).split("/").filter(Boolean);
-  if (path25.length === 0) {
+  const path24 = ref.slice(1).split("/").filter(Boolean);
+  if (path24.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path25[0] === defsKey) {
-    const key = path25[1];
+  if (path24[0] === defsKey) {
+    const key = path24[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -42831,8 +42831,8 @@ var HttpClient = class _HttpClient {
       version: this._originVersion
     }));
   }
-  async request(method, path25, body, query, options) {
-    const url2 = new URL(path25, this._baseUrl);
+  async request(method, path24, body, query, options) {
+    const url2 = new URL(path24, this._baseUrl);
     if (query) {
       for (const [k2, v2] of Object.entries(query)) {
         if (v2 !== void 0)
@@ -42902,20 +42902,20 @@ var HttpClient = class _HttpClient {
       return camelizeKeys(parsedData);
     }
   }
-  get(path25, query, options) {
-    return this.request("GET", path25, void 0, query, options);
+  get(path24, query, options) {
+    return this.request("GET", path24, void 0, query, options);
   }
-  post(path25, body, options) {
-    return this.request("POST", path25, body, void 0, options);
+  post(path24, body, options) {
+    return this.request("POST", path24, body, void 0, options);
   }
-  patch(path25, body, options) {
-    return this.request("PATCH", path25, body, void 0, options);
+  patch(path24, body, options) {
+    return this.request("PATCH", path24, body, void 0, options);
   }
-  put(path25, body, options) {
-    return this.request("PUT", path25, body, void 0, options);
+  put(path24, body, options) {
+    return this.request("PUT", path24, body, void 0, options);
   }
-  async delete(path25, options) {
-    await this.request("DELETE", path25, void 0, void 0, options);
+  async delete(path24, options) {
+    await this.request("DELETE", path24, void 0, void 0, options);
   }
 };
 
@@ -45517,8 +45517,8 @@ function isAgentStep(step) {
 
 // packages/sdk/dist/workflows/runner.js
 var import_node_child_process7 = require("node:child_process");
-var import_node_crypto8 = require("node:crypto");
-var import_node_fs21 = require("node:fs");
+var import_node_crypto7 = require("node:crypto");
+var import_node_fs20 = require("node:fs");
 var import_promises8 = require("node:fs/promises");
 var import_node_os8 = require("node:os");
 var import_node_path28 = __toESM(require("node:path"), 1);
@@ -45780,9 +45780,9 @@ async function resolveCli(cli) {
   for (const binary of def.binaries) {
     try {
       const { stdout } = await execFileAsync("which", [binary]);
-      const path25 = stdout.trim();
-      if (path25) {
-        const result = { binary, path: path25 };
+      const path24 = stdout.trim();
+      if (path24) {
+        const result = { binary, path: path24 };
         resolveCache.set(cli, result);
         return result;
       }
@@ -45819,9 +45819,9 @@ function resolveCliSync(cli) {
   for (const binary of def.binaries) {
     try {
       const stdout = execFileSync2("which", [binary], { stdio: ["pipe", "pipe", "ignore"] });
-      const path25 = stdout.toString().trim();
-      if (path25) {
-        const result = { binary, path: path25 };
+      const path24 = stdout.toString().trim();
+      if (path24) {
+        const result = { binary, path: path24 };
         resolveCache.set(cli, result);
         return result;
       }
@@ -47035,8 +47035,8 @@ var RelayFileClient = class {
       signal: options.signal
     });
   }
-  async readFile(workspaceId, path25, correlationId, signal) {
-    const query = buildQuery({ path: path25 });
+  async readFile(workspaceId, path24, correlationId, signal) {
+    const query = buildQuery({ path: path24 });
     return this.request({
       method: "GET",
       path: `/v1/workspaces/${encodeURIComponent(workspaceId)}/fs/file${query}`,
@@ -47077,8 +47077,8 @@ var RelayFileClient = class {
     });
   }
   async writeFile(input) {
-    const { workspaceId, path: path25, correlationId, baseRevision, content, contentType, encoding, semantics, signal } = input;
-    const query = buildQuery({ path: path25 });
+    const { workspaceId, path: path24, correlationId, baseRevision, content, contentType, encoding, semantics, signal } = input;
+    const query = buildQuery({ path: path24 });
     return this.request({
       method: "PUT",
       path: `/v1/workspaces/${encodeURIComponent(workspaceId)}/fs/file${query}`,
@@ -53020,10 +53020,987 @@ function delay(ms2) {
 }
 
 // packages/sdk/dist/workflows/trajectory.js
-var import_node_crypto7 = require("node:crypto");
-var import_node_fs20 = require("node:fs");
-var import_promises7 = require("node:fs/promises");
-var import_node_path27 = __toESM(require("node:path"), 1);
+var import_node_path27 = require("node:path");
+
+// node_modules/agent-trajectories/dist/chunk-W222QB6V.js
+var import_module = require("module");
+var import_crypto = require("crypto");
+var import_fs5 = require("fs");
+var import_promises7 = require("fs/promises");
+var import_path4 = require("path");
+var ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+var ID_LENGTH = 12;
+function generateRandomId(length = ID_LENGTH) {
+  let id = "";
+  const randomValues = new Uint8Array(length);
+  import_crypto.webcrypto.getRandomValues(randomValues);
+  for (let i = 0; i < length; i++) {
+    id += ALPHABET[randomValues[i] % ALPHABET.length];
+  }
+  return id;
+}
+function generateTrajectoryId() {
+  return `traj_${generateRandomId()}`;
+}
+function generateChapterId() {
+  return `chap_${generateRandomId()}`;
+}
+var TaskSourceSystemSchema = external_exports.union([
+  external_exports.literal("beads"),
+  external_exports.literal("github"),
+  external_exports.literal("linear"),
+  external_exports.literal("jira"),
+  external_exports.literal("plain"),
+  external_exports.string()
+  // Allow custom systems
+]);
+var TaskSourceSchema = external_exports.object({
+  system: TaskSourceSystemSchema,
+  id: external_exports.string().min(1, "Task ID is required"),
+  url: external_exports.string().url().optional()
+});
+var TaskReferenceSchema = external_exports.object({
+  title: external_exports.string().min(1, "Trajectory title is required").max(500, "Trajectory title must be 500 characters or less"),
+  description: external_exports.string().optional(),
+  source: TaskSourceSchema.optional()
+});
+var TrajectoryStatusSchema = external_exports.enum([
+  "active",
+  "completed",
+  "abandoned"
+]);
+var TrajectoryEventTypeSchema = external_exports.union([
+  external_exports.literal("prompt"),
+  external_exports.literal("thinking"),
+  external_exports.literal("tool_call"),
+  external_exports.literal("tool_result"),
+  external_exports.literal("message_sent"),
+  external_exports.literal("message_received"),
+  external_exports.literal("decision"),
+  external_exports.literal("finding"),
+  external_exports.literal("reflection"),
+  external_exports.literal("note"),
+  external_exports.literal("error"),
+  external_exports.string()
+  // Allow event types emitted by other tools (e.g. agent-relay's completion-evidence / completion-marker). Downstream code filters to known types.
+]);
+var EventSignificanceSchema = external_exports.enum([
+  "low",
+  "medium",
+  "high",
+  "critical"
+]);
+var TrajectoryEventSchema = external_exports.object({
+  ts: external_exports.number().int().positive(),
+  type: TrajectoryEventTypeSchema,
+  content: external_exports.string().min(1, "Event content is required"),
+  raw: external_exports.unknown().optional(),
+  significance: EventSignificanceSchema.optional(),
+  tags: external_exports.array(external_exports.string()).optional(),
+  confidence: external_exports.number().min(0, "Confidence must be between 0 and 1").max(1, "Confidence must be between 0 and 1").optional()
+});
+var AlternativeSchema = external_exports.object({
+  option: external_exports.string().min(1, "Alternative option is required"),
+  reason: external_exports.string().optional()
+});
+var DecisionSchema = external_exports.object({
+  question: external_exports.string().min(1, "Decision question is required"),
+  chosen: external_exports.string().min(1, "Chosen option is required"),
+  alternatives: external_exports.array(external_exports.union([external_exports.string(), AlternativeSchema])),
+  reasoning: external_exports.string().min(1, "Decision reasoning is required"),
+  confidence: external_exports.number().min(0, "Confidence must be between 0 and 1").max(1, "Confidence must be between 0 and 1").optional()
+});
+var AgentParticipationSchema = external_exports.object({
+  name: external_exports.string().min(1, "Agent name is required"),
+  role: external_exports.string().min(1, "Agent role is required"),
+  joinedAt: external_exports.string().datetime(),
+  leftAt: external_exports.string().datetime().optional()
+});
+var ChapterSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  title: external_exports.string().min(1, "Chapter title is required"),
+  agentName: external_exports.string().min(1, "Agent name is required"),
+  startedAt: external_exports.string().datetime(),
+  endedAt: external_exports.string().datetime().optional(),
+  events: external_exports.array(TrajectoryEventSchema)
+});
+var RetrospectiveSchema = external_exports.object({
+  summary: external_exports.string().min(1, "Retrospective summary is required"),
+  approach: external_exports.string().min(1, "Approach description is required"),
+  decisions: external_exports.array(DecisionSchema).optional(),
+  challenges: external_exports.array(external_exports.string()).optional(),
+  learnings: external_exports.array(external_exports.string()).optional(),
+  suggestions: external_exports.array(external_exports.string()).optional(),
+  confidence: external_exports.number().min(0, "Confidence must be between 0 and 1").max(1, "Confidence must be between 0 and 1"),
+  timeSpent: external_exports.string().optional()
+});
+var TraceRangeSchema = external_exports.object({
+  start_line: external_exports.number().int().positive("Start line must be positive"),
+  end_line: external_exports.number().int().positive("End line must be positive"),
+  revision: external_exports.string().optional(),
+  content_hash: external_exports.string().optional()
+});
+var ContributorTypeSchema = external_exports.enum([
+  "human",
+  "ai",
+  "mixed",
+  "unknown"
+]);
+var TraceContributorSchema = external_exports.object({
+  type: ContributorTypeSchema,
+  model_id: external_exports.string().max(250).optional()
+});
+var TraceConversationSchema = external_exports.object({
+  contributor: TraceContributorSchema,
+  url: external_exports.string().url().optional(),
+  ranges: external_exports.array(TraceRangeSchema)
+});
+var TraceFileSchema = external_exports.object({
+  path: external_exports.string().min(1, "File path is required"),
+  conversations: external_exports.array(TraceConversationSchema)
+});
+var TraceRecordSchema = external_exports.object({
+  version: external_exports.string().min(1, "Version is required"),
+  id: external_exports.string().min(1, "Trace ID is required"),
+  timestamp: external_exports.string().datetime(),
+  trajectory: external_exports.string().optional(),
+  files: external_exports.array(TraceFileSchema)
+});
+var TrajectoryTraceRefSchema = external_exports.object({
+  startRef: external_exports.string().min(1, "Start ref is required"),
+  endRef: external_exports.string().optional(),
+  traceId: external_exports.string().optional()
+});
+var TrajectorySchema = external_exports.object({
+  id: external_exports.string().regex(/^traj_[a-z0-9_]+$/, "Invalid trajectory ID format"),
+  version: external_exports.literal(1),
+  task: TaskReferenceSchema,
+  status: TrajectoryStatusSchema,
+  startedAt: external_exports.string().datetime(),
+  completedAt: external_exports.string().datetime().optional(),
+  agents: external_exports.array(AgentParticipationSchema),
+  chapters: external_exports.array(ChapterSchema),
+  retrospective: RetrospectiveSchema.optional(),
+  commits: external_exports.array(external_exports.string()).default([]),
+  filesChanged: external_exports.array(external_exports.string()).default([]),
+  projectId: external_exports.string().optional(),
+  workflowId: external_exports.string().optional(),
+  tags: external_exports.array(external_exports.string()).default([]),
+  _trace: TrajectoryTraceRefSchema.optional()
+});
+var CreateTrajectoryInputSchema = external_exports.object({
+  title: external_exports.string().min(1, "Trajectory title is required").max(500, "Trajectory title must be 500 characters or less"),
+  description: external_exports.string().optional(),
+  source: TaskSourceSchema.optional(),
+  projectId: external_exports.string().optional(),
+  tags: external_exports.array(external_exports.string()).optional()
+});
+var AddChapterInputSchema = external_exports.object({
+  title: external_exports.string().min(1, "Chapter title is required"),
+  agentName: external_exports.string().min(1, "Agent name is required")
+});
+var AddEventInputSchema = external_exports.object({
+  type: TrajectoryEventTypeSchema,
+  content: external_exports.string().min(1, "Event content is required"),
+  raw: external_exports.unknown().optional(),
+  significance: EventSignificanceSchema.optional(),
+  tags: external_exports.array(external_exports.string()).optional()
+});
+var CompleteTrajectoryInputSchema = external_exports.object({
+  summary: external_exports.string().min(1, "Retrospective summary is required"),
+  approach: external_exports.string().min(1, "Approach description is required"),
+  decisions: external_exports.array(DecisionSchema).optional(),
+  challenges: external_exports.array(external_exports.string()).optional(),
+  learnings: external_exports.array(external_exports.string()).optional(),
+  suggestions: external_exports.array(external_exports.string()).optional(),
+  confidence: external_exports.number().min(0, "Confidence must be between 0 and 1").max(1, "Confidence must be between 0 and 1")
+});
+var TrajectoryQuerySchema = external_exports.object({
+  status: TrajectoryStatusSchema.optional(),
+  since: external_exports.string().datetime().optional(),
+  until: external_exports.string().datetime().optional(),
+  limit: external_exports.number().int().positive().max(100).optional(),
+  offset: external_exports.number().int().nonnegative().optional(),
+  sortBy: external_exports.enum(["startedAt", "completedAt", "title"]).optional(),
+  sortOrder: external_exports.enum(["asc", "desc"]).optional()
+});
+function validateTrajectory(data) {
+  const result = TrajectorySchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, errors: result.error };
+}
+var TrajectoryError = class extends Error {
+  constructor(message, code, suggestion) {
+    super(message);
+    this.code = code;
+    this.suggestion = suggestion;
+    this.name = "TrajectoryError";
+  }
+};
+function createTrajectory(input) {
+  const validation = CreateTrajectoryInputSchema.safeParse(input);
+  if (!validation.success) {
+    const firstError = validation.error.errors[0];
+    throw new TrajectoryError(
+      firstError.message,
+      "VALIDATION_ERROR",
+      "Check your input and try again"
+    );
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: generateTrajectoryId(),
+    version: 1,
+    task: {
+      title: input.title,
+      description: input.description,
+      source: input.source
+    },
+    status: "active",
+    startedAt: now,
+    agents: [],
+    chapters: [],
+    commits: [],
+    filesChanged: [],
+    projectId: input.projectId ?? process.cwd(),
+    tags: input.tags ?? []
+  };
+}
+function addChapter(trajectory2, input) {
+  if (trajectory2.status === "completed") {
+    throw new TrajectoryError(
+      "Cannot add chapter to completed trajectory",
+      "TRAJECTORY_ALREADY_COMPLETED",
+      "Start a new trajectory instead"
+    );
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedChapters = trajectory2.chapters.map((chapter, index) => {
+    if (index === trajectory2.chapters.length - 1 && !chapter.endedAt) {
+      return { ...chapter, endedAt: now };
+    }
+    return chapter;
+  });
+  const newChapter = {
+    id: generateChapterId(),
+    title: input.title,
+    agentName: input.agentName,
+    startedAt: now,
+    events: []
+  };
+  let updatedAgents = trajectory2.agents;
+  const agentExists = trajectory2.agents.some((a) => a.name === input.agentName);
+  if (!agentExists) {
+    const isFirstAgent = trajectory2.agents.length === 0;
+    updatedAgents = [
+      ...trajectory2.agents,
+      {
+        name: input.agentName,
+        role: isFirstAgent ? "lead" : "contributor",
+        joinedAt: now
+      }
+    ];
+  }
+  return {
+    ...trajectory2,
+    agents: updatedAgents,
+    chapters: [...updatedChapters, newChapter]
+  };
+}
+function addEvent(trajectory2, input) {
+  let updatedTrajectory = trajectory2;
+  if (trajectory2.chapters.length === 0) {
+    updatedTrajectory = addChapter(trajectory2, {
+      title: "Work",
+      agentName: "default"
+    });
+  }
+  const event = {
+    ts: Date.now(),
+    type: input.type,
+    content: input.content,
+    raw: input.raw,
+    significance: input.significance,
+    tags: input.tags
+  };
+  const chapters = [...updatedTrajectory.chapters];
+  const lastChapter = chapters[chapters.length - 1];
+  chapters[chapters.length - 1] = {
+    ...lastChapter,
+    events: [...lastChapter.events, event]
+  };
+  return {
+    ...updatedTrajectory,
+    chapters
+  };
+}
+function completeTrajectory(trajectory2, input) {
+  if (trajectory2.status === "completed") {
+    throw new TrajectoryError(
+      "Trajectory is already completed",
+      "TRAJECTORY_ALREADY_COMPLETED",
+      "Start a new trajectory instead"
+    );
+  }
+  const validation = CompleteTrajectoryInputSchema.safeParse(input);
+  if (!validation.success) {
+    const firstError = validation.error.errors[0];
+    throw new TrajectoryError(
+      firstError.message,
+      "VALIDATION_ERROR",
+      "Check your input and try again"
+    );
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const chapters = trajectory2.chapters.map((chapter, index) => {
+    if (index === trajectory2.chapters.length - 1 && !chapter.endedAt) {
+      return { ...chapter, endedAt: now };
+    }
+    return chapter;
+  });
+  return {
+    ...trajectory2,
+    status: "completed",
+    completedAt: now,
+    chapters,
+    retrospective: {
+      summary: input.summary,
+      approach: input.approach,
+      decisions: input.decisions,
+      challenges: input.challenges,
+      learnings: input.learnings,
+      suggestions: input.suggestions,
+      confidence: input.confidence
+    }
+  };
+}
+function abandonTrajectory(trajectory2, reason) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const chapters = trajectory2.chapters.map((chapter, index) => {
+    if (index === trajectory2.chapters.length - 1 && !chapter.endedAt) {
+      return { ...chapter, endedAt: now };
+    }
+    return chapter;
+  });
+  let updatedChapters = chapters;
+  if (reason && chapters.length > 0) {
+    const lastChapter = chapters[chapters.length - 1];
+    updatedChapters = [
+      ...chapters.slice(0, -1),
+      {
+        ...lastChapter,
+        events: [
+          ...lastChapter.events,
+          {
+            ts: Date.now(),
+            type: "note",
+            content: `Abandoned: ${reason}`,
+            significance: "high"
+          }
+        ]
+      }
+    ];
+  }
+  return {
+    ...trajectory2,
+    status: "abandoned",
+    completedAt: now,
+    chapters: updatedChapters
+  };
+}
+function exportToMarkdown(trajectory2) {
+  const lines = [];
+  lines.push(`# Trajectory: ${trajectory2.task.title}`);
+  lines.push("");
+  lines.push(`> **Status:** ${formatStatus(trajectory2.status)}`);
+  if (trajectory2.task.source) {
+    const linkText = trajectory2.task.source.url ? `[${trajectory2.task.source.id}](${trajectory2.task.source.url})` : trajectory2.task.source.id;
+    lines.push(`> **Task:** ${linkText}`);
+  }
+  if (trajectory2.retrospective?.confidence !== void 0) {
+    lines.push(
+      `> **Confidence:** ${Math.round(trajectory2.retrospective.confidence * 100)}%`
+    );
+  }
+  lines.push(`> **Started:** ${formatDate(trajectory2.startedAt)}`);
+  if (trajectory2.completedAt) {
+    lines.push(`> **Completed:** ${formatDate(trajectory2.completedAt)}`);
+  }
+  lines.push("");
+  if (trajectory2.retrospective) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Summary");
+    lines.push("");
+    lines.push(trajectory2.retrospective.summary);
+    lines.push("");
+    if (trajectory2.retrospective.approach) {
+      lines.push(`**Approach:** ${trajectory2.retrospective.approach}`);
+      lines.push("");
+    }
+  }
+  const decisions = extractDecisions(trajectory2);
+  if (decisions.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Key Decisions");
+    lines.push("");
+    for (const decision of decisions) {
+      lines.push(`### ${decision.question}`);
+      lines.push(`- **Chose:** ${decision.chosen}`);
+      if (decision.alternatives.length > 0) {
+        const altStrings = decision.alternatives.map(
+          (a) => typeof a === "string" ? a : a.option
+        );
+        lines.push(`- **Rejected:** ${altStrings.join(", ")}`);
+      }
+      lines.push(`- **Reasoning:** ${decision.reasoning}`);
+      lines.push("");
+    }
+  }
+  if (trajectory2.chapters.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Chapters");
+    lines.push("");
+    trajectory2.chapters.forEach((chapter, index) => {
+      lines.push(`### ${index + 1}. ${chapter.title}`);
+      lines.push(`*Agent: ${chapter.agentName}*`);
+      lines.push("");
+      if (chapter.events.length > 0) {
+        const significantEvents = chapter.events.filter(
+          (e) => e.significance === "high" || e.significance === "critical" || e.type === "decision"
+        );
+        if (significantEvents.length > 0) {
+          for (const event of significantEvents) {
+            lines.push(`- ${event.content}`);
+          }
+          lines.push("");
+        }
+      }
+    });
+  }
+  if (trajectory2.retrospective?.challenges && trajectory2.retrospective.challenges.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Challenges");
+    lines.push("");
+    for (const challenge of trajectory2.retrospective.challenges) {
+      lines.push(`- ${challenge}`);
+    }
+    lines.push("");
+  }
+  if (trajectory2.retrospective?.learnings && trajectory2.retrospective.learnings.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Learnings");
+    lines.push("");
+    for (const learning of trajectory2.retrospective.learnings) {
+      lines.push(`- ${learning}`);
+    }
+    lines.push("");
+  }
+  if (trajectory2.retrospective?.suggestions && trajectory2.retrospective.suggestions.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Suggestions");
+    lines.push("");
+    for (const suggestion of trajectory2.retrospective.suggestions) {
+      lines.push(`- ${suggestion}`);
+    }
+    lines.push("");
+  }
+  if (trajectory2.commits.length > 0 || trajectory2.filesChanged.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Artifacts");
+    lines.push("");
+    if (trajectory2.commits.length > 0) {
+      lines.push(`**Commits:** ${trajectory2.commits.join(", ")}`);
+    }
+    if (trajectory2.filesChanged.length > 0) {
+      lines.push(`**Files changed:** ${trajectory2.filesChanged.length}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatStatus(status) {
+  switch (status) {
+    case "active":
+      return "\u{1F504} Active";
+    case "completed":
+      return "\u2705 Completed";
+    case "abandoned":
+      return "\u274C Abandoned";
+    default:
+      return status;
+  }
+}
+function formatDate(isoString) {
+  const date5 = new Date(isoString);
+  return date5.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function extractDecisions(trajectory2) {
+  const decisions = [];
+  if (trajectory2.retrospective?.decisions) {
+    decisions.push(...trajectory2.retrospective.decisions);
+  }
+  for (const chapter of trajectory2.chapters) {
+    for (const event of chapter.events) {
+      if (event.type === "decision" && event.raw) {
+        const raw = event.raw;
+        if (raw.question && raw.chosen && raw.reasoning) {
+          if (!decisions.some((d) => d.question === raw.question)) {
+            decisions.push(raw);
+          }
+        }
+      }
+    }
+  }
+  return decisions;
+}
+function expandPath(path24) {
+  if (path24.startsWith("~")) {
+    return (0, import_path4.join)(process.env.HOME ?? "", path24.slice(1));
+  }
+  return path24;
+}
+var FileStorage = class {
+  baseDir;
+  trajectoriesDir;
+  activeDir;
+  completedDir;
+  indexPath;
+  constructor(baseDir) {
+    this.baseDir = baseDir ?? process.cwd();
+    const dataDir = process.env.TRAJECTORIES_DATA_DIR;
+    if (dataDir) {
+      this.trajectoriesDir = expandPath(dataDir);
+    } else {
+      this.trajectoriesDir = (0, import_path4.join)(this.baseDir, ".trajectories");
+    }
+    this.activeDir = (0, import_path4.join)(this.trajectoriesDir, "active");
+    this.completedDir = (0, import_path4.join)(this.trajectoriesDir, "completed");
+    this.indexPath = (0, import_path4.join)(this.trajectoriesDir, "index.json");
+  }
+  /**
+   * Initialize storage directories
+   */
+  async initialize() {
+    await (0, import_promises7.mkdir)(this.trajectoriesDir, { recursive: true });
+    await (0, import_promises7.mkdir)(this.activeDir, { recursive: true });
+    await (0, import_promises7.mkdir)(this.completedDir, { recursive: true });
+    if (!(0, import_fs5.existsSync)(this.indexPath)) {
+      await this.saveIndex({
+        version: 1,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+        trajectories: {}
+      });
+    }
+    await this.reconcileIndex();
+  }
+  /**
+   * Scan active/ and completed/ recursively and add any trajectory files
+   * missing from the index. Existing entries are preserved — reconcile
+   * only adds, never removes.
+   *
+   * Handles three on-disk layouts in completed/:
+   *   - flat:      completed/{id}.json         (legacy workforce data)
+   *   - monthly:   completed/YYYY-MM/{id}.json (current save() writes)
+   *   - nested:    completed/.../{id}.json     (defensive — any depth)
+   *
+   * Returns a ReconcileSummary so tests and CLI wrappers can observe
+   * outcomes without parsing logs. Only writes the index if anything was
+   * added.
+   */
+  async reconcileIndex() {
+    const summary = {
+      scanned: 0,
+      added: 0,
+      alreadyIndexed: 0,
+      skippedMalformedJson: 0,
+      skippedSchemaViolation: 0,
+      skippedIoError: 0
+    };
+    const index = await this.loadIndex();
+    const before = Object.keys(index.trajectories).length;
+    const discovered = [];
+    try {
+      const activeFiles = await (0, import_promises7.readdir)(this.activeDir);
+      for (const file2 of activeFiles) {
+        if (!file2.endsWith(".json")) continue;
+        discovered.push((0, import_path4.join)(this.activeDir, file2));
+      }
+    } catch (error48) {
+      if (error48.code !== "ENOENT") throw error48;
+    }
+    await this.walkJsonFilesInto(this.completedDir, discovered);
+    for (const filePath of discovered) {
+      summary.scanned += 1;
+      const result = await this.readTrajectoryFile(filePath);
+      if (!result.ok) {
+        if (result.reason === "malformed_json") {
+          summary.skippedMalformedJson += 1;
+        } else if (result.reason === "schema_violation") {
+          summary.skippedSchemaViolation += 1;
+        } else {
+          summary.skippedIoError += 1;
+        }
+        continue;
+      }
+      const trajectory2 = result.trajectory;
+      if (index.trajectories[trajectory2.id]) {
+        summary.alreadyIndexed += 1;
+        continue;
+      }
+      index.trajectories[trajectory2.id] = {
+        title: trajectory2.task.title,
+        status: trajectory2.status,
+        startedAt: trajectory2.startedAt,
+        completedAt: trajectory2.completedAt,
+        path: filePath
+      };
+      summary.added += 1;
+    }
+    if (Object.keys(index.trajectories).length !== before) {
+      await this.saveIndex(index);
+    }
+    const hadSkips = summary.skippedMalformedJson + summary.skippedSchemaViolation + summary.skippedIoError > 0;
+    if (summary.added > 0 || hadSkips) {
+      const parts = [`reconciled ${summary.added}/${summary.scanned}`];
+      if (summary.skippedMalformedJson > 0) {
+        parts.push(`malformed: ${summary.skippedMalformedJson}`);
+      }
+      if (summary.skippedSchemaViolation > 0) {
+        parts.push(`invalid: ${summary.skippedSchemaViolation}`);
+      }
+      if (summary.skippedIoError > 0) {
+        parts.push(`io: ${summary.skippedIoError}`);
+      }
+      console.warn(`[trajectories] ${parts.join(", ")}`);
+    }
+    return summary;
+  }
+  /**
+   * Recursively collect all .json file paths under `dir` into `out`.
+   * Silently treats a missing directory as empty.
+   */
+  async walkJsonFilesInto(dir, out) {
+    let entries;
+    try {
+      entries = await (0, import_promises7.readdir)(dir, { withFileTypes: true });
+    } catch (error48) {
+      if (error48.code === "ENOENT") return;
+      throw error48;
+    }
+    for (const entry of entries) {
+      const entryPath = (0, import_path4.join)(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this.walkJsonFilesInto(entryPath, out);
+      } else if (entry.isFile() && entry.name.endsWith(".json")) {
+        out.push(entryPath);
+      }
+    }
+  }
+  /**
+   * Save a trajectory.
+   *
+   * Validates the input against the trajectory schema before touching
+   * disk. Closes the historical read/write asymmetry where save() would
+   * happily write data that the reader then rejected, producing files
+   * that could never be loaded back.
+   */
+  async save(input) {
+    const validation = validateTrajectory(input);
+    if (!validation.success) {
+      const issues = validation.errors?.issues.map((issue2) => {
+        const path24 = issue2.path.length > 0 ? issue2.path.join(".") : "root";
+        return `${path24}: ${issue2.message}`;
+      }).join("; ") ?? "unknown validation error";
+      throw new Error(`Cannot save invalid trajectory: ${issues}`);
+    }
+    const trajectory2 = validation.data;
+    const isCompleted = trajectory2.status === "completed" || trajectory2.status === "abandoned";
+    let filePath;
+    if (isCompleted) {
+      const date5 = new Date(trajectory2.completedAt ?? trajectory2.startedAt);
+      const monthDir = (0, import_path4.join)(
+        this.completedDir,
+        `${date5.getFullYear()}-${String(date5.getMonth() + 1).padStart(2, "0")}`
+      );
+      await (0, import_promises7.mkdir)(monthDir, { recursive: true });
+      filePath = (0, import_path4.join)(monthDir, `${trajectory2.id}.json`);
+      const activePath = (0, import_path4.join)(this.activeDir, `${trajectory2.id}.json`);
+      if ((0, import_fs5.existsSync)(activePath)) {
+        await (0, import_promises7.unlink)(activePath);
+      }
+      const mdPath = (0, import_path4.join)(monthDir, `${trajectory2.id}.md`);
+      const markdown = exportToMarkdown(trajectory2);
+      await (0, import_promises7.writeFile)(mdPath, markdown, "utf-8");
+    } else {
+      filePath = (0, import_path4.join)(this.activeDir, `${trajectory2.id}.json`);
+    }
+    await (0, import_promises7.writeFile)(filePath, JSON.stringify(trajectory2, null, 2), "utf-8");
+    await this.updateIndex(trajectory2, filePath);
+  }
+  /**
+   * Get a trajectory by ID
+   */
+  async get(id) {
+    const activePath = (0, import_path4.join)(this.activeDir, `${id}.json`);
+    if ((0, import_fs5.existsSync)(activePath)) {
+      return this.readTrajectoryOrNull(activePath);
+    }
+    const index = await this.loadIndex();
+    const entry = index.trajectories[id];
+    if (entry?.path && (0, import_fs5.existsSync)(entry.path)) {
+      return this.readTrajectoryOrNull(entry.path);
+    }
+    try {
+      const flatPath = (0, import_path4.join)(this.completedDir, `${id}.json`);
+      if ((0, import_fs5.existsSync)(flatPath)) {
+        return this.readTrajectoryOrNull(flatPath);
+      }
+      const months = await (0, import_promises7.readdir)(this.completedDir);
+      for (const month of months) {
+        const filePath = (0, import_path4.join)(this.completedDir, month, `${id}.json`);
+        if ((0, import_fs5.existsSync)(filePath)) {
+          return this.readTrajectoryOrNull(filePath);
+        }
+      }
+    } catch (error48) {
+      if (error48.code !== "ENOENT") {
+        console.error("Error searching completed trajectories:", error48);
+      }
+    }
+    return null;
+  }
+  /**
+   * Get the currently active trajectory
+   */
+  async getActive() {
+    try {
+      const files = await (0, import_promises7.readdir)(this.activeDir);
+      const jsonFiles = files.filter((f2) => f2.endsWith(".json"));
+      if (jsonFiles.length === 0) {
+        return null;
+      }
+      let mostRecent = null;
+      let mostRecentTime = 0;
+      for (const file2 of jsonFiles) {
+        const trajectory2 = await this.readTrajectoryOrNull(
+          (0, import_path4.join)(this.activeDir, file2)
+        );
+        if (trajectory2) {
+          const startTime = new Date(trajectory2.startedAt).getTime();
+          if (startTime > mostRecentTime) {
+            mostRecentTime = startTime;
+            mostRecent = trajectory2;
+          }
+        }
+      }
+      return mostRecent;
+    } catch (error48) {
+      if (error48.code === "ENOENT") {
+        return null;
+      }
+      console.error("Error reading active trajectories:", error48);
+      return null;
+    }
+  }
+  /**
+   * List trajectories with optional filtering
+   */
+  async list(query) {
+    const index = await this.loadIndex();
+    let entries = Object.entries(index.trajectories);
+    if (query.status) {
+      entries = entries.filter(([, entry]) => entry.status === query.status);
+    }
+    if (query.since) {
+      const sinceTime = new Date(query.since).getTime();
+      entries = entries.filter(
+        ([, entry]) => new Date(entry.startedAt).getTime() >= sinceTime
+      );
+    }
+    if (query.until) {
+      const untilTime = new Date(query.until).getTime();
+      entries = entries.filter(
+        ([, entry]) => new Date(entry.startedAt).getTime() <= untilTime
+      );
+    }
+    const sortBy = query.sortBy ?? "startedAt";
+    const sortOrder = query.sortOrder ?? "desc";
+    entries.sort((a, b2) => {
+      const aVal = a[1][sortBy] ?? "";
+      const bVal = b2[1][sortBy] ?? "";
+      const cmp = String(aVal).localeCompare(String(bVal));
+      return sortOrder === "asc" ? cmp : -cmp;
+    });
+    const offset = query.offset ?? 0;
+    const limit = query.limit ?? 50;
+    entries = entries.slice(offset, offset + limit);
+    return Promise.all(
+      entries.map(async ([id, entry]) => {
+        const trajectory2 = await this.get(id);
+        return {
+          id,
+          title: entry.title,
+          status: entry.status,
+          startedAt: entry.startedAt,
+          completedAt: entry.completedAt,
+          confidence: trajectory2?.retrospective?.confidence,
+          chapterCount: trajectory2?.chapters.length ?? 0,
+          decisionCount: trajectory2?.chapters.reduce(
+            (count, chapter) => count + chapter.events.filter((e) => e.type === "decision").length,
+            0
+          ) ?? 0
+        };
+      })
+    );
+  }
+  /**
+   * Delete a trajectory
+   */
+  async delete(id) {
+    const activePath = (0, import_path4.join)(this.activeDir, `${id}.json`);
+    if ((0, import_fs5.existsSync)(activePath)) {
+      await (0, import_promises7.unlink)(activePath);
+    }
+    const index = await this.loadIndex();
+    const entry = index.trajectories[id];
+    if (entry?.path && (0, import_fs5.existsSync)(entry.path)) {
+      await (0, import_promises7.unlink)(entry.path);
+      const mdPath = entry.path.replace(".json", ".md");
+      if ((0, import_fs5.existsSync)(mdPath)) {
+        await (0, import_promises7.unlink)(mdPath);
+      }
+    }
+    delete index.trajectories[id];
+    await this.saveIndex(index);
+  }
+  /**
+   * Search trajectories by text
+   */
+  async search(text, options) {
+    const allTrajectories = await this.list({});
+    const searchLower = text.toLowerCase();
+    const limit = options?.limit ?? 20;
+    const matches = [];
+    for (const summary of allTrajectories) {
+      if (matches.length >= limit) break;
+      if (summary.title.toLowerCase().includes(searchLower)) {
+        matches.push(summary);
+        continue;
+      }
+      const trajectory2 = await this.get(summary.id);
+      if (!trajectory2) continue;
+      if (trajectory2.retrospective?.summary.toLowerCase().includes(searchLower)) {
+        matches.push(summary);
+        continue;
+      }
+      const hasMatchingDecision = trajectory2.chapters.some(
+        (chapter) => chapter.events.some(
+          (event) => event.type === "decision" && event.content.toLowerCase().includes(searchLower)
+        )
+      );
+      if (hasMatchingDecision) {
+        matches.push(summary);
+      }
+    }
+    return matches;
+  }
+  /**
+   * Close storage (no-op for file storage)
+   */
+  async close() {
+  }
+  // Private helpers
+  /**
+   * Read a trajectory file and return a tagged result so callers can
+   * distinguish missing files, malformed JSON, and schema violations.
+   *
+   * Does NOT log. Callers choose whether to warn, swallow, or throw.
+   */
+  async readTrajectoryFile(path24) {
+    let content;
+    try {
+      content = await (0, import_promises7.readFile)(path24, "utf-8");
+    } catch (error48) {
+      return { ok: false, reason: "io_error", path: path24, error: error48 };
+    }
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch (error48) {
+      return { ok: false, reason: "malformed_json", path: path24, error: error48 };
+    }
+    const validation = validateTrajectory(data);
+    if (validation.success) {
+      return { ok: true, trajectory: validation.data };
+    }
+    return {
+      ok: false,
+      reason: "schema_violation",
+      path: path24,
+      error: validation.errors
+    };
+  }
+  /**
+   * Convenience wrapper for callers that only care whether they got a
+   * trajectory. Returns null for any failure and writes nothing to the
+   * console — so nothing leaks into test output or the CLI spinner.
+   */
+  async readTrajectoryOrNull(path24) {
+    const result = await this.readTrajectoryFile(path24);
+    return result.ok ? result.trajectory : null;
+  }
+  async loadIndex() {
+    try {
+      const content = await (0, import_promises7.readFile)(this.indexPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error48) {
+      if (error48.code !== "ENOENT") {
+        console.error(
+          "Error loading trajectory index, using empty index:",
+          error48
+        );
+      }
+      return {
+        version: 1,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+        trajectories: {}
+      };
+    }
+  }
+  async saveIndex(index) {
+    index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    await (0, import_promises7.writeFile)(this.indexPath, JSON.stringify(index, null, 2), "utf-8");
+  }
+  async updateIndex(trajectory2, filePath) {
+    const index = await this.loadIndex();
+    index.trajectories[trajectory2.id] = {
+      title: trajectory2.task.title,
+      status: trajectory2.status,
+      startedAt: trajectory2.startedAt,
+      completedAt: trajectory2.completedAt,
+      path: filePath
+    };
+    await this.saveIndex(index);
+  }
+};
+var require22 = (0, import_module.createRequire)(import_meta_url);
+
+// packages/sdk/dist/workflows/trajectory.js
 function classifyFailure(error48) {
   const e = error48.toLowerCase();
   if (e.includes("timed out") || e.includes("timeout"))
@@ -53041,30 +54018,84 @@ function classifyFailure(error48) {
 function diagnosisFor(cause, outcome) {
   switch (cause) {
     case "timeout":
-      if (outcome.nonInteractive) {
-        return `Non-interactive agent timed out \u2014 the task is likely too large or complex for a single subprocess call. Consider pre-reading large files in a deterministic step and injecting only the relevant excerpt via {{steps.X.output}}.`;
-      }
-      return `Interactive agent timed out \u2014 it may have gone idle, failed to self-terminate, or the task scope was too broad. Check if the agent was waiting for relay signals that never arrived.`;
+      return outcome.nonInteractive ? "Non-interactive agent timed out \u2014 the task is likely too large or complex for a single subprocess call. Consider pre-reading large files in a deterministic step and injecting only the relevant excerpt via {{steps.X.output}}." : "Interactive agent timed out \u2014 it may have gone idle, failed to self-terminate, or the task scope was too broad. Check if the agent was waiting for relay signals that never arrived.";
     case "verification_mismatch":
       return `Agent completed but did not output the expected sentinel "${outcome.verificationValue ?? "(unknown)"}". The task prompt may not clearly specify the required output format, or the agent produced correct work but did not emit the signal.`;
     case "spawn_failed":
-      return `The agent process could not be started \u2014 the CLI binary may be missing from PATH or the working directory is incorrect.`;
+      return "The agent process could not be started \u2014 the CLI binary may be missing from PATH or the working directory is incorrect.";
     case "exit_nonzero":
-      return `The agent process exited with a non-zero exit code. Check stderr for the root cause.`;
+      return "The agent process exited with a non-zero exit code. Check stderr for the root cause.";
     case "aborted":
-      return `The step was cancelled (user interrupt or upstream abort).`;
+      return "The step was cancelled (user interrupt or upstream abort).";
     default:
-      return `Unexpected failure. Review the error and step definition.`;
-  }
-}
+      return "Unexpected failure. Review the error and step definition.";
+  }
+}
+function buildSynthesis(label, outcomes, unblocks) {
+  const completed = outcomes.filter((o) => o.status === "completed");
+  const failed = outcomes.filter((o) => o.status === "failed");
+  const retried = outcomes.filter((o) => o.attempts > 1 && o.status !== "failed");
+  const parts = [`${label} resolved.`, `${completed.length}/${outcomes.length} steps completed.`];
+  if (failed.length > 0)
+    parts.push(`${failed.length} step(s) failed: ${failed.map((s3) => s3.name).join(", ")}.`);
+  if (retried.length > 0)
+    parts.push(`${retried.length} step(s) required retries: ${retried.map((s3) => s3.name).join(", ")}.`);
+  else if (failed.length === 0)
+    parts.push("All steps completed on first attempt.");
+  if (unblocks?.length)
+    parts.push(`Unblocking: ${unblocks.join(", ")}.`);
+  return parts.join(" ");
+}
+function computeConfidence(outcomes) {
+  if (outcomes.length === 0)
+    return 0.7;
+  const total = outcomes.length;
+  const completed = outcomes.filter((o) => o.status === "completed").length;
+  const firstAttempt = outcomes.filter((o) => o.attempts === 1 && o.status === "completed").length;
+  const verified = outcomes.filter((o) => o.verificationPassed).length;
+  return Math.min(1, 0.5 * (completed / total) + 0.25 * (firstAttempt / total) + 0.25 * (verified / total));
+}
+function formatElapsed(elapsed, long) {
+  return elapsed > 6e4 ? `${Math.round(elapsed / 6e4)}${long ? " minutes" : "min"}` : `${Math.round(elapsed / 1e3)}${long ? " seconds" : "s"}`;
+}
+function buildRunSummary(outcomes, startTime) {
+  const completed = outcomes.filter((o) => o.status === "completed");
+  const failed = outcomes.filter((o) => o.status === "failed");
+  const skipped = outcomes.filter((o) => o.status === "skipped");
+  const elapsedStr = formatElapsed(Date.now() - startTime, false);
+  if (failed.length === 0) {
+    const retried = completed.filter((o) => o.attempts > 1);
+    const base = `All ${completed.length} steps completed in ${elapsedStr}.`;
+    return retried.length > 0 ? `${base} ${retried.length} step(s) needed retries: ${retried.map((o) => o.name).join(", ")}.` : base;
+  }
+  const firstFailure = failed[0];
+  const cause = classifyFailure(firstFailure.error ?? "");
+  const cascaded = skipped.length > 0 ? ` Caused ${skipped.length} downstream step(s) to be skipped: ${skipped.map((o) => o.name).join(", ")}.` : "";
+  return `Failed at "${firstFailure.name}" [${cause}] after ${elapsedStr}.${cascaded} ${completed.length}/${outcomes.length} steps completed before failure.`;
+}
+function extractLearnings(outcomes) {
+  const learnings = [];
+  const timeouts = outcomes.filter((o) => o.status === "failed" && classifyFailure(o.error ?? "") === "timeout");
+  if (timeouts.some((o) => o.nonInteractive))
+    learnings.push(`Non-interactive agent timeouts detected (${timeouts.map((o) => o.name).join(", ")}). Use deterministic steps to pre-read files and inject content \u2014 non-interactive agents should not discover information via tools.`);
+  const verifyFails = outcomes.filter((o) => o.status === "failed" && classifyFailure(o.error ?? "") === "verification_mismatch");
+  if (verifyFails.length > 0)
+    learnings.push(`Verification mismatch on: ${verifyFails.map((o) => `"${o.name}" (expected "${o.verificationValue ?? "?"}")`).join(", ")}. Make the required output format more explicit in the task prompt.`);
+  const retried = outcomes.filter((o) => o.attempts > 1 && o.status === "completed");
+  if (retried.length > 0)
+    learnings.push(`${retried.map((o) => `"${o.name}" (${o.attempts} attempts)`).join(", ")} succeeded after retries \u2014 consider adding clearer output instructions to reduce retries.`);
+  return learnings;
+}
+var extractChallenges = (outcomes) => outcomes.filter((o) => o.status === "failed").map((step) => diagnosisFor(classifyFailure(step.error ?? ""), step));
 var WorkflowTrajectory = class {
   trajectory = null;
-  currentChapterId = null;
+  storage;
+  storageInit;
   enabled;
   reflectOnBarriers;
   reflectOnConverge;
   autoDecisions;
-  dataDir;
+  storageBaseDir;
   runId;
   startTime = 0;
   swarmPattern = "dag";
@@ -53075,100 +54106,73 @@ var WorkflowTrajectory = class {
     this.reflectOnConverge = cfg.reflectOnConverge !== false;
     this.autoDecisions = cfg.autoDecisions !== false;
     this.runId = runId;
-    this.dataDir = process.env.TRAJECTORIES_DATA_DIR ?? import_node_path27.default.join(cwd, ".trajectories");
+    const dataDir = process.env.TRAJECTORIES_DATA_DIR ?? (0, import_node_path27.join)(cwd, ".trajectories");
+    this.storageBaseDir = process.env.TRAJECTORIES_DATA_DIR ? (0, import_node_path27.dirname)(dataDir) : cwd;
   }
-  // ── Lifecycle ──────────────────────────────────────────────────────────────
-  /** Start the trajectory (called at run:started). */
   async start(workflowName, stepCount, trackInfo, description, pattern) {
     if (!this.enabled)
       return;
     this.startTime = Date.now();
     this.swarmPattern = pattern ?? "dag";
-    const id = `traj_${Date.now()}_${(0, import_node_crypto7.randomBytes)(4).toString("hex")}`;
-    this.trajectory = {
-      id,
-      version: 1,
-      task: {
-        title: workflowName,
-        source: { system: "workflow-runner", id: this.runId }
-      },
-      status: "active",
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      agents: [{ name: "orchestrator", role: "workflow-runner", joinedAt: (/* @__PURE__ */ new Date()).toISOString() }],
-      chapters: []
-    };
+    this.trajectory = createTrajectory({
+      title: workflowName,
+      description,
+      source: { system: "workflow-runner", id: this.runId }
+    });
+    const workflowId = process.env.TRAJECTORIES_WORKFLOW_ID?.trim();
+    if (workflowId)
+      this.trajectory = { ...this.trajectory, workflowId };
+    this.trajectory.agents.push({
+      name: "orchestrator",
+      role: "workflow-runner",
+      joinedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
     this.openChapter("Planning", "orchestrator");
-    if (description) {
+    if (description)
       this.addEvent("note", `Purpose: ${description.trim()}`);
-    }
     this.addEvent("note", `Approach: ${stepCount}-step ${this.swarmPattern} workflow${trackInfo ? ` \u2014 ${trackInfo}` : ""}`);
     await this.flush();
   }
-  // ── Chapters ───────────────────────────────────────────────────────────────
-  /** Begin a new parallel track chapter. */
   async beginTrack(trackName) {
-    if (!this.enabled || !this.trajectory)
-      return;
-    this.closeCurrentChapter();
-    this.openChapter(`Execution: ${trackName}`, "orchestrator");
-    await this.flush();
+    if (this.enabled && this.trajectory) {
+      this.openChapter(`Execution: ${trackName}`, "orchestrator");
+      await this.flush();
+    }
   }
-  /** Begin a convergence chapter (after barrier/parallel completion). */
   async beginConvergence(label) {
-    if (!this.enabled || !this.trajectory)
-      return;
-    this.closeCurrentChapter();
-    this.openChapter(`Convergence: ${label}`, "orchestrator");
-    await this.flush();
-  }
-  /** Begin the retrospective chapter. */
-  openRetrospective() {
-    if (!this.trajectory)
-      return;
-    this.closeCurrentChapter();
-    this.openChapter("Retrospective", "orchestrator");
+    if (this.enabled && this.trajectory) {
+      this.openChapter(`Convergence: ${label}`, "orchestrator");
+      await this.flush();
+    }
   }
-  // ── Step events ────────────────────────────────────────────────────────────
-  /** Record step started — captures intent, not just assignment. */
   async stepStarted(step, agent, participants) {
     if (!this.enabled || !this.trajectory)
       return;
     await this.registerAgent(agent, participants?.role ?? step.agent ?? "deterministic");
-    if (participants?.owner && participants.owner !== agent) {
+    if (participants?.owner && participants.owner !== agent)
       await this.registerAgent(participants.owner, "owner");
-    }
-    if (participants?.specialist) {
+    if (participants?.specialist)
       await this.registerAgent(participants.specialist, "specialist");
-    }
-    if (participants?.reviewer) {
+    if (participants?.reviewer)
       await this.registerAgent(participants.reviewer, "reviewer");
-    }
-    this.closeCurrentChapter();
     this.openChapter(`Execution: ${step.name}`, agent);
     const intent = step.task ? step.task.trim().split(/\n|\.(?=\s)/)[0].trim().slice(0, 120) : `${step.type ?? "deterministic"} step`;
     this.addEvent("note", `"${step.name}": ${intent}`, void 0, { agent });
     await this.flush();
   }
   async registerAgent(name, role) {
-    if (!this.enabled || !this.trajectory)
+    if (!this.enabled || !this.trajectory || this.trajectory.agents.some((agent) => agent.name === name))
       return;
-    if (!this.trajectory.agents.some((a) => a.name === name)) {
-      this.trajectory.agents.push({
-        name,
-        role,
-        joinedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      await this.flush();
-    }
+    this.trajectory.agents.push({ name, role, joinedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    await this.flush();
   }
   async stepSupervisionAssigned(step, supervised) {
     if (!this.enabled || !this.trajectory)
       return;
     await this.registerAgent(supervised.owner.name, "owner");
     await this.registerAgent(supervised.specialist.name, "specialist");
-    if (supervised.reviewer?.name) {
+    if (supervised.reviewer?.name)
       await this.registerAgent(supervised.reviewer.name, "reviewer");
-    }
     const reviewerNote = supervised.reviewer?.name ? `, reviewer=${supervised.reviewer.name}` : "";
     this.addEvent("decision", `"${step.name}" supervision assigned \u2192 owner=${supervised.owner.name}, specialist=${supervised.specialist.name}${reviewerNote}`, "medium", {
       owner: supervised.owner.name,
@@ -53200,31 +54204,20 @@ var WorkflowTrajectory = class {
     const modeLabel = decision.mode === "marker" ? "marker-based" : `${decision.mode}-based`;
     const reason = decision.reason ? ` \u2014 ${decision.reason}` : "";
     const evidence = this.formatCompletionEvidenceSummary(decision.evidence);
-    const evidenceSuffix = evidence ? ` (${evidence})` : "";
-    this.addEvent(decision.mode === "marker" ? "completion-marker" : "completion-evidence", `"${stepName}" ${modeLabel} completion${reason}${evidenceSuffix}`, "medium", {
-      stepName,
-      completionMode: decision.mode,
-      reason: decision.reason,
-      evidence: decision.evidence
-    });
+    this.addEvent(decision.mode === "marker" ? "completion-marker" : "completion-evidence", `"${stepName}" ${modeLabel} completion${reason}${evidence ? ` (${evidence})` : ""}`, "medium", { stepName, completionMode: decision.mode, reason: decision.reason, evidence: decision.evidence });
     await this.flush();
   }
-  /** Record step completed — captures what was accomplished. */
   async stepCompleted(step, output, attempt, decision) {
     if (!this.enabled || !this.trajectory)
       return;
-    const suffix = attempt > 1 ? ` (after ${attempt} attempts)` : "";
-    const lines = output.split("\n").map((l) => l.trim()).filter(Boolean);
+    if (decision)
+      await this.stepCompletionDecision(step.name, decision);
+    const lines = output.split("\n").map((line) => line.trim()).filter(Boolean);
     const lastMeaningful = lines.at(-1) ?? "";
     const completion = lastMeaningful.length > 0 && lastMeaningful.length < 100 ? lastMeaningful : output.trim().slice(0, 120) || "(no output)";
-    if (decision) {
-      await this.stepCompletionDecision(step.name, decision);
-    }
-    const modeSuffix = decision ? ` [${decision.mode}]` : "";
-    this.addEvent("finding", `"${step.name}" completed${suffix}${modeSuffix} \u2192 ${completion}`, "medium");
+    this.addEvent("finding", `"${step.name}" completed${attempt > 1 ? ` (after ${attempt} attempts)` : ""}${decision ? ` [${decision.mode}]` : ""} \u2192 ${completion}`, "medium");
     await this.flush();
   }
-  /** Record step failed — categorizes root cause for actionable diagnosis. */
   async stepFailed(step, error48, attempt, maxRetries, outcome) {
     if (!this.enabled || !this.trajectory)
       return;
@@ -53246,44 +54239,30 @@ var WorkflowTrajectory = class {
     });
     await this.flush();
   }
-  /** Record step skipped — note the cascade impact. */
   async stepSkipped(step, reason) {
-    if (!this.enabled || !this.trajectory)
-      return;
-    this.addEvent("note", `"${step.name}" skipped \u2014 ${reason}`);
-    await this.flush();
+    if (this.enabled && this.trajectory) {
+      this.addEvent("note", `"${step.name}" skipped \u2014 ${reason}`);
+      await this.flush();
+    }
   }
-  /** Record step retrying. */
   async stepRetrying(step, attempt, maxRetries) {
-    if (!this.enabled || !this.trajectory)
-      return;
-    this.addEvent("note", `"${step.name}" retrying (attempt ${attempt}/${maxRetries + 1})`);
-    await this.flush();
+    if (this.enabled && this.trajectory) {
+      this.addEvent("note", `"${step.name}" retrying (attempt ${attempt}/${maxRetries + 1})`);
+      await this.flush();
+    }
   }
-  // ── Reflections ────────────────────────────────────────────────────────────
-  /** Record a reflection at a convergence point. */
   async reflect(synthesis, confidence, focalPoints) {
     if (!this.enabled || !this.trajectory)
       return;
-    const raw = { confidence };
-    if (focalPoints?.length) {
-      raw.focalPoints = focalPoints;
-    }
-    this.addEvent("reflection", synthesis, "high", raw);
+    this.addEvent("reflection", synthesis, "high", focalPoints?.length ? { confidence, focalPoints } : { confidence });
     await this.flush();
   }
-  /** Synthesize and reflect after a set of steps complete (barrier or parallel convergence). */
   async synthesizeAndReflect(label, outcomes, unblocks) {
     if (!this.enabled || !this.trajectory)
       return;
-    const synthesis = this.buildSynthesis(label, outcomes, unblocks);
-    const confidence = this.computeConfidence(outcomes);
-    const focalPoints = outcomes.map((o) => `${o.name}: ${o.status}`);
     await this.beginConvergence(label);
-    await this.reflect(synthesis, confidence, focalPoints);
+    await this.reflect(buildSynthesis(label, outcomes, unblocks), computeConfidence(outcomes), outcomes.map((o) => `${o.name}: ${o.status}`));
   }
-  // ── Decisions ──────────────────────────────────────────────────────────────
-  /** Record an orchestrator decision. */
   async decide(question, chosen, reasoning) {
     if (!this.enabled || !this.trajectory || !this.autoDecisions)
       return;
@@ -53294,52 +54273,39 @@ var WorkflowTrajectory = class {
     });
     await this.flush();
   }
-  // ── Completion ─────────────────────────────────────────────────────────────
-  /** Complete the trajectory with a summary. */
   async complete(summary, confidence, meta3) {
     if (!this.enabled || !this.trajectory)
       return;
-    this.openRetrospective();
-    const elapsed = Date.now() - this.startTime;
-    const elapsedStr = elapsed > 6e4 ? `${Math.round(elapsed / 6e4)} minutes` : `${Math.round(elapsed / 1e3)} seconds`;
-    this.addEvent("reflection", `${summary} (completed in ${elapsedStr})`, "high");
-    this.trajectory.status = "completed";
-    this.trajectory.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    this.trajectory.retrospective = {
+    this.openChapter("Retrospective", "orchestrator");
+    this.addEvent("reflection", `${summary} (completed in ${formatElapsed(Date.now() - this.startTime, true)})`, "high");
+    this.trajectory = completeTrajectory(this.trajectory, {
       summary,
-      approach: `${this.swarmPattern} workflow (${this.trajectory.agents.filter((a) => a.role !== "workflow-runner").length} agents)`,
+      approach: this.buildApproach(),
       confidence,
       learnings: meta3?.learnings,
       challenges: meta3?.challenges
-    };
-    this.closeCurrentChapter();
+    });
     await this.flush();
-    await this.moveToCompleted();
   }
-  /** Abandon the trajectory. */
   async abandon(reason, meta3) {
     if (!this.enabled || !this.trajectory)
       return;
-    const elapsed = Date.now() - this.startTime;
-    const elapsedStr = elapsed > 6e4 ? `${Math.round(elapsed / 6e4)} minutes` : `${Math.round(elapsed / 1e3)} seconds`;
     const summary = meta3?.summary ?? `Workflow abandoned: ${reason}`;
-    this.openRetrospective();
-    this.addEvent("reflection", `${summary} (abandoned after ${elapsedStr})`, "high");
+    this.openChapter("Retrospective", "orchestrator");
+    this.addEvent("reflection", `${summary} (abandoned after ${formatElapsed(Date.now() - this.startTime, true)})`, "high");
     this.addEvent("error", `Workflow abandoned: ${reason}`, "high");
-    this.trajectory.status = "abandoned";
-    this.trajectory.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    this.trajectory.retrospective = {
-      summary,
-      approach: `${this.swarmPattern} workflow (${this.trajectory.agents.filter((a) => a.role !== "workflow-runner").length} agents)`,
-      confidence: meta3?.confidence ?? 0,
-      learnings: meta3?.learnings,
-      challenges: meta3?.challenges
+    this.trajectory = {
+      ...abandonTrajectory(this.trajectory),
+      retrospective: {
+        summary,
+        approach: this.buildApproach(),
+        confidence: meta3?.confidence ?? 0,
+        learnings: meta3?.learnings,
+        challenges: meta3?.challenges
+      }
     };
-    this.closeCurrentChapter();
     await this.flush();
-    await this.moveToCompleted();
   }
-  // ── Getters ────────────────────────────────────────────────────────────────
   isEnabled() {
     return this.enabled;
   }
@@ -53352,117 +54318,33 @@ var WorkflowTrajectory = class {
   getTrajectoryId() {
     return this.trajectory?.id ?? null;
   }
-  // ── Synthesis helpers ──────────────────────────────────────────────────────
   buildSynthesis(label, outcomes, unblocks) {
-    const completed = outcomes.filter((o) => o.status === "completed");
-    const failed = outcomes.filter((o) => o.status === "failed");
-    const retried = outcomes.filter((o) => o.attempts > 1 && o.status !== "failed");
-    const parts = [`${label} resolved.`, `${completed.length}/${outcomes.length} steps completed.`];
-    if (failed.length > 0) {
-      parts.push(`${failed.length} step(s) failed: ${failed.map((s3) => s3.name).join(", ")}.`);
-    }
-    if (retried.length > 0) {
-      parts.push(`${retried.length} step(s) required retries: ${retried.map((s3) => s3.name).join(", ")}.`);
-    } else if (failed.length === 0) {
-      parts.push("All steps completed on first attempt.");
-    }
-    if (unblocks?.length) {
-      parts.push(`Unblocking: ${unblocks.join(", ")}.`);
-    }
-    return parts.join(" ");
+    return buildSynthesis(label, outcomes, unblocks);
   }
   computeConfidence(outcomes) {
-    if (outcomes.length === 0)
-      return 0.7;
-    const total = outcomes.length;
-    const completed = outcomes.filter((o) => o.status === "completed").length;
-    const firstAttempt = outcomes.filter((o) => o.attempts === 1 && o.status === "completed").length;
-    const verified = outcomes.filter((o) => o.verificationPassed).length;
-    const completionRate = completed / total;
-    return Math.min(1, 0.5 * completionRate + firstAttempt / total * 0.25 + verified / total * 0.25);
+    return computeConfidence(outcomes);
   }
   buildRunSummary(outcomes) {
-    const completed = outcomes.filter((o) => o.status === "completed");
-    const failed = outcomes.filter((o) => o.status === "failed");
-    const skipped = outcomes.filter((o) => o.status === "skipped");
-    const elapsed = Date.now() - this.startTime;
-    const elapsedStr = elapsed > 6e4 ? `${Math.round(elapsed / 6e4)}min` : `${Math.round(elapsed / 1e3)}s`;
-    if (failed.length === 0) {
-      const retried = completed.filter((o) => o.attempts > 1);
-      const base = `All ${completed.length} steps completed in ${elapsedStr}.`;
-      return retried.length > 0 ? `${base} ${retried.length} step(s) needed retries: ${retried.map((o) => o.name).join(", ")}.` : base;
-    }
-    const firstFailure = failed[0];
-    const cause = classifyFailure(firstFailure.error ?? "");
-    const cascaded = skipped.length > 0 ? ` Caused ${skipped.length} downstream step(s) to be skipped: ${skipped.map((o) => o.name).join(", ")}.` : "";
-    return `Failed at "${firstFailure.name}" [${cause}] after ${elapsedStr}.${cascaded} ${completed.length}/${outcomes.length} steps completed before failure.`;
+    return buildRunSummary(outcomes, this.startTime);
   }
   extractLearnings(outcomes) {
-    const learnings = [];
-    const timeouts = outcomes.filter((o) => o.status === "failed" && classifyFailure(o.error ?? "") === "timeout");
-    if (timeouts.some((o) => o.nonInteractive)) {
-      learnings.push(`Non-interactive agent timeouts detected (${timeouts.map((o) => o.name).join(", ")}). Use deterministic steps to pre-read files and inject content \u2014 non-interactive agents should not discover information via tools.`);
-    }
-    const verifyFails = outcomes.filter((o) => o.status === "failed" && classifyFailure(o.error ?? "") === "verification_mismatch");
-    if (verifyFails.length > 0) {
-      learnings.push(`Verification mismatch on: ${verifyFails.map((o) => `"${o.name}" (expected "${o.verificationValue ?? "?"}")`).join(", ")}. Make the required output format more explicit in the task prompt.`);
-    }
-    const retried = outcomes.filter((o) => o.attempts > 1 && o.status === "completed");
-    if (retried.length > 0) {
-      learnings.push(`${retried.map((o) => `"${o.name}" (${o.attempts} attempts)`).join(", ")} succeeded after retries \u2014 consider adding clearer output instructions to reduce retries.`);
-    }
-    return learnings;
+    return extractLearnings(outcomes);
   }
   extractChallenges(outcomes) {
-    const challenges = [];
-    const failed = outcomes.filter((o) => o.status === "failed");
-    for (const step of failed) {
-      const cause = classifyFailure(step.error ?? "");
-      challenges.push(diagnosisFor(cause, step));
-    }
-    return challenges;
+    return extractChallenges(outcomes);
   }
-  // ── Internal helpers ───────────────────────────────────────────────────────
   openChapter(title, agentName) {
     if (!this.trajectory)
       return;
-    const chapter = {
-      id: `ch_${(0, import_node_crypto7.randomBytes)(4).toString("hex")}`,
-      title,
-      agentName,
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      events: []
-    };
-    this.trajectory.chapters.push(chapter);
-    this.currentChapterId = chapter.id;
-  }
-  closeCurrentChapter() {
-    if (!this.trajectory || !this.currentChapterId)
-      return;
-    const chapter = this.trajectory.chapters.find((c) => c.id === this.currentChapterId);
-    if (chapter && !chapter.endedAt) {
-      chapter.endedAt = (/* @__PURE__ */ new Date()).toISOString();
-    }
-    this.currentChapterId = null;
+    this.trajectory = addChapter(this.trajectory, { title, agentName });
   }
   addEvent(type, content, significance, raw) {
     if (!this.trajectory)
       return;
-    let chapter = this.trajectory.chapters.find((c) => c.id === this.currentChapterId);
-    if (!chapter) {
-      this.openChapter("Execution", "orchestrator");
-      chapter = this.trajectory.chapters[this.trajectory.chapters.length - 1];
-    }
-    const event = {
-      ts: Date.now(),
-      type,
-      content
-    };
-    if (significance)
-      event.significance = significance;
-    if (raw)
-      event.raw = raw;
-    chapter.events.push(event);
+    this.trajectory = addEvent(this.trajectory, { type, content, significance, raw });
+  }
+  buildApproach() {
+    return `${this.swarmPattern} workflow (${this.trajectory?.agents.filter((a) => a.role !== "workflow-runner").length ?? 0} agents)`;
   }
   formatCompletionEvidenceSummary(evidence) {
     if (!evidence)
@@ -53480,29 +54362,17 @@ var WorkflowTrajectory = class {
       parts.push(`exit=${evidence.exitCode}`);
     return parts.length > 0 ? parts.join("; ") : void 0;
   }
+  async ensureStorage() {
+    this.storage ??= new FileStorage(this.storageBaseDir);
+    this.storageInit ??= this.storage.initialize();
+    await this.storageInit;
+  }
   async flush() {
     if (!this.trajectory)
       return;
     try {
-      const activeDir = import_node_path27.default.join(this.dataDir, "active");
-      await (0, import_promises7.mkdir)(activeDir, { recursive: true });
-      const filePath = import_node_path27.default.join(activeDir, `${this.trajectory.id}.json`);
-      await (0, import_promises7.writeFile)(filePath, JSON.stringify(this.trajectory, null, 2), "utf-8");
-    } catch {
-    }
-  }
-  async moveToCompleted() {
-    if (!this.trajectory)
-      return;
-    try {
-      const activeDir = import_node_path27.default.join(this.dataDir, "active");
-      const completedDir = import_node_path27.default.join(this.dataDir, "completed");
-      await (0, import_promises7.mkdir)(completedDir, { recursive: true });
-      const activePath = import_node_path27.default.join(activeDir, `${this.trajectory.id}.json`);
-      const completedPath = import_node_path27.default.join(completedDir, `${this.trajectory.id}.json`);
-      if ((0, import_node_fs20.existsSync)(activePath)) {
-        await (0, import_promises7.rename)(activePath, completedPath);
-      }
+      await this.ensureStorage();
+      await this.storage?.save(this.trajectory);
     } catch {
     }
   }
@@ -53693,7 +54563,7 @@ var WorkflowRunner = class _WorkflowRunner {
       const abs = import_node_path28.default.resolve(baseCwd, expanded);
       resolved.set(pd.name, abs);
       const isRequired = pd.required !== false;
-      if (!(0, import_node_fs21.existsSync)(abs)) {
+      if (!(0, import_node_fs20.existsSync)(abs)) {
         if (isRequired) {
           errors.push(`Path "${pd.name}" resolves to "${abs}" which does not exist (required)`);
         } else {
@@ -54328,12 +55198,12 @@ ${next}` : next;
   }
   captureFileSnapshot(root) {
     const snapshot = /* @__PURE__ */ new Map();
-    if (!(0, import_node_fs21.existsSync)(root))
+    if (!(0, import_node_fs20.existsSync)(root))
       return snapshot;
     const visit = (currentPath) => {
       let entries;
       try {
-        entries = (0, import_node_fs21.readdirSync)(currentPath, { withFileTypes: true });
+        entries = (0, import_node_fs20.readdirSync)(currentPath, { withFileTypes: true });
       } catch {
         return;
       }
@@ -54347,7 +55217,7 @@ ${next}` : next;
           continue;
         }
         try {
-          const stats = (0, import_node_fs21.statSync)(fullPath);
+          const stats = (0, import_node_fs20.statSync)(fullPath);
           if (!stats.isFile())
             continue;
           snapshot.set(fullPath, { mtimeMs: stats.mtimeMs, size: stats.size });
@@ -54356,7 +55226,7 @@ ${next}` : next;
       }
     };
     try {
-      const stats = (0, import_node_fs21.statSync)(root);
+      const stats = (0, import_node_fs20.statSync)(root);
       if (stats.isFile()) {
         snapshot.set(root, { mtimeMs: stats.mtimeMs, size: stats.size });
         return snapshot;
@@ -54477,7 +55347,7 @@ ${next}` : next;
       this.relayApiKey = envKey;
       return;
     }
-    const workspaceName = `relay-${channel}-${(0, import_node_crypto8.randomBytes)(4).toString("hex")}`;
+    const workspaceName = `relay-${channel}-${(0, import_node_crypto7.randomBytes)(4).toString("hex")}`;
     const baseUrl = this.relayOptions.env?.RELAYCAST_BASE_URL ?? process.env.RELAYCAST_BASE_URL ?? "https://api.relaycast.dev";
     const res = await fetch(`${baseUrl}/v1/workspaces`, {
       method: "POST",
@@ -54538,7 +55408,7 @@ ${next}` : next;
       ...this.getRelayEnv() ?? {}
     };
     const result = await provisionWorkflowAgents({
-      secret: this.envSecrets?.RELAY_AUTH_SECRET ?? relayEnv.RELAY_AUTH_SECRET ?? (0, import_node_crypto8.randomBytes)(32).toString("hex"),
+      secret: this.envSecrets?.RELAY_AUTH_SECRET ?? relayEnv.RELAY_AUTH_SECRET ?? (0, import_node_crypto7.randomBytes)(32).toString("hex"),
       workspace: this.workspaceId,
       projectDir: this.cwd,
       relayfileBaseUrl: relayEnv.RELAYFILE_BASE_URL ?? "http://127.0.0.1:8080",
@@ -54578,7 +55448,7 @@ ${next}` : next;
     } catch (err) {
       if (err instanceof RelayError && err.code === "name_conflict") {
         registration = await rc.agents.register({
-          name: `WorkflowRunner-${(0, import_node_crypto8.randomBytes)(4).toString("hex")}`,
+          name: `WorkflowRunner-${(0, import_node_crypto7.randomBytes)(4).toString("hex")}`,
           type: "agent"
         });
       } else {
@@ -54822,14 +55692,14 @@ ${err.suggestion}`);
     for (const agent of resolved.agents) {
       if (agent.cwd) {
         const resolvedCwd = import_node_path28.default.resolve(this.cwd, agent.cwd);
-        if (!(0, import_node_fs21.existsSync)(resolvedCwd)) {
+        if (!(0, import_node_fs20.existsSync)(resolvedCwd)) {
           warnings.push(`Agent "${agent.name}" cwd "${agent.cwd}" resolves to "${resolvedCwd}" which does not exist`);
         }
       }
       if (agent.additionalPaths) {
         for (const ap of agent.additionalPaths) {
           const resolvedPath = import_node_path28.default.resolve(this.cwd, ap);
-          if (!(0, import_node_fs21.existsSync)(resolvedPath)) {
+          if (!(0, import_node_fs20.existsSync)(resolvedPath)) {
             warnings.push(`Agent "${agent.name}" additionalPath "${ap}" resolves to "${resolvedPath}" which does not exist`);
           }
         }
@@ -57020,9 +57890,9 @@ WORKER COMPLETION CONTRACT:
         promptTaskText: taskText
       };
     }
-    const taskTmpDir = (0, import_node_fs21.mkdtempSync)(import_node_path28.default.join((0, import_node_os8.tmpdir)(), "relay-pty-task-"));
+    const taskTmpDir = (0, import_node_fs20.mkdtempSync)(import_node_path28.default.join((0, import_node_os8.tmpdir)(), "relay-pty-task-"));
     const taskTmpFile = import_node_path28.default.join(taskTmpDir, `${agentName}-${Date.now()}.txt`);
-    (0, import_node_fs21.writeFileSync)(taskTmpFile, taskText, { encoding: "utf8", mode: 384, flag: "wx" });
+    (0, import_node_fs20.writeFileSync)(taskTmpFile, taskText, { encoding: "utf8", mode: 384, flag: "wx" });
     const promptTaskText = `TASK_FILE:${taskTmpFile}
 Read that file completely before taking any action.
 Treat the file contents as the full workflow task and follow them exactly.
@@ -57428,7 +58298,7 @@ DO NOT:
     const { cmd, args } = _WorkflowRunner.buildNonInteractiveCommand(agentDef.cli, taskWithDeliverable, modelArgs);
     const logsDir = this.getWorkerLogsDir();
     const logPath = import_node_path28.default.join(logsDir, `${agentName}.log`);
-    const logStream = (0, import_node_fs21.createWriteStream)(logPath, { flags: "a" });
+    const logStream = (0, import_node_fs20.createWriteStream)(logPath, { flags: "a" });
     this.registerWorker(agentName, agentDef.cli, step.task ?? "", void 0, false);
     let stopHeartbeat;
     if (this.relayApiKey) {
@@ -57591,7 +58461,7 @@ DO NOT:
     const preparedTask = this.prepareInteractiveSpawnTask(agentName, taskWithExit);
     this.ptyOutputBuffers.set(agentName, []);
     const logsDir = this.getWorkerLogsDir();
-    const logStream = (0, import_node_fs21.createWriteStream)(import_node_path28.default.join(logsDir, `${agentName}.log`), { flags: "a" });
+    const logStream = (0, import_node_fs20.createWriteStream)(import_node_path28.default.join(logsDir, `${agentName}.log`), { flags: "a" });
     this.ptyLogStreams.set(agentName, logStream);
     this.ptyListeners.set(agentName, (chunk) => {
       const stripped = _WorkflowRunner.stripAnsi(chunk);
@@ -57644,11 +58514,11 @@ DO NOT:
           oldLogStream.end();
           this.ptyLogStreams.delete(oldName);
           try {
-            (0, import_node_fs21.renameSync)(oldLogPath, newLogPath);
+            (0, import_node_fs20.renameSync)(oldLogPath, newLogPath);
           } catch {
           }
         }
-        const newLogStream = (0, import_node_fs21.createWriteStream)(newLogPath, { flags: "a" });
+        const newLogStream = (0, import_node_fs20.createWriteStream)(newLogPath, { flags: "a" });
         this.ptyLogStreams.set(agent.name, newLogStream);
         const oldListener = this.ptyListeners.get(oldName);
         if (oldListener) {
@@ -57756,7 +58626,7 @@ DO NOT:
       output = ptyChunks.join("");
     } else {
       const summaryPath = import_node_path28.default.join(this.summaryDir, `${step.name}.md`);
-      output = (0, import_node_fs21.existsSync)(summaryPath) ? await (0, import_promises8.readFile)(summaryPath, "utf-8") : exitResult === "timeout" ? "Agent completed (released after idle timeout)" : exitResult === "released" ? "Agent completed (idle \u2014 treated as done)" : `Agent exited (${exitResult})`;
+      output = (0, import_node_fs20.existsSync)(summaryPath) ? await (0, import_promises8.readFile)(summaryPath, "utf-8") : exitResult === "timeout" ? "Agent completed (released after idle timeout)" : exitResult === "released" ? "Agent completed (idle \u2014 treated as done)" : `Agent exited (${exitResult})`;
     }
     if (ptyChunks.length === 0) {
       this.captureStepTerminalEvidence(evidenceStepName, { stdout: output, combined: output }, { exitCode: agent?.exitCode, exitSignal: agent?.exitSignal }, {
@@ -58261,16 +59131,16 @@ ${excerpt}` : "";
     if (!target)
       return;
     try {
-      (0, import_node_fs21.mkdirSync)(import_node_path28.default.dirname(target), { recursive: true });
-      (0, import_node_fs21.writeFileSync)(target, runId + "\n", "utf8");
+      (0, import_node_fs20.mkdirSync)(import_node_path28.default.dirname(target), { recursive: true });
+      (0, import_node_fs20.writeFileSync)(target, runId + "\n", "utf8");
     } catch {
     }
   }
   generateId() {
-    return (0, import_node_crypto8.randomBytes)(12).toString("hex");
+    return (0, import_node_crypto7.randomBytes)(12).toString("hex");
   }
   generateShortId() {
-    return (0, import_node_crypto8.randomBytes)(4).toString("hex");
+    return (0, import_node_crypto7.randomBytes)(4).toString("hex");
   }
   /** Strip ANSI escape codes from terminal output — delegates to pty.ts canonical regex. */
   static stripAnsi(text) {
@@ -58378,7 +59248,7 @@ ${excerpt}` : "";
     const outputPath = import_node_path28.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
     try {
       const dir = this.getStepOutputDir(runId);
-      (0, import_node_fs21.mkdirSync)(dir, { recursive: true });
+      (0, import_node_fs20.mkdirSync)(dir, { recursive: true });
       const cleaned = _WorkflowRunner.stripAnsi(output);
       await (0, import_promises8.writeFile)(outputPath, cleaned);
     } catch {
@@ -58407,7 +59277,7 @@ ${preview}
   async persistAgentReport(runId, stepName, report) {
     const reportPath = import_node_path28.default.join(this.getStepOutputDir(runId), `${stepName}.report.json`);
     try {
-      (0, import_node_fs21.mkdirSync)(this.getStepOutputDir(runId), { recursive: true });
+      (0, import_node_fs20.mkdirSync)(this.getStepOutputDir(runId), { recursive: true });
       await (0, import_promises8.writeFile)(reportPath, JSON.stringify(report, null, 2), "utf8");
     } catch {
     }
@@ -58416,17 +59286,17 @@ ${preview}
   findMostRecentRunWithSteps(stepNames) {
     try {
       const baseDir = import_node_path28.default.join(this.cwd, ".agent-relay", "step-outputs");
-      if (!(0, import_node_fs21.existsSync)(baseDir))
+      if (!(0, import_node_fs20.existsSync)(baseDir))
         return void 0;
-      const entries = (0, import_node_fs21.readdirSync)(baseDir);
+      const entries = (0, import_node_fs20.readdirSync)(baseDir);
       let best;
       for (const entry of entries) {
         const dirPath = import_node_path28.default.join(baseDir, entry);
         try {
-          const stat2 = (0, import_node_fs21.statSync)(dirPath);
+          const stat2 = (0, import_node_fs20.statSync)(dirPath);
           if (!stat2.isDirectory())
             continue;
-          const hasAny = [...stepNames].some((name) => (0, import_node_fs21.existsSync)(import_node_path28.default.join(dirPath, `${name}.md`)));
+          const hasAny = [...stepNames].some((name) => (0, import_node_fs20.existsSync)(import_node_path28.default.join(dirPath, `${name}.md`)));
           if (!hasAny)
             continue;
           if (!best || stat2.mtimeMs > best.mtime) {
@@ -58445,9 +59315,9 @@ ${preview}
   loadStepOutput(runId, stepName) {
     try {
       const filePath = import_node_path28.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
-      if (!(0, import_node_fs21.existsSync)(filePath))
+      if (!(0, import_node_fs20.existsSync)(filePath))
         return void 0;
-      return (0, import_node_fs21.readFileSync)(filePath, "utf-8");
+      return (0, import_node_fs20.readFileSync)(filePath, "utf-8");
     } catch {
       return void 0;
     }
@@ -58469,14 +59339,14 @@ ${preview}
   }
   reconstructRunFromCache(runId, config2) {
     const stepOutputDir = this.getStepOutputDir(runId);
-    if (!(0, import_node_fs21.existsSync)(stepOutputDir))
+    if (!(0, import_node_fs20.existsSync)(stepOutputDir))
       return null;
     let resumeConfig = config2 ?? this.currentConfig;
     if (!resumeConfig) {
       const yamlPath = import_node_path28.default.join(this.cwd, "relay.yaml");
-      if ((0, import_node_fs21.existsSync)(yamlPath)) {
+      if ((0, import_node_fs20.existsSync)(yamlPath)) {
         try {
-          const raw = (0, import_node_fs21.readFileSync)(yamlPath, "utf-8");
+          const raw = (0, import_node_fs20.readFileSync)(yamlPath, "utf-8");
           resumeConfig = this.parseYamlString(raw, yamlPath);
         } catch {
           return null;
@@ -58487,7 +59357,7 @@ ${preview}
     }
     let entries;
     try {
-      entries = (0, import_node_fs21.readdirSync)(stepOutputDir, { withFileTypes: true });
+      entries = (0, import_node_fs20.readdirSync)(stepOutputDir, { withFileTypes: true });
     } catch {
       return null;
     }
@@ -58504,8 +59374,8 @@ ${preview}
       try {
         const mdPath = import_node_path28.default.join(stepOutputDir, `${stepName}.md`);
         const reportPath = import_node_path28.default.join(stepOutputDir, `${stepName}.report.json`);
-        const mdStat = (0, import_node_fs21.existsSync)(mdPath) ? (0, import_node_fs21.statSync)(mdPath) : null;
-        const reportStat = (0, import_node_fs21.existsSync)(reportPath) ? (0, import_node_fs21.statSync)(reportPath) : null;
+        const mdStat = (0, import_node_fs20.existsSync)(mdPath) ? (0, import_node_fs20.statSync)(mdPath) : null;
+        const reportStat = (0, import_node_fs20.existsSync)(reportPath) ? (0, import_node_fs20.statSync)(reportPath) : null;
         const mtime = Math.max(mdStat?.mtimeMs ?? 0, reportStat?.mtimeMs ?? 0);
         if (mtime > 0) {
           stepMtimes.set(stepName, new Date(mtime).toISOString());
@@ -58558,7 +59428,7 @@ ${preview}
   /** Get or create the worker logs directory (.agent-relay/team/worker-logs) */
   getWorkerLogsDir() {
     const logsDir = import_node_path28.default.join(this.cwd, ".agent-relay", "team", "worker-logs");
-    (0, import_node_fs21.mkdirSync)(logsDir, { recursive: true });
+    (0, import_node_fs20.mkdirSync)(logsDir, { recursive: true });
     return logsDir;
   }
   /** Register a spawned agent in workers.json so `agents:kill` can find it. */
@@ -58574,7 +59444,7 @@ ${preview}
     this.activeWorkers.set(agentName, workerEntry);
     this.workersFileLock = this.workersFileLock.then(() => {
       try {
-        (0, import_node_fs21.mkdirSync)(import_node_path28.default.dirname(this.workersPath), { recursive: true });
+        (0, import_node_fs20.mkdirSync)(import_node_path28.default.dirname(this.workersPath), { recursive: true });
         const existing = this.readWorkers().filter((w2) => w2.name !== agentName);
         existing.push({ name: agentName, ...workerEntry });
         this.writeWorkers(existing);
@@ -58596,21 +59466,21 @@ ${preview}
   }
   readWorkers() {
     try {
-      if (!(0, import_node_fs21.existsSync)(this.workersPath))
+      if (!(0, import_node_fs20.existsSync)(this.workersPath))
         return [];
-      const raw = JSON.parse((0, import_node_fs21.readFileSync)(this.workersPath, "utf-8"));
+      const raw = JSON.parse((0, import_node_fs20.readFileSync)(this.workersPath, "utf-8"));
       return Array.isArray(raw?.workers) ? raw.workers : [];
     } catch {
       return [];
     }
   }
   writeWorkers(workers) {
-    (0, import_node_fs21.writeFileSync)(this.workersPath, JSON.stringify({ workers }, null, 2));
+    (0, import_node_fs20.writeFileSync)(this.workersPath, JSON.stringify({ workers }, null, 2));
   }
 };
 
 // packages/sdk/dist/workflows/file-db.js
-var import_node_fs22 = require("node:fs");
+var import_node_fs21 = require("node:fs");
 var import_node_path29 = __toESM(require("node:path"), 1);
 var JsonFileWorkflowDb = class {
   filePath;
@@ -58621,7 +59491,7 @@ var JsonFileWorkflowDb = class {
     this.filePath = filePath;
     let writable = false;
     try {
-      (0, import_node_fs22.mkdirSync)(import_node_path29.default.dirname(filePath), { recursive: true });
+      (0, import_node_fs21.mkdirSync)(import_node_path29.default.dirname(filePath), { recursive: true });
       writable = true;
     } catch {
     }
@@ -58634,7 +59504,7 @@ var JsonFileWorkflowDb = class {
   hasStepOutputs(runId) {
     try {
       const dir = import_node_path29.default.join(import_node_path29.default.dirname(this.filePath), "step-outputs", runId);
-      return (0, import_node_fs22.existsSync)(dir) && (0, import_node_fs22.readdirSync)(dir).length > 0;
+      return (0, import_node_fs21.existsSync)(dir) && (0, import_node_fs21.readdirSync)(dir).length > 0;
     } catch {
       return false;
     }
@@ -58644,7 +59514,7 @@ var JsonFileWorkflowDb = class {
     if (!this.writable)
       return;
     try {
-      (0, import_node_fs22.appendFileSync)(this.filePath, JSON.stringify(entry) + "\n", "utf8");
+      (0, import_node_fs21.appendFileSync)(this.filePath, JSON.stringify(entry) + "\n", "utf8");
     } catch (err) {
       if (!this.appendFailedOnce) {
         this.appendFailedOnce = true;
@@ -58658,7 +59528,7 @@ var JsonFileWorkflowDb = class {
     const steps = /* @__PURE__ */ new Map();
     let raw = "";
     try {
-      raw = (0, import_node_fs22.readFileSync)(this.filePath, "utf8");
+      raw = (0, import_node_fs21.readFileSync)(this.filePath, "utf8");
     } catch {
       return { runs, steps };
     }
@@ -59260,7 +60130,7 @@ function workflow(name) {
 }
 
 // packages/sdk/dist/workflows/coordinator.js
-var import_node_crypto9 = require("node:crypto");
+var import_node_crypto8 = require("node:crypto");
 var import_node_events3 = require("node:events");
 var PATTERN_HEURISTICS = [
   // ── Dependency-based patterns (highest priority) ──────────────────────
@@ -59615,7 +60485,7 @@ var SwarmCoordinator = class extends import_node_events3.EventEmitter {
   }
   // ── Lifecycle: create run ───────────────────────────────────────────────
   async createRun(workspaceId, config2) {
-    const id = `run_${Date.now()}_${(0, import_node_crypto9.randomBytes)(4).toString("hex")}`;
+    const id = `run_${Date.now()}_${(0, import_node_crypto8.randomBytes)(4).toString("hex")}`;
     const pattern = this.selectPattern(config2);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const { rows } = await this.db.query(`INSERT INTO workflow_runs (id, workspace_id, workflow_name, pattern, status, config, started_at, created_at, updated_at)
@@ -59654,7 +60524,7 @@ var SwarmCoordinator = class extends import_node_events3.EventEmitter {
     const created = [];
     for (const wf of workflows) {
       for (const step of wf.steps) {
-        const id = `step_${Date.now()}_${(0, import_node_crypto9.randomBytes)(4).toString("hex")}`;
+        const id = `step_${Date.now()}_${(0, import_node_crypto8.randomBytes)(4).toString("hex")}`;
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const { rows } = await this.db.query(`INSERT INTO workflow_steps (id, run_id, step_name, agent_name, status, task, depends_on, created_at, updated_at)
            VALUES ($1, $2, $3, $4, 'pending', $5, $6, $7, $7)
@@ -59831,7 +60701,7 @@ var SwarmCoordinator = class extends import_node_events3.EventEmitter {
 };
 
 // packages/sdk/dist/workflows/barrier.js
-var import_node_crypto10 = require("node:crypto");
+var import_node_crypto9 = require("node:crypto");
 var import_node_events4 = require("node:events");
 var BarrierManager = class extends import_node_events4.EventEmitter {
   db;
@@ -59847,7 +60717,7 @@ var BarrierManager = class extends import_node_events4.EventEmitter {
    * Create a barrier for a workflow run.
    */
   async createBarrier(runId, definition) {
-    const id = `bar_${Date.now()}_${(0, import_node_crypto10.randomBytes)(4).toString("hex")}`;
+    const id = `bar_${Date.now()}_${(0, import_node_crypto9.randomBytes)(4).toString("hex")}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const mode = definition.mode ?? "all";
     const { rows } = await this.db.query(`INSERT INTO workflow_barriers (id, run_id, barrier_name, wait_for, resolved, is_satisfied, timeout_ms, created_at, updated_at)
@@ -59981,7 +60851,7 @@ var BarrierManager = class extends import_node_events4.EventEmitter {
 };
 
 // packages/sdk/dist/workflows/state.js
-var import_node_crypto11 = require("node:crypto");
+var import_node_crypto10 = require("node:crypto");
 var import_node_events5 = require("node:events");
 var StateStore = class extends import_node_events5.EventEmitter {
   db;
@@ -60024,7 +60894,7 @@ var StateStore = class extends import_node_events5.EventEmitter {
     const namespace = options.namespace ?? this.defaultNamespace;
     const ttlMs = options.ttlMs ?? this.defaultTtlMs;
     const expiresAt = ttlMs ? new Date(Date.now() + ttlMs).toISOString() : null;
-    const id = `st_${Date.now()}_${(0, import_node_crypto11.randomBytes)(4).toString("hex")}`;
+    const id = `st_${Date.now()}_${(0, import_node_crypto10.randomBytes)(4).toString("hex")}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const { rows } = await this.db.query(`INSERT INTO swarm_state (id, run_id, namespace, key, value, expires_at, created_at, updated_at)
        VALUES ($1, $2, $3, $4, $5, $6, $7, $7)
@@ -60112,7 +60982,7 @@ var StateStore = class extends import_node_events5.EventEmitter {
 };
 
 // packages/sdk/dist/workflows/templates.js
-var import_node_fs23 = require("node:fs");
+var import_node_fs22 = require("node:fs");
 var import_node_path31 = __toESM(require("node:path"), 1);
 var import_node_url2 = require("node:url");
 var import_yaml4 = __toESM(require_dist(), 1);
@@ -60216,9 +61086,9 @@ var TemplateRegistry = class {
       throw new Error(`Invalid template name: "${templateName}" contains path separators or traversal sequences`);
     }
     this.validateRelayConfig(parsed, url2);
-    await import_node_fs23.promises.mkdir(this.customTemplatesDir, { recursive: true });
+    await import_node_fs22.promises.mkdir(this.customTemplatesDir, { recursive: true });
     const targetPath = import_node_path31.default.join(this.customTemplatesDir, `${templateName}.yaml`);
-    await import_node_fs23.promises.writeFile(targetPath, (0, import_yaml4.stringify)(parsed), "utf-8");
+    await import_node_fs22.promises.writeFile(targetPath, (0, import_yaml4.stringify)(parsed), "utf-8");
     return targetPath;
   }
   isTemplateShorthand(input) {
@@ -60247,7 +61117,7 @@ var TemplateRegistry = class {
       import_node_path31.default.resolve(currentDir, "../workflows/builtin-templates")
     ];
     for (const candidate of candidates) {
-      if ((0, import_node_fs23.existsSync)(candidate)) {
+      if ((0, import_node_fs22.existsSync)(candidate)) {
         return candidate;
       }
     }
@@ -60269,7 +61139,7 @@ var TemplateRegistry = class {
     for (const ext of YAML_EXTENSIONS) {
       const candidate = import_node_path31.default.join(directory, `${templateName}${ext}`);
       try {
-        const stat2 = await import_node_fs23.promises.stat(candidate);
+        const stat2 = await import_node_fs22.promises.stat(candidate);
         if (stat2.isFile()) {
           return candidate;
         }
@@ -60279,7 +61149,7 @@ var TemplateRegistry = class {
     return void 0;
   }
   async readTemplateFile(templatePath) {
-    const raw = await import_node_fs23.promises.readFile(templatePath, "utf-8");
+    const raw = await import_node_fs22.promises.readFile(templatePath, "utf-8");
     const parsed = (0, import_yaml4.parse)(raw);
     if (!isRecord(parsed)) {
       throw new Error(`Template at ${templatePath} is not a YAML object`);
@@ -60472,7 +61342,7 @@ var TemplateRegistry = class {
   }
   async safeReadDir(directory) {
     try {
-      return await import_node_fs23.promises.readdir(directory);
+      return await import_node_fs22.promises.readdir(directory);
     } catch {
       return [];
     }
@@ -60639,7 +61509,7 @@ function isValidAgentName(name) {
 }
 
 // packages/utils/dist/logger.js
-var import_node_fs24 = __toESM(require("node:fs"), 1);
+var import_node_fs23 = __toESM(require("node:fs"), 1);
 var import_node_path32 = __toESM(require("node:path"), 1);
 function getLogFile() {
   return process.env.AGENT_RELAY_LOG_FILE;
@@ -60659,8 +61529,8 @@ var LEVEL_PRIORITY = {
 var createdLogDirs = /* @__PURE__ */ new Set();
 function ensureLogDir(logFile) {
   const logDir = import_node_path32.default.dirname(logFile);
-  if (!createdLogDirs.has(logDir) && !import_node_fs24.default.existsSync(logDir)) {
-    import_node_fs24.default.mkdirSync(logDir, { recursive: true });
+  if (!createdLogDirs.has(logDir) && !import_node_fs23.default.existsSync(logDir)) {
+    import_node_fs23.default.mkdirSync(logDir, { recursive: true });
     createdLogDirs.add(logDir);
   }
 }
@@ -60689,7 +61559,7 @@ function log(level, component, msg, extra) {
   const logFile = getLogFile();
   if (logFile) {
     ensureLogDir(logFile);
-    import_node_fs24.default.appendFileSync(logFile, formatted + "\n");
+    import_node_fs23.default.appendFileSync(logFile, formatted + "\n");
     return;
   }
   if (level === "ERROR" || level === "WARN") {
@@ -60960,7 +61830,7 @@ function benchmarkPatterns(iterations = 1e4) {
 
 // packages/utils/dist/command-resolver.js
 var import_node_child_process8 = require("node:child_process");
-var import_node_fs25 = __toESM(require("node:fs"), 1);
+var import_node_fs24 = __toESM(require("node:fs"), 1);
 function resolveCommand(command) {
   if (command.startsWith("/")) {
     return resolveSymlinks(command);
@@ -60986,7 +61856,7 @@ function resolveCommand(command) {
 }
 function resolveSymlinks(filePath) {
   try {
-    const resolved = import_node_fs25.default.realpathSync(filePath);
+    const resolved = import_node_fs24.default.realpathSync(filePath);
     if (resolved !== filePath && process.env.DEBUG_SPAWN === "1") {
       console.log(`[command-resolver] Resolved symlink: ${filePath} -> ${resolved}`);
     }
@@ -61012,7 +61882,7 @@ function commandExists(command) {
 
 // packages/utils/dist/git-remote.js
 var fs8 = __toESM(require("node:fs"), 1);
-var path21 = __toESM(require("node:path"), 1);
+var path20 = __toESM(require("node:path"), 1);
 var import_node_child_process9 = require("node:child_process");
 function parseGitRemoteUrl(url2) {
   if (!url2)
@@ -61029,7 +61899,7 @@ function parseGitRemoteUrl(url2) {
 }
 function getGitRemoteUrl(workingDirectory, remoteName = "origin") {
   try {
-    const gitDir = path21.join(workingDirectory, ".git");
+    const gitDir = path20.join(workingDirectory, ".git");
     if (!fs8.existsSync(gitDir)) {
       return null;
     }
@@ -61042,7 +61912,7 @@ function getGitRemoteUrl(workingDirectory, remoteName = "origin") {
     return result.trim() || null;
   } catch {
     try {
-      const configPath = path21.join(workingDirectory, ".git", "config");
+      const configPath = path20.join(workingDirectory, ".git", "config");
       if (!fs8.existsSync(configPath)) {
         return null;
       }
@@ -61063,13 +61933,13 @@ function getRepoFullName(workingDirectory) {
   return parseGitRemoteUrl(remoteUrl);
 }
 function findGitRoot(startPath) {
-  let currentPath = path21.resolve(startPath);
-  const root = path21.parse(currentPath).root;
+  let currentPath = path20.resolve(startPath);
+  const root = path20.parse(currentPath).root;
   while (currentPath !== root) {
-    if (fs8.existsSync(path21.join(currentPath, ".git"))) {
+    if (fs8.existsSync(path20.join(currentPath, ".git"))) {
       return currentPath;
     }
-    currentPath = path21.dirname(currentPath);
+    currentPath = path20.dirname(currentPath);
   }
   return null;
 }
@@ -61086,7 +61956,7 @@ function getRepoFullNameFromPath(workingDirectory) {
 }
 
 // packages/utils/dist/update-checker.js
-var import_node_fs26 = __toESM(require("node:fs"), 1);
+var import_node_fs25 = __toESM(require("node:fs"), 1);
 var import_node_path33 = __toESM(require("node:path"), 1);
 var import_node_https2 = __toESM(require("node:https"), 1);
 var import_node_os10 = __toESM(require("node:os"), 1);
@@ -61101,9 +61971,9 @@ function getCachePath() {
 function readCache() {
   try {
     const cachePath = getCachePath();
-    if (!import_node_fs26.default.existsSync(cachePath))
+    if (!import_node_fs25.default.existsSync(cachePath))
       return null;
-    const data = import_node_fs26.default.readFileSync(cachePath, "utf-8");
+    const data = import_node_fs25.default.readFileSync(cachePath, "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
@@ -61113,10 +61983,10 @@ function writeCache(cache) {
   try {
     const cachePath = getCachePath();
     const cacheDir = import_node_path33.default.dirname(cachePath);
-    if (!import_node_fs26.default.existsSync(cacheDir)) {
-      import_node_fs26.default.mkdirSync(cacheDir, { recursive: true });
+    if (!import_node_fs25.default.existsSync(cacheDir)) {
+      import_node_fs25.default.mkdirSync(cacheDir, { recursive: true });
     }
-    import_node_fs26.default.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+    import_node_fs25.default.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
   } catch {
   }
 }
@@ -61234,10 +62104,10 @@ function checkForUpdatesInBackground(currentVersion) {
 }
 
 // packages/utils/dist/error-tracking.js
-var import_node_crypto12 = require("node:crypto");
+var import_node_crypto11 = require("node:crypto");
 function generateErrorId() {
   const timestamp = Math.floor(Date.now() / 1e3);
-  const random = (0, import_node_crypto12.randomBytes)(2).toString("hex");
+  const random = (0, import_node_crypto11.randomBytes)(2).toString("hex");
   return `ERR-${timestamp}-${random}`;
 }
 function createTraceableError(message, context = {}, originalError) {
@@ -61395,7 +62265,7 @@ function validateModelForCli(cli, model) {
 }
 
 // packages/utils/dist/relay-pty-path.js
-var import_node_fs27 = __toESM(require("node:fs"), 1);
+var import_node_fs26 = __toESM(require("node:fs"), 1);
 var import_node_os11 = __toESM(require("node:os"), 1);
 var import_node_path34 = __toESM(require("node:path"), 1);
 var SUPPORTED_PLATFORMS = {
@@ -61456,12 +62326,12 @@ function findRelayPtyBinary(callerDirname) {
   const home = process.env.HOME || process.env.USERPROFILE || "";
   if (home) {
     const npxCacheBase = import_node_path34.default.join(home, ".npm", "_npx");
-    if (import_node_fs27.default.existsSync(npxCacheBase)) {
+    if (import_node_fs26.default.existsSync(npxCacheBase)) {
       try {
-        const entries = import_node_fs27.default.readdirSync(npxCacheBase);
+        const entries = import_node_fs26.default.readdirSync(npxCacheBase);
         for (const entry of entries) {
           const npxPackage = import_node_path34.default.join(npxCacheBase, entry, "node_modules", "agent-relay");
-          if (import_node_fs27.default.existsSync(npxPackage)) {
+          if (import_node_fs26.default.existsSync(npxPackage)) {
             packageRoots.push(npxPackage);
           }
         }
@@ -61519,7 +62389,7 @@ function findRelayPtyBinary(callerDirname) {
 }
 function isExecutable2(filePath) {
   try {
-    import_node_fs27.default.accessSync(filePath, import_node_fs27.default.constants.X_OK);
+    import_node_fs26.default.accessSync(filePath, import_node_fs26.default.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -61528,9 +62398,9 @@ function isExecutable2(filePath) {
 function isPlatformCompatibleBinary(filePath) {
   let fd;
   try {
-    fd = import_node_fs27.default.openSync(filePath, "r");
+    fd = import_node_fs26.default.openSync(filePath, "r");
     const header = Buffer.alloc(4);
-    const bytesRead = import_node_fs27.default.readSync(fd, header, 0, 4, 0);
+    const bytesRead = import_node_fs26.default.readSync(fd, header, 0, 4, 0);
     if (bytesRead < 4) {
       return false;
     }
@@ -61548,7 +62418,7 @@ function isPlatformCompatibleBinary(filePath) {
   } finally {
     if (fd !== void 0) {
       try {
-        import_node_fs27.default.closeSync(fd);
+        import_node_fs26.default.closeSync(fd);
       } catch {
       }
     }
@@ -61579,7 +62449,7 @@ function clearBinaryCache() {
 
 // packages/utils/dist/client-helpers.js
 var import_node_net = require("node:net");
-var import_node_crypto13 = require("node:crypto");
+var import_node_crypto12 = require("node:crypto");
 
 // packages/utils/dist/legacy-protocol.js
 var PROTOCOL_VERSION2 = 1;
@@ -61706,14 +62576,14 @@ function createRequestHandler(socketPath, envelope, options) {
   });
 }
 function generateRequestId(prefix = "") {
-  return `${prefix}${Date.now().toString(36)}-${(0, import_node_crypto13.randomUUID)().slice(0, 8)}`;
+  return `${prefix}${Date.now().toString(36)}-${(0, import_node_crypto12.randomUUID)().slice(0, 8)}`;
 }
 
 // packages/hooks/dist/types.js
 var HOOK_ABI_VERSION = PROTOCOL_VERSION;
 
 // packages/hooks/dist/registry.js
-var import_node_crypto15 = require("node:crypto");
+var import_node_crypto14 = require("node:crypto");
 var InMemoryHookMemory = class {
   store = /* @__PURE__ */ new Map();
   get(key) {
@@ -61762,8 +62632,8 @@ var HookRegistry = class {
   injectFn;
   sendFn;
   constructor(options = {}) {
-    this.sessionId = (0, import_node_crypto15.randomUUID)();
-    this.agentId = options.agentId ?? (0, import_node_crypto15.randomUUID)();
+    this.sessionId = (0, import_node_crypto14.randomUUID)();
+    this.agentId = options.agentId ?? (0, import_node_crypto14.randomUUID)();
     this.agentName = options.agentName ?? "agent";
     this.workingDir = options.workingDir ?? process.cwd();
     this.projectId = options.projectId ?? "default";
@@ -62167,9 +63037,9 @@ var HookRegistry = class {
 var import_node_child_process10 = require("node:child_process");
 
 // packages/config/dist/project-namespace.js
-var import_node_crypto16 = __toESM(require("node:crypto"), 1);
+var import_node_crypto15 = __toESM(require("node:crypto"), 1);
 var import_node_path35 = __toESM(require("node:path"), 1);
-var import_node_fs28 = __toESM(require("node:fs"), 1);
+var import_node_fs27 = __toESM(require("node:fs"), 1);
 var import_node_os12 = __toESM(require("node:os"), 1);
 function getGlobalBaseDir2() {
   if (process.env.AGENT_RELAY_DATA_DIR) {
@@ -62185,7 +63055,7 @@ var GLOBAL_BASE_DIR2 = getGlobalBaseDir2();
 var PROJECT_DATA_DIR = ".agent-relay";
 function hashPath(projectPath) {
   const normalized = import_node_path35.default.resolve(projectPath);
-  const hash2 = import_node_crypto16.default.createHash("sha256").update(normalized).digest("hex");
+  const hash2 = import_node_crypto15.default.createHash("sha256").update(normalized).digest("hex");
   return hash2.substring(0, 12);
 }
 function findProjectRoot(startDir = process.cwd()) {
@@ -62197,7 +63067,7 @@ function findProjectRoot(startDir = process.cwd()) {
   const markers = [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".agent-relay"];
   while (current !== root) {
     for (const marker of markers) {
-      if (import_node_fs28.default.existsSync(import_node_path35.default.join(current, marker))) {
+      if (import_node_fs27.default.existsSync(import_node_path35.default.join(current, marker))) {
         return current;
       }
     }
@@ -62220,10 +63090,10 @@ function getProjectPaths2(projectRoot) {
 }
 
 // packages/config/dist/trajectory-config.js
-var import_node_fs29 = require("node:fs");
+var import_node_fs28 = require("node:fs");
 var import_node_path36 = require("node:path");
 var import_node_os13 = require("node:os");
-var import_node_crypto17 = require("node:crypto");
+var import_node_crypto16 = require("node:crypto");
 function getAgentRelayConfigDir() {
   return process.env.AGENT_RELAY_CONFIG_DIR ?? (0, import_node_path36.join)((0, import_node_os13.homedir)(), ".config", "agent-relay");
 }
@@ -62235,7 +63105,7 @@ function readRelayConfig(projectRoot) {
   const configPath = getRelayConfigPath(projectRoot);
   if (configCache && configCache.path === configPath) {
     try {
-      const stat2 = (0, import_node_fs29.statSync)(configPath);
+      const stat2 = (0, import_node_fs28.statSync)(configPath);
       if (stat2.mtimeMs === configCache.mtime) {
         return configCache.config;
       }
@@ -62243,13 +63113,13 @@ function readRelayConfig(projectRoot) {
     }
   }
   try {
-    if (!(0, import_node_fs29.existsSync)(configPath)) {
+    if (!(0, import_node_fs28.existsSync)(configPath)) {
       return {};
     }
-    const content = (0, import_node_fs29.readFileSync)(configPath, "utf-8");
+    const content = (0, import_node_fs28.readFileSync)(configPath, "utf-8");
     const config2 = JSON.parse(content);
     try {
-      const stat2 = (0, import_node_fs29.statSync)(configPath);
+      const stat2 = (0, import_node_fs28.statSync)(configPath);
       configCache = { path: configPath, config: config2, mtime: stat2.mtimeMs };
     } catch {
     }
@@ -62265,7 +63135,7 @@ function shouldStoreInRepo(projectRoot) {
 }
 function getProjectHash(projectRoot) {
   const root = projectRoot ?? getProjectPaths2().projectRoot;
-  return (0, import_node_crypto17.createHash)("sha256").update(root).digest("hex").slice(0, 16);
+  return (0, import_node_crypto16.createHash)("sha256").update(root).digest("hex").slice(0, 16);
 }
 function getUserTrajectoriesDir(projectRoot) {
   const projectHash = getProjectHash(projectRoot);
@@ -62383,7 +63253,7 @@ async function recordMessage(direction, from, to2, body) {
   const content = `Message ${direction}: ${direction === "sent" ? `\u2192 ${to2}` : `\u2190 ${from}`}: ${body.slice(0, 100)}${body.length > 100 ? "..." : ""}`;
   return recordEvent(content, "observation");
 }
-async function completeTrajectory(options = {}) {
+async function completeTrajectory2(options = {}) {
   const args = ["complete"];
   if (options.summary) {
     args.push("--summary", options.summary);
@@ -62400,7 +63270,7 @@ async function completeTrajectory(options = {}) {
   const result = await runTrail(args);
   return { success: result.success, error: result.error };
 }
-async function abandonTrajectory(reason) {
+async function abandonTrajectory2(reason) {
   const args = ["abandon"];
   if (reason) {
     args.push("--reason", reason);
@@ -62686,7 +63556,7 @@ var TrajectoryIntegration = class {
   async complete(options) {
     if (!await this.isAvailable())
       return false;
-    const result = await completeTrajectory(options);
+    const result = await completeTrajectory2(options);
     if (result.success) {
       this.currentPhase = null;
     }
@@ -62698,7 +63568,7 @@ var TrajectoryIntegration = class {
   async abandon(reason) {
     if (!await this.isAvailable())
       return false;
-    const result = await abandonTrajectory(reason);
+    const result = await abandonTrajectory2(reason);
     if (result.success) {
       this.currentPhase = null;
     }
@@ -62754,16 +63624,16 @@ function createTrajectoryHooks(options) {
 }
 function createSessionStartHook2(state) {
   return async (ctx) => {
-    const { trajectory, options } = state;
+    const { trajectory: trajectory2, options } = state;
     if (ctx.task) {
-      const success2 = await trajectory.initialize(ctx.task, ctx.taskId, ctx.taskSource);
+      const success2 = await trajectory2.initialize(ctx.task, ctx.taskId, ctx.taskSource);
       if (success2) {
         console.log(`[trajectory] Started tracking: ${ctx.task}`);
       }
     } else {
-      await trajectory.initialize();
+      await trajectory2.initialize();
     }
-    if (options.injectInstructions && trajectory.isTrailInstalledSync()) {
+    if (options.injectInstructions && trajectory2.isTrailInstalledSync()) {
       const instructions = getCompactTrailInstructions();
       return { inject: `
 ${instructions}
@@ -62773,8 +63643,8 @@ ${instructions}
 }
 function createSessionEndHook2(state) {
   return async (ctx) => {
-    const { trajectory, options } = state;
-    if (!trajectory.hasActiveTrajectory()) {
+    const { trajectory: trajectory2, options } = state;
+    if (!trajectory2.hasActiveTrajectory()) {
       return;
     }
     if (ctx.graceful) {
@@ -62790,28 +63660,28 @@ Or if you need to document learnings:
   trail decision "Key choice" --reasoning "Why"
 `
         };
-        await trajectory.complete({
+        await trajectory2.complete({
           summary: `Session ended after ${durationSeconds}s`
         });
         return result;
       } else {
-        await trajectory.complete({
+        await trajectory2.complete({
           summary: `Session ended gracefully`
         });
       }
     } else {
-      await trajectory.abandon("Session terminated");
+      await trajectory2.abandon("Session terminated");
     }
   };
 }
 function createOutputHook2(state) {
   return async (ctx) => {
-    const { trajectory, options } = state;
+    const { trajectory: trajectory2, options } = state;
     if (options.autoDetectPhase) {
       const detectedPhase = detectPhaseFromContent(ctx.content);
       if (detectedPhase && detectedPhase !== state.lastDetectedPhase) {
         state.lastDetectedPhase = detectedPhase;
-        await trajectory.transition(detectedPhase, "Auto-detected from output");
+        await trajectory2.transition(detectedPhase, "Auto-detected from output");
       }
     }
     if (options.detectTools) {
@@ -62821,7 +63691,7 @@ function createOutputHook2(state) {
         if (!state.seenTools.has(key)) {
           state.seenTools.add(key);
           const statusLabel = tool.status === "completed" ? " (completed)" : "";
-          await trajectory.event(`Tool: ${tool.tool}${statusLabel}`, "tool_call");
+          await trajectory2.event(`Tool: ${tool.tool}${statusLabel}`, "tool_call");
         }
       }
     }
@@ -62831,7 +63701,7 @@ function createOutputHook2(state) {
         if (!state.seenErrors.has(error48.message)) {
           state.seenErrors.add(error48.message);
           const prefix = error48.type === "warning" ? "Warning" : "Error";
-          await trajectory.event(`${prefix}: ${error48.message}`, "error");
+          await trajectory2.event(`${prefix}: ${error48.message}`, "error");
         }
       }
     }
@@ -62839,22 +63709,22 @@ function createOutputHook2(state) {
 }
 function createMessageReceivedHook(state) {
   return async (ctx) => {
-    const { trajectory, options } = state;
-    await trajectory.message("received", ctx.from, options.agentName, ctx.body);
+    const { trajectory: trajectory2, options } = state;
+    await trajectory2.message("received", ctx.from, options.agentName, ctx.body);
   };
 }
 function createMessageSentHook(state) {
   return async (ctx) => {
-    const { trajectory, options } = state;
-    await trajectory.message("sent", options.agentName, ctx.to, ctx.body);
+    const { trajectory: trajectory2, options } = state;
+    await trajectory2.message("sent", options.agentName, ctx.to, ctx.body);
   };
 }
 function getTrajectoryHooks(projectId, agentName) {
   return createTrajectoryHooks({ projectId, agentName });
 }
 function isTrajectoryTrackingAvailable(projectId, agentName) {
-  const trajectory = getTrajectoryIntegration(projectId, agentName);
-  return trajectory.isTrailInstalledSync();
+  const trajectory2 = getTrajectoryIntegration(projectId, agentName);
+  return trajectory2.isTrailInstalledSync();
 }
 
 // packages/hooks/dist/emitter.js
@@ -62914,7 +63784,7 @@ var HookEmitter = class {
 };
 
 // packages/hooks/dist/inbox-check/utils.js
-var import_node_fs30 = require("node:fs");
+var import_node_fs29 = require("node:fs");
 var import_node_path37 = require("node:path");
 var DEFAULT_INBOX_DIR = "/tmp/agent-relay";
 function getAgentName() {
@@ -62928,13 +63798,13 @@ function getInboxPath(config2) {
   return (0, import_node_path37.join)(config2.inboxDir, agentName, "inbox.md");
 }
 function inboxExists(inboxPath) {
-  return (0, import_node_fs30.existsSync)(inboxPath);
+  return (0, import_node_fs29.existsSync)(inboxPath);
 }
 function readInbox(inboxPath) {
   if (!inboxExists(inboxPath)) {
     return "";
   }
-  return (0, import_node_fs30.readFileSync)(inboxPath, "utf-8");
+  return (0, import_node_fs29.readFileSync)(inboxPath, "utf-8");
 }
 function hasUnreadMessages(inboxPath) {
   const content = readInbox(inboxPath);