@cleocode/core 2026.3.74 → 2026.3.76

package/dist/index.js

@@ -516,6 +516,1207 @@ var init_status_registry = __esm({
   }
 });
 
+// packages/contracts/src/wasm/lafs-core/lafs_core.js
+var lafs_core_exports = {};
+__export(lafs_core_exports, {
+  WasmLafsEnvelope: () => WasmLafsEnvelope,
+  WasmLafsMeta: () => WasmLafsMeta,
+  WasmLafsTransport: () => WasmLafsTransport,
+  create_transport: () => create_transport,
+  default: () => __wbg_init,
+  initSync: () => initSync
+});
+function create_transport(transport) {
+  const ptr0 = passStringToWasm0(transport, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.create_transport(ptr0, len0);
+  return WasmLafsTransport.__wrap(ret);
+}
+function __wbg_get_imports() {
+  const import0 = {
+    __proto__: null,
+    __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    },
+    __wbg_getRandomValues_a1cf2e70b003a59d: function() {
+      return handleError(function(arg0, arg1) {
+        globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+      }, arguments);
+    },
+    __wbg_getTime_1dad7b5386ddd2d9: function(arg0) {
+      const ret = arg0.getTime();
+      return ret;
+    },
+    __wbg_new_0_1dcafdf5e786e876: function() {
+      const ret = /* @__PURE__ */ new Date();
+      return ret;
+    },
+    __wbindgen_init_externref_table: function() {
+      const table = wasm.__wbindgen_externrefs;
+      const offset = table.grow(4);
+      table.set(0, void 0);
+      table.set(offset + 0, void 0);
+      table.set(offset + 1, null);
+      table.set(offset + 2, true);
+      table.set(offset + 3, false);
+    }
+  };
+  return {
+    __proto__: null,
+    "./lafs_core_bg.js": import0
+  };
+}
+function addToExternrefTable0(obj) {
+  const idx = wasm.__externref_table_alloc();
+  wasm.__wbindgen_externrefs.set(idx, obj);
+  return idx;
+}
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    const idx = addToExternrefTable0(e);
+    wasm.__wbindgen_exn_store(idx);
+  }
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+function __wbg_finalize_init(instance, module) {
+  wasm = instance.exports;
+  wasmModule = module;
+  cachedUint8ArrayMemory0 = null;
+  wasm.__wbindgen_start();
+  return wasm;
+}
+async function __wbg_load(module, imports) {
+  if (typeof Response === "function" && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module, imports);
+      } catch (e) {
+        const validResponse = module.ok && expectedResponseType(module.type);
+        if (validResponse && module.headers.get("Content-Type") !== "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module };
+    } else {
+      return instance;
+    }
+  }
+  function expectedResponseType(type) {
+    switch (type) {
+      case "basic":
+      case "cors":
+      case "default":
+        return true;
+    }
+    return false;
+  }
+}
+function initSync(module) {
+  if (wasm !== void 0) return wasm;
+  if (module !== void 0) {
+    if (Object.getPrototypeOf(module) === Object.prototype) {
+      ({ module } = module);
+    } else {
+      console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports();
+  if (!(module instanceof WebAssembly.Module)) {
+    module = new WebAssembly.Module(module);
+  }
+  const instance = new WebAssembly.Instance(module, imports);
+  return __wbg_finalize_init(instance, module);
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0) return wasm;
+  if (module_or_path !== void 0) {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  if (module_or_path === void 0) {
+    module_or_path = new URL("lafs_core_bg.wasm", import.meta.url);
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  const { instance, module } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module);
+}
+var WasmLafsEnvelope, WasmLafsMeta, WasmLafsTransport, WasmLafsEnvelopeFinalization, WasmLafsMetaFinalization, WasmLafsTransportFinalization, cachedUint8ArrayMemory0, cachedTextDecoder, MAX_SAFARI_DECODE_BYTES, numBytesDecoded, cachedTextEncoder, WASM_VECTOR_LEN, wasmModule, wasm;
+var init_lafs_core = __esm({
+  "packages/contracts/src/wasm/lafs-core/lafs_core.js"() {
+    "use strict";
+    WasmLafsEnvelope = class _WasmLafsEnvelope {
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_WasmLafsEnvelope.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmLafsEnvelopeFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmLafsEnvelopeFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmlafsenvelope_free(ptr, 0);
+      }
+      /**
+       * Create an error envelope.
+       *
+       * # Arguments
+       * * `code` - Error code string
+       * * `message` - Error message
+       * * `meta` - LAFS metadata
+       * @param {string} code
+       * @param {string} message
+       * @param {WasmLafsMeta} meta
+       * @returns {WasmLafsEnvelope}
+       */
+      static createError(code, message, meta) {
+        const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        _assertClass(meta, WasmLafsMeta);
+        var ptr2 = meta.__destroy_into_raw();
+        const ret = wasm.wasmlafsenvelope_createError(ptr0, len0, ptr1, len1, ptr2);
+        return _WasmLafsEnvelope.__wrap(ret);
+      }
+      /**
+       * Create a success envelope.
+       *
+       * # Arguments
+       * * `data` - JSON string of the result data
+       * * `meta` - LAFS metadata
+       * @param {string} data
+       * @param {WasmLafsMeta} meta
+       * @returns {WasmLafsEnvelope}
+       */
+      static createSuccess(data, meta) {
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(meta, WasmLafsMeta);
+        var ptr1 = meta.__destroy_into_raw();
+        const ret = wasm.wasmlafsenvelope_createSuccess(ptr0, len0, ptr1);
+        return _WasmLafsEnvelope.__wrap(ret);
+      }
+      /**
+       * Get the error as a JSON string.
+       * @returns {string}
+       */
+      get error_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm.wasmlafsenvelope_error_json(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+          wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Get the metadata as a JSON string.
+       * @returns {string}
+       */
+      get meta_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm.wasmlafsenvelope_meta_json(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+          wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Get the result as a JSON string.
+       * @returns {string}
+       */
+      get result_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm.wasmlafsenvelope_result_json(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+          wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Check if the envelope represents success.
+       * @returns {boolean}
+       */
+      get success() {
+        const ret = wasm.wasmlafsenvelope_success(this.__wbg_ptr);
+        return ret !== 0;
+      }
+    };
+    if (Symbol.dispose) WasmLafsEnvelope.prototype[Symbol.dispose] = WasmLafsEnvelope.prototype.free;
+    WasmLafsMeta = class {
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmLafsMetaFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmlafsmeta_free(ptr, 0);
+      }
+      /**
+       * Create new LAFS metadata.
+       *
+       * # Arguments
+       * * `operation` - The operation name (e.g., "tasks.list")
+       * * `transport` - Transport type string ("cli", "http", "grpc", "sdk")
+       * @param {string} operation
+       * @param {string} transport
+       */
+      constructor(operation, transport) {
+        const ptr0 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(transport, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmlafsmeta_new(ptr0, len0, ptr1, len1);
+        this.__wbg_ptr = ret >>> 0;
+        WasmLafsMetaFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+      }
+      /**
+       * Get the operation name.
+       * @returns {string}
+       */
+      get operation() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm.wasmlafsmeta_operation(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+          wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Get the schema version.
+       * @returns {string}
+       */
+      get schema_version() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm.wasmlafsmeta_schema_version(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+          wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Get the LAFS spec version.
+       * @returns {string}
+       */
+      get spec_version() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm.wasmlafsmeta_spec_version(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+          wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Get the transport type as a string.
+       * @returns {string}
+       */
+      get transport() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm.wasmlafsmeta_transport(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+          wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+    };
+    if (Symbol.dispose) WasmLafsMeta.prototype[Symbol.dispose] = WasmLafsMeta.prototype.free;
+    WasmLafsTransport = class _WasmLafsTransport {
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_WasmLafsTransport.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmLafsTransportFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmLafsTransportFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmlafstransport_free(ptr, 0);
+      }
+      /**
+       * Create a CLI transport variant.
+       * @returns {WasmLafsTransport}
+       */
+      static Cli() {
+        const ret = wasm.wasmlafstransport_Cli();
+        return _WasmLafsTransport.__wrap(ret);
+      }
+      /**
+       * Create a gRPC transport variant.
+       * @returns {WasmLafsTransport}
+       */
+      static Grpc() {
+        const ret = wasm.wasmlafstransport_Grpc();
+        return _WasmLafsTransport.__wrap(ret);
+      }
+      /**
+       * Create an HTTP transport variant.
+       * @returns {WasmLafsTransport}
+       */
+      static Http() {
+        const ret = wasm.wasmlafstransport_Http();
+        return _WasmLafsTransport.__wrap(ret);
+      }
+      /**
+       * Create an SDK transport variant.
+       * @returns {WasmLafsTransport}
+       */
+      static Sdk() {
+        const ret = wasm.wasmlafstransport_Sdk();
+        return _WasmLafsTransport.__wrap(ret);
+      }
+      /**
+       * Get the transport as a string.
+       * @returns {string}
+       */
+      get as_string() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm.wasmlafstransport_as_string(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+          wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+    };
+    if (Symbol.dispose) WasmLafsTransport.prototype[Symbol.dispose] = WasmLafsTransport.prototype.free;
+    WasmLafsEnvelopeFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm.__wbg_wasmlafsenvelope_free(ptr >>> 0, 1));
+    WasmLafsMetaFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm.__wbg_wasmlafsmeta_free(ptr >>> 0, 1));
+    WasmLafsTransportFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm.__wbg_wasmlafstransport_free(ptr >>> 0, 1));
+    cachedUint8ArrayMemory0 = null;
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    MAX_SAFARI_DECODE_BYTES = 2146435072;
+    numBytesDecoded = 0;
+    cachedTextEncoder = new TextEncoder();
+    if (!("encodeInto" in cachedTextEncoder)) {
+      cachedTextEncoder.encodeInto = function(arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+          read: arg.length,
+          written: buf.length
+        };
+      };
+    }
+    WASM_VECTOR_LEN = 0;
+  }
+});
+
+// packages/contracts/src/wasm/conduit-core/conduit_core.js
+var conduit_core_exports = {};
+__export(conduit_core_exports, {
+  WasmCantMetadata: () => WasmCantMetadata,
+  WasmConduitMessage: () => WasmConduitMessage,
+  WasmConduitState: () => WasmConduitState,
+  create_conduit_state: () => create_conduit_state,
+  default: () => __wbg_init2,
+  initSync: () => initSync2,
+  parse_conduit_message: () => parse_conduit_message
+});
+function create_conduit_state(state) {
+  const ptr0 = passStringToWasm02(state, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN2;
+  const ret = wasm2.create_conduit_state(ptr0, len0);
+  return WasmConduitState.__wrap(ret);
+}
+function parse_conduit_message(json3) {
+  const ptr0 = passStringToWasm02(json3, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN2;
+  const ret = wasm2.parse_conduit_message(ptr0, len0);
+  return ret === 0 ? void 0 : WasmConduitMessage.__wrap(ret);
+}
+function __wbg_get_imports2() {
+  const import0 = {
+    __proto__: null,
+    __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
+      throw new Error(getStringFromWasm02(arg0, arg1));
+    },
+    __wbindgen_init_externref_table: function() {
+      const table = wasm2.__wbindgen_externrefs;
+      const offset = table.grow(4);
+      table.set(0, void 0);
+      table.set(offset + 0, void 0);
+      table.set(offset + 1, null);
+      table.set(offset + 2, true);
+      table.set(offset + 3, false);
+    }
+  };
+  return {
+    __proto__: null,
+    "./conduit_core_bg.js": import0
+  };
+}
+function getStringFromWasm02(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText2(ptr, len);
+}
+function getUint8ArrayMemory02() {
+  if (cachedUint8ArrayMemory02 === null || cachedUint8ArrayMemory02.byteLength === 0) {
+    cachedUint8ArrayMemory02 = new Uint8Array(wasm2.memory.buffer);
+  }
+  return cachedUint8ArrayMemory02;
+}
+function passStringToWasm02(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder2.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory02().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN2 = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory02();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory02().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder2.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN2 = offset;
+  return ptr;
+}
+function decodeText2(ptr, len) {
+  numBytesDecoded2 += len;
+  if (numBytesDecoded2 >= MAX_SAFARI_DECODE_BYTES2) {
+    cachedTextDecoder2 = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder2.decode();
+    numBytesDecoded2 = len;
+  }
+  return cachedTextDecoder2.decode(getUint8ArrayMemory02().subarray(ptr, ptr + len));
+}
+function __wbg_finalize_init2(instance, module) {
+  wasm2 = instance.exports;
+  wasmModule2 = module;
+  cachedUint8ArrayMemory02 = null;
+  wasm2.__wbindgen_start();
+  return wasm2;
+}
+async function __wbg_load2(module, imports) {
+  if (typeof Response === "function" && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module, imports);
+      } catch (e) {
+        const validResponse = module.ok && expectedResponseType(module.type);
+        if (validResponse && module.headers.get("Content-Type") !== "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module };
+    } else {
+      return instance;
+    }
+  }
+  function expectedResponseType(type) {
+    switch (type) {
+      case "basic":
+      case "cors":
+      case "default":
+        return true;
+    }
+    return false;
+  }
+}
+function initSync2(module) {
+  if (wasm2 !== void 0) return wasm2;
+  if (module !== void 0) {
+    if (Object.getPrototypeOf(module) === Object.prototype) {
+      ({ module } = module);
+    } else {
+      console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports2();
+  if (!(module instanceof WebAssembly.Module)) {
+    module = new WebAssembly.Module(module);
+  }
+  const instance = new WebAssembly.Instance(module, imports);
+  return __wbg_finalize_init2(instance, module);
+}
+async function __wbg_init2(module_or_path) {
+  if (wasm2 !== void 0) return wasm2;
+  if (module_or_path !== void 0) {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  if (module_or_path === void 0) {
+    module_or_path = new URL("conduit_core_bg.wasm", import.meta.url);
+  }
+  const imports = __wbg_get_imports2();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  const { instance, module } = await __wbg_load2(await module_or_path, imports);
+  return __wbg_finalize_init2(instance, module);
+}
+var WasmCantMetadata, WasmConduitMessage, WasmConduitState, WasmCantMetadataFinalization, WasmConduitMessageFinalization, WasmConduitStateFinalization, cachedUint8ArrayMemory02, cachedTextDecoder2, MAX_SAFARI_DECODE_BYTES2, numBytesDecoded2, cachedTextEncoder2, WASM_VECTOR_LEN2, wasmModule2, wasm2;
+var init_conduit_core = __esm({
+  "packages/contracts/src/wasm/conduit-core/conduit_core.js"() {
+    "use strict";
+    WasmCantMetadata = class {
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmCantMetadataFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm2.__wbg_wasmcantmetadata_free(ptr, 0);
+      }
+      /**
+       * Get addresses as JSON string.
+       * @returns {string}
+       */
+      get addresses_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm2.wasmcantmetadata_addresses_json(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm02(ret[0], ret[1]);
+        } finally {
+          wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Get the directive type.
+       * @returns {string}
+       */
+      get directive_type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm2.wasmcantmetadata_directive_type(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm02(ret[0], ret[1]);
+        } finally {
+          wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Create new CANT metadata.
+       *
+       * # Arguments
+       * * `directive_type` - "actionable", "routing", or "informational"
+       * * `addresses` - JSON array of addresses
+       * * `task_refs` - JSON array of task refs
+       * * `tags` - JSON array of tags
+       * @param {string} directive_type
+       * @param {string} addresses
+       * @param {string} task_refs
+       * @param {string} tags
+       */
+      constructor(directive_type, addresses, task_refs, tags) {
+        const ptr0 = passStringToWasm02(directive_type, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN2;
+        const ptr1 = passStringToWasm02(addresses, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN2;
+        const ptr2 = passStringToWasm02(task_refs, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN2;
+        const ptr3 = passStringToWasm02(tags, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN2;
+        const ret = wasm2.wasmcantmetadata_new(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        this.__wbg_ptr = ret >>> 0;
+        WasmCantMetadataFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+      }
+      /**
+       * Get tags as JSON string.
+       * @returns {string}
+       */
+      get tags_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm2.wasmcantmetadata_tags_json(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm02(ret[0], ret[1]);
+        } finally {
+          wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Get task refs as JSON string.
+       * @returns {string}
+       */
+      get task_refs_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm2.wasmcantmetadata_task_refs_json(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm02(ret[0], ret[1]);
+        } finally {
+          wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Convert to JSON string.
+       * @returns {string}
+       */
+      toJson() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm2.wasmcantmetadata_toJson(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm02(ret[0], ret[1]);
+        } finally {
+          wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+    };
+    if (Symbol.dispose) WasmCantMetadata.prototype[Symbol.dispose] = WasmCantMetadata.prototype.free;
+    WasmConduitMessage = class _WasmConduitMessage {
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_WasmConduitMessage.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmConduitMessageFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmConduitMessageFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm2.__wbg_wasmconduitmessage_free(ptr, 0);
+      }
+      /**
+       * Get the message content.
+       * @returns {string}
+       */
+      get content() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm2.wasmconduitmessage_content(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm02(ret[0], ret[1]);
+        } finally {
+          wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Get the sender agent ID.
+       * @returns {string}
+       */
+      get from() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm2.wasmconduitmessage_from(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm02(ret[0], ret[1]);
+        } finally {
+          wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Parse from JSON string.
+       * @param {string} json
+       * @returns {WasmConduitMessage | undefined}
+       */
+      static fromJson(json3) {
+        const ptr0 = passStringToWasm02(json3, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN2;
+        const ret = wasm2.wasmconduitmessage_fromJson(ptr0, len0);
+        return ret === 0 ? void 0 : _WasmConduitMessage.__wrap(ret);
+      }
+      /**
+       * Get the message ID.
+       * @returns {string}
+       */
+      get id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm2.wasmconduitmessage_id(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm02(ret[0], ret[1]);
+        } finally {
+          wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Get metadata as JSON string.
+       * @returns {string}
+       */
+      get metadata_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm2.wasmconduitmessage_metadata_json(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm02(ret[0], ret[1]);
+        } finally {
+          wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Create a new Conduit message.
+       *
+       * # Arguments
+       * * `id` - Unique message ID
+       * * `from` - Sender agent ID
+       * * `content` - Message content
+       * * `timestamp` - ISO 8601 timestamp
+       * @param {string} id
+       * @param {string} from
+       * @param {string} content
+       * @param {string} timestamp
+       */
+      constructor(id, from, content, timestamp2) {
+        const ptr0 = passStringToWasm02(id, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN2;
+        const ptr1 = passStringToWasm02(from, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN2;
+        const ptr2 = passStringToWasm02(content, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN2;
+        const ptr3 = passStringToWasm02(timestamp2, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN2;
+        const ret = wasm2.wasmconduitmessage_new(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        this.__wbg_ptr = ret >>> 0;
+        WasmConduitMessageFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+      }
+      /**
+       * Get tags as JSON string.
+       * @returns {string}
+       */
+      get tags_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm2.wasmconduitmessage_tags_json(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm02(ret[0], ret[1]);
+        } finally {
+          wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Get the timestamp.
+       * @returns {string}
+       */
+      get timestamp() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm2.wasmconduitmessage_timestamp(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm02(ret[0], ret[1]);
+        } finally {
+          wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Convert to JSON string.
+       * @returns {string}
+       */
+      toJson() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm2.wasmconduitmessage_toJson(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm02(ret[0], ret[1]);
+        } finally {
+          wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+    };
+    if (Symbol.dispose) WasmConduitMessage.prototype[Symbol.dispose] = WasmConduitMessage.prototype.free;
+    WasmConduitState = class _WasmConduitState {
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_WasmConduitState.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmConduitStateFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmConduitStateFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm2.__wbg_wasmconduitstate_free(ptr, 0);
+      }
+      /**
+       * Create connected state.
+       * @returns {WasmConduitState}
+       */
+      static Connected() {
+        const ret = wasm2.wasmconduitstate_Connected();
+        return _WasmConduitState.__wrap(ret);
+      }
+      /**
+       * Create connecting state.
+       * @returns {WasmConduitState}
+       */
+      static Connecting() {
+        const ret = wasm2.wasmconduitstate_Connecting();
+        return _WasmConduitState.__wrap(ret);
+      }
+      /**
+       * Create disconnected state.
+       * @returns {WasmConduitState}
+       */
+      static Disconnected() {
+        const ret = wasm2.wasmconduitstate_Disconnected();
+        return _WasmConduitState.__wrap(ret);
+      }
+      /**
+       * Create error state.
+       * @returns {WasmConduitState}
+       */
+      static Error() {
+        const ret = wasm2.wasmconduitstate_Error();
+        return _WasmConduitState.__wrap(ret);
+      }
+      /**
+       * Create reconnecting state.
+       * @returns {WasmConduitState}
+       */
+      static Reconnecting() {
+        const ret = wasm2.wasmconduitstate_Reconnecting();
+        return _WasmConduitState.__wrap(ret);
+      }
+      /**
+       * Get state as string.
+       * @returns {string}
+       */
+      get as_string() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm2.wasmconduitstate_as_string(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm02(ret[0], ret[1]);
+        } finally {
+          wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+    };
+    if (Symbol.dispose) WasmConduitState.prototype[Symbol.dispose] = WasmConduitState.prototype.free;
+    WasmCantMetadataFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm2.__wbg_wasmcantmetadata_free(ptr >>> 0, 1));
+    WasmConduitMessageFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm2.__wbg_wasmconduitmessage_free(ptr >>> 0, 1));
+    WasmConduitStateFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm2.__wbg_wasmconduitstate_free(ptr >>> 0, 1));
+    cachedUint8ArrayMemory02 = null;
+    cachedTextDecoder2 = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder2.decode();
+    MAX_SAFARI_DECODE_BYTES2 = 2146435072;
+    numBytesDecoded2 = 0;
+    cachedTextEncoder2 = new TextEncoder();
+    if (!("encodeInto" in cachedTextEncoder2)) {
+      cachedTextEncoder2.encodeInto = function(arg, view) {
+        const buf = cachedTextEncoder2.encode(arg);
+        view.set(buf);
+        return {
+          read: arg.length,
+          written: buf.length
+        };
+      };
+    }
+    WASM_VECTOR_LEN2 = 0;
+  }
+});
+
+// packages/contracts/src/wasm/index.ts
+var wasm_exports = {};
+__export(wasm_exports, {
+  conduit: () => conduit,
+  initWasm: () => initWasm,
+  isWasmReady: () => isWasmReady,
+  lafs: () => lafs
+});
+async function initWasm() {
+  if (isInitialized) return;
+  if (isInitializing) {
+    return initPromise;
+  }
+  isInitializing = true;
+  initPromise = (async () => {
+    try {
+      const [lafs2, conduit2] = await Promise.all([
+        Promise.resolve().then(() => (init_lafs_core(), lafs_core_exports)),
+        Promise.resolve().then(() => (init_conduit_core(), conduit_core_exports))
+      ]);
+      await Promise.all([lafs2.default(), conduit2.default()]);
+      lafsModule = lafs2;
+      conduitModule = conduit2;
+      isInitialized = true;
+    } catch (_error) {
+      throw new Error("WASM initialization failed. Ensure WASM files are present.");
+    }
+  })();
+  await initPromise;
+  isInitializing = false;
+}
+function isWasmReady() {
+  return isInitialized;
+}
+var lafsModule, conduitModule, isInitialized, isInitializing, initPromise, lafs, conduit;
+var init_wasm = __esm({
+  "packages/contracts/src/wasm/index.ts"() {
+    "use strict";
+    lafsModule = null;
+    conduitModule = null;
+    isInitialized = false;
+    isInitializing = false;
+    initPromise = null;
+    lafs = {
+      /**
+       * LAFS Transport enum
+       * Use WasmLafsTransport.cli(), .http(), .grpc(), or .sdk()
+       */
+      get WasmLafsTransport() {
+        if (!lafsModule) throw new Error("WASM not initialized. Call initWasm() first.");
+        return lafsModule.WasmLafsTransport;
+      },
+      /**
+       * LAFS Metadata constructor
+       * new WasmLafsMeta(operation: string, transport: string)
+       */
+      get WasmLafsMeta() {
+        if (!lafsModule) throw new Error("WASM not initialized. Call initWasm() first.");
+        return lafsModule.WasmLafsMeta;
+      },
+      /**
+       * LAFS Envelope class
+       * Use WasmLafsEnvelope.createSuccess() or .createError()
+       */
+      get WasmLafsEnvelope() {
+        if (!lafsModule) throw new Error("WASM not initialized. Call initWasm() first.");
+        return lafsModule.WasmLafsEnvelope;
+      },
+      /**
+       * Helper function to create transport from string
+       * @param transport - "cli", "http", "grpc", or "sdk"
+       */
+      get createTransport() {
+        if (!lafsModule) throw new Error("WASM not initialized. Call initWasm() first.");
+        return lafsModule.create_transport;
+      }
+    };
+    conduit = {
+      /**
+       * Conduit Message constructor
+       * new WasmConduitMessage(id, from, content, timestamp)
+       */
+      get WasmConduitMessage() {
+        if (!conduitModule) throw new Error("WASM not initialized. Call initWasm() first.");
+        return conduitModule.WasmConduitMessage;
+      },
+      /**
+       * Conduit State enum
+       * Use WasmConduitState.disconnected(), .connecting(), .connected(), etc.
+       */
+      get WasmConduitState() {
+        if (!conduitModule) throw new Error("WASM not initialized. Call initWasm() first.");
+        return conduitModule.WasmConduitState;
+      },
+      /**
+       * CANT Metadata constructor
+       * new WasmCantMetadata(directiveType, addressesJson, taskRefsJson, tagsJson)
+       */
+      get WasmCantMetadata() {
+        if (!conduitModule) throw new Error("WASM not initialized. Call initWasm() first.");
+        return conduitModule.WasmCantMetadata;
+      },
+      /**
+       * Parse a ConduitMessage from JSON string
+       * @param json - JSON string
+       * @returns WasmConduitMessage or undefined
+       */
+      get parseConduitMessage() {
+        if (!conduitModule) throw new Error("WASM not initialized. Call initWasm() first.");
+        return conduitModule.parse_conduit_message;
+      },
+      /**
+       * Create a ConduitState from string
+       * @param state - "disconnected", "connecting", "connected", "reconnecting", "error"
+       */
+      get createConduitState() {
+        if (!conduitModule) throw new Error("WASM not initialized. Call initWasm() first.");
+        return conduitModule.create_conduit_state;
+      }
+    };
+  }
+});
+
 // packages/contracts/src/index.ts
 var init_src = __esm({
   "packages/contracts/src/index.ts"() {
@@ -526,6 +1727,7 @@ var init_src = __esm({
     init_operations();
     init_session2();
     init_status_registry();
+    init_wasm();
   }
 });
 
@@ -1253,7 +2455,8 @@ function rowToTask(row) {
       modifiedBy: row.modifiedBy ?? null,
       sessionId: row.sessionId ?? null
     } : void 0,
-    pipelineStage: row.pipelineStage ?? void 0
+    pipelineStage: row.pipelineStage ?? void 0,
+    assignee: row.assignee ?? void 0
   };
 }
 function taskToRow(task) {
@@ -1286,7 +2489,8 @@ function taskToRow(task) {
     createdBy: task.provenance?.createdBy ?? null,
     modifiedBy: task.provenance?.modifiedBy ?? null,
     sessionId: task.provenance?.sessionId ?? null,
-    pipelineStage: task.pipelineStage ?? null
+    pipelineStage: task.pipelineStage ?? null,
+    assignee: task.assignee ?? null
   };
 }
 function archivedTaskToRow(task) {
@@ -1880,7 +3084,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       _sql.raw = raw;
-      function join105(chunks, separator) {
+      function join106(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) result.push(separator);
@@ -1888,7 +3092,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      _sql.join = join105;
+      _sql.join = join106;
       function identifier(value) {
         return new Name(value);
       }
@@ -6662,7 +7866,7 @@ var init_select2 = __esm({
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table)) this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join105) => join105.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins?.some((join106) => join106.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
           if (!this.isPartialSelect) {
             if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") this.config.fields = { [baseTableName]: this.config.fields };
             if (typeof tableName === "string" && !is(table, SQL)) {
@@ -7947,7 +9151,7 @@ var init_dialect = __esm({
           if (!joins2) return;
           const withEntries = Object.entries(joins2).filter(([_, v]) => v);
           if (!withEntries.length) return;
-          return sql.join(withEntries.map(([k, join105]) => {
+          return sql.join(withEntries.map(([k, join106]) => {
             const relation = tableConfig.relations[k];
             const isSingle2 = is(relation, One3);
             const targetTable = aliasedTable(relation.targetTable, `d${currentDepth + 1}`);
@@ -7958,7 +9162,7 @@ var init_dialect = __esm({
               table: targetTable,
               mode: isSingle2 ? "first" : "many",
               schema,
-              queryConfig: join105,
+              queryConfig: join106,
               tableConfig: schema[relation.targetTableName],
               relationWhere: filter,
               isNested: true,
@@ -7972,7 +9176,7 @@ var init_dialect = __esm({
               key: k,
               selection: innerQuery.selection,
               isArray: !isSingle2,
-              isOptional: (relation.optional ?? false) || join105 !== true && !!join105.where
+              isOptional: (relation.optional ?? false) || join106 !== true && !!join106.where
             });
             const jsonColumns = sql.join(innerQuery.selection.map((s) => {
               return sql`${sql.raw(this.escapeString(s.key))}, ${s.selection ? sql`${jsonb2}(${sql.identifier(s.key)})` : sql.identifier(s.key)}`;
@@ -8371,7 +9575,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return ((table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join105) => join105.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins.some((join106) => join106.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
           if (typeof on === "function") {
             const from = this.config.from ? is(table, SQLiteTable) ? table[Table.Symbol.Columns] : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? table[ViewBaseConfig].selectedFields : void 0 : void 0;
             on = on(new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
@@ -9159,6 +10363,7 @@ __export(tasks_schema_exports, {
   TOKEN_USAGE_TRANSPORTS: () => TOKEN_USAGE_TRANSPORTS,
   adrRelations: () => adrRelations,
   adrTaskLinks: () => adrTaskLinks,
+  agentCredentials: () => agentCredentials,
   agentErrorLog: () => agentErrorLog,
   agentInstances: () => agentInstances,
   architectureDecisions: () => architectureDecisions,
@@ -9185,7 +10390,7 @@ __export(tasks_schema_exports, {
   warpChains: () => warpChains
 });
 import { sql as sql4 } from "drizzle-orm";
-var TASK_PRIORITIES, TASK_TYPES, TASK_SIZES, LIFECYCLE_STAGE_NAMES, LIFECYCLE_GATE_RESULTS, LIFECYCLE_EVIDENCE_TYPES, TOKEN_USAGE_METHODS, TOKEN_USAGE_CONFIDENCE, TOKEN_USAGE_TRANSPORTS, TASK_RELATION_TYPES, LIFECYCLE_TRANSITION_TYPES, EXTERNAL_LINK_TYPES, SYNC_DIRECTIONS, tasks, taskDependencies, taskRelations, sessions, taskWorkHistory, lifecyclePipelines, lifecycleStages, lifecycleGateResults, lifecycleEvidence, lifecycleTransitions, manifestEntries, pipelineManifest, releaseManifests, schemaMeta, auditLog, tokenUsage, architectureDecisions, adrTaskLinks, adrRelations, externalTaskLinks, statusRegistryTable;
+var TASK_PRIORITIES, TASK_TYPES, TASK_SIZES, LIFECYCLE_STAGE_NAMES, LIFECYCLE_GATE_RESULTS, LIFECYCLE_EVIDENCE_TYPES, TOKEN_USAGE_METHODS, TOKEN_USAGE_CONFIDENCE, TOKEN_USAGE_TRANSPORTS, TASK_RELATION_TYPES, LIFECYCLE_TRANSITION_TYPES, EXTERNAL_LINK_TYPES, SYNC_DIRECTIONS, tasks, taskDependencies, taskRelations, sessions, taskWorkHistory, lifecyclePipelines, lifecycleStages, lifecycleGateResults, lifecycleEvidence, lifecycleTransitions, manifestEntries, pipelineManifest, releaseManifests, schemaMeta, auditLog, tokenUsage, architectureDecisions, adrTaskLinks, adrRelations, externalTaskLinks, statusRegistryTable, agentCredentials;
 var init_tasks_schema = __esm({
   "packages/core/src/store/tasks-schema.ts"() {
     "use strict";
@@ -9277,7 +10482,9 @@ var init_tasks_schema = __esm({
         // T060: pipeline stage name (RCASD-IVTR+C). Stored as a plain stage name string.
         // Not referencing lifecycle_stages.id so that stage binding works without
         // requiring a lifecycle pipeline record for every task.
-        pipelineStage: text("pipeline_stage")
+        pipelineStage: text("pipeline_stage"),
+        /** Agent ID that has claimed/is assigned to this task. */
+        assignee: text("assignee")
       },
       (table) => [
         index("idx_tasks_status").on(table.status),
@@ -9287,6 +10494,7 @@ var init_tasks_schema = __esm({
         index("idx_tasks_priority").on(table.priority),
         index("idx_tasks_session_id").on(table.sessionId),
         index("idx_tasks_pipeline_stage").on(table.pipelineStage),
+        index("idx_tasks_assignee").on(table.assignee),
         // T033 composite indexes
         index("idx_tasks_parent_status").on(table.parentId, table.status),
         index("idx_tasks_status_priority").on(table.status, table.priority),
@@ -9756,6 +10964,32 @@ var init_tasks_schema = __esm({
         index("idx_status_registry_namespace").on(table.namespace)
       ]
     );
+    agentCredentials = sqliteTable(
+      "agent_credentials",
+      {
+        agentId: text("agent_id").primaryKey(),
+        displayName: text("display_name").notNull(),
+        /** API key encrypted at rest using AES-256-GCM with machine-bound key. */
+        apiKeyEncrypted: text("api_key_encrypted").notNull(),
+        apiBaseUrl: text("api_base_url").notNull().default("https://api.signaldock.io"),
+        classification: text("classification"),
+        privacyTier: text("privacy_tier").notNull().default("public"),
+        /** JSON array of capability slugs. */
+        capabilities: text("capabilities").notNull().default("[]"),
+        /** JSON array of skill slugs. */
+        skills: text("skills").notNull().default("[]"),
+        /** JSON object with transport-specific settings. */
+        transportConfig: text("transport_config").notNull().default("{}"),
+        isActive: integer("is_active", { mode: "boolean" }).notNull().default(true),
+        lastUsedAt: integer("last_used_at"),
+        createdAt: integer("created_at").notNull(),
+        updatedAt: integer("updated_at").notNull()
+      },
+      (table) => [
+        index("idx_agent_credentials_active").on(table.isActive),
+        index("idx_agent_credentials_last_used").on(table.lastUsedAt)
+      ]
+    );
   }
 });
 
@@ -9799,6 +11033,7 @@ async function upsertTask(db, row, archiveFields) {
     sessionId: row.sessionId,
     // T060: pipeline stage name (RCASD-IVTR+C)
     pipelineStage: row.pipelineStage ?? null,
+    assignee: row.assignee ?? null,
     // Always include archive metadata so unarchive clears stale values (T5034)
     archivedAt: archiveFields?.archivedAt ?? null,
     archiveReason: archiveFields?.archiveReason ?? null,
@@ -11430,7 +12665,10 @@ var init_sqlite2 = __esm({
     _initPromise2 = null;
     _gitTrackingChecked = false;
     MIN_BACKUP_TASK_COUNT = 10;
-    REQUIRED_TASK_COLUMNS = [{ name: "pipeline_stage", ddl: "text" }];
+    REQUIRED_TASK_COLUMNS = [
+      { name: "pipeline_stage", ddl: "text" },
+      { name: "assignee", ddl: "text" }
+    ];
     REQUIRED_SESSION_COLUMNS = [
       { name: "provider_id", ddl: "text" },
       { name: "stats_json", ddl: "text" },
@@ -11440,13 +12678,253 @@ var init_sqlite2 = __esm({
   }
 });
 
+// packages/core/src/agents/registry.ts
+var registry_exports2 = {};
+__export(registry_exports2, {
+  checkAgentHealth: () => checkAgentHealth,
+  classifyError: () => classifyError,
+  deregisterAgent: () => deregisterAgent,
+  generateAgentId: () => generateAgentId,
+  getAgentErrorHistory: () => getAgentErrorHistory,
+  getAgentInstance: () => getAgentInstance,
+  getHealthReport: () => getHealthReport,
+  heartbeat: () => heartbeat,
+  incrementTasksCompleted: () => incrementTasksCompleted,
+  listAgentInstances: () => listAgentInstances,
+  markCrashed: () => markCrashed,
+  registerAgent: () => registerAgent,
+  updateAgentStatus: () => updateAgentStatus
+});
+import { randomBytes } from "node:crypto";
+import { and as and2, eq as eq4, inArray as inArray3, lt as lt2, sql as sql7 } from "drizzle-orm";
+function generateAgentId() {
+  const now = /* @__PURE__ */ new Date();
+  const ts = now.toISOString().replace(/[-:T]/g, "").substring(0, 14);
+  const hex = randomBytes(3).toString("hex");
+  return `agt_${ts}_${hex}`;
+}
+async function registerAgent(opts, cwd) {
+  const db = await getDb(cwd);
+  const id = generateAgentId();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const row = {
+    id,
+    agentType: opts.agentType,
+    status: "starting",
+    sessionId: opts.sessionId ?? null,
+    taskId: opts.taskId ?? null,
+    startedAt: now,
+    lastHeartbeat: now,
+    stoppedAt: null,
+    errorCount: 0,
+    totalTasksCompleted: 0,
+    capacity: "1.0",
+    metadataJson: opts.metadata ? JSON.stringify(opts.metadata) : "{}",
+    parentAgentId: opts.parentAgentId ?? null
+  };
+  await db.insert(agentInstances).values(row);
+  return row;
+}
+async function deregisterAgent(id, cwd) {
+  const db = await getDb(cwd);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = await db.select().from(agentInstances).where(eq4(agentInstances.id, id)).get();
+  if (!existing) return null;
+  if (existing.status === "stopped") return existing;
+  await db.update(agentInstances).set({ status: "stopped", stoppedAt: now }).where(eq4(agentInstances.id, id));
+  return { ...existing, status: "stopped", stoppedAt: now };
+}
+async function heartbeat(id, cwd) {
+  const db = await getDb(cwd);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = await db.select().from(agentInstances).where(eq4(agentInstances.id, id)).get();
+  if (!existing) return null;
+  if (existing.status === "stopped" || existing.status === "crashed") {
+    return existing.status;
+  }
+  await db.update(agentInstances).set({ lastHeartbeat: now }).where(eq4(agentInstances.id, id));
+  return existing.status;
+}
+async function updateAgentStatus(id, opts, cwd) {
+  const db = await getDb(cwd);
+  const existing = await db.select().from(agentInstances).where(eq4(agentInstances.id, id)).get();
+  if (!existing) return null;
+  const updates = {
+    status: opts.status
+  };
+  if (opts.taskId !== void 0) {
+    updates.taskId = opts.taskId;
+  }
+  if (opts.status === "active") {
+    updates.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  if (opts.status === "error" || opts.status === "crashed") {
+    updates.errorCount = existing.errorCount + 1;
+    if (opts.error) {
+      const errorType = classifyError(new Error(opts.error));
+      await db.insert(agentErrorLog).values({
+        agentId: id,
+        errorType,
+        message: opts.error,
+        occurredAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  if (opts.status === "stopped") {
+    updates.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  await db.update(agentInstances).set(updates).where(eq4(agentInstances.id, id));
+  return { ...existing, ...updates };
+}
+async function incrementTasksCompleted(id, cwd) {
+  const db = await getDb(cwd);
+  await db.update(agentInstances).set({ totalTasksCompleted: sql7`${agentInstances.totalTasksCompleted} + 1` }).where(eq4(agentInstances.id, id));
+}
+async function listAgentInstances(filters, cwd) {
+  const db = await getDb(cwd);
+  const conditions = [];
+  if (filters?.status) {
+    const statuses = Array.isArray(filters.status) ? filters.status : [filters.status];
+    conditions.push(inArray3(agentInstances.status, statuses));
+  }
+  if (filters?.agentType) {
+    const types = Array.isArray(filters.agentType) ? filters.agentType : [filters.agentType];
+    conditions.push(inArray3(agentInstances.agentType, types));
+  }
+  if (filters?.sessionId) {
+    conditions.push(eq4(agentInstances.sessionId, filters.sessionId));
+  }
+  if (filters?.parentAgentId) {
+    conditions.push(eq4(agentInstances.parentAgentId, filters.parentAgentId));
+  }
+  if (conditions.length === 0) {
+    return db.select().from(agentInstances).all();
+  }
+  return db.select().from(agentInstances).where(and2(...conditions)).all();
+}
+async function getAgentInstance(id, cwd) {
+  const db = await getDb(cwd);
+  const row = await db.select().from(agentInstances).where(eq4(agentInstances.id, id)).get();
+  return row ?? null;
+}
+function classifyError(error40) {
+  const message = error40 instanceof Error ? error40.message : String(error40);
+  for (const pattern of RETRIABLE_PATTERNS) {
+    if (pattern.test(message)) return "retriable";
+  }
+  for (const pattern of PERMANENT_PATTERNS) {
+    if (pattern.test(message)) return "permanent";
+  }
+  return "unknown";
+}
+async function getAgentErrorHistory(agentId, cwd) {
+  const db = await getDb(cwd);
+  return db.select().from(agentErrorLog).where(eq4(agentErrorLog.agentId, agentId)).all();
+}
+async function checkAgentHealth(thresholdMs = 3e4, cwd) {
+  const db = await getDb(cwd);
+  const cutoff = new Date(Date.now() - thresholdMs).toISOString();
+  return db.select().from(agentInstances).where(
+    and2(
+      inArray3(agentInstances.status, ["active", "idle", "starting"]),
+      lt2(agentInstances.lastHeartbeat, cutoff)
+    )
+  ).all();
+}
+async function markCrashed(id, reason, cwd) {
+  return updateAgentStatus(
+    id,
+    { status: "crashed", error: reason ?? "Heartbeat timeout \u2014 agent presumed crashed" },
+    cwd
+  );
+}
+async function getHealthReport(thresholdMs = 3e4, cwd) {
+  const allAgents = await listAgentInstances(void 0, cwd);
+  const staleAgents = await checkAgentHealth(thresholdMs, cwd);
+  const report = {
+    total: allAgents.length,
+    active: 0,
+    idle: 0,
+    starting: 0,
+    error: 0,
+    crashed: 0,
+    stopped: 0,
+    totalErrors: 0,
+    staleAgents
+  };
+  for (const agent of allAgents) {
+    switch (agent.status) {
+      case "active":
+        report.active++;
+        break;
+      case "idle":
+        report.idle++;
+        break;
+      case "starting":
+        report.starting++;
+        break;
+      case "error":
+        report.error++;
+        break;
+      case "crashed":
+        report.crashed++;
+        break;
+      case "stopped":
+        report.stopped++;
+        break;
+    }
+    report.totalErrors += agent.errorCount;
+  }
+  return report;
+}
+var RETRIABLE_PATTERNS, PERMANENT_PATTERNS;
+var init_registry2 = __esm({
+  "packages/core/src/agents/registry.ts"() {
+    "use strict";
+    init_sqlite2();
+    init_agent_schema();
+    RETRIABLE_PATTERNS = [
+      /timeout/i,
+      /ECONNREFUSED/,
+      /ECONNRESET/,
+      /EPIPE/,
+      /ETIMEDOUT/,
+      /rate.?limit/i,
+      /429/,
+      /503/,
+      /502/,
+      /SQLITE_BUSY/i,
+      /database is locked/i,
+      /temporarily unavailable/i,
+      /too many requests/i,
+      /network/i,
+      /socket hang up/i
+    ];
+    PERMANENT_PATTERNS = [
+      /permission denied/i,
+      /EACCES/,
+      /authentication/i,
+      /unauthorized/i,
+      /401/,
+      /403/,
+      /404/,
+      /not found/i,
+      /invalid.*token/i,
+      /SQLITE_CONSTRAINT/i,
+      /syntax error/i,
+      /type error/i,
+      /reference error/i
+    ];
+  }
+});
+
 // packages/core/src/store/sqlite-data-accessor.ts
 var sqlite_data_accessor_exports = {};
 __export(sqlite_data_accessor_exports, {
   createSqliteDataAccessor: () => createSqliteDataAccessor,
   setMetaValue: () => setMetaValue
 });
-import { and as and2, eq as eq4, inArray as inArray3, isNull as isNull2, like as like2, ne as ne2, notInArray as notInArray2, or as or2, sql as sql7 } from "drizzle-orm";
+import { and as and3, eq as eq5, inArray as inArray4, isNull as isNull2, like as like2, ne as ne2, notInArray as notInArray2, or as or2, sql as sql8 } from "drizzle-orm";
 function generateAuditLogId() {
   const epoch = Math.floor(Date.now() / 1e3);
   const rand = Math.random().toString(36).slice(2, 8);
@@ -11454,7 +12932,7 @@ function generateAuditLogId() {
 }
 async function getMetaValue(cwd, key) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(schemaMeta).where(eq4(schemaMeta.key, key)).all();
+  const rows = await db.select().from(schemaMeta).where(eq5(schemaMeta.key, key)).all();
   if (rows.length === 0 || !rows[0]) return null;
   try {
     return JSON.parse(rows[0].value);
@@ -11482,7 +12960,7 @@ async function createSqliteDataAccessor(cwd) {
     // ---- loadArchive ----
     async loadArchive() {
       const db = await getDb(cwd);
-      const archivedRows = await db.select().from(tasks).where(eq4(tasks.status, "archived")).all();
+      const archivedRows = await db.select().from(tasks).where(eq5(tasks.status, "archived")).all();
       if (archivedRows.length === 0) return null;
       const archivedTasks = archivedRows.map((row) => {
         const task = rowToTask(row);
@@ -11554,7 +13032,7 @@ async function createSqliteDataAccessor(cwd) {
       const incomingIds = new Set(sessions2.map((s) => s.id));
       for (const eid of existingIds) {
         if (!incomingIds.has(eid)) {
-          await db.delete(sessions).where(eq4(sessions.id, eid)).run();
+          await db.delete(sessions).where(eq5(sessions.id, eid)).run();
         }
       }
       for (const session of sessions2) {
@@ -11607,7 +13085,7 @@ async function createSqliteDataAccessor(cwd) {
     },
     async archiveSingleTask(taskId, fields) {
       const db = await getDb(cwd);
-      const rows = await db.select({ id: tasks.id }).from(tasks).where(eq4(tasks.id, taskId)).all();
+      const rows = await db.select({ id: tasks.id }).from(tasks).where(eq5(tasks.id, taskId)).all();
       if (rows.length === 0) return;
       await db.update(tasks).set({
         status: "archived",
@@ -11615,17 +13093,17 @@ async function createSqliteDataAccessor(cwd) {
         archiveReason: fields.archiveReason ?? "completed",
         cycleTimeDays: fields.cycleTimeDays ?? null,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }).where(eq4(tasks.id, taskId)).run();
+      }).where(eq5(tasks.id, taskId)).run();
     },
     async removeSingleTask(taskId) {
       const db = await getDb(cwd);
-      await db.delete(taskDependencies).where(eq4(taskDependencies.taskId, taskId)).run();
-      await db.delete(taskDependencies).where(eq4(taskDependencies.dependsOn, taskId)).run();
-      await db.delete(tasks).where(eq4(tasks.id, taskId)).run();
+      await db.delete(taskDependencies).where(eq5(taskDependencies.taskId, taskId)).run();
+      await db.delete(taskDependencies).where(eq5(taskDependencies.dependsOn, taskId)).run();
+      await db.delete(tasks).where(eq5(tasks.id, taskId)).run();
     },
     async loadSingleTask(taskId) {
       const db = await getDb(cwd);
-      const rows = await db.select().from(tasks).where(eq4(tasks.id, taskId)).limit(1).all();
+      const rows = await db.select().from(tasks).where(eq5(tasks.id, taskId)).limit(1).all();
       if (rows.length === 0 || !rows[0]) return null;
       const task = rowToTask(rows[0]);
       const allIdRows = await db.select({ id: tasks.id }).from(tasks).all();
@@ -11636,7 +13114,7 @@ async function createSqliteDataAccessor(cwd) {
     },
     async getActiveSession() {
       const db = await getDb(cwd);
-      const rows = await db.select().from(sessions).where(eq4(sessions.status, "active")).orderBy(sql7`${sessions.startedAt} DESC`).limit(1).all();
+      const rows = await db.select().from(sessions).where(eq5(sessions.status, "active")).orderBy(sql8`${sessions.startedAt} DESC`).limit(1).all();
       if (rows.length === 0 || !rows[0]) return null;
       return rowToSession(rows[0]);
     },
@@ -11646,7 +13124,7 @@ async function createSqliteDataAccessor(cwd) {
     },
     async removeSingleSession(sessionId) {
       const db = await getDb(cwd);
-      await db.delete(sessions).where(eq4(sessions.id, sessionId)).run();
+      await db.delete(sessions).where(eq5(sessions.id, sessionId)).run();
     },
     // ---- Targeted query methods (Phase 2 modernization) ----
     async queryTasks(filters) {
@@ -11657,7 +13135,7 @@ async function createSqliteDataAccessor(cwd) {
         if (!statuses.includes("archived")) {
           conditions.push(ne2(tasks.status, "archived"));
         }
-        conditions.push(inArray3(tasks.status, statuses));
+        conditions.push(inArray4(tasks.status, statuses));
       } else if (filters.excludeStatus) {
         const excluded = Array.isArray(filters.excludeStatus) ? filters.excludeStatus : [filters.excludeStatus];
         for (const s of excluded) {
@@ -11666,14 +13144,14 @@ async function createSqliteDataAccessor(cwd) {
       } else {
         conditions.push(ne2(tasks.status, "archived"));
       }
-      if (filters.priority) conditions.push(eq4(tasks.priority, filters.priority));
-      if (filters.type) conditions.push(eq4(tasks.type, filters.type));
-      if (filters.phase) conditions.push(eq4(tasks.phase, filters.phase));
+      if (filters.priority) conditions.push(eq5(tasks.priority, filters.priority));
+      if (filters.type) conditions.push(eq5(tasks.type, filters.type));
+      if (filters.phase) conditions.push(eq5(tasks.phase, filters.phase));
       if (filters.parentId !== void 0) {
         if (filters.parentId === null) {
           conditions.push(isNull2(tasks.parentId));
         } else {
-          conditions.push(eq4(tasks.parentId, filters.parentId));
+          conditions.push(eq5(tasks.parentId, filters.parentId));
         }
       }
       if (filters.search) {
@@ -11689,25 +13167,25 @@ async function createSqliteDataAccessor(cwd) {
       if (filters.label) {
         conditions.push(like2(tasks.labelsJson, `%${JSON.stringify(filters.label)}%`));
       }
-      const where = conditions.length > 0 ? and2(...conditions) : void 0;
-      const countResult = await db.select({ count: sql7`count(*)` }).from(tasks).where(where).get();
+      const where = conditions.length > 0 ? and3(...conditions) : void 0;
+      const countResult = await db.select({ count: sql8`count(*)` }).from(tasks).where(where).get();
       const total = countResult?.count ?? 0;
       let orderClause;
       switch (filters.orderBy) {
         case "createdAt":
-          orderClause = sql7`${tasks.createdAt} ASC`;
+          orderClause = sql8`${tasks.createdAt} ASC`;
           break;
         case "updatedAt":
-          orderClause = sql7`${tasks.updatedAt} DESC NULLS LAST`;
+          orderClause = sql8`${tasks.updatedAt} DESC NULLS LAST`;
           break;
         case "priority": {
-          orderClause = sql7`CASE ${tasks.priority}
+          orderClause = sql8`CASE ${tasks.priority}
             WHEN 'critical' THEN 0 WHEN 'high' THEN 1
             WHEN 'medium' THEN 2 WHEN 'low' THEN 3 ELSE 4 END ASC`;
           break;
         }
         default:
-          orderClause = sql7`${tasks.position} ASC, ${tasks.createdAt} ASC`;
+          orderClause = sql8`${tasks.position} ASC, ${tasks.createdAt} ASC`;
       }
       let query = db.select().from(tasks).where(where).orderBy(orderClause);
       if (filters.limit !== void 0) {
@@ -11730,20 +13208,20 @@ async function createSqliteDataAccessor(cwd) {
       const conditions = [];
       if (filters?.status) {
         const statuses = Array.isArray(filters.status) ? filters.status : [filters.status];
-        conditions.push(inArray3(tasks.status, statuses));
+        conditions.push(inArray4(tasks.status, statuses));
       } else {
         conditions.push(ne2(tasks.status, "archived"));
       }
       if (filters?.parentId) {
-        conditions.push(eq4(tasks.parentId, filters.parentId));
+        conditions.push(eq5(tasks.parentId, filters.parentId));
       }
-      const where = conditions.length > 0 ? and2(...conditions) : void 0;
-      const result = await db.select({ count: sql7`count(*)` }).from(tasks).where(where).get();
+      const where = conditions.length > 0 ? and3(...conditions) : void 0;
+      const result = await db.select({ count: sql8`count(*)` }).from(tasks).where(where).get();
       return result?.count ?? 0;
     },
     async getChildren(parentId) {
       const db = await getDb(cwd);
-      const rows = await db.select().from(tasks).where(and2(eq4(tasks.parentId, parentId), ne2(tasks.status, "archived"))).orderBy(sql7`${tasks.position} ASC, ${tasks.createdAt} ASC`).all();
+      const rows = await db.select().from(tasks).where(and3(eq5(tasks.parentId, parentId), ne2(tasks.status, "archived"))).orderBy(sql8`${tasks.position} ASC, ${tasks.createdAt} ASC`).all();
       const tasks2 = rows.map(rowToTask);
       if (tasks2.length > 0) {
         const allIds = await getAllTaskIds();
@@ -11754,14 +13232,14 @@ async function createSqliteDataAccessor(cwd) {
     },
     async countChildren(parentId) {
       const db = await getDb(cwd);
-      const result = await db.select({ count: sql7`count(*)` }).from(tasks).where(and2(eq4(tasks.parentId, parentId), ne2(tasks.status, "archived"))).get();
+      const result = await db.select({ count: sql8`count(*)` }).from(tasks).where(and3(eq5(tasks.parentId, parentId), ne2(tasks.status, "archived"))).get();
       return result?.count ?? 0;
     },
     async countActiveChildren(parentId) {
       const db = await getDb(cwd);
-      const result = await db.select({ count: sql7`count(*)` }).from(tasks).where(
-        and2(
-          eq4(tasks.parentId, parentId),
+      const result = await db.select({ count: sql8`count(*)` }).from(tasks).where(
+        and3(
+          eq5(tasks.parentId, parentId),
           notInArray2(tasks.status, [...TERMINAL_TASK_STATUSES])
         )
       ).get();
@@ -11783,7 +13261,7 @@ async function createSqliteDataAccessor(cwd) {
       if (idRows.length === 0) return [];
       const db = await getDb(cwd);
       const ids = idRows.map((r) => r.id);
-      const taskRows = await db.select().from(tasks).where(inArray3(tasks.id, ids)).all();
+      const taskRows = await db.select().from(tasks).where(inArray4(tasks.id, ids)).all();
       const tasks2 = taskRows.map(rowToTask);
       if (tasks2.length > 0) {
         const allIds = await getAllTaskIds();
@@ -11809,7 +13287,7 @@ async function createSqliteDataAccessor(cwd) {
       if (idRows.length === 0) return [];
       const db = await getDb(cwd);
       const ids = idRows.map((r) => r.id);
-      const rows = await db.select().from(tasks).where(inArray3(tasks.id, ids)).all();
+      const rows = await db.select().from(tasks).where(inArray4(tasks.id, ids)).all();
       const tasks2 = rows.map(rowToTask);
       if (tasks2.length > 0) {
         const allIds = await getAllTaskIds();
@@ -11820,10 +13298,10 @@ async function createSqliteDataAccessor(cwd) {
     },
     async getDependents(taskId) {
       const db = await getDb(cwd);
-      const depRows = await db.select().from(taskDependencies).where(eq4(taskDependencies.dependsOn, taskId)).all();
+      const depRows = await db.select().from(taskDependencies).where(eq5(taskDependencies.dependsOn, taskId)).all();
       if (depRows.length === 0) return [];
       const dependentIds = depRows.map((r) => r.taskId);
-      const rows = await db.select().from(tasks).where(inArray3(tasks.id, dependentIds)).all();
+      const rows = await db.select().from(tasks).where(inArray4(tasks.id, dependentIds)).all();
       const tasks2 = rows.map(rowToTask);
       if (tasks2.length > 0) {
         const allIds = await getAllTaskIds();
@@ -11848,13 +13326,13 @@ async function createSqliteDataAccessor(cwd) {
     },
     async taskExists(taskId) {
       const db = await getDb(cwd);
-      const result = await db.select({ id: tasks.id }).from(tasks).where(eq4(tasks.id, taskId)).limit(1).get();
+      const result = await db.select({ id: tasks.id }).from(tasks).where(eq5(tasks.id, taskId)).limit(1).get();
       return !!result;
     },
     async loadTasks(taskIds) {
       if (taskIds.length === 0) return [];
       const db = await getDb(cwd);
-      const rows = await db.select().from(tasks).where(inArray3(tasks.id, taskIds)).all();
+      const rows = await db.select().from(tasks).where(inArray4(tasks.id, taskIds)).all();
       const tasks2 = rows.map(rowToTask);
       if (tasks2.length > 0) {
         const allIds = await getAllTaskIds();
@@ -11922,14 +13400,15 @@ async function createSqliteDataAccessor(cwd) {
         ["verificationJson", "verificationJson"],
         ["createdBy", "createdBy"],
         ["modifiedBy", "modifiedBy"],
-        ["sessionId", "sessionId"]
+        ["sessionId", "sessionId"],
+        ["assignee", "assignee"]
       ];
       for (const [key, col] of fieldMap) {
         if (fields[key] !== void 0) {
           updateRow[col] = fields[key];
         }
       }
-      await db.update(tasks).set(updateRow).where(eq4(tasks.id, taskId)).run();
+      await db.update(tasks).set(updateRow).where(eq5(tasks.id, taskId)).run();
     },
     async transaction(fn) {
       const nativeDb = getNativeTasksDb();
@@ -11952,12 +13431,12 @@ async function createSqliteDataAccessor(cwd) {
               archiveReason: fields.archiveReason ?? "completed",
               cycleTimeDays: fields.cycleTimeDays ?? null,
               updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-            }).where(eq4(tasks.id, taskId)).run();
+            }).where(eq5(tasks.id, taskId)).run();
           },
           async removeSingleTask(taskId) {
-            await db.delete(taskDependencies).where(eq4(taskDependencies.taskId, taskId)).run();
-            await db.delete(taskDependencies).where(eq4(taskDependencies.dependsOn, taskId)).run();
-            await db.delete(tasks).where(eq4(tasks.id, taskId)).run();
+            await db.delete(taskDependencies).where(eq5(taskDependencies.taskId, taskId)).run();
+            await db.delete(taskDependencies).where(eq5(taskDependencies.dependsOn, taskId)).run();
+            await db.delete(tasks).where(eq5(tasks.id, taskId)).run();
           },
           async setMetaValue(key, value) {
             await setMetaValue(cwd, key, value);
@@ -11991,6 +13470,46 @@ async function createSqliteDataAccessor(cwd) {
     async getSchemaVersion() {
       const meta = await getMetaValue(cwd, "file_meta");
       return meta?.schemaVersion ?? null;
+    },
+    // ---- Agent instances ----
+    async listAgentInstances(filters) {
+      const { listAgentInstances: listAgents2 } = await Promise.resolve().then(() => (init_registry2(), registry_exports2));
+      return listAgents2(filters, cwd);
+    },
+    async getAgentInstance(agentId) {
+      const { getAgentInstance: getAgent2 } = await Promise.resolve().then(() => (init_registry2(), registry_exports2));
+      return getAgent2(agentId, cwd);
+    },
+    // ---- Agent task claiming ----
+    async claimTask(taskId, agentId) {
+      const nativeDb = getNativeTasksDb();
+      if (!nativeDb) {
+        throw new Error("Native database not initialized");
+      }
+      const existsRow = nativeDb.prepare("SELECT assignee FROM tasks WHERE id = ?").get(taskId);
+      if (!existsRow) {
+        throw new Error(`Task not found: ${taskId}`);
+      }
+      const result = nativeDb.prepare(
+        "UPDATE tasks SET assignee = ?, updated_at = ? WHERE id = ? AND (assignee IS NULL OR assignee = ?)"
+      ).run(agentId, (/* @__PURE__ */ new Date()).toISOString(), taskId, agentId);
+      if (result.changes === 0) {
+        const currentRow = nativeDb.prepare("SELECT assignee FROM tasks WHERE id = ?").get(taskId);
+        throw new Error(
+          `Task ${taskId} is already claimed by agent: ${currentRow?.assignee ?? "unknown"}`
+        );
+      }
+    },
+    async unclaimTask(taskId) {
+      const nativeDb = getNativeTasksDb();
+      if (!nativeDb) {
+        throw new Error("Native database not initialized");
+      }
+      const existsRow = nativeDb.prepare("SELECT id FROM tasks WHERE id = ?").get(taskId);
+      if (!existsRow) {
+        throw new Error(`Task not found: ${taskId}`);
+      }
+      nativeDb.prepare("UPDATE tasks SET assignee = NULL, updated_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), taskId);
     }
   };
   return accessor;
@@ -14215,6 +15734,20 @@ var init_safety_data_accessor = __esm({
       async removeSingleSession(sessionId) {
         return this.inner.removeSingleSession(sessionId);
       }
+      // ---- Agent instances ----
+      async listAgentInstances(filters) {
+        return this.inner.listAgentInstances(filters);
+      }
+      async getAgentInstance(agentId) {
+        return this.inner.getAgentInstance(agentId);
+      }
+      // ---- Agent task claiming ----
+      async claimTask(taskId, agentId) {
+        return this.inner.claimTask(taskId, agentId);
+      }
+      async unclaimTask(taskId) {
+        return this.inner.unclaimTask(taskId);
+      }
       // ---- Lifecycle ----
       async close() {
         this.logVerbose("Closing accessor");
@@ -14386,7 +15919,7 @@ var init_link_pipeline = __esm({
 });
 
 // packages/core/src/store/brain-accessor.ts
-import { and as and3, asc as asc2, desc as desc2, eq as eq5, gte as gte2, or as or3 } from "drizzle-orm";
+import { and as and4, asc as asc2, desc as desc2, eq as eq6, gte as gte2, or as or3 } from "drizzle-orm";
 async function getBrainAccessor(cwd) {
   const db = await getBrainDb(cwd);
   return new BrainDataAccessor(db);
@@ -14406,30 +15939,30 @@ var init_brain_accessor = __esm({
       // =========================================================================
       async addDecision(row) {
         await this.db.insert(brainDecisions).values(row);
-        const result = await this.db.select().from(brainDecisions).where(eq5(brainDecisions.id, row.id));
+        const result = await this.db.select().from(brainDecisions).where(eq6(brainDecisions.id, row.id));
         return result[0];
       }
       async getDecision(id) {
-        const result = await this.db.select().from(brainDecisions).where(eq5(brainDecisions.id, id));
+        const result = await this.db.select().from(brainDecisions).where(eq6(brainDecisions.id, id));
         return result[0] ?? null;
       }
       async findDecisions(params = {}) {
         const conditions = [];
         if (params.type) {
-          conditions.push(eq5(brainDecisions.type, params.type));
+          conditions.push(eq6(brainDecisions.type, params.type));
         }
         if (params.confidence) {
-          conditions.push(eq5(brainDecisions.confidence, params.confidence));
+          conditions.push(eq6(brainDecisions.confidence, params.confidence));
         }
         if (params.outcome) {
-          conditions.push(eq5(brainDecisions.outcome, params.outcome));
+          conditions.push(eq6(brainDecisions.outcome, params.outcome));
         }
         if (params.contextTaskId) {
-          conditions.push(eq5(brainDecisions.contextTaskId, params.contextTaskId));
+          conditions.push(eq6(brainDecisions.contextTaskId, params.contextTaskId));
         }
         let query = this.db.select().from(brainDecisions).orderBy(desc2(brainDecisions.createdAt));
         if (conditions.length > 0) {
-          query = query.where(and3(...conditions));
+          query = query.where(and4(...conditions));
         }
         if (params.limit) {
           query = query.limit(params.limit);
@@ -14437,34 +15970,34 @@ var init_brain_accessor = __esm({
         return query;
       }
       async updateDecision(id, updates) {
-        await this.db.update(brainDecisions).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq5(brainDecisions.id, id));
+        await this.db.update(brainDecisions).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq6(brainDecisions.id, id));
       }
       // =========================================================================
       // Patterns CRUD
       // =========================================================================
       async addPattern(row) {
         await this.db.insert(brainPatterns).values(row);
-        const result = await this.db.select().from(brainPatterns).where(eq5(brainPatterns.id, row.id));
+        const result = await this.db.select().from(brainPatterns).where(eq6(brainPatterns.id, row.id));
         return result[0];
       }
       async getPattern(id) {
-        const result = await this.db.select().from(brainPatterns).where(eq5(brainPatterns.id, id));
+        const result = await this.db.select().from(brainPatterns).where(eq6(brainPatterns.id, id));
         return result[0] ?? null;
       }
       async findPatterns(params = {}) {
         const conditions = [];
         if (params.type) {
-          conditions.push(eq5(brainPatterns.type, params.type));
+          conditions.push(eq6(brainPatterns.type, params.type));
         }
         if (params.impact) {
-          conditions.push(eq5(brainPatterns.impact, params.impact));
+          conditions.push(eq6(brainPatterns.impact, params.impact));
         }
         if (params.minFrequency !== void 0) {
           conditions.push(gte2(brainPatterns.frequency, params.minFrequency));
         }
         let query = this.db.select().from(brainPatterns).orderBy(desc2(brainPatterns.frequency));
         if (conditions.length > 0) {
-          query = query.where(and3(...conditions));
+          query = query.where(and4(...conditions));
         }
         if (params.limit) {
           query = query.limit(params.limit);
@@ -14472,18 +16005,18 @@ var init_brain_accessor = __esm({
         return query;
       }
       async updatePattern(id, updates) {
-        await this.db.update(brainPatterns).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq5(brainPatterns.id, id));
+        await this.db.update(brainPatterns).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq6(brainPatterns.id, id));
       }
       // =========================================================================
       // Learnings CRUD
       // =========================================================================
       async addLearning(row) {
         await this.db.insert(brainLearnings).values(row);
-        const result = await this.db.select().from(brainLearnings).where(eq5(brainLearnings.id, row.id));
+        const result = await this.db.select().from(brainLearnings).where(eq6(brainLearnings.id, row.id));
         return result[0];
       }
       async getLearning(id) {
-        const result = await this.db.select().from(brainLearnings).where(eq5(brainLearnings.id, id));
+        const result = await this.db.select().from(brainLearnings).where(eq6(brainLearnings.id, id));
         return result[0] ?? null;
       }
       async findLearnings(params = {}) {
@@ -14492,11 +16025,11 @@ var init_brain_accessor = __esm({
           conditions.push(gte2(brainLearnings.confidence, params.minConfidence));
         }
         if (params.actionable !== void 0) {
-          conditions.push(eq5(brainLearnings.actionable, params.actionable));
+          conditions.push(eq6(brainLearnings.actionable, params.actionable));
         }
         let query = this.db.select().from(brainLearnings).orderBy(desc2(brainLearnings.confidence));
         if (conditions.length > 0) {
-          query = query.where(and3(...conditions));
+          query = query.where(and4(...conditions));
         }
         if (params.limit) {
           query = query.limit(params.limit);
@@ -14504,37 +16037,37 @@ var init_brain_accessor = __esm({
         return query;
       }
       async updateLearning(id, updates) {
-        await this.db.update(brainLearnings).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq5(brainLearnings.id, id));
+        await this.db.update(brainLearnings).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq6(brainLearnings.id, id));
       }
       // =========================================================================
       // Observations CRUD
       // =========================================================================
       async addObservation(row) {
         await this.db.insert(brainObservations).values(row);
-        const result = await this.db.select().from(brainObservations).where(eq5(brainObservations.id, row.id));
+        const result = await this.db.select().from(brainObservations).where(eq6(brainObservations.id, row.id));
         return result[0];
       }
       async getObservation(id) {
-        const result = await this.db.select().from(brainObservations).where(eq5(brainObservations.id, id));
+        const result = await this.db.select().from(brainObservations).where(eq6(brainObservations.id, id));
         return result[0] ?? null;
       }
       async findObservations(params = {}) {
         const conditions = [];
         if (params.type) {
-          conditions.push(eq5(brainObservations.type, params.type));
+          conditions.push(eq6(brainObservations.type, params.type));
         }
         if (params.project) {
-          conditions.push(eq5(brainObservations.project, params.project));
+          conditions.push(eq6(brainObservations.project, params.project));
         }
         if (params.sourceType) {
-          conditions.push(eq5(brainObservations.sourceType, params.sourceType));
+          conditions.push(eq6(brainObservations.sourceType, params.sourceType));
         }
         if (params.sourceSessionId) {
-          conditions.push(eq5(brainObservations.sourceSessionId, params.sourceSessionId));
+          conditions.push(eq6(brainObservations.sourceSessionId, params.sourceSessionId));
         }
         let query = this.db.select().from(brainObservations).orderBy(desc2(brainObservations.createdAt));
         if (conditions.length > 0) {
-          query = query.where(and3(...conditions));
+          query = query.where(and4(...conditions));
         }
         if (params.limit) {
           query = query.limit(params.limit);
@@ -14542,7 +16075,7 @@ var init_brain_accessor = __esm({
         return query;
       }
       async updateObservation(id, updates) {
-        await this.db.update(brainObservations).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq5(brainObservations.id, id));
+        await this.db.update(brainObservations).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq6(brainObservations.id, id));
       }
       // =========================================================================
       // Memory Links CRUD
@@ -14552,22 +16085,22 @@ var init_brain_accessor = __esm({
       }
       async getLinksForMemory(memoryType, memoryId) {
         return this.db.select().from(brainMemoryLinks).where(
-          and3(
-            eq5(brainMemoryLinks.memoryType, memoryType),
-            eq5(brainMemoryLinks.memoryId, memoryId)
+          and4(
+            eq6(brainMemoryLinks.memoryType, memoryType),
+            eq6(brainMemoryLinks.memoryId, memoryId)
           )
         ).orderBy(asc2(brainMemoryLinks.createdAt));
       }
       async getLinksForTask(taskId) {
-        return this.db.select().from(brainMemoryLinks).where(eq5(brainMemoryLinks.taskId, taskId)).orderBy(asc2(brainMemoryLinks.createdAt));
+        return this.db.select().from(brainMemoryLinks).where(eq6(brainMemoryLinks.taskId, taskId)).orderBy(asc2(brainMemoryLinks.createdAt));
       }
       async removeLink(memoryType, memoryId, taskId, linkType) {
         await this.db.delete(brainMemoryLinks).where(
-          and3(
-            eq5(brainMemoryLinks.memoryType, memoryType),
-            eq5(brainMemoryLinks.memoryId, memoryId),
-            eq5(brainMemoryLinks.taskId, taskId),
-            eq5(brainMemoryLinks.linkType, linkType)
+          and4(
+            eq6(brainMemoryLinks.memoryType, memoryType),
+            eq6(brainMemoryLinks.memoryId, memoryId),
+            eq6(brainMemoryLinks.taskId, taskId),
+            eq6(brainMemoryLinks.linkType, linkType)
           )
         );
       }
@@ -14576,27 +16109,27 @@ var init_brain_accessor = __esm({
       // =========================================================================
       async addStickyNote(row) {
         await this.db.insert(brainStickyNotes).values(row);
-        const result = await this.db.select().from(brainStickyNotes).where(eq5(brainStickyNotes.id, row.id));
+        const result = await this.db.select().from(brainStickyNotes).where(eq6(brainStickyNotes.id, row.id));
         return result[0];
       }
       async getStickyNote(id) {
-        const result = await this.db.select().from(brainStickyNotes).where(eq5(brainStickyNotes.id, id));
+        const result = await this.db.select().from(brainStickyNotes).where(eq6(brainStickyNotes.id, id));
         return result[0] ?? null;
       }
       async findStickyNotes(params = {}) {
         const conditions = [];
         if (params.status) {
-          conditions.push(eq5(brainStickyNotes.status, params.status));
+          conditions.push(eq6(brainStickyNotes.status, params.status));
         }
         if (params.color) {
-          conditions.push(eq5(brainStickyNotes.color, params.color));
+          conditions.push(eq6(brainStickyNotes.color, params.color));
         }
         if (params.priority) {
-          conditions.push(eq5(brainStickyNotes.priority, params.priority));
+          conditions.push(eq6(brainStickyNotes.priority, params.priority));
         }
         let query = this.db.select().from(brainStickyNotes).orderBy(desc2(brainStickyNotes.createdAt));
         if (conditions.length > 0) {
-          query = query.where(and3(...conditions));
+          query = query.where(and4(...conditions));
         }
         if (params.limit) {
           query = query.limit(params.limit);
@@ -14604,31 +16137,31 @@ var init_brain_accessor = __esm({
         return query;
       }
       async updateStickyNote(id, updates) {
-        await this.db.update(brainStickyNotes).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq5(brainStickyNotes.id, id));
+        await this.db.update(brainStickyNotes).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq6(brainStickyNotes.id, id));
       }
       async deleteStickyNote(id) {
-        await this.db.delete(brainStickyNotes).where(eq5(brainStickyNotes.id, id));
+        await this.db.delete(brainStickyNotes).where(eq6(brainStickyNotes.id, id));
       }
       // =========================================================================
       // PageIndex Node CRUD (T5383)
       // =========================================================================
       async addPageNode(node) {
         await this.db.insert(brainPageNodes).values(node);
-        const result = await this.db.select().from(brainPageNodes).where(eq5(brainPageNodes.id, node.id));
+        const result = await this.db.select().from(brainPageNodes).where(eq6(brainPageNodes.id, node.id));
         return result[0];
       }
       async getPageNode(id) {
-        const result = await this.db.select().from(brainPageNodes).where(eq5(brainPageNodes.id, id));
+        const result = await this.db.select().from(brainPageNodes).where(eq6(brainPageNodes.id, id));
         return result[0] ?? null;
       }
       async findPageNodes(params = {}) {
         const conditions = [];
         if (params.nodeType) {
-          conditions.push(eq5(brainPageNodes.nodeType, params.nodeType));
+          conditions.push(eq6(brainPageNodes.nodeType, params.nodeType));
         }
         let query = this.db.select().from(brainPageNodes).orderBy(desc2(brainPageNodes.createdAt));
         if (conditions.length > 0) {
-          query = query.where(and3(...conditions));
+          query = query.where(and4(...conditions));
         }
         if (params.limit) {
           query = query.limit(params.limit);
@@ -14637,9 +16170,9 @@ var init_brain_accessor = __esm({
       }
       async removePageNode(id) {
         await this.db.delete(brainPageEdges).where(
-          or3(eq5(brainPageEdges.fromId, id), eq5(brainPageEdges.toId, id))
+          or3(eq6(brainPageEdges.fromId, id), eq6(brainPageEdges.toId, id))
         );
-        await this.db.delete(brainPageNodes).where(eq5(brainPageNodes.id, id));
+        await this.db.delete(brainPageNodes).where(eq6(brainPageNodes.id, id));
       }
       // =========================================================================
       // PageIndex Edge CRUD (T5383)
@@ -14647,34 +16180,34 @@ var init_brain_accessor = __esm({
       async addPageEdge(edge) {
         await this.db.insert(brainPageEdges).values(edge);
         const result = await this.db.select().from(brainPageEdges).where(
-          and3(
-            eq5(brainPageEdges.fromId, edge.fromId),
-            eq5(brainPageEdges.toId, edge.toId),
-            eq5(brainPageEdges.edgeType, edge.edgeType)
+          and4(
+            eq6(brainPageEdges.fromId, edge.fromId),
+            eq6(brainPageEdges.toId, edge.toId),
+            eq6(brainPageEdges.edgeType, edge.edgeType)
           )
         );
         return result[0];
       }
       async getPageEdges(nodeId, direction = "both") {
         if (direction === "out") {
-          return this.db.select().from(brainPageEdges).where(eq5(brainPageEdges.fromId, nodeId)).orderBy(asc2(brainPageEdges.createdAt));
+          return this.db.select().from(brainPageEdges).where(eq6(brainPageEdges.fromId, nodeId)).orderBy(asc2(brainPageEdges.createdAt));
         }
         if (direction === "in") {
-          return this.db.select().from(brainPageEdges).where(eq5(brainPageEdges.toId, nodeId)).orderBy(asc2(brainPageEdges.createdAt));
+          return this.db.select().from(brainPageEdges).where(eq6(brainPageEdges.toId, nodeId)).orderBy(asc2(brainPageEdges.createdAt));
         }
         return this.db.select().from(brainPageEdges).where(
           or3(
-            eq5(brainPageEdges.fromId, nodeId),
-            eq5(brainPageEdges.toId, nodeId)
+            eq6(brainPageEdges.fromId, nodeId),
+            eq6(brainPageEdges.toId, nodeId)
           )
         ).orderBy(asc2(brainPageEdges.createdAt));
       }
       async getNeighbors(nodeId, edgeType) {
-        const conditions = [eq5(brainPageEdges.fromId, nodeId)];
+        const conditions = [eq6(brainPageEdges.fromId, nodeId)];
         if (edgeType) {
-          conditions.push(eq5(brainPageEdges.edgeType, edgeType));
+          conditions.push(eq6(brainPageEdges.edgeType, edgeType));
         }
-        const edges = await this.db.select().from(brainPageEdges).where(and3(...conditions));
+        const edges = await this.db.select().from(brainPageEdges).where(and4(...conditions));
         if (edges.length === 0) return [];
         const neighborIds = edges.map((e) => e.toId);
         const nodes = [];
@@ -14686,10 +16219,10 @@ var init_brain_accessor = __esm({
       }
       async removePageEdge(fromId, toId, edgeType) {
         await this.db.delete(brainPageEdges).where(
-          and3(
-            eq5(brainPageEdges.fromId, fromId),
-            eq5(brainPageEdges.toId, toId),
-            eq5(brainPageEdges.edgeType, edgeType)
+          and4(
+            eq6(brainPageEdges.fromId, fromId),
+            eq6(brainPageEdges.toId, toId),
+            eq6(brainPageEdges.edgeType, edgeType)
           )
         );
       }
@@ -14697,246 +16230,6 @@ var init_brain_accessor = __esm({
   }
 });
 
-// packages/core/src/agents/registry.ts
-var registry_exports2 = {};
-__export(registry_exports2, {
-  checkAgentHealth: () => checkAgentHealth,
-  classifyError: () => classifyError,
-  deregisterAgent: () => deregisterAgent,
-  generateAgentId: () => generateAgentId,
-  getAgentErrorHistory: () => getAgentErrorHistory,
-  getAgentInstance: () => getAgentInstance,
-  getHealthReport: () => getHealthReport,
-  heartbeat: () => heartbeat,
-  incrementTasksCompleted: () => incrementTasksCompleted,
-  listAgentInstances: () => listAgentInstances,
-  markCrashed: () => markCrashed,
-  registerAgent: () => registerAgent,
-  updateAgentStatus: () => updateAgentStatus
-});
-import { randomBytes as randomBytes2 } from "node:crypto";
-import { and as and4, eq as eq6, inArray as inArray4, lt as lt2, sql as sql8 } from "drizzle-orm";
-function generateAgentId() {
-  const now = /* @__PURE__ */ new Date();
-  const ts = now.toISOString().replace(/[-:T]/g, "").substring(0, 14);
-  const hex = randomBytes2(3).toString("hex");
-  return `agt_${ts}_${hex}`;
-}
-async function registerAgent(opts, cwd) {
-  const db = await getDb(cwd);
-  const id = generateAgentId();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const row = {
-    id,
-    agentType: opts.agentType,
-    status: "starting",
-    sessionId: opts.sessionId ?? null,
-    taskId: opts.taskId ?? null,
-    startedAt: now,
-    lastHeartbeat: now,
-    stoppedAt: null,
-    errorCount: 0,
-    totalTasksCompleted: 0,
-    capacity: "1.0",
-    metadataJson: opts.metadata ? JSON.stringify(opts.metadata) : "{}",
-    parentAgentId: opts.parentAgentId ?? null
-  };
-  await db.insert(agentInstances).values(row);
-  return row;
-}
-async function deregisterAgent(id, cwd) {
-  const db = await getDb(cwd);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const existing = await db.select().from(agentInstances).where(eq6(agentInstances.id, id)).get();
-  if (!existing) return null;
-  if (existing.status === "stopped") return existing;
-  await db.update(agentInstances).set({ status: "stopped", stoppedAt: now }).where(eq6(agentInstances.id, id));
-  return { ...existing, status: "stopped", stoppedAt: now };
-}
-async function heartbeat(id, cwd) {
-  const db = await getDb(cwd);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const existing = await db.select().from(agentInstances).where(eq6(agentInstances.id, id)).get();
-  if (!existing) return null;
-  if (existing.status === "stopped" || existing.status === "crashed") {
-    return existing.status;
-  }
-  await db.update(agentInstances).set({ lastHeartbeat: now }).where(eq6(agentInstances.id, id));
-  return existing.status;
-}
-async function updateAgentStatus(id, opts, cwd) {
-  const db = await getDb(cwd);
-  const existing = await db.select().from(agentInstances).where(eq6(agentInstances.id, id)).get();
-  if (!existing) return null;
-  const updates = {
-    status: opts.status
-  };
-  if (opts.taskId !== void 0) {
-    updates.taskId = opts.taskId;
-  }
-  if (opts.status === "active") {
-    updates.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
-  }
-  if (opts.status === "error" || opts.status === "crashed") {
-    updates.errorCount = existing.errorCount + 1;
-    if (opts.error) {
-      const errorType = classifyError(new Error(opts.error));
-      await db.insert(agentErrorLog).values({
-        agentId: id,
-        errorType,
-        message: opts.error,
-        occurredAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    }
-  }
-  if (opts.status === "stopped") {
-    updates.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
-  }
-  await db.update(agentInstances).set(updates).where(eq6(agentInstances.id, id));
-  return { ...existing, ...updates };
-}
-async function incrementTasksCompleted(id, cwd) {
-  const db = await getDb(cwd);
-  await db.update(agentInstances).set({ totalTasksCompleted: sql8`${agentInstances.totalTasksCompleted} + 1` }).where(eq6(agentInstances.id, id));
-}
-async function listAgentInstances(filters, cwd) {
-  const db = await getDb(cwd);
-  const conditions = [];
-  if (filters?.status) {
-    const statuses = Array.isArray(filters.status) ? filters.status : [filters.status];
-    conditions.push(inArray4(agentInstances.status, statuses));
-  }
-  if (filters?.agentType) {
-    const types = Array.isArray(filters.agentType) ? filters.agentType : [filters.agentType];
-    conditions.push(inArray4(agentInstances.agentType, types));
-  }
-  if (filters?.sessionId) {
-    conditions.push(eq6(agentInstances.sessionId, filters.sessionId));
-  }
-  if (filters?.parentAgentId) {
-    conditions.push(eq6(agentInstances.parentAgentId, filters.parentAgentId));
-  }
-  if (conditions.length === 0) {
-    return db.select().from(agentInstances).all();
-  }
-  return db.select().from(agentInstances).where(and4(...conditions)).all();
-}
-async function getAgentInstance(id, cwd) {
-  const db = await getDb(cwd);
-  const row = await db.select().from(agentInstances).where(eq6(agentInstances.id, id)).get();
-  return row ?? null;
-}
-function classifyError(error40) {
-  const message = error40 instanceof Error ? error40.message : String(error40);
-  for (const pattern of RETRIABLE_PATTERNS) {
-    if (pattern.test(message)) return "retriable";
-  }
-  for (const pattern of PERMANENT_PATTERNS) {
-    if (pattern.test(message)) return "permanent";
-  }
-  return "unknown";
-}
-async function getAgentErrorHistory(agentId, cwd) {
-  const db = await getDb(cwd);
-  return db.select().from(agentErrorLog).where(eq6(agentErrorLog.agentId, agentId)).all();
-}
-async function checkAgentHealth(thresholdMs = 3e4, cwd) {
-  const db = await getDb(cwd);
-  const cutoff = new Date(Date.now() - thresholdMs).toISOString();
-  return db.select().from(agentInstances).where(
-    and4(
-      inArray4(agentInstances.status, ["active", "idle", "starting"]),
-      lt2(agentInstances.lastHeartbeat, cutoff)
-    )
-  ).all();
-}
-async function markCrashed(id, reason, cwd) {
-  return updateAgentStatus(
-    id,
-    { status: "crashed", error: reason ?? "Heartbeat timeout \u2014 agent presumed crashed" },
-    cwd
-  );
-}
-async function getHealthReport(thresholdMs = 3e4, cwd) {
-  const allAgents = await listAgentInstances(void 0, cwd);
-  const staleAgents = await checkAgentHealth(thresholdMs, cwd);
-  const report = {
-    total: allAgents.length,
-    active: 0,
-    idle: 0,
-    starting: 0,
-    error: 0,
-    crashed: 0,
-    stopped: 0,
-    totalErrors: 0,
-    staleAgents
-  };
-  for (const agent of allAgents) {
-    switch (agent.status) {
-      case "active":
-        report.active++;
-        break;
-      case "idle":
-        report.idle++;
-        break;
-      case "starting":
-        report.starting++;
-        break;
-      case "error":
-        report.error++;
-        break;
-      case "crashed":
-        report.crashed++;
-        break;
-      case "stopped":
-        report.stopped++;
-        break;
-    }
-    report.totalErrors += agent.errorCount;
-  }
-  return report;
-}
-var RETRIABLE_PATTERNS, PERMANENT_PATTERNS;
-var init_registry2 = __esm({
-  "packages/core/src/agents/registry.ts"() {
-    "use strict";
-    init_sqlite2();
-    init_agent_schema();
-    RETRIABLE_PATTERNS = [
-      /timeout/i,
-      /ECONNREFUSED/,
-      /ECONNRESET/,
-      /EPIPE/,
-      /ETIMEDOUT/,
-      /rate.?limit/i,
-      /429/,
-      /503/,
-      /502/,
-      /SQLITE_BUSY/i,
-      /database is locked/i,
-      /temporarily unavailable/i,
-      /too many requests/i,
-      /network/i,
-      /socket hang up/i
-    ];
-    PERMANENT_PATTERNS = [
-      /permission denied/i,
-      /EACCES/,
-      /authentication/i,
-      /unauthorized/i,
-      /401/,
-      /403/,
-      /404/,
-      /not found/i,
-      /invalid.*token/i,
-      /SQLITE_CONSTRAINT/i,
-      /syntax error/i,
-      /type error/i,
-      /reference error/i
-    ];
-  }
-});
-
 // packages/core/src/store/project-detect.ts
 var project_detect_exports = {};
 __export(project_detect_exports, {
@@ -16261,6 +17554,42 @@ var init_learnings = __esm({
   }
 });
 
+// packages/core/src/mvi-helpers.ts
+function taskShowNext(taskId) {
+  return {
+    full: `cleo show ${taskId} --mvi full`,
+    children: `cleo find --parent ${taskId}`,
+    deps: `cleo deps ${taskId}`
+  };
+}
+function taskListItemNext(taskId) {
+  return {
+    show: `cleo show ${taskId}`
+  };
+}
+function sessionListItemNext(sessionId) {
+  return {
+    show: `cleo session show ${sessionId}`,
+    serialize: `cleo session serialize ${sessionId}`
+  };
+}
+function sessionStartNext() {
+  return {
+    current: "cleo current",
+    stop: "cleo session end"
+  };
+}
+function memoryFindHitNext(entryId) {
+  return {
+    fetch: `cleo memory fetch ${entryId}`
+  };
+}
+var init_mvi_helpers = __esm({
+  "packages/core/src/mvi-helpers.ts"() {
+    "use strict";
+  }
+});
+
 // packages/core/src/store/typed-query.ts
 function typedAll(stmt, ...params) {
   return stmt.all(...params);
@@ -17813,6 +19142,27 @@ var init_memory_bridge = __esm({
   }
 });
 
+// packages/core/src/hooks/handlers/handler-helpers.ts
+function isMissingBrainSchemaError(err) {
+  if (!(err instanceof Error)) return false;
+  const message = String(err.message || "").toLowerCase();
+  return message.includes("no such table") && message.includes("brain_");
+}
+async function isAutoCaptureEnabled(projectRoot) {
+  try {
+    const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const config2 = await loadConfig3(projectRoot);
+    return config2.brain?.autoCapture ?? false;
+  } catch {
+    return false;
+  }
+}
+var init_handler_helpers = __esm({
+  "packages/core/src/hooks/handlers/handler-helpers.ts"() {
+    "use strict";
+  }
+});
+
 // packages/core/src/hooks/handlers/memory-bridge-refresh.ts
 async function maybeRefreshMemoryBridge(projectRoot) {
   try {
@@ -18371,11 +19721,6 @@ var init_auto_extract = __esm({
 });
 
 // packages/core/src/hooks/handlers/session-hooks.ts
-function isMissingBrainSchemaError(err) {
-  if (!(err instanceof Error)) return false;
-  const message = String(err.message || "").toLowerCase();
-  return message.includes("no such table") && message.includes("brain_");
-}
 async function handleSessionStart(projectRoot, payload) {
   const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
   try {
@@ -18437,6 +19782,7 @@ var init_session_hooks = __esm({
   "packages/core/src/hooks/handlers/session-hooks.ts"() {
     "use strict";
     init_registry();
+    init_handler_helpers();
     init_memory_bridge_refresh();
     hooks.register({
       id: "brain-session-start",
@@ -18454,11 +19800,6 @@ var init_session_hooks = __esm({
 });
 
 // packages/core/src/hooks/handlers/task-hooks.ts
-function isMissingBrainSchemaError2(err) {
-  if (!(err instanceof Error)) return false;
-  const message = String(err.message || "").toLowerCase();
-  return message.includes("no such table") && message.includes("brain_");
-}
 async function handleToolStart(projectRoot, payload) {
   const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
   try {
@@ -18469,7 +19810,7 @@ async function handleToolStart(projectRoot, payload) {
       sourceType: "agent"
     });
   } catch (err) {
-    if (!isMissingBrainSchemaError2(err)) throw err;
+    if (!isMissingBrainSchemaError(err)) throw err;
   }
 }
 async function handleToolComplete(projectRoot, payload) {
@@ -18482,7 +19823,7 @@ async function handleToolComplete(projectRoot, payload) {
       sourceType: "agent"
     });
   } catch (err) {
-    if (!isMissingBrainSchemaError2(err)) throw err;
+    if (!isMissingBrainSchemaError(err)) throw err;
   }
   await maybeRefreshMemoryBridge(projectRoot);
 }
@@ -18490,6 +19831,7 @@ var init_task_hooks = __esm({
   "packages/core/src/hooks/handlers/task-hooks.ts"() {
     "use strict";
     init_registry();
+    init_handler_helpers();
     init_memory_bridge_refresh();
     hooks.register({
       id: "brain-tool-start",
@@ -18507,7 +19849,7 @@ var init_task_hooks = __esm({
 });
 
 // packages/core/src/hooks/handlers/error-hooks.ts
-async function handleError(projectRoot, payload) {
+async function handleError2(projectRoot, payload) {
   if (payload.metadata?.["_fromHook"]) return;
   const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
   const domainOp = payload.domain && payload.operation ? `${payload.domain}.${payload.operation}` : "unknown";
@@ -18530,7 +19872,7 @@ var init_error_hooks = __esm({
     hooks.register({
       id: "brain-error",
       event: "PostToolUseFailure",
-      handler: handleError,
+      handler: handleError2,
       priority: 100
     });
   }
@@ -18538,11 +19880,6 @@ var init_error_hooks = __esm({
 
 // packages/core/src/hooks/handlers/file-hooks.ts
 import { isAbsolute, relative } from "node:path";
-function isMissingBrainSchemaError3(err) {
-  if (!(err instanceof Error)) return false;
-  const message = String(err.message || "").toLowerCase();
-  return message.includes("no such table") && message.includes("brain_");
-}
 function shouldSkipPath(relativePath) {
   return SKIP_PATTERNS.some((pattern) => pattern.test(relativePath));
 }
@@ -18577,7 +19914,7 @@ async function handleFileChange(projectRoot, payload) {
       sourceType: "agent"
     });
   } catch (err) {
-    if (!isMissingBrainSchemaError3(err)) throw err;
+    if (!isMissingBrainSchemaError(err)) throw err;
   }
 }
 var recentWrites, DEDUP_INTERVAL_MS, SKIP_PATTERNS;
@@ -18585,6 +19922,7 @@ var init_file_hooks = __esm({
   "packages/core/src/hooks/handlers/file-hooks.ts"() {
     "use strict";
     init_registry();
+    init_handler_helpers();
     recentWrites = /* @__PURE__ */ new Map();
     DEDUP_INTERVAL_MS = 5e3;
     SKIP_PATTERNS = [
@@ -18615,11 +19953,6 @@ var init_file_hooks = __esm({
 });
 
 // packages/core/src/hooks/handlers/mcp-hooks.ts
-function isMissingBrainSchemaError4(err) {
-  if (!(err instanceof Error)) return false;
-  const message = String(err.message || "").toLowerCase();
-  return message.includes("no such table") && message.includes("brain_");
-}
 async function isBrainCaptureEnabled(projectRoot) {
   const envOverride = process.env["CLEO_BRAIN_CAPTURE_MCP"];
   if (envOverride !== void 0) {
@@ -18644,7 +19977,7 @@ async function handlePromptSubmit(projectRoot, payload) {
       sourceType: "agent"
     });
   } catch (err) {
-    if (!isMissingBrainSchemaError4(err)) throw err;
+    if (!isMissingBrainSchemaError(err)) throw err;
   }
 }
 async function handleResponseComplete(projectRoot, payload) {
@@ -18658,19 +19991,13 @@ async function handleResponseComplete(projectRoot, payload) {
       sourceType: "agent"
     });
   } catch (err) {
-    if (!isMissingBrainSchemaError4(err)) throw err;
+    if (!isMissingBrainSchemaError(err)) throw err;
   }
 }
 async function handleSystemNotification(projectRoot, payload) {
   if (payload.filePath || payload.changeType) return;
   if (!payload.message) return;
-  try {
-    const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config(), config_exports));
-    const config2 = await loadConfig3(projectRoot);
-    if (!config2.brain?.autoCapture) return;
-  } catch {
-    return;
-  }
+  if (!await isAutoCaptureEnabled(projectRoot)) return;
   const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
   try {
     await observeBrain2(projectRoot, {
@@ -18681,13 +20008,14 @@ async function handleSystemNotification(projectRoot, payload) {
       sourceType: "agent"
     });
   } catch (err) {
-    if (!isMissingBrainSchemaError4(err)) throw err;
+    if (!isMissingBrainSchemaError(err)) throw err;
   }
 }
 var init_mcp_hooks = __esm({
   "packages/core/src/hooks/handlers/mcp-hooks.ts"() {
     "use strict";
     init_registry();
+    init_handler_helpers();
     hooks.register({
       id: "brain-prompt-submit",
       event: "PromptSubmit",
@@ -18710,11 +20038,6 @@ var init_mcp_hooks = __esm({
 });
 
 // packages/core/src/hooks/handlers/work-capture-hooks.ts
-function isMissingBrainSchemaError5(err) {
-  if (!(err instanceof Error)) return false;
-  const message = String(err.message || "").toLowerCase();
-  return message.includes("no such table") && message.includes("brain_");
-}
 async function isWorkCaptureEnabled(projectRoot) {
   const envOverride = process.env["CLEO_BRAIN_CAPTURE_WORK"];
   if (envOverride !== void 0) {
@@ -18745,7 +20068,7 @@ async function handleWorkPromptSubmit(projectRoot, payload) {
       sourceType: "agent"
     });
   } catch (err) {
-    if (!isMissingBrainSchemaError5(err)) throw err;
+    if (!isMissingBrainSchemaError(err)) throw err;
   }
 }
 async function handleWorkResponseComplete(projectRoot, payload) {
@@ -18762,7 +20085,7 @@ async function handleWorkResponseComplete(projectRoot, payload) {
       sourceType: "agent"
     });
   } catch (err) {
-    if (!isMissingBrainSchemaError5(err)) throw err;
+    if (!isMissingBrainSchemaError(err)) throw err;
   }
 }
 var CAPTURE_OPERATIONS;
@@ -18770,6 +20093,7 @@ var init_work_capture_hooks = __esm({
   "packages/core/src/hooks/handlers/work-capture-hooks.ts"() {
     "use strict";
     init_registry();
+    init_handler_helpers();
     CAPTURE_OPERATIONS = /* @__PURE__ */ new Set([
       "tasks.add",
       "tasks.update",
@@ -18796,20 +20120,6 @@ var init_work_capture_hooks = __esm({
 });
 
 // packages/core/src/hooks/handlers/agent-hooks.ts
-function isMissingBrainSchemaError6(err) {
-  if (!(err instanceof Error)) return false;
-  const message = String(err.message || "").toLowerCase();
-  return message.includes("no such table") && message.includes("brain_");
-}
-async function isAutoCaptureEnabled(projectRoot) {
-  try {
-    const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config(), config_exports));
-    const config2 = await loadConfig3(projectRoot);
-    return config2.brain?.autoCapture ?? false;
-  } catch {
-    return false;
-  }
-}
 async function handleSubagentStart(projectRoot, payload) {
   if (!await isAutoCaptureEnabled(projectRoot)) return;
   const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
@@ -18824,7 +20134,7 @@ async function handleSubagentStart(projectRoot, payload) {
       sourceType: "agent"
     });
   } catch (err) {
-    if (!isMissingBrainSchemaError6(err)) throw err;
+    if (!isMissingBrainSchemaError(err)) throw err;
   }
 }
 async function handleSubagentStop(projectRoot, payload) {
@@ -18843,13 +20153,14 @@ Summary: ${payload.summary}` : "";
       sourceType: "agent"
     });
   } catch (err) {
-    if (!isMissingBrainSchemaError6(err)) throw err;
+    if (!isMissingBrainSchemaError(err)) throw err;
   }
 }
 var init_agent_hooks = __esm({
   "packages/core/src/hooks/handlers/agent-hooks.ts"() {
     "use strict";
     init_registry();
+    init_handler_helpers();
     hooks.register({
       id: "brain-subagent-start",
       event: "SubagentStart",
@@ -18866,22 +20177,8 @@ var init_agent_hooks = __esm({
 });
 
 // packages/core/src/hooks/handlers/context-hooks.ts
-function isMissingBrainSchemaError7(err) {
-  if (!(err instanceof Error)) return false;
-  const message = String(err.message || "").toLowerCase();
-  return message.includes("no such table") && message.includes("brain_");
-}
-async function isAutoCaptureEnabled2(projectRoot) {
-  try {
-    const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config(), config_exports));
-    const config2 = await loadConfig3(projectRoot);
-    return config2.brain?.autoCapture ?? false;
-  } catch {
-    return false;
-  }
-}
 async function handlePreCompact(projectRoot, payload) {
-  if (!await isAutoCaptureEnabled2(projectRoot)) return;
+  if (!await isAutoCaptureEnabled(projectRoot)) return;
   const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
   const tokensPart = payload.tokensBefore != null ? ` (~${payload.tokensBefore.toLocaleString()} tokens)` : "";
   const reasonPart = payload.reason ? ` Reason: ${payload.reason}` : "";
@@ -18894,11 +20191,11 @@ async function handlePreCompact(projectRoot, payload) {
       sourceType: "agent"
     });
   } catch (err) {
-    if (!isMissingBrainSchemaError7(err)) throw err;
+    if (!isMissingBrainSchemaError(err)) throw err;
   }
 }
 async function handlePostCompact(projectRoot, payload) {
-  if (!await isAutoCaptureEnabled2(projectRoot)) return;
+  if (!await isAutoCaptureEnabled(projectRoot)) return;
   const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
   const statusPart = payload.success ? "succeeded" : "failed";
   const beforePart = payload.tokensBefore != null ? ` before=${payload.tokensBefore.toLocaleString()}` : "";
@@ -18912,13 +20209,14 @@ async function handlePostCompact(projectRoot, payload) {
       sourceType: "agent"
     });
   } catch (err) {
-    if (!isMissingBrainSchemaError7(err)) throw err;
+    if (!isMissingBrainSchemaError(err)) throw err;
   }
 }
 var init_context_hooks = __esm({
   "packages/core/src/hooks/handlers/context-hooks.ts"() {
     "use strict";
     init_registry();
+    init_handler_helpers();
     hooks.register({
       id: "brain-pre-compact",
       event: "PreCompact",
@@ -20068,12 +21366,14 @@ function toMinimal(s) {
     name: s.name,
     status: s.status,
     startedAt: s.startedAt,
-    scope: s.scope
+    scope: s.scope,
+    _next: sessionListItemNext(s.id)
   };
 }
 var init_find = __esm({
   "packages/core/src/sessions/find.ts"() {
     "use strict";
+    init_mvi_helpers();
   }
 });
 
@@ -20807,6 +22107,7 @@ async function startSession(options, cwd, accessor) {
     providerId: session.providerId ?? void 0
   }).catch(() => {
   });
+  Object.assign(session, { _next: sessionStartNext() });
   return session;
 }
 async function endSession(options = {}, cwd, accessor) {
@@ -20899,6 +22200,9 @@ async function listSessions(options = {}, cwd, accessor) {
   if (options.limit) {
     sessions2 = sessions2.slice(0, options.limit);
   }
+  for (const s of sessions2) {
+    Object.assign(s, { _next: sessionListItemNext(s.id) });
+  }
   return sessions2;
 }
 async function gcSessions(maxAgeHours = 24, cwd, accessor) {
@@ -20943,6 +22247,7 @@ var init_sessions = __esm({
     "use strict";
     init_src();
     init_errors3();
+    init_mvi_helpers();
     init_data_accessor();
     init_handlers();
     init_assumptions();
@@ -21025,6 +22330,9 @@ async function searchBrainCompact(projectRoot, params) {
   if (dateEnd) {
     results = results.filter((r) => r.date <= dateEnd);
   }
+  for (const hit of results) {
+    hit._next = memoryFindHitNext(hit.id);
+  }
   return {
     results,
     total: results.length,
@@ -21349,6 +22657,7 @@ var TYPE_KEYWORDS, observeSeq;
 var init_brain_retrieval = __esm({
   "packages/core/src/memory/brain-retrieval.ts"() {
     "use strict";
+    init_mvi_helpers();
     init_brain_accessor();
     init_typed_query();
     init_brain_embedding();
@@ -24702,10 +26011,10 @@ async function readProjectMeta(projectPath) {
 }
 async function readProjectId(projectPath) {
   try {
-    const { readFileSync: readFileSync78, existsSync: existsSync104 } = await import("node:fs");
+    const { readFileSync: readFileSync79, existsSync: existsSync105 } = await import("node:fs");
     const infoPath = join59(projectPath, ".cleo", "project-info.json");
-    if (!existsSync104(infoPath)) return "";
-    const data = JSON.parse(readFileSync78(infoPath, "utf-8"));
+    if (!existsSync105(infoPath)) return "";
+    const data = JSON.parse(readFileSync79(infoPath, "utf-8"));
     return typeof data.projectId === "string" ? data.projectId : "";
   } catch {
     return "";
@@ -25067,6 +26376,9 @@ async function startTask(taskId, cwd, accessor) {
   }
   focus.sessionNotes.push(noteEntry);
   await acc.setMetaValue("focus_state", focus);
+  if (!task.assignee) {
+    await acc.updateTaskFields(taskId, { assignee: process.env["CLEO_AGENT_ID"] ?? "local" });
+  }
   await logOperation(
     "task_start",
     taskId,
@@ -25747,6 +27059,153 @@ var init_hooks = __esm({
   }
 });
 
+// packages/core/src/store/signaldock-sqlite.ts
+var signaldock_sqlite_exports = {};
+__export(signaldock_sqlite_exports, {
+  SIGNALDOCK_SCHEMA_VERSION: () => SIGNALDOCK_SCHEMA_VERSION,
+  checkSignaldockDbHealth: () => checkSignaldockDbHealth,
+  ensureSignaldockDb: () => ensureSignaldockDb,
+  getSignaldockDbPath: () => getSignaldockDbPath
+});
+import { existsSync as existsSync100, mkdirSync as mkdirSync22, readFileSync as readFileSync74 } from "node:fs";
+import { createRequire as createRequire5 } from "node:module";
+import { dirname as dirname19, join as join101 } from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+function getSignaldockDbPath(cwd) {
+  const cleoDir = cwd ? join101(cwd, ".cleo") : getCleoDirAbsolute();
+  return join101(cleoDir, DB_FILENAME4);
+}
+function resolveMigrationSql(cwd) {
+  const projectRoot = cwd ?? process.cwd();
+  const monorepoPath = join101(
+    projectRoot,
+    "crates",
+    "signaldock-storage",
+    "migrations",
+    "2026-03-28-000000_initial",
+    "up.sql"
+  );
+  if (existsSync100(monorepoPath)) return monorepoPath;
+  const thisDir = dirname19(fileURLToPath5(import.meta.url));
+  const installedPath = join101(
+    thisDir,
+    "..",
+    "..",
+    "..",
+    "..",
+    "crates",
+    "signaldock-storage",
+    "migrations",
+    "2026-03-28-000000_initial",
+    "up.sql"
+  );
+  if (existsSync100(installedPath)) return installedPath;
+  return null;
+}
+async function ensureSignaldockDb(cwd) {
+  const dbPath = getSignaldockDbPath(cwd);
+  const alreadyExists = existsSync100(dbPath);
+  mkdirSync22(dirname19(dbPath), { recursive: true });
+  const db = new DatabaseSyncClass(dbPath);
+  try {
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA busy_timeout = 5000");
+    db.exec("PRAGMA synchronous = NORMAL");
+    db.exec("PRAGMA foreign_keys = ON");
+    db.exec("PRAGMA cache_size = -64000");
+    const hasSchema = (() => {
+      try {
+        const result = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='agents'").get();
+        return !!result;
+      } catch {
+        return false;
+      }
+    })();
+    if (!hasSchema) {
+      const migrationPath = resolveMigrationSql(cwd);
+      if (!migrationPath) {
+        throw new Error(
+          "signaldock-storage migration SQL not found. Ensure crates/signaldock-storage/ exists."
+        );
+      }
+      const migrationSql = readFileSync74(migrationPath, "utf-8");
+      db.exec("BEGIN TRANSACTION");
+      try {
+        db.exec(migrationSql);
+        db.exec("COMMIT");
+      } catch (err) {
+        db.exec("ROLLBACK");
+        throw err;
+      }
+    }
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS _signaldock_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now'))
+      )
+    `);
+    db.exec(`
+      INSERT OR REPLACE INTO _signaldock_meta (key, value, updated_at)
+      VALUES ('schema_version', '${SIGNALDOCK_SCHEMA_VERSION}', strftime('%s', 'now'))
+    `);
+    return {
+      action: alreadyExists && hasSchema ? "exists" : "created",
+      path: dbPath
+    };
+  } finally {
+    db.close();
+  }
+}
+async function checkSignaldockDbHealth(cwd) {
+  const dbPath = getSignaldockDbPath(cwd);
+  if (!existsSync100(dbPath)) {
+    return {
+      exists: false,
+      path: dbPath,
+      tableCount: 0,
+      walMode: false,
+      schemaVersion: null,
+      foreignKeysEnabled: false
+    };
+  }
+  const db = new DatabaseSyncClass(dbPath);
+  try {
+    const tables = db.prepare(
+      "SELECT COUNT(*) as count FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+    ).get();
+    const journalMode = db.prepare("PRAGMA journal_mode").get();
+    const fkEnabled = db.prepare("PRAGMA foreign_keys").get();
+    let schemaVersion = null;
+    try {
+      const meta = db.prepare("SELECT value FROM _signaldock_meta WHERE key = 'schema_version'").get();
+      schemaVersion = meta?.value ?? null;
+    } catch {
+    }
+    return {
+      exists: true,
+      path: dbPath,
+      tableCount: tables.count,
+      walMode: journalMode.journal_mode === "wal",
+      schemaVersion,
+      foreignKeysEnabled: fkEnabled.foreign_keys === 1
+    };
+  } finally {
+    db.close();
+  }
+}
+var _require5, DatabaseSyncClass, DB_FILENAME4, SIGNALDOCK_SCHEMA_VERSION;
+var init_signaldock_sqlite = __esm({
+  "packages/core/src/store/signaldock-sqlite.ts"() {
+    "use strict";
+    init_paths();
+    _require5 = createRequire5(import.meta.url);
+    ({ DatabaseSync: DatabaseSyncClass } = _require5("node:sqlite"));
+    DB_FILENAME4 = "signaldock.db";
+    SIGNALDOCK_SCHEMA_VERSION = "2026.3.76";
+  }
+});
+
 // packages/core/src/init.ts
 var init_exports = {};
 __export(init_exports, {
@@ -25761,27 +27220,27 @@ __export(init_exports, {
   isAutoInitEnabled: () => isAutoInitEnabled,
   updateDocs: () => updateDocs
 });
-import { existsSync as existsSync100, readdirSync as readdirSync34, readFileSync as readFileSync74 } from "node:fs";
+import { existsSync as existsSync101, readdirSync as readdirSync34, readFileSync as readFileSync75 } from "node:fs";
 import { copyFile as copyFile3, lstat, mkdir as mkdir16, readFile as readFile17, symlink, unlink as unlink4, writeFile as writeFile11 } from "node:fs/promises";
 import { platform as platform4 } from "node:os";
-import { basename as basename17, dirname as dirname19, join as join101 } from "node:path";
+import { basename as basename17, dirname as dirname20, join as join102 } from "node:path";
 async function initAgentDefinition(created, warnings) {
   let agentSourceDir = null;
   try {
-    const { createRequire: createRequire5 } = await import("node:module");
-    const req = createRequire5(import.meta.url);
+    const { createRequire: createRequire6 } = await import("node:module");
+    const req = createRequire6(import.meta.url);
     const agentsPkgMain = req.resolve("@cleocode/agents/package.json");
-    const agentsPkgRoot = dirname19(agentsPkgMain);
-    const candidate = join101(agentsPkgRoot, "cleo-subagent");
-    if (existsSync100(candidate)) {
+    const agentsPkgRoot = dirname20(agentsPkgMain);
+    const candidate = join102(agentsPkgRoot, "cleo-subagent");
+    if (existsSync101(candidate)) {
       agentSourceDir = candidate;
     }
   } catch {
   }
   if (!agentSourceDir) {
     const packageRoot = getPackageRoot();
-    const bundled = join101(packageRoot, "agents", "cleo-subagent");
-    if (existsSync100(bundled)) {
+    const bundled = join102(packageRoot, "agents", "cleo-subagent");
+    if (existsSync101(bundled)) {
       agentSourceDir = bundled;
     }
   }
@@ -25789,8 +27248,8 @@ async function initAgentDefinition(created, warnings) {
     warnings.push("agents/cleo-subagent/ not found in package, skipping agent definition install");
     return;
   }
-  const globalAgentsDir = join101(getAgentsHome(), "agents", "cleo-subagent");
-  await mkdir16(dirname19(globalAgentsDir), { recursive: true });
+  const globalAgentsDir = join102(getAgentsHome(), "agents", "cleo-subagent");
+  await mkdir16(dirname20(globalAgentsDir), { recursive: true });
   try {
     try {
       const stat2 = await lstat(globalAgentsDir);
@@ -25813,7 +27272,7 @@ async function initAgentDefinition(created, warnings) {
       await mkdir16(globalAgentsDir, { recursive: true });
       const files = readdirSync34(agentSourceDir);
       for (const file2 of files) {
-        await copyFile3(join101(agentSourceDir, file2), join101(globalAgentsDir, file2));
+        await copyFile3(join102(agentSourceDir, file2), join102(globalAgentsDir, file2));
       }
       created.push("agent: cleo-subagent (copied)");
     } catch (copyErr) {
@@ -25865,23 +27324,23 @@ async function initCoreSkills(created, warnings) {
     const packageRoot = getPackageRoot();
     let ctSkillsRoot = null;
     try {
-      const { createRequire: createRequire5 } = await import("node:module");
-      const req = createRequire5(import.meta.url);
+      const { createRequire: createRequire6 } = await import("node:module");
+      const req = createRequire6(import.meta.url);
       const skillsPkgMain = req.resolve("@cleocode/skills/package.json");
-      const skillsPkgRoot = dirname19(skillsPkgMain);
-      if (existsSync100(join101(skillsPkgRoot, "skills.json"))) {
+      const skillsPkgRoot = dirname20(skillsPkgMain);
+      if (existsSync101(join102(skillsPkgRoot, "skills.json"))) {
         ctSkillsRoot = skillsPkgRoot;
       }
     } catch {
     }
     if (!ctSkillsRoot) {
       try {
-        const bundledPath = join101(packageRoot, "packages", "skills");
-        if (existsSync100(join101(bundledPath, "skills.json"))) {
+        const bundledPath = join102(packageRoot, "packages", "skills");
+        if (existsSync101(join102(bundledPath, "skills.json"))) {
           ctSkillsRoot = bundledPath;
         } else {
-          const ctSkillsPath = join101(packageRoot, "node_modules", "@cleocode", "skills");
-          if (existsSync100(join101(ctSkillsPath, "skills.json"))) {
+          const ctSkillsPath = join102(packageRoot, "node_modules", "@cleocode", "skills");
+          if (existsSync101(join102(ctSkillsPath, "skills.json"))) {
             ctSkillsRoot = ctSkillsPath;
           }
         }
@@ -25897,14 +27356,14 @@ async function initCoreSkills(created, warnings) {
     } catch {
       warnings.push("Failed to register skill library with CAAMP");
     }
-    const catalogPath = join101(ctSkillsRoot, "skills.json");
-    const catalog3 = JSON.parse(readFileSync74(catalogPath, "utf-8"));
+    const catalogPath = join102(ctSkillsRoot, "skills.json");
+    const catalog3 = JSON.parse(readFileSync75(catalogPath, "utf-8"));
     const skills = catalog3.skills ?? [];
     const coreSkills = skills.filter((s) => s.tier <= 2);
     const installed = [];
     for (const skill of coreSkills) {
-      const skillSourceDir = dirname19(join101(ctSkillsRoot, skill.path));
-      if (!existsSync100(skillSourceDir)) {
+      const skillSourceDir = dirname20(join102(ctSkillsRoot, skill.path));
+      if (!existsSync101(skillSourceDir)) {
         continue;
       }
       try {
@@ -25947,38 +27406,38 @@ async function initNexusRegistration(projectRoot, created, warnings) {
   }
 }
 async function installGitHubTemplates(projectRoot, created, skipped) {
-  if (!existsSync100(join101(projectRoot, ".git"))) {
+  if (!existsSync101(join102(projectRoot, ".git"))) {
     return;
   }
-  const githubDir = join101(projectRoot, ".github");
-  const issueTemplateDir = join101(githubDir, "ISSUE_TEMPLATE");
+  const githubDir = join102(projectRoot, ".github");
+  const issueTemplateDir = join102(githubDir, "ISSUE_TEMPLATE");
   const packageRoot = getPackageRoot();
-  const templateSrcDir = join101(packageRoot, "templates", "github");
-  if (!existsSync100(templateSrcDir)) {
+  const templateSrcDir = join102(packageRoot, "templates", "github");
+  if (!existsSync101(templateSrcDir)) {
     return;
   }
   await mkdir16(issueTemplateDir, { recursive: true });
-  const issueSrcDir = join101(templateSrcDir, "ISSUE_TEMPLATE");
-  if (existsSync100(issueSrcDir)) {
+  const issueSrcDir = join102(templateSrcDir, "ISSUE_TEMPLATE");
+  if (existsSync101(issueSrcDir)) {
     const issueFiles = readdirSync34(issueSrcDir);
     for (const file2 of issueFiles) {
-      const dest = join101(issueTemplateDir, file2);
-      if (existsSync100(dest)) {
+      const dest = join102(issueTemplateDir, file2);
+      if (existsSync101(dest)) {
         skipped.push(`.github/ISSUE_TEMPLATE/${file2}`);
         continue;
       }
-      const content = readFileSync74(join101(issueSrcDir, file2), "utf-8");
+      const content = readFileSync75(join102(issueSrcDir, file2), "utf-8");
       await writeFile11(dest, content, "utf-8");
       created.push(`.github/ISSUE_TEMPLATE/${file2}`);
     }
   }
-  const prTemplateSrc = join101(templateSrcDir, "pull_request_template.md");
-  const prTemplateDest = join101(githubDir, "pull_request_template.md");
-  if (existsSync100(prTemplateSrc)) {
-    if (existsSync100(prTemplateDest)) {
+  const prTemplateSrc = join102(templateSrcDir, "pull_request_template.md");
+  const prTemplateDest = join102(githubDir, "pull_request_template.md");
+  if (existsSync101(prTemplateSrc)) {
+    if (existsSync101(prTemplateDest)) {
       skipped.push(".github/pull_request_template.md");
     } else {
-      const content = readFileSync74(prTemplateSrc, "utf-8");
+      const content = readFileSync75(prTemplateSrc, "utf-8");
       await writeFile11(prTemplateDest, content, "utf-8");
       created.push(".github/pull_request_template.md");
     }
@@ -26009,7 +27468,7 @@ async function updateDocs() {
 async function initProject(opts = {}) {
   const cleoDir = getCleoDirAbsolute();
   const projRoot = getProjectRoot();
-  const alreadyInitialized = existsSync100(cleoDir) && (existsSync100(join101(cleoDir, "tasks.db")) || existsSync100(join101(cleoDir, "config.json")));
+  const alreadyInitialized = existsSync101(cleoDir) && (existsSync101(join102(cleoDir, "tasks.db")) || existsSync101(join102(cleoDir, "config.json")));
   if (alreadyInitialized && !opts.force) {
     throw new CleoError(
       1 /* GENERAL_ERROR */,
@@ -26033,7 +27492,7 @@ async function initProject(opts = {}) {
   }
   try {
     const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-    await getDb3(join101(cleoDir, ".."));
+    await getDb3(join102(cleoDir, ".."));
     created.push("tasks.db");
   } catch (err) {
     created.push(`tasks.db (deferred: ${err instanceof Error ? err.message : String(err)})`);
@@ -26046,6 +27505,15 @@ async function initProject(opts = {}) {
   } catch (err) {
     created.push(`brain.db (deferred: ${err instanceof Error ? err.message : String(err)})`);
   }
+  try {
+    const { ensureSignaldockDb: ensureSignaldockDb2 } = await Promise.resolve().then(() => (init_signaldock_sqlite(), signaldock_sqlite_exports));
+    const sdResult = await ensureSignaldockDb2(projRoot);
+    if (sdResult.action === "created") {
+      created.push("signaldock.db");
+    }
+  } catch (err) {
+    created.push(`signaldock.db (deferred: ${err instanceof Error ? err.message : String(err)})`);
+  }
   if (force) {
     const gitignoreResult = await ensureGitignore(projRoot);
     if (gitignoreResult.action === "skipped") {
@@ -26054,8 +27522,8 @@ async function initProject(opts = {}) {
       created.push(".gitignore");
     }
   } else {
-    const gitignorePath = join101(cleoDir, ".gitignore");
-    if (existsSync100(gitignorePath)) {
+    const gitignorePath = join102(cleoDir, ".gitignore");
+    if (existsSync101(gitignorePath)) {
       skipped.push(".gitignore");
     } else {
       const gitignoreResult = await ensureGitignore(projRoot);
@@ -26066,12 +27534,12 @@ async function initProject(opts = {}) {
       }
     }
   }
-  const legacySequencePath = join101(cleoDir, ".sequence");
+  const legacySequencePath = join102(cleoDir, ".sequence");
   try {
     await unlink4(legacySequencePath);
   } catch {
   }
-  const legacySequenceJsonPath = join101(cleoDir, ".sequence.json");
+  const legacySequenceJsonPath = join102(cleoDir, ".sequence.json");
   try {
     await unlink4(legacySequenceJsonPath);
   } catch {
@@ -26232,8 +27700,8 @@ function isAutoInitEnabled() {
 }
 async function ensureInitialized(projectRoot) {
   const root = projectRoot ?? getProjectRoot();
-  const cleoDir = join101(root, ".cleo");
-  const isInit = existsSync100(cleoDir) && (existsSync100(join101(cleoDir, "tasks.db")) || existsSync100(join101(cleoDir, "config.json")));
+  const cleoDir = join102(root, ".cleo");
+  const isInit = existsSync101(cleoDir) && (existsSync101(join102(cleoDir, "tasks.db")) || existsSync101(join102(cleoDir, "config.json")));
   if (isInit) {
     return { initialized: true };
   }
@@ -26245,7 +27713,7 @@ async function ensureInitialized(projectRoot) {
 }
 async function getVersion2(projectRoot) {
   const root = projectRoot ?? getProjectRoot();
-  const versionPaths = [join101(root, "VERSION"), join101(root, "..", "VERSION")];
+  const versionPaths = [join102(root, "VERSION"), join102(root, "..", "VERSION")];
   for (const versionPath of versionPaths) {
     try {
       const content = await readFile17(versionPath, "utf-8");
@@ -26256,7 +27724,7 @@ async function getVersion2(projectRoot) {
     } catch {
     }
   }
-  const pkg = await readJson(join101(root, "package.json"));
+  const pkg = await readJson(join102(root, "package.json"));
   if (pkg?.version) {
     return { version: pkg.version };
   }
@@ -27511,15 +28979,15 @@ import { and as and5, eq as eq7, inArray as inArray5 } from "drizzle-orm";
 
 // packages/core/src/agents/execution-learning.ts
 init_brain_accessor();
-import { randomBytes } from "node:crypto";
+import { randomBytes as randomBytes2 } from "node:crypto";
 function generateDecisionId() {
-  return `AGT-${randomBytes(5).toString("hex")}`;
+  return `AGT-${randomBytes2(5).toString("hex")}`;
 }
 function generatePatternId() {
-  return `P-agt-${randomBytes(4).toString("hex")}`;
+  return `P-agt-${randomBytes2(4).toString("hex")}`;
 }
 function generateObservationId() {
-  return `O-agt-${randomBytes(4).toString("hex")}`;
+  return `O-agt-${randomBytes2(4).toString("hex")}`;
 }
 function nowSql() {
   return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
@@ -28782,6 +30250,195 @@ async function getValueMetrics(days = 7, cwd) {
   };
 }
 
+// packages/core/src/conduit/index.ts
+var conduit_exports = {};
+__export(conduit_exports, {
+  ConduitClient: () => ConduitClient,
+  HttpTransport: () => HttpTransport,
+  createConduit: () => createConduit
+});
+
+// packages/core/src/conduit/conduit-client.ts
+var ConduitClient = class {
+  transport;
+  credential;
+  state = "disconnected";
+  constructor(transport, credential) {
+    this.transport = transport;
+    this.credential = credential;
+  }
+  get agentId() {
+    return this.credential.agentId;
+  }
+  getState() {
+    return this.state;
+  }
+  async connect() {
+    this.state = "connecting";
+    try {
+      await this.transport.connect({
+        agentId: this.credential.agentId,
+        apiKey: this.credential.apiKey,
+        apiBaseUrl: this.credential.apiBaseUrl,
+        ...this.credential.transportConfig
+      });
+      this.state = "connected";
+    } catch (err) {
+      this.state = "error";
+      throw err;
+    }
+  }
+  async send(to, content, options) {
+    const result = await this.transport.push(to, content, {
+      conversationId: options?.threadId
+    });
+    return {
+      messageId: result.messageId,
+      deliveredAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  onMessage(handler) {
+    if (this.transport.subscribe) {
+      return this.transport.subscribe(handler);
+    }
+    const interval2 = setInterval(async () => {
+      const messages = await this.transport.poll();
+      for (const msg of messages) handler(msg);
+      if (messages.length > 0) {
+        await this.transport.ack(messages.map((m) => m.id));
+      }
+    }, this.credential.transportConfig.pollIntervalMs ?? 5e3);
+    return () => clearInterval(interval2);
+  }
+  async heartbeat() {
+    await this.transport.push(this.credential.agentId, "", {});
+  }
+  async isOnline(agentId) {
+    try {
+      const response = await fetch(`${this.credential.apiBaseUrl}/agents/${agentId}`, {
+        headers: {
+          Authorization: `Bearer ${this.credential.apiKey}`,
+          "X-Agent-Id": this.credential.agentId
+        }
+      });
+      if (!response.ok) return false;
+      const data = await response.json();
+      return data.data?.agent?.status === "online";
+    } catch {
+      return false;
+    }
+  }
+  async disconnect() {
+    await this.transport.disconnect();
+    this.state = "disconnected";
+  }
+};
+
+// packages/core/src/conduit/http-transport.ts
+var HttpTransport = class {
+  name = "http";
+  state = null;
+  async connect(config2) {
+    this.state = {
+      agentId: config2.agentId,
+      apiKey: config2.apiKey,
+      apiBaseUrl: config2.apiBaseUrl,
+      connected: true
+    };
+  }
+  async disconnect() {
+    this.state = null;
+  }
+  async push(to, content, options) {
+    this.ensureConnected();
+    const body = { content };
+    let url2;
+    if (options?.conversationId) {
+      url2 = `${this.state.apiBaseUrl}/conversations/${options.conversationId}/messages`;
+      if (options.replyTo) {
+        body["replyTo"] = options.replyTo;
+      }
+    } else {
+      url2 = `${this.state.apiBaseUrl}/messages`;
+      body["toAgentId"] = to;
+    }
+    const response = await fetch(url2, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const text3 = await response.text().catch(() => "");
+      throw new Error(`HttpTransport push failed: ${response.status} ${text3}`);
+    }
+    const data = await response.json();
+    const messageId = data.data?.message?.id ?? data.data?.id ?? "unknown";
+    return { messageId };
+  }
+  async poll(options) {
+    this.ensureConnected();
+    const params = new URLSearchParams();
+    params.set("mentioned", this.state.agentId);
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.since) params.set("since", options.since);
+    const url2 = `${this.state.apiBaseUrl}/messages/peek?${params}`;
+    const response = await fetch(url2, {
+      method: "GET",
+      headers: this.headers()
+    });
+    if (!response.ok) return [];
+    const data = await response.json();
+    return (data.data?.messages ?? []).map((m) => ({
+      id: m.id,
+      from: m.fromAgentId ?? "unknown",
+      content: m.content ?? "",
+      threadId: m.conversationId,
+      timestamp: m.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  }
+  async ack(messageIds) {
+    this.ensureConnected();
+    await fetch(`${this.state.apiBaseUrl}/messages/ack`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({ messageIds })
+    });
+  }
+  headers() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.state.apiKey}`,
+      "X-Agent-Id": this.state.agentId
+    };
+  }
+  ensureConnected() {
+    if (!this.state?.connected) {
+      throw new Error("HttpTransport not connected. Call connect() first.");
+    }
+  }
+};
+
+// packages/core/src/conduit/factory.ts
+function resolveTransport(credential) {
+  if (credential.transportConfig.wsUrl) {
+  }
+  if (credential.transportConfig.sseEndpoint) {
+  }
+  return new HttpTransport();
+}
+async function createConduit(registry2, agentId) {
+  const credential = agentId ? await registry2.get(agentId) : await registry2.getActive();
+  if (!credential) {
+    throw new Error(
+      "No agent credential found. Run: cleo agent register --id <id> --api-key <key>"
+    );
+  }
+  const transport = resolveTransport(credential);
+  const conduit2 = new ConduitClient(transport, credential);
+  await conduit2.connect();
+  return conduit2;
+}
+
 // packages/core/src/context/index.ts
 var context_exports = {};
 __export(context_exports, {
@@ -28925,7 +30582,7 @@ __export(hooks_exports, {
   OnToolCompletePayloadSchema: () => OnToolCompletePayloadSchema,
   OnToolStartPayloadSchema: () => OnToolStartPayloadSchema,
   OnWorkAvailablePayloadSchema: () => OnWorkAvailablePayloadSchema,
-  handleError: () => handleError,
+  handleError: () => handleError2,
   handleFileChange: () => handleFileChange,
   handlePostCompact: () => handlePostCompact,
   handlePreCompact: () => handlePreCompact,
@@ -48208,7 +49865,7 @@ function checkRateLimit(agentId) {
     );
   }
 }
-var DEFAULT_ACL = { authorizedAgents: ["*"] };
+var DEFAULT_ACL = { authorizedAgents: [] };
 async function loadProjectACL(projectPath) {
   try {
     const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -48218,9 +49875,18 @@ async function loadProjectACL(projectPath) {
       return { authorizedAgents: agents };
     }
   } catch {
+    await logAclFailure(projectPath);
   }
   return DEFAULT_ACL;
 }
+async function logAclFailure(projectPath) {
+  try {
+    const { getLogger: getLogger2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+    const log9 = getLogger2("nexus.acl");
+    log9.warn({ projectPath }, "Failed to load ACL configuration, defaulting to deny-all");
+  } catch {
+  }
+}
 function isAuthorized(acl, agentId) {
   if (acl.authorizedAgents.includes("*")) return true;
   return acl.authorizedAgents.includes(agentId);
@@ -48304,10 +49970,11 @@ async function routeSingleTask(taskId, directive, operation, projects) {
   }
   const acl = await loadProjectACL(targetProject.path);
   if (!isAuthorized(acl, directive.agentId)) {
+    await logRouteAudit(directive, targetProject.name, taskId, operation, false);
     return {
       success: false,
       project: targetProject.name,
-      projectPath: targetProject.path,
+      projectPath: "",
       taskId,
       operation,
       error: `Agent '${directive.agentId}' not authorized to mutate project '${targetProject.name}'`
@@ -48436,8 +50103,8 @@ async function workspaceAgents() {
   const agents = [];
   for (const project of projects) {
     try {
-      const { listAgentInstances: listAgentInstances2 } = await Promise.resolve().then(() => (init_registry2(), registry_exports2));
-      const instances = await listAgentInstances2(void 0, project.path);
+      const acc = await getAccessor(project.path);
+      const instances = await acc.listAgentInstances();
       for (const inst of instances) {
         agents.push({
           agentId: inst.id,
@@ -54349,222 +56016,6 @@ function sanitizeParams(params, projectRoot, context) {
 init_sequence();
 init_sessions();
 
-// packages/core/src/signaldock/index.ts
-var signaldock_exports = {};
-__export(signaldock_exports, {
-  ClaudeCodeTransport: () => ClaudeCodeTransport,
-  SignalDockTransport: () => SignalDockTransport,
-  createTransport: () => createTransport
-});
-
-// packages/core/src/signaldock/claude-code-transport.ts
-var ClaudeCodeTransport = class {
-  name = "claude-code";
-  agents = /* @__PURE__ */ new Map();
-  conversations = /* @__PURE__ */ new Map();
-  messages = [];
-  async register(name2, agentClass, privacyTier) {
-    const registration = {
-      agentId: `cc-${name2}`,
-      name: name2,
-      agentClass,
-      privacyTier
-    };
-    this.agents.set(registration.agentId, registration);
-    return registration;
-  }
-  async deregister(agentId) {
-    this.agents.delete(agentId);
-  }
-  async send(fromAgentId, toAgentId, content, conversationId) {
-    const resolvedConversationId = conversationId ?? `cc-conv-${fromAgentId}-${toAgentId}`;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const messageId = `cc-msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    const message = {
-      id: messageId,
-      conversationId: resolvedConversationId,
-      fromAgentId,
-      toAgentId,
-      content,
-      contentType: "text",
-      status: "delivered",
-      createdAt: now,
-      deliveredAt: now
-    };
-    this.messages.push(message);
-    return {
-      messageId,
-      conversationId: resolvedConversationId,
-      status: "delivered"
-    };
-  }
-  async poll(agentId, since) {
-    return this.messages.filter((m) => {
-      if (m.toAgentId !== agentId) return false;
-      if (since && m.createdAt <= since) return false;
-      return true;
-    });
-  }
-  async heartbeat(agentId) {
-    const agent = this.agents.get(agentId);
-    if (agent) {
-      this.agents.set(agentId, { ...agent });
-    }
-  }
-  async createConversation(participants, visibility) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const id = `cc-conv-${participants.sort().join("-")}`;
-    const existing = this.conversations.get(id);
-    if (existing) return existing;
-    const conversation = {
-      id,
-      participants,
-      visibility: visibility ?? "private",
-      messageCount: 0,
-      createdAt: now,
-      updatedAt: now
-    };
-    this.conversations.set(id, conversation);
-    return conversation;
-  }
-  async getAgent(agentId) {
-    const registration = this.agents.get(agentId);
-    if (!registration) return null;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    return {
-      id: registration.agentId,
-      name: registration.name,
-      agentClass: registration.agentClass,
-      privacyTier: registration.privacyTier,
-      status: "online",
-      createdAt: now,
-      updatedAt: now
-    };
-  }
-};
-
-// packages/core/src/signaldock/signaldock-transport.ts
-var SignalDockTransport = class {
-  name = "signaldock";
-  config;
-  constructor(config2) {
-    this.config = config2;
-  }
-  async register(name2, agentClass, privacyTier) {
-    const prefixedName = `${this.config.agentPrefix}${name2}`;
-    const body = {
-      name: prefixedName,
-      agentClass,
-      privacyTier
-    };
-    const response = await this.request("POST", "/agents", body);
-    return {
-      agentId: response.id,
-      name: response.name,
-      agentClass: response.agentClass,
-      privacyTier: response.privacyTier
-    };
-  }
-  async deregister(agentId) {
-    await this.request("DELETE", `/agents/${encodeURIComponent(agentId)}`);
-  }
-  async send(fromAgentId, toAgentId, content, conversationId) {
-    let convId = conversationId;
-    if (!convId) {
-      const conversation = await this.createConversation([fromAgentId, toAgentId], "private");
-      convId = conversation.id;
-    }
-    const body = {
-      conversationId: convId,
-      fromAgentId,
-      toAgentId,
-      content,
-      contentType: "text"
-    };
-    const message = await this.request("POST", "/messages", body, fromAgentId);
-    return {
-      messageId: message.id,
-      conversationId: message.conversationId,
-      status: message.status === "delivered" ? "delivered" : "pending"
-    };
-  }
-  async poll(agentId, since) {
-    const path2 = since ? `/messages/poll/new?since=${encodeURIComponent(since)}` : "/messages/poll/new";
-    const messages = await this.request("GET", path2, void 0, agentId);
-    return messages;
-  }
-  async heartbeat(agentId) {
-    await this.request(
-      "POST",
-      `/agents/${encodeURIComponent(agentId)}/heartbeat`,
-      void 0,
-      agentId
-    );
-  }
-  async createConversation(participants, visibility = "private") {
-    const body = {
-      participants: [...participants].sort(),
-      visibility
-    };
-    return this.request("POST", "/conversations", body);
-  }
-  async getAgent(agentId) {
-    try {
-      return await this.request("GET", `/agents/${encodeURIComponent(agentId)}`);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Make an HTTP request to the SignalDock API.
-   */
-  async request(method, path2, body, agentId) {
-    const url2 = `${this.config.endpoint}${path2}`;
-    const headers = {
-      "Content-Type": "application/json",
-      Accept: "application/json"
-    };
-    if (agentId) {
-      headers["X-Agent-Id"] = agentId;
-    }
-    const init = {
-      method,
-      headers
-    };
-    if (body !== void 0) {
-      init.body = JSON.stringify(body);
-    }
-    const response = await fetch(url2, init);
-    if (!response.ok) {
-      const text3 = await response.text().catch(() => "");
-      throw new Error(
-        `SignalDock API error: ${method} ${path2} returned ${response.status}: ${text3}`
-      );
-    }
-    if (response.status === 204) {
-      return void 0;
-    }
-    const envelope = await response.json();
-    if (!envelope.success && envelope.error) {
-      throw new Error(`SignalDock error [${envelope.error.code}]: ${envelope.error.message}`);
-    }
-    return envelope.data;
-  }
-};
-
-// packages/core/src/signaldock/factory.ts
-function createTransport(config2) {
-  if (!config2?.enabled) {
-    return new ClaudeCodeTransport();
-  }
-  const sdConfig = {
-    endpoint: config2.endpoint,
-    agentPrefix: config2.agentPrefix,
-    privacyTier: config2.privacyTier
-  };
-  return new SignalDockTransport(sdConfig);
-}
-
 // packages/core/src/skills/index.ts
 var skills_exports = {};
 __export(skills_exports, {
@@ -57601,8 +59052,8 @@ async function initializeSpawnAdapters(manifests) {
     if (!manifest.capabilities?.supportsSpawn) continue;
     if (spawnRegistry.hasAdapterForProvider(manifest.provider)) continue;
     try {
-      const { join: join105 } = await import("node:path");
-      const modulePath = join105(manifest.packagePath, manifest.entryPoint);
+      const { join: join106 } = await import("node:path");
+      const modulePath = join106(manifest.packagePath, manifest.entryPoint);
       const adapterModule = await import(modulePath);
       let SpawnProviderClass;
       for (const [exportName, exportValue] of Object.entries(adapterModule)) {
@@ -60359,6 +61810,37 @@ function getSystemHealth(projectRoot, opts) {
   if (existsSync86(dbPath)) {
     checks.push(checkAuditLogAvailability(dbPath));
   }
+  const sdDbPath = join90(cleoDir, "signaldock.db");
+  if (existsSync86(sdDbPath)) {
+    try {
+      const sdSize = statSync19(sdDbPath).size;
+      if (sdSize > 0) {
+        checks.push({
+          name: "signaldock_db",
+          status: "pass",
+          message: `signaldock.db: ${sdSize} bytes`
+        });
+      } else {
+        checks.push({
+          name: "signaldock_db",
+          status: "warn",
+          message: "signaldock.db exists but is empty"
+        });
+      }
+    } catch {
+      checks.push({
+        name: "signaldock_db",
+        status: "fail",
+        message: "signaldock.db exists but is not readable"
+      });
+    }
+  } else {
+    checks.push({
+      name: "signaldock_db",
+      status: "warn",
+      message: "signaldock.db not found. Run: cleo init"
+    });
+  }
   const configPath = join90(cleoDir, "config.json");
   if (existsSync86(configPath)) {
     try {
@@ -61478,6 +62960,7 @@ async function deleteTask(options, cwd, accessor) {
 // packages/core/src/tasks/find.ts
 init_src();
 init_errors3();
+init_mvi_helpers();
 init_data_accessor();
 function fuzzyScore(query, text3) {
   const q = query.toLowerCase();
@@ -61583,8 +63066,12 @@ async function findTasks(options, cwd, accessor) {
   const limit = options.limit ?? 20;
   const offset = options.offset ?? 0;
   results = results.slice(offset, offset + limit);
+  const enrichedResults = results.map((r) => ({
+    ...r,
+    _next: taskListItemNext(r.id)
+  }));
   return {
-    results,
+    results: enrichedResults,
     total,
     query: queryStr,
     searchType
@@ -61592,6 +63079,7 @@ async function findTasks(options, cwd, accessor) {
 }
 
 // packages/core/src/tasks/list.ts
+init_mvi_helpers();
 var TASK_LIST_DEFAULT_LIMIT = 10;
 async function listTasks(options = {}, cwd, accessor) {
   const dataAccessor = accessor ?? await (await Promise.resolve().then(() => (init_data_accessor(), data_accessor_exports))).getAccessor(cwd);
@@ -61616,8 +63104,12 @@ async function listTasks(options = {}, cwd, accessor) {
     offset: page.offset,
     hasMore: page.hasMore
   } : void 0;
+  const enrichedTasks = tasks2.map((t) => ({
+    ...t,
+    _next: taskListItemNext(t.id)
+  }));
   return {
-    tasks: tasks2,
+    tasks: enrichedTasks,
     total,
     filtered: filteredCount,
     page,
@@ -61628,6 +63120,7 @@ async function listTasks(options = {}, cwd, accessor) {
 // packages/core/src/tasks/show.ts
 init_src();
 init_errors3();
+init_mvi_helpers();
 init_data_accessor();
 async function showTask(taskId, cwd, accessor) {
   if (!taskId) {
@@ -61686,6 +63179,7 @@ async function showTask(taskId, cwd, accessor) {
       detail.hierarchyPath = [...ancestors.map((t) => t.id), taskId];
     }
   }
+  detail._next = taskShowNext(taskId);
   return detail;
 }
 
@@ -65369,13 +66863,13 @@ import { randomUUID as randomUUID6 } from "node:crypto";
 
 // packages/core/src/sessions/context-alert.ts
 init_paths();
-import { existsSync as existsSync101, readFileSync as readFileSync75, writeFileSync as writeFileSync18 } from "node:fs";
-import { join as join102 } from "node:path";
+import { existsSync as existsSync102, readFileSync as readFileSync76, writeFileSync as writeFileSync18 } from "node:fs";
+import { join as join103 } from "node:path";
 function getCurrentSessionId(cwd) {
   if (process.env.CLEO_SESSION) return process.env.CLEO_SESSION;
-  const sessionFile = join102(getCleoDir(cwd), ".current-session");
-  if (existsSync101(sessionFile)) {
-    return readFileSync75(sessionFile, "utf-8").trim() || null;
+  const sessionFile = join103(getCleoDir(cwd), ".current-session");
+  if (existsSync102(sessionFile)) {
+    return readFileSync76(sessionFile, "utf-8").trim() || null;
   }
   return null;
 }
@@ -65391,7 +66885,7 @@ function drainWarnings() {
   pendingWarnings.length = 0;
   return drained;
 }
-function createCliMeta(operation, mvi = "standard") {
+function createCliMeta(operation, mvi = "minimal") {
   const warnings = drainWarnings();
   const meta = {
     specVersion: "1.2.3",
@@ -65413,20 +66907,37 @@ function createCliMeta(operation, mvi = "standard") {
 }
 function formatSuccess(data, message, operationOrOpts) {
   const opts = typeof operationOrOpts === "string" ? { operation: operationOrOpts } : operationOrOpts ?? {};
-  const envelope = {
+  const mviLevel = opts.mvi ?? "minimal";
+  const meta = createCliMeta(opts.operation ?? "cli.output", mviLevel);
+  const fullEnvelope = {
     $schema: "https://lafs.dev/schemas/v1/envelope.schema.json",
-    _meta: createCliMeta(opts.operation ?? "cli.output", opts.mvi),
+    _meta: meta,
     success: true,
     result: data,
-    ...message && { message }
+    ...message && { message },
+    ...opts.page && { page: opts.page },
+    ...opts.extensions && Object.keys(opts.extensions).length > 0 && { _extensions: opts.extensions }
   };
-  if (opts.page) {
-    envelope["page"] = opts.page;
+  if (mviLevel === "full") {
+    return JSON.stringify(fullEnvelope);
   }
-  if (opts.extensions && Object.keys(opts.extensions).length > 0) {
-    envelope["_extensions"] = opts.extensions;
+  if (mviLevel === "minimal") {
+    const minimalMeta = {
+      op: meta.operation,
+      rid: meta.requestId
+    };
+    if (meta.sessionId) minimalMeta.sid = meta.sessionId;
+    if (meta.warnings?.length) minimalMeta.w = meta.warnings;
+    const minimal = {
+      ok: true,
+      r: data,
+      _m: minimalMeta
+    };
+    if (message) minimal.msg = message;
+    if (opts.page) minimal.p = opts.page;
+    return JSON.stringify(minimal);
   }
-  return JSON.stringify(envelope);
+  return JSON.stringify(fullEnvelope);
 }
 function formatError3(error40, operation) {
   const envelope = {
@@ -65450,13 +66961,13 @@ init_paths();
 
 // packages/core/src/project-info.ts
 init_paths();
-import { existsSync as existsSync102, readFileSync as readFileSync76, writeFileSync as writeFileSync19 } from "node:fs";
+import { existsSync as existsSync103, readFileSync as readFileSync77, writeFileSync as writeFileSync19 } from "node:fs";
 import { readFile as readFile18 } from "node:fs/promises";
-import { join as join103 } from "node:path";
+import { join as join104 } from "node:path";
 async function getProjectInfo(cwd) {
   const projectRoot = cwd ?? process.cwd();
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const infoPath = join103(cleoDir, "project-info.json");
+  const infoPath = join104(cleoDir, "project-info.json");
   const raw = await readFile18(infoPath, "utf-8");
   const data = JSON.parse(raw);
   if (typeof data.projectHash !== "string" || data.projectHash.length === 0) {
@@ -65474,10 +66985,10 @@ async function getProjectInfo(cwd) {
 function getProjectInfoSync(cwd) {
   const projectRoot = cwd ?? process.cwd();
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const infoPath = join103(cleoDir, "project-info.json");
-  if (!existsSync102(infoPath)) return null;
+  const infoPath = join104(cleoDir, "project-info.json");
+  if (!existsSync103(infoPath)) return null;
   try {
-    const raw = readFileSync76(infoPath, "utf-8");
+    const raw = readFileSync77(infoPath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.projectHash !== "string" || data.projectHash.length === 0) {
       return null;
@@ -65496,9 +67007,9 @@ function getProjectInfoSync(cwd) {
 }
 function updateProjectName(cwd, name2) {
   const cleoDir = getCleoDirAbsolute(cwd);
-  const infoPath = join103(cleoDir, "project-info.json");
-  if (!existsSync102(infoPath)) return;
-  const data = JSON.parse(readFileSync76(infoPath, "utf-8"));
+  const infoPath = join104(cleoDir, "project-info.json");
+  if (!existsSync103(infoPath)) return;
+  const data = JSON.parse(readFileSync77(infoPath, "utf-8"));
   data.projectName = name2;
   data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
   writeFileSync19(infoPath, `${JSON.stringify(data, null, 2)}
@@ -65512,10 +67023,10 @@ init_adapters();
 // packages/core/src/bootstrap.ts
 init_paths();
 init_scaffold();
-import { existsSync as existsSync103, readFileSync as readFileSync77 } from "node:fs";
+import { existsSync as existsSync104, readFileSync as readFileSync78 } from "node:fs";
 import { mkdir as mkdir17, readFile as readFile19, writeFile as writeFile12 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { join as join104 } from "node:path";
+import { join as join105 } from "node:path";
 async function bootstrapGlobalCleo(options) {
   const ctx = {
     created: [],
@@ -65537,8 +67048,8 @@ async function bootstrapGlobalCleo(options) {
 }
 async function writeTemplateTo(content, destPath, isDryRun) {
   if (isDryRun) return false;
-  const { dirname: dirname20 } = await import("node:path");
-  await mkdir17(dirname20(destPath), { recursive: true });
+  const { dirname: dirname21 } = await import("node:path");
+  await mkdir17(dirname21(destPath), { recursive: true });
   await writeFile12(destPath, content);
   return true;
 }
@@ -65550,9 +67061,9 @@ async function ensureGlobalTemplatesBootstrap(ctx, packageRootOverride) {
   let templateContent = null;
   try {
     const pkgRoot = packageRootOverride ?? getPackageRoot();
-    const templatePath = join104(pkgRoot, "templates", "CLEO-INJECTION.md");
-    if (existsSync103(templatePath)) {
-      templateContent = readFileSync77(templatePath, "utf-8");
+    const templatePath = join105(pkgRoot, "templates", "CLEO-INJECTION.md");
+    if (existsSync104(templatePath)) {
+      templateContent = readFileSync78(templatePath, "utf-8");
     }
   } catch {
   }
@@ -65569,15 +67080,15 @@ async function ensureGlobalTemplatesBootstrap(ctx, packageRootOverride) {
     ctx.warnings.push("Could not refresh CLEO-INJECTION.md template");
     return;
   }
-  const xdgDest = join104(globalTemplatesDir, "CLEO-INJECTION.md");
+  const xdgDest = join105(globalTemplatesDir, "CLEO-INJECTION.md");
   const xdgWritten = await writeTemplateTo(templateContent, xdgDest, ctx.isDryRun);
   ctx.created.push(
     `${getCleoTemplatesTildePath()}/CLEO-INJECTION.md (${xdgWritten ? "refreshed" : "would refresh"})`
   );
   const home = homedir6();
-  const legacyTemplatesDir = join104(home, ".cleo", "templates");
-  if (legacyTemplatesDir !== globalTemplatesDir && existsSync103(join104(home, ".cleo"))) {
-    const legacyDest = join104(legacyTemplatesDir, "CLEO-INJECTION.md");
+  const legacyTemplatesDir = join105(home, ".cleo", "templates");
+  if (legacyTemplatesDir !== globalTemplatesDir && existsSync104(join105(home, ".cleo"))) {
+    const legacyDest = join105(legacyTemplatesDir, "CLEO-INJECTION.md");
     const legacyWritten = await writeTemplateTo(templateContent, legacyDest, ctx.isDryRun);
     if (legacyWritten) {
       ctx.created.push("~/.cleo/templates/CLEO-INJECTION.md (legacy sync)");
@@ -65596,12 +67107,12 @@ function sanitizeCaampFile(content) {
 }
 async function injectAgentsHub(ctx) {
   const globalAgentsDir = getAgentsHome();
-  const globalAgentsMd = join104(globalAgentsDir, "AGENTS.md");
+  const globalAgentsMd = join105(globalAgentsDir, "AGENTS.md");
   try {
     const { inject: inject2, getInstalledProviders: getInstalledProviders3, injectAll: injectAll2, buildInjectionContent } = await import("@cleocode/caamp");
     if (!ctx.isDryRun) {
       await mkdir17(globalAgentsDir, { recursive: true });
-      if (existsSync103(globalAgentsMd)) {
+      if (existsSync104(globalAgentsMd)) {
         const content = await readFile19(globalAgentsMd, "utf8");
         const stripped = content.replace(
           /\n?<!-- CLEO:START[^>]*-->[\s\S]*?<!-- CLEO:END -->\n?/g,
@@ -65636,8 +67147,8 @@ async function injectAgentsHub(ctx) {
       });
       if (!ctx.isDryRun) {
         for (const provider of providers) {
-          const instructFilePath = join104(provider.pathGlobal, provider.instructFile);
-          if (existsSync103(instructFilePath)) {
+          const instructFilePath = join105(provider.pathGlobal, provider.instructFile);
+          if (existsSync104(instructFilePath)) {
             const fileContent = await readFile19(instructFilePath, "utf8");
             const stripped = fileContent.replace(
               /\n?<!-- CLEO:START[^>]*-->[\s\S]*?<!-- CLEO:END -->\n?/g,
@@ -65655,7 +67166,7 @@ async function injectAgentsHub(ctx) {
         }
       } else {
         for (const p of providers) {
-          const displayPath = join104(p.pathGlobal, p.instructFile).replace(homedir6(), "~");
+          const displayPath = join105(p.pathGlobal, p.instructFile).replace(homedir6(), "~");
           ctx.created.push(`${displayPath} (would update CAAMP block)`);
         }
       }
@@ -65760,17 +67271,17 @@ async function installProviderAdapters(ctx, packageRootOverride) {
 async function verifyBootstrapHealth(ctx) {
   if (ctx.isDryRun) return;
   try {
-    const xdgTemplatePath = join104(getCleoTemplatesDir(), "CLEO-INJECTION.md");
-    const agentsMd = join104(getAgentsHome(), "AGENTS.md");
-    if (!existsSync103(xdgTemplatePath)) {
+    const xdgTemplatePath = join105(getCleoTemplatesDir(), "CLEO-INJECTION.md");
+    const agentsMd = join105(getAgentsHome(), "AGENTS.md");
+    if (!existsSync104(xdgTemplatePath)) {
       ctx.warnings.push("Health: XDG template missing after bootstrap");
       return;
     }
     const xdgContent = await readFile19(xdgTemplatePath, "utf8");
     const xdgVersion = xdgContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
     const home = homedir6();
-    const legacyTemplatePath = join104(home, ".cleo", "templates", "CLEO-INJECTION.md");
-    if (existsSync103(legacyTemplatePath)) {
+    const legacyTemplatePath = join105(home, ".cleo", "templates", "CLEO-INJECTION.md");
+    if (existsSync104(legacyTemplatePath)) {
       const legacyContent = await readFile19(legacyTemplatePath, "utf8");
       const legacyVersion = legacyContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
       if (legacyVersion !== xdgVersion) {
@@ -65779,7 +67290,7 @@ async function verifyBootstrapHealth(ctx) {
         );
       }
     }
-    if (existsSync103(agentsMd)) {
+    if (existsSync104(agentsMd)) {
       const agentsContent = await readFile19(agentsMd, "utf8");
       const expectedRef = `@${getCleoTemplatesTildePath()}/CLEO-INJECTION.md`;
       if (!agentsContent.includes(expectedRef)) {
@@ -66248,6 +67759,7 @@ var Cleo = class _Cleo {
 init_registry();
 init_brain_retrieval();
 init_brain_search();
+init_mvi_helpers();
 init_sessions();
 init_task_work();
 init_add();
@@ -66316,6 +67828,7 @@ export {
   compareSemver,
   completeTask,
   compliance_exports as compliance,
+  conduit_exports as conduit,
   context_exports as context,
   hooks_exports as coreHooks,
   mcp_exports as coreMcp,
@@ -66410,6 +67923,7 @@ export {
   loadConfig,
   manifestStatusSchema,
   memory_exports as memory,
+  memoryFindHitNext,
   metrics_exports as metrics,
   migration_exports as migration,
   nexus_exports as nexus,
@@ -66452,13 +67966,14 @@ export {
   selectTaskSchema,
   sequence_exports as sequence,
   serializeSession,
+  sessionListItemNext,
+  sessionStartNext,
   sessionStatus,
   sessionStatusSchema,
   sessions_exports as sessions,
   setConfigValue,
   sha256,
   showTask,
-  signaldock_exports as signaldock,
   skills_exports as skills,
   snapshot_exports as snapshot,
   spawn_exports as spawn,
@@ -66469,8 +67984,10 @@ export {
   stopTask,
   syncDirectionSchema,
   system_exports as system,
+  taskListItemNext,
   taskPrioritySchema,
   taskRelationTypeSchema,
+  taskShowNext,
   taskSizeSchema,
   taskStatusSchema,
   taskTypeSchema,
@@ -66485,6 +68002,7 @@ export {
   updateProjectName,
   updateTask,
   validateAgainstSchema,
-  validation_exports as validation
+  validation_exports as validation,
+  wasm_exports as wasm
 };
 //# sourceMappingURL=index.js.map