omnius 1.0.668 → 1.0.670

package/dist/index.js

@@ -72598,13 +72598,13 @@ var init_episodeStore = __esm({
         }
         return true;
       }
-      recordRetrieved(episodes, timestamp2) {
+      recordRetrieved(episodes, timestamp) {
         if (episodes.length === 0)
           return;
         const updateStmt = this.db.prepare("UPDATE episodes SET strength = strength + 1, last_retrieved = ? WHERE id = ?");
         const updateAll = this.db.transaction(() => {
           for (const episode of episodes)
-            updateStmt.run(timestamp2, episode.id);
+            updateStmt.run(timestamp, episode.id);
         });
         updateAll();
       }
@@ -73777,7 +73777,7 @@ var init_temporalGraph = __esm({
        * earlier recorded time. The recorded-time branch deliberately treats an
        * edge as open before Omnius learned of its later supersession.
        */
-      edgesAtTime(nodeId2, timestamp2, recordedAsOf) {
+      edgesAtTime(nodeId2, timestamp, recordedAsOf) {
         if (recordedAsOf !== void 0) {
           return this.db.prepare(`
         SELECT * FROM kg_edges
@@ -73790,7 +73790,7 @@ var init_temporalGraph = __esm({
             OR valid_until > ?
           )
         ORDER BY valid_from DESC, recorded_at DESC
-      `).all(nodeId2, nodeId2, recordedAsOf, timestamp2, recordedAsOf, timestamp2).map((r2) => this.rowToEdge(r2));
+      `).all(nodeId2, nodeId2, recordedAsOf, timestamp, recordedAsOf, timestamp).map((r2) => this.rowToEdge(r2));
         }
         return this.db.prepare(`
       SELECT * FROM kg_edges
@@ -73798,7 +73798,7 @@ var init_temporalGraph = __esm({
         AND valid_from <= ?
         AND (valid_until IS NULL OR valid_until > ?)
       ORDER BY valid_from DESC
-    `).all(nodeId2, nodeId2, timestamp2, timestamp2).map((r2) => this.rowToEdge(r2));
+    `).all(nodeId2, nodeId2, timestamp, timestamp).map((r2) => this.rowToEdge(r2));
       }
       /** Get full history of a node (all edges, including superseded). */
       nodeHistory(nodeId2) {
@@ -74331,10 +74331,10 @@ function seededUnit(seed) {
 function edgeKey(edge) {
   return String(edge.id ?? `${edge.srcId}:${edge.dstId}:${edge.relation}:${edge.sourceEpisodeId ?? ""}`);
 }
-function recencyScore(timestamp2, now2) {
-  if (!timestamp2 || !Number.isFinite(timestamp2))
+function recencyScore(timestamp, now2) {
+  if (!timestamp || !Number.isFinite(timestamp))
     return 0;
-  const ageMs = Math.max(0, now2 - timestamp2);
+  const ageMs = Math.max(0, now2 - timestamp);
   return Math.exp(-ageMs / (7 * 24 * 60 * 6e4));
 }
 function relationAllowed(edge, options2) {
@@ -98581,9 +98581,9 @@ var init_transcribe_tool = __esm({
         const transcriptDir = join49(this.workingDir, ".omnius", "transcripts");
         mkdirSync30(transcriptDir, { recursive: true });
         const fileBase = basename8(filePath).replace(/\.[^.]+$/, "");
-        const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-        const txtFile = join49(transcriptDir, `${fileBase}-${timestamp2}.txt`);
-        const jsonFile = join49(transcriptDir, `${fileBase}-${timestamp2}.json`);
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+        const txtFile = join49(transcriptDir, `${fileBase}-${timestamp}.txt`);
+        const jsonFile = join49(transcriptDir, `${fileBase}-${timestamp}.json`);
         writeFileSync29(txtFile, text3, "utf-8");
         const structured = {
           source: filePath,
@@ -170739,12 +170739,12 @@ var require_axios = __commonJS({
       };
     }
     function throttle(fn, freq) {
-      let timestamp2 = 0;
+      let timestamp = 0;
       let threshold = 1e3 / freq;
       let lastArgs;
       let timer;
       const invoke = (args, now2 = Date.now()) => {
-        timestamp2 = now2;
+        timestamp = now2;
         lastArgs = null;
         if (timer) {
           clearTimeout(timer);
@@ -170754,7 +170754,7 @@ var require_axios = __commonJS({
       };
       const throttled = (...args) => {
         const now2 = Date.now();
-        const passed = now2 - timestamp2;
+        const passed = now2 - timestamp;
         if (passed >= threshold) {
           invoke(args, now2);
         } else {
@@ -173686,7 +173686,7 @@ var require_auto = __commonJS({
 // ../node_modules/acme-client/src/client.js
 var require_client = __commonJS({
   "../node_modules/acme-client/src/client.js"(exports, module) {
-    var { createHash: createHash82 } = __require("crypto");
+    var { createHash: createHash81 } = __require("crypto");
     var { getPemBodyAsB64u } = require_crypto();
     var { log: log22 } = require_logger();
     var HttpClient = require_http();
@@ -173997,14 +173997,14 @@ var require_client = __commonJS({
        */
       async getChallengeKeyAuthorization(challenge) {
         const jwk = this.http.getJwk();
-        const keysum = createHash82("sha256").update(JSON.stringify(jwk));
+        const keysum = createHash81("sha256").update(JSON.stringify(jwk));
         const thumbprint = keysum.digest("base64url");
         const result = `${challenge.token}.${thumbprint}`;
         if (challenge.type === "http-01") {
           return result;
         }
         if (challenge.type === "dns-01") {
-          return createHash82("sha256").update(result).digest("base64url");
+          return createHash81("sha256").update(result).digest("base64url");
         }
         if (challenge.type === "tls-alpn-01") {
           return result;
@@ -191728,9 +191728,9 @@ var require_pkcs7 = __commonJS({
         var jan_1_2050 = /* @__PURE__ */ new Date("2050-01-01T00:00:00Z");
         var date = attr.value;
         if (typeof date === "string") {
-          var timestamp2 = Date.parse(date);
-          if (!isNaN(timestamp2)) {
-            date = new Date(timestamp2);
+          var timestamp = Date.parse(date);
+          if (!isNaN(timestamp)) {
+            date = new Date(timestamp);
           } else if (date.length === 13) {
             date = asn1.utcTimeToDate(date);
           } else {
@@ -193412,7 +193412,7 @@ var init_autonat = __esm({
           };
         }
         this.log("dial multiaddrs %s for peer %p", multiaddrs.map((ma) => ma.toString()).join(", "), peerId);
-        let errorMessage2 = "";
+        let errorMessage = "";
         let lastMultiaddr = multiaddrs[0];
         for (const multiaddr2 of multiaddrs) {
           let connection2;
@@ -193433,7 +193433,7 @@ var init_autonat = __esm({
             };
           } catch (err) {
             this.log.error("could not dial %p - %e", peerId, err);
-            errorMessage2 = err.message;
+            errorMessage = err.message;
           } finally {
             if (connection2 != null) {
               await connection2.close();
@@ -193444,7 +193444,7 @@ var init_autonat = __esm({
           type: Message.MessageType.DIAL_RESPONSE,
           dialResponse: {
             status: Message.ResponseStatus.E_DIAL_ERROR,
-            statusText: errorMessage2,
+            statusText: errorMessage,
             addr: lastMultiaddr.bytes
           }
         };
@@ -201479,8 +201479,8 @@ var require_util4 = __commonJS({
         request.headersList.append("origin", serializedOrigin, true);
       }
     }
-    function coarsenTime(timestamp2, crossOriginIsolatedCapability) {
-      return timestamp2;
+    function coarsenTime(timestamp, crossOriginIsolatedCapability) {
+      return timestamp;
     }
     function clampAndCoarsenConnectionTimingInfo(connectionTimingInfo, defaultStartTime, crossOriginIsolatedCapability) {
       if (!connectionTimingInfo?.startTime || connectionTimingInfo.startTime < defaultStartTime) {
@@ -206463,8 +206463,8 @@ var require_socks5_client = __commonJS({
           return;
         }
         if (reply !== REPLY_CODES.SUCCEEDED) {
-          const errorMessage2 = this.getReplyErrorMessage(reply);
-          throw new Socks5ProxyError(`SOCKS5 connection failed: ${errorMessage2}`, `UND_ERR_SOCKS5_REPLY_${reply}`);
+          const errorMessage = this.getReplyErrorMessage(reply);
+          throw new Socks5ProxyError(`SOCKS5 connection failed: ${errorMessage}`, `UND_ERR_SOCKS5_REPLY_${reply}`);
         }
         let boundAddress;
         let offset = 4;
@@ -211331,11 +211331,11 @@ var require_dns = __commonJS({
         return ip;
       }
       setRecords(origin, addresses) {
-        const timestamp2 = Date.now();
+        const timestamp = Date.now();
         const records = { records: { 4: null, 6: null } };
         let minTTL = this.#maxTTL;
         for (const record of addresses) {
-          record.timestamp = timestamp2;
+          record.timestamp = timestamp;
           if (typeof record.ttl === "number") {
             record.ttl = Math.min(record.ttl, this.#maxTTL);
             minTTL = Math.min(minTTL, record.ttl);
@@ -297526,7 +297526,7 @@ var require_build3 = __commonJS({
       return validations;
     }
     var JsonProp = (options2 = {}) => (target, propertyKey) => {
-      const errorMessage2 = `Cannot set type for ${propertyKey} property of ${target.constructor.name} schema`;
+      const errorMessage = `Cannot set type for ${propertyKey} property of ${target.constructor.name} schema`;
       let schema;
       if (!schemaStorage.has(target.constructor)) {
         schema = schemaStorage.create(target.constructor);
@@ -297546,7 +297546,7 @@ var require_build3 = __commonJS({
       copyOptions.validations = getValidations(copyOptions);
       if (typeof copyOptions.type !== "number") {
         if (!schemaStorage.has(copyOptions.type) && !isConvertible(copyOptions.type)) {
-          throw new Error(`${errorMessage2}. Assigning type doesn't have schema.`);
+          throw new Error(`${errorMessage}. Assigning type doesn't have schema.`);
         }
       }
       let schemaNames;
@@ -316684,7 +316684,7 @@ var require_websocket2 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes32, createHash: createHash82 } = __require("crypto");
+    var { randomBytes: randomBytes32, createHash: createHash81 } = __require("crypto");
     var { Duplex: Duplex3, Readable: Readable2 } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate2();
@@ -317344,7 +317344,7 @@ var require_websocket2 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest4 = createHash82("sha1").update(key + GUID).digest("base64");
+        const digest4 = createHash81("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest4) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -317711,7 +317711,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter15 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash82 } = __require("crypto");
+    var { createHash: createHash81 } = __require("crypto");
     var extension3 = require_extension2();
     var PerMessageDeflate3 = require_permessage_deflate2();
     var subprotocol3 = require_subprotocol();
@@ -318012,7 +318012,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest4 = createHash82("sha1").update(key + GUID).digest("base64");
+        const digest4 = createHash81("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -330819,13 +330819,13 @@ Justification: ${justification || "(none provided)"}`,
         }
         const snapshot = JSON.stringify(this.selfState, null, 2);
         try {
-          const { createHash: createHash82 } = await import("node:crypto");
+          const { createHash: createHash81 } = await import("node:crypto");
           const snapshotDir = join52(this.cwd, ".omnius", "identity", "snapshots");
           await mkdir7(snapshotDir, { recursive: true });
           const version5 = this.selfState.version;
           const snapshotPath = join52(snapshotDir, `v${version5}.json`);
           await writeFile12(snapshotPath, snapshot, "utf8");
-          const hash2 = createHash82("sha256").update(snapshot).digest("hex");
+          const hash2 = createHash81("sha256").update(snapshot).digest("hex");
           await writeFile12(join52(this.cwd, ".omnius", "identity", "latest-hash.txt"), hash2, "utf8");
           let ipfsCid = "";
           try {
@@ -330958,8 +330958,8 @@ New: ${newNarrative.slice(0, 200)}...`,
       }
       // ── Helpers ──────────────────────────────────────────────────────────────
       createDefaultState() {
-        const { createHash: createHash82 } = __require("node:crypto");
-        const machineId = createHash82("sha256").update(this.cwd).digest("hex").slice(0, 12);
+        const { createHash: createHash81 } = __require("node:crypto");
+        const machineId = createHash81("sha256").update(this.cwd).digest("hex").slice(0, 12);
         return {
           self_id: `omnius-${machineId}`,
           version: 1,
@@ -331041,9 +331041,9 @@ New: ${newNarrative.slice(0, 200)}...`,
         let cid;
         if (this.selfState.version > prevVersion) {
           try {
-            const { createHash: createHash82 } = await import("node:crypto");
+            const { createHash: createHash81 } = await import("node:crypto");
             const stateJson = JSON.stringify(this.selfState);
-            const hash2 = createHash82("sha256").update(stateJson).digest("hex").slice(0, 32);
+            const hash2 = createHash81("sha256").update(stateJson).digest("hex").slice(0, 32);
             const cidsPath = join52(this.cwd, ".omnius", "identity", "cids.json");
             const cidsData = { latest: "", hash: hash2, version: this.selfState.version };
             try {
@@ -353460,7 +353460,7 @@ function requireWorkboard(workingDir, runId) {
   }
   return snapshot;
 }
-function normalizeCardInput(input, timestamp2) {
+function normalizeCardInput(input, timestamp) {
   const title = cleanString(input.title);
   if (!title)
     throw new WorkboardError("title_required", "card title is required");
@@ -353488,9 +353488,9 @@ function normalizeCardInput(input, timestamp2) {
     evidenceRequirements,
     evidence: [],
     decisions: [],
-    createdAt: timestamp2,
-    updatedAt: timestamp2,
-    startedAt: status === "in_progress" ? timestamp2 : void 0,
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    startedAt: status === "in_progress" ? timestamp : void 0,
     blocker: status === "blocked" ? "Blocked when created." : void 0,
     diagnosticFingerprint: cleanString(input.diagnosticFingerprint),
     ownedFiles: normalizeStringArray(input.ownedFiles),
@@ -360989,7 +360989,7 @@ var require_typescript = __commonJS({
         textSpanOverlapsWith: () => textSpanOverlapsWith,
         textSpansEqual: () => textSpansEqual,
         textToKeywordObj: () => textToKeywordObj,
-        timestamp: () => timestamp2,
+        timestamp: () => timestamp,
         toArray: () => toArray,
         toBuilderFileEmit: () => toBuilderFileEmit,
         toBuilderStateFileInfoForMultiEmit: () => toBuilderStateFileInfoForMultiEmit,
@@ -363948,7 +363948,7 @@ ${lanes.join("\n")}
       function tryGetNativePerformanceHooks() {
         return nativePerformanceHooks;
       }
-      var timestamp2 = nativePerformanceTime ? () => nativePerformanceTime.now() : Date.now;
+      var timestamp = nativePerformanceTime ? () => nativePerformanceTime.now() : Date.now;
       var ts_performance_exports = {};
       __export2(ts_performance_exports, {
         clearMarks: () => clearMarks,
@@ -363993,7 +363993,7 @@ ${lanes.join("\n")}
       }
       var nullTimer = { enter: noop2, exit: noop2 };
       var enabled2 = false;
-      var timeorigin = timestamp2();
+      var timeorigin = timestamp();
       var marks = /* @__PURE__ */ new Map();
       var counts = /* @__PURE__ */ new Map();
       var durations = /* @__PURE__ */ new Map();
@@ -364001,7 +364001,7 @@ ${lanes.join("\n")}
         if (enabled2) {
           const count = counts.get(markName) ?? 0;
           counts.set(markName, count + 1);
-          marks.set(markName, timestamp2());
+          marks.set(markName, timestamp());
           performanceImpl == null ? void 0 : performanceImpl.mark(markName);
           if (typeof onProfilerEvent === "function") {
             onProfilerEvent(markName);
@@ -364010,7 +364010,7 @@ ${lanes.join("\n")}
       }
       function measure(measureName, startMarkName, endMarkName) {
         if (enabled2) {
-          const end = (endMarkName !== void 0 ? marks.get(endMarkName) : void 0) ?? timestamp2();
+          const end = (endMarkName !== void 0 ? marks.get(endMarkName) : void 0) ?? timestamp();
           const start2 = (startMarkName !== void 0 ? marks.get(startMarkName) : void 0) ?? timeorigin;
           const previousDuration = durations.get(measureName) || 0;
           durations.set(measureName, previousDuration + (end - start2));
@@ -364108,7 +364108,7 @@ ${lanes.join("\n")}
           });
           traceFd = fs14.openSync(tracePath, "w");
           tracing = tracingEnabled2;
-          const meta = { cat: "__metadata", ph: "M", ts: 1e3 * timestamp2(), pid: 1, tid: 1 };
+          const meta = { cat: "__metadata", ph: "M", ts: 1e3 * timestamp(), pid: 1, tid: 1 };
           fs14.writeSync(
             traceFd,
             "[\n" + [{ name: "process_name", args: { name: "tsc" }, ...meta }, { name: "thread_name", args: { name: "Main" }, ...meta }, { name: "TracingStartedInBrowser", ...meta, cat: "disabled-by-default-devtools.timeline" }].map((v) => JSON.stringify(v)).join(",\n")
@@ -364155,17 +364155,17 @@ ${lanes.join("\n")}
           if (separateBeginAndEnd) {
             writeEvent("B", phase, name10, args);
           }
-          eventStack.push({ phase, name: name10, args, time: 1e3 * timestamp2(), separateBeginAndEnd });
+          eventStack.push({ phase, name: name10, args, time: 1e3 * timestamp(), separateBeginAndEnd });
         }
         tracingEnabled2.push = push;
         function pop(results) {
           Debug.assert(eventStack.length > 0);
-          writeStackEvent(eventStack.length - 1, 1e3 * timestamp2(), results);
+          writeStackEvent(eventStack.length - 1, 1e3 * timestamp(), results);
           eventStack.length--;
         }
         tracingEnabled2.pop = pop;
         function popAll() {
-          const endTime = 1e3 * timestamp2();
+          const endTime = 1e3 * timestamp();
           for (let i2 = eventStack.length - 1; i2 >= 0; i2--) {
             writeStackEvent(i2, endTime);
           }
@@ -364190,7 +364190,7 @@ ${lanes.join("\n")}
             writeEvent("X", phase, name10, { ...args, results }, `"dur":${endTime - time}`, time);
           }
         }
-        function writeEvent(eventType, phase, name10, args, extras, time = 1e3 * timestamp2()) {
+        function writeEvent(eventType, phase, name10, args, extras, time = 1e3 * timestamp()) {
           if (mode === "server" && phase === "checkTypes") return;
           mark("beginTracing");
           fs14.writeSync(traceFd, `,
@@ -366905,7 +366905,7 @@ ${lanes.join("\n")}
           var _a2;
           timerToUpdateChildWatches = void 0;
           sysLog(`sysLog:: onTimerToUpdateChildWatches:: ${cacheToUpdateChildWatches.size}`);
-          const start2 = timestamp2();
+          const start2 = timestamp();
           const invokeMap = /* @__PURE__ */ new Map();
           while (!timerToUpdateChildWatches && cacheToUpdateChildWatches.size) {
             const result = cacheToUpdateChildWatches.entries().next();
@@ -366915,7 +366915,7 @@ ${lanes.join("\n")}
             const hasChanges = updateChildWatches(dirName, dirPath, options2);
             if (!((_a2 = cache8.get(dirPath)) == null ? void 0 : _a2.targetWatcher)) invokeCallbacks(dirName, dirPath, invokeMap, hasChanges ? void 0 : fileNames);
           }
-          sysLog(`sysLog:: invokingWatchers:: Elapsed:: ${timestamp2() - start2}ms:: ${cacheToUpdateChildWatches.size}`);
+          sysLog(`sysLog:: invokingWatchers:: Elapsed:: ${timestamp() - start2}ms:: ${cacheToUpdateChildWatches.size}`);
           callbackCache.forEach((callbacks, rootDirName) => {
             const existing = invokeMap.get(rootDirName);
             if (existing) {
@@ -366928,7 +366928,7 @@ ${lanes.join("\n")}
               });
             }
           });
-          const elapsed = timestamp2() - start2;
+          const elapsed = timestamp() - start2;
           sysLog(`sysLog:: Elapsed:: ${elapsed}ms:: onTimerToUpdateChildWatches:: ${cacheToUpdateChildWatches.size} ${timerToUpdateChildWatches}`);
         }
         function removeChildWatches(parentWatcher) {
@@ -416760,10 +416760,10 @@ ${lanes.join("\n")}
             }
           }
         }
-        function resolveExternalModuleName(location, moduleReferenceExpression, ignoreErrors, errorMessage2) {
+        function resolveExternalModuleName(location, moduleReferenceExpression, ignoreErrors, errorMessage) {
           const isClassic = getEmitModuleResolutionKind(compilerOptions) === 1;
-          errorMessage2 ?? (errorMessage2 = getCannotResolveModuleNameErrorForSpecificModule(moduleReferenceExpression) ?? (isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option : Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations));
-          return resolveExternalModuleNameWorker(location, moduleReferenceExpression, ignoreErrors ? void 0 : errorMessage2, ignoreErrors);
+          errorMessage ?? (errorMessage = getCannotResolveModuleNameErrorForSpecificModule(moduleReferenceExpression) ?? (isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option : Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations));
+          return resolveExternalModuleNameWorker(location, moduleReferenceExpression, ignoreErrors ? void 0 : errorMessage, ignoreErrors);
         }
         function resolveExternalModuleNameWorker(location, moduleReferenceExpression, moduleNotFoundError, ignoreErrors = false, isForAugmentation = false) {
           return isStringLiteralLike(moduleReferenceExpression) ? resolveExternalModule(location, moduleReferenceExpression.text, moduleNotFoundError, !ignoreErrors ? moduleReferenceExpression : void 0, isForAugmentation) : void 0;
@@ -431169,8 +431169,8 @@ ${lanes.join("\n")}
               if (moduleSymbol.flags & targetMeaning) {
                 links3.resolvedType = resolveImportSymbolType(node, links3, moduleSymbol, targetMeaning);
               } else {
-                const errorMessage2 = targetMeaning === 111551 ? Diagnostics.Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here : Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0;
-                error2(node, errorMessage2, node.argument.literal.text);
+                const errorMessage = targetMeaning === 111551 ? Diagnostics.Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here : Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0;
+                error2(node, errorMessage, node.argument.literal.text);
                 links3.resolvedSymbol = unknownSymbol;
                 links3.resolvedType = errorType;
               }
@@ -432459,7 +432459,7 @@ ${lanes.join("\n")}
         function elaborateElementwise(iterator, source, target, relation, containingMessageChain, errorOutputContainer) {
           let reportedError = false;
           for (const value2 of iterator) {
-            const { errorNode: prop, innerExpression: next, nameType, errorMessage: errorMessage2 } = value2;
+            const { errorNode: prop, innerExpression: next, nameType, errorMessage } = value2;
             let targetPropType = getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType);
             if (!targetPropType || targetPropType.flags & 33554432) continue;
             let sourcePropType = getIndexedAccessTypeOrUndefined(source, nameType);
@@ -432499,9 +432499,9 @@ ${lanes.join("\n")}
                   const sourceIsOptional = !!(propName && (getPropertyOfType(source, propName) || unknownSymbol).flags & 16777216);
                   targetPropType = removeMissingType(targetPropType, targetIsOptional);
                   sourcePropType = removeMissingType(sourcePropType, targetIsOptional && sourceIsOptional);
-                  const result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage2, containingMessageChain, resultObj);
+                  const result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj);
                   if (result && specificSource !== sourcePropType) {
-                    checkTypeRelatedTo(sourcePropType, targetPropType, relation, prop, errorMessage2, containingMessageChain, resultObj);
+                    checkTypeRelatedTo(sourcePropType, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj);
                   }
                 }
                 if (resultObj.errors) {
@@ -432548,7 +432548,7 @@ ${lanes.join("\n")}
           ) : void 0;
           let reportedError = false;
           for (let status = iterator.next(); !status.done; status = iterator.next()) {
-            const { errorNode: prop, innerExpression: next, nameType, errorMessage: errorMessage2 } = status.value;
+            const { errorNode: prop, innerExpression: next, nameType, errorMessage } = status.value;
             let targetPropType = iterationType;
             const targetIndexedPropType = tupleOrArrayLikeTargetParts !== neverType ? getBestMatchIndexedAccessTypeOrUndefined(source, tupleOrArrayLikeTargetParts, nameType) : void 0;
             if (targetIndexedPropType && !(targetIndexedPropType.flags & 33554432)) {
@@ -432592,9 +432592,9 @@ ${lanes.join("\n")}
                   const sourceIsOptional = !!(propName && (getPropertyOfType(source, propName) || unknownSymbol).flags & 16777216);
                   targetPropType = removeMissingType(targetPropType, targetIsOptional);
                   sourcePropType = removeMissingType(sourcePropType, targetIsOptional && sourceIsOptional);
-                  const result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage2, containingMessageChain, resultObj);
+                  const result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj);
                   if (result && specificSource !== sourcePropType) {
-                    checkTypeRelatedTo(sourcePropType, targetPropType, relation, prop, errorMessage2, containingMessageChain, resultObj);
+                    checkTypeRelatedTo(sourcePropType, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj);
                   }
                 }
               }
@@ -443619,9 +443619,9 @@ ${lanes.join("\n")}
             return void 0;
           }
           const isClassic = getEmitModuleResolutionKind(compilerOptions) === 1;
-          const errorMessage2 = isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option : Diagnostics.This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed;
+          const errorMessage = isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option : Diagnostics.This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed;
           const specifier = getJSXRuntimeImportSpecifier(file, runtimeImportSpecifier);
-          const mod3 = resolveExternalModule(specifier || location, runtimeImportSpecifier, errorMessage2, location);
+          const mod3 = resolveExternalModule(specifier || location, runtimeImportSpecifier, errorMessage, location);
           const result = mod3 && mod3 !== unknownSymbol ? getMergedSymbol(resolveSymbol(mod3)) : void 0;
           if (links3) {
             links3.jsxImplicitImportContainer = result || false;
@@ -455325,7 +455325,7 @@ ${lanes.join("\n")}
               if (baseDeclarationFlags & 2 || derivedDeclarationFlags & 2) {
                 continue;
               }
-              let errorMessage2;
+              let errorMessage;
               const basePropertyFlags = base3.flags & 98308;
               const derivedPropertyFlags = derived.flags & 98308;
               if (basePropertyFlags && derivedPropertyFlags) {
@@ -455335,16 +455335,16 @@ ${lanes.join("\n")}
                 const overriddenInstanceProperty = basePropertyFlags !== 4 && derivedPropertyFlags === 4;
                 const overriddenInstanceAccessor = basePropertyFlags === 4 && derivedPropertyFlags !== 4;
                 if (overriddenInstanceProperty || overriddenInstanceAccessor) {
-                  const errorMessage22 = overriddenInstanceProperty ? Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property : Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor;
-                  error2(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage22, symbolToString(base3), typeToString(baseType), typeToString(type));
+                  const errorMessage2 = overriddenInstanceProperty ? Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property : Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor;
+                  error2(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage2, symbolToString(base3), typeToString(baseType), typeToString(type));
                 } else if (useDefineForClassFields) {
                   const uninitialized = (_d = derived.declarations) == null ? void 0 : _d.find((d2) => d2.kind === 173 && !d2.initializer);
                   if (uninitialized && !(derived.flags & 33554432) && !(baseDeclarationFlags & 64) && !(derivedDeclarationFlags & 64) && !((_e = derived.declarations) == null ? void 0 : _e.some((d2) => !!(d2.flags & 33554432)))) {
                     const constructor = findConstructorDeclaration(getClassLikeDeclarationOfSymbol(type.symbol));
                     const propName = uninitialized.name;
                     if (uninitialized.exclamationToken || !constructor || !isIdentifier(propName) || !strictNullChecks || !isPropertyInitializedInConstructor(propName, type, constructor)) {
-                      const errorMessage22 = Diagnostics.Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration;
-                      error2(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage22, symbolToString(base3), typeToString(baseType));
+                      const errorMessage2 = Diagnostics.Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration;
+                      error2(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage2, symbolToString(base3), typeToString(baseType));
                     }
                   }
                 }
@@ -455354,14 +455354,14 @@ ${lanes.join("\n")}
                   continue;
                 } else {
                   Debug.assert(!!(derived.flags & 98304));
-                  errorMessage2 = Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor;
+                  errorMessage = Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor;
                 }
               } else if (base3.flags & 98304) {
-                errorMessage2 = Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function;
+                errorMessage = Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function;
               } else {
-                errorMessage2 = Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function;
+                errorMessage = Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function;
               }
-              error2(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage2, typeToString(baseType), symbolToString(base3), typeToString(type));
+              error2(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage, typeToString(baseType), symbolToString(base3), typeToString(type));
             }
           }
           for (const [errorNode, memberInfo] of notImplementedInfo) {
@@ -456368,10 +456368,10 @@ ${lanes.join("\n")}
           }
           return false;
         }
-        function checkGrammarModuleElementContext(node, errorMessage2) {
+        function checkGrammarModuleElementContext(node, errorMessage) {
           const isInAppropriateContext = node.parent.kind === 308 || node.parent.kind === 269 || node.parent.kind === 268;
           if (!isInAppropriateContext) {
-            grammarErrorOnFirstToken(node, errorMessage2);
+            grammarErrorOnFirstToken(node, errorMessage);
           }
           return !isInAppropriateContext;
         }
@@ -494595,17 +494595,17 @@ ${lanes.join("\n")}
         function createDirectoryWatcherWithLogging(file, cb, flags, options2, detailInfo1, detailInfo2) {
           const watchInfo = `DirectoryWatcher:: Added:: ${getWatchInfo(file, flags, options2, detailInfo1, detailInfo2, getDetailWatchInfo2)}`;
           log22(watchInfo);
-          const start2 = timestamp2();
+          const start2 = timestamp();
           const watcher = triggerInvokingFactory.watchDirectory(file, cb, flags, options2, detailInfo1, detailInfo2);
-          const elapsed = timestamp2() - start2;
+          const elapsed = timestamp() - start2;
           log22(`Elapsed:: ${elapsed}ms ${watchInfo}`);
           return {
             close: () => {
               const watchInfo2 = `DirectoryWatcher:: Close:: ${getWatchInfo(file, flags, options2, detailInfo1, detailInfo2, getDetailWatchInfo2)}`;
               log22(watchInfo2);
-              const start22 = timestamp2();
+              const start22 = timestamp();
               watcher.close();
-              const elapsed2 = timestamp2() - start22;
+              const elapsed2 = timestamp() - start22;
               log22(`Elapsed:: ${elapsed2}ms ${watchInfo2}`);
             }
           };
@@ -494618,13 +494618,13 @@ ${lanes.join("\n")}
             (...args) => {
               const triggerredInfo = `${key === "watchFile" ? "FileWatcher" : "DirectoryWatcher"}:: Triggered with ${args[0]} ${args[1] !== void 0 ? args[1] : ""}:: ${getWatchInfo(file, flags, options2, detailInfo1, detailInfo2, getDetailWatchInfo2)}`;
               log22(triggerredInfo);
-              const start2 = timestamp2();
+              const start2 = timestamp();
               cb.call(
                 /*thisArg*/
                 void 0,
                 ...args
               );
-              const elapsed = timestamp2() - start2;
+              const elapsed = timestamp() - start2;
               log22(`Elapsed:: ${elapsed}ms ${triggerredInfo}`);
             },
             flags,
@@ -494898,14 +494898,14 @@ ${lanes.join("\n")}
         return output2;
       }
       function formatDiagnostic(diagnostic, host2) {
-        const errorMessage2 = `${diagnosticCategoryName(diagnostic)} TS${diagnostic.code}: ${flattenDiagnosticMessageText(diagnostic.messageText, host2.getNewLine())}${host2.getNewLine()}`;
+        const errorMessage = `${diagnosticCategoryName(diagnostic)} TS${diagnostic.code}: ${flattenDiagnosticMessageText(diagnostic.messageText, host2.getNewLine())}${host2.getNewLine()}`;
         if (diagnostic.file) {
           const { line, character } = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
           const fileName = diagnostic.file.fileName;
           const relativeFileName = convertToRelativePath(fileName, host2.getCurrentDirectory(), (fileName2) => host2.getCanonicalFileName(fileName2));
-          return `${relativeFileName}(${line + 1},${character + 1}): ` + errorMessage2;
+          return `${relativeFileName}(${line + 1},${character + 1}): ` + errorMessage;
         }
-        return errorMessage2;
+        return errorMessage;
       }
       var ForegroundColorEscapeSequences = /* @__PURE__ */ ((ForegroundColorEscapeSequences2) => {
         ForegroundColorEscapeSequences2["Grey"] = "\x1B[90m";
@@ -511483,7 +511483,7 @@ ${lanes.join("\n")}
         ));
         const autoImportProvider = useAutoImportProvider && ((_a2 = host2.getPackageJsonAutoImportProvider) == null ? void 0 : _a2.call(host2));
         if (autoImportProvider) {
-          const start2 = timestamp2();
+          const start2 = timestamp();
           const checker = program.getTypeChecker();
           forEachExternalModule(autoImportProvider.getTypeChecker(), autoImportProvider.getSourceFiles(), excludePatterns, host2, (module22, file) => {
             if (file && !program.getSourceFile(file.fileName) || !file && !checker.resolveName(
@@ -511503,7 +511503,7 @@ ${lanes.join("\n")}
               );
             }
           });
-          (_b = host2.log) == null ? void 0 : _b.call(host2, `forEachExternalModuleToImportFrom autoImportProvider: ${timestamp2() - start2}`);
+          (_b = host2.log) == null ? void 0 : _b.call(host2, `forEachExternalModuleToImportFrom autoImportProvider: ${timestamp() - start2}`);
         }
       }
       function getIsExcludedPatterns(preferences, useCaseSensitiveFileNames2) {
@@ -511558,7 +511558,7 @@ ${lanes.join("\n")}
       }
       function getExportInfoMap(importingFile, host2, program, preferences, cancellationToken) {
         var _a2, _b, _c, _d, _e;
-        const start2 = timestamp2();
+        const start2 = timestamp();
         (_a2 = host2.getPackageJsonAutoImportProvider) == null ? void 0 : _a2.call(host2);
         const cache8 = ((_b = host2.getCachedExportInfoMap) == null ? void 0 : _b.call(host2)) || createCacheableExportInfoMap({
           getCurrentProgram: () => program,
@@ -511621,7 +511621,7 @@ ${lanes.join("\n")}
           cache8.clear();
           throw err;
         }
-        (_e = host2.log) == null ? void 0 : _e.call(host2, `getExportInfoMap: done in ${timestamp2() - start2} ms`);
+        (_e = host2.log) == null ? void 0 : _e.call(host2, `getExportInfoMap: done in ${timestamp() - start2} ms`);
         return cache8;
       }
       function getDefaultLikeExportInfo(moduleSymbol, checker) {
@@ -522252,7 +522252,7 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
           this.lastCancellationCheckTime = 0;
         }
         isCancellationRequested() {
-          const time = timestamp2();
+          const time = timestamp();
           const duration = Math.abs(time - this.lastCancellationCheckTime);
           if (duration >= this.throttleWaitMilliseconds) {
             this.lastCancellationCheckTime = time;
@@ -523076,13 +523076,13 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
           return match ? [createTextSpanFromNode(token, sourceFile), createTextSpanFromNode(match, sourceFile)].sort((a2, b) => a2.start - b.start) : emptyArray;
         }
         function getIndentationAtPosition(fileName, position, editorOptions) {
-          let start2 = timestamp2();
+          let start2 = timestamp();
           const settings = toEditorSettings(editorOptions);
           const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
-          log22("getIndentationAtPosition: getCurrentSourceFile: " + (timestamp2() - start2));
-          start2 = timestamp2();
+          log22("getIndentationAtPosition: getCurrentSourceFile: " + (timestamp() - start2));
+          start2 = timestamp();
           const result = ts_formatting_exports.SmartIndenter.getIndentation(position, sourceFile, settings);
-          log22("getIndentationAtPosition: computeIndentation  : " + (timestamp2() - start2));
+          log22("getIndentationAtPosition: computeIndentation  : " + (timestamp() - start2));
           return result;
         }
         function getFormattingEditsForRange(fileName, start2, end, options2) {
@@ -536800,7 +536800,7 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
       }
       function resolvingModuleSpecifiers(logPrefix, host2, resolver, program, position, preferences, isForImportStatementCompletion, isValidTypeOnlyUseSite, cb) {
         var _a2, _b, _c, _d;
-        const start2 = timestamp2();
+        const start2 = timestamp();
         const needsFullResolution = isForImportStatementCompletion || getResolvePackageJsonExports(program.getCompilerOptions()) || ((_a2 = preferences.autoImportSpecifierExcludeRegexes) == null ? void 0 : _a2.length);
         let skippedAny = false;
         let ambientCount = 0;
@@ -536816,7 +536816,7 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
         const hitRateMessage = cacheAttemptCount ? ` (${(resolvedFromCacheCount / cacheAttemptCount * 100).toFixed(1)}% hit rate)` : "";
         (_b = host2.log) == null ? void 0 : _b.call(host2, `${logPrefix}: resolved ${resolvedCount} module specifiers, plus ${ambientCount} ambient and ${resolvedFromCacheCount} from cache${hitRateMessage}`);
         (_c = host2.log) == null ? void 0 : _c.call(host2, `${logPrefix}: response is ${skippedAny ? "incomplete" : "complete"}`);
-        (_d = host2.log) == null ? void 0 : _d.call(host2, `${logPrefix}: ${timestamp2() - start2}`);
+        (_d = host2.log) == null ? void 0 : _d.call(host2, `${logPrefix}: ${timestamp() - start2}`);
         return result;
         function tryResolve(exportInfo, isFromAmbientModule) {
           if (isFromAmbientModule) {
@@ -538403,7 +538403,7 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
         }
       }
       function getCompletionEntriesFromSymbols(symbols, entries2, replacementToken, contextToken, location, position, sourceFile, host2, program, target, log22, kind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importStatementCompletion, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextMap, isJsxIdentifierExpected, isRightOfOpenTag, includeSymbol = false) {
-        const start2 = timestamp2();
+        const start2 = timestamp();
         const closestSymbolDeclaration = getClosestSymbolDeclaration(contextToken, location);
         const useSemicolons = probablyUsesSemicolons(sourceFile);
         const typeChecker = program.getTypeChecker();
@@ -538462,7 +538462,7 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
             true
           );
         }
-        log22("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (timestamp2() - start2));
+        log22("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (timestamp() - start2));
         return {
           has: (name10) => uniques.has(name10),
           add: (name10) => uniques.set(name10, true)
@@ -538885,12 +538885,12 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
       function getCompletionData(program, log22, sourceFile, compilerOptions, position, preferences, detailsEntryId, host2, formatContext, cancellationToken) {
         const typeChecker = program.getTypeChecker();
         const inCheckedFile = isCheckedFile(sourceFile, compilerOptions);
-        let start2 = timestamp2();
+        let start2 = timestamp();
         let currentToken = getTokenAtPosition(sourceFile, position);
-        log22("getCompletionData: Get current token: " + (timestamp2() - start2));
-        start2 = timestamp2();
+        log22("getCompletionData: Get current token: " + (timestamp() - start2));
+        start2 = timestamp();
         const insideComment = isInComment(sourceFile, position, currentToken);
-        log22("getCompletionData: Is inside comment: " + (timestamp2() - start2));
+        log22("getCompletionData: Is inside comment: " + (timestamp() - start2));
         let insideJsDocTagTypeExpression = false;
         let insideJsDocImportTag = false;
         let isInSnippetScope = false;
@@ -538939,12 +538939,12 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
             return void 0;
           }
         }
-        start2 = timestamp2();
+        start2 = timestamp();
         const isJsOnlyLocation = !insideJsDocTagTypeExpression && !insideJsDocImportTag && isSourceFileJS(sourceFile);
         const tokens3 = getRelevantTokens(position, sourceFile);
         const previousToken = tokens3.previousToken;
         let contextToken = tokens3.contextToken;
-        log22("getCompletionData: Get previous token: " + (timestamp2() - start2));
+        log22("getCompletionData: Get previous token: " + (timestamp() - start2));
         let node = currentToken;
         let propertyAccessToConvert;
         let isRightOfDot = false;
@@ -539077,7 +539077,7 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
             }
           }
         }
-        const semanticStart = timestamp2();
+        const semanticStart = timestamp();
         let completionKind = 5;
         let hasUnresolvedAutoImports = false;
         let symbols = [];
@@ -539110,7 +539110,7 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
             return keywordFilters ? keywordCompletionData(keywordFilters, isJsOnlyLocation, isNewIdentifierLocation) : void 0;
           }
         }
-        log22("getCompletionData: Semantic work: " + (timestamp2() - semanticStart));
+        log22("getCompletionData: Semantic work: " + (timestamp() - semanticStart));
         const contextualTypeOrConstraint = previousToken && (getContextualType(previousToken, position, sourceFile, typeChecker) ?? getConstraintOfTypeArgumentProperty(previousToken, typeChecker));
         const isLiteralExpected = !tryCast(previousToken, isStringLiteralLike) && !isJsxIdentifierExpected;
         const literals = !isLiteralExpected ? [] : mapDefined(
@@ -539655,9 +539655,9 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
           return scope;
         }
         function isCompletionListBlocker(contextToken2) {
-          const start22 = timestamp2();
+          const start22 = timestamp();
           const result = isInStringOrRegularExpressionOrTemplateLiteral(contextToken2) || isSolelyIdentifierDefinitionLocation(contextToken2) || isDotOfNumericLiteral(contextToken2) || isInJsxText(contextToken2) || isBigIntLiteral(contextToken2);
-          log22("getCompletionsAtPosition: isCompletionListBlocker: " + (timestamp2() - start22));
+          log22("getCompletionsAtPosition: isCompletionListBlocker: " + (timestamp() - start22));
           return result;
         }
         function isInJsxText(contextToken2) {
@@ -557240,7 +557240,7 @@ ${options2.prefix}` : "\n" : options2.prefix
         textSpanOverlapsWith: () => textSpanOverlapsWith,
         textSpansEqual: () => textSpansEqual,
         textToKeywordObj: () => textToKeywordObj,
-        timestamp: () => timestamp2,
+        timestamp: () => timestamp,
         toArray: () => toArray,
         toBuilderFileEmit: () => toBuilderFileEmit,
         toBuilderStateFileInfoForMultiEmit: () => toBuilderStateFileInfoForMultiEmit,
@@ -559959,7 +559959,7 @@ ${options2.prefix}` : "\n" : options2.prefix
           Debug.assert(oldProgram === this.program);
           Debug.assert(!this.isClosed(), "Called update graph worker of closed project");
           this.writeLog(`Starting updateGraphWorker: Project: ${this.getProjectName()}`);
-          const start2 = timestamp2();
+          const start2 = timestamp();
           const { hasInvalidatedResolutions, hasInvalidatedLibResolutions } = this.resolutionCache.createHasInvalidatedResolutions(returnFalse, returnFalse);
           this.hasInvalidatedResolutions = hasInvalidatedResolutions;
           this.hasInvalidatedLibResolutions = hasInvalidatedLibResolutions;
@@ -560065,7 +560065,7 @@ ${options2.prefix}` : "\n" : options2.prefix
             },
             (removed) => this.detachScriptInfoFromProject(removed)
           );
-          const elapsed = timestamp2() - start2;
+          const elapsed = timestamp() - start2;
           this.sendPerformanceEvent("UpdateGraph", elapsed);
           this.writeLog(`Finishing updateGraphWorker: Project: ${this.getProjectName()} projectStateVersion: ${this.projectStateVersion} projectProgramVersion: ${this.projectProgramVersion} structureChanged: ${hasNewProgram}${this.program ? ` structureIsReused:: ${StructureIsReused[this.program.structureIsReused]}` : ""} Elapsed: ${elapsed}ms`);
           if (this.projectService.logger.isTestLogger) {
@@ -560535,7 +560535,7 @@ ${options2.prefix}` : "\n" : options2.prefix
           const dependencySelection = this.includePackageJsonAutoImports();
           if (dependencySelection) {
             (_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Session, "getPackageJsonAutoImportProvider");
-            const start2 = timestamp2();
+            const start2 = timestamp();
             this.autoImportProviderHost = AutoImportProviderProject.create(
               dependencySelection,
               this,
@@ -560543,7 +560543,7 @@ ${options2.prefix}` : "\n" : options2.prefix
             ) ?? false;
             if (this.autoImportProviderHost) {
               updateProjectIfDirty(this.autoImportProviderHost);
-              this.sendPerformanceEvent("CreatePackageJsonAutoImportProvider", timestamp2() - start2);
+              this.sendPerformanceEvent("CreatePackageJsonAutoImportProvider", timestamp() - start2);
               (_b = tracing) == null ? void 0 : _b.pop();
               return this.autoImportProviderHost.getCurrentProgram();
             }
@@ -560786,7 +560786,7 @@ ${options2.prefix}` : "\n" : options2.prefix
           if (!program) {
             return emptyArray;
           }
-          const start2 = timestamp2();
+          const start2 = timestamp();
           let dependencyNames;
           let rootNames;
           const rootFileName = combinePaths(hostProject.currentDirectory, inferredTypesContainingFile);
@@ -560878,7 +560878,7 @@ ${options2.prefix}` : "\n" : options2.prefix
             });
           }
           if (rootNames == null ? void 0 : rootNames.size) {
-            hostProject.log(`AutoImportProviderProject: found ${rootNames.size} root files in ${dependenciesAdded} dependencies ${referencesAddded} referenced projects in ${timestamp2() - start2} ms`);
+            hostProject.log(`AutoImportProviderProject: found ${rootNames.size} root files in ${dependenciesAdded} dependencies ${referencesAddded} referenced projects in ${timestamp() - start2} ms`);
           }
           return rootNames ? arrayFrom(rootNames.values()) : emptyArray;
           function addRootNames(entrypoints) {
@@ -567219,7 +567219,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
         }
         semanticCheck(file, project) {
           var _a2, _b;
-          const diagnosticsStartTime = timestamp2();
+          const diagnosticsStartTime = timestamp();
           (_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Session, "semanticCheck", { file, configFilePath: project.canonicalConfigFilePath });
           const diags = isDeclarationFileInJSOnlyNonConfiguredProject(project, file) ? emptyArray2 : project.getLanguageService().getSemanticDiagnostics(file).filter((d2) => !!d2.file);
           this.sendDiagnosticsEvent(file, project, diags, "semanticDiag", diagnosticsStartTime);
@@ -567227,21 +567227,21 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
         }
         syntacticCheck(file, project) {
           var _a2, _b;
-          const diagnosticsStartTime = timestamp2();
+          const diagnosticsStartTime = timestamp();
           (_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Session, "syntacticCheck", { file, configFilePath: project.canonicalConfigFilePath });
           this.sendDiagnosticsEvent(file, project, project.getLanguageService().getSyntacticDiagnostics(file), "syntaxDiag", diagnosticsStartTime);
           (_b = tracing) == null ? void 0 : _b.pop();
         }
         suggestionCheck(file, project) {
           var _a2, _b;
-          const diagnosticsStartTime = timestamp2();
+          const diagnosticsStartTime = timestamp();
           (_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Session, "suggestionCheck", { file, configFilePath: project.canonicalConfigFilePath });
           this.sendDiagnosticsEvent(file, project, project.getLanguageService().getSuggestionDiagnostics(file), "suggestionDiag", diagnosticsStartTime);
           (_b = tracing) == null ? void 0 : _b.pop();
         }
         regionSemanticCheck(file, project, ranges) {
           var _a2, _b, _c;
-          const diagnosticsStartTime = timestamp2();
+          const diagnosticsStartTime = timestamp();
           (_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Session, "regionSemanticCheck", { file, configFilePath: project.canonicalConfigFilePath });
           let diagnosticsResult;
           if (!this.shouldDoRegionCheck(file) || !(diagnosticsResult = project.getLanguageService().getRegionSemanticDiagnostics(file, ranges))) {
@@ -567263,7 +567263,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
         sendDiagnosticsEvent(file, project, diagnostics, kind, diagnosticsStartTime, spans) {
           try {
             const scriptInfo = Debug.checkDefined(project.getScriptInfo(file));
-            const duration = timestamp2() - diagnosticsStartTime;
+            const duration = timestamp() - diagnosticsStartTime;
             const body = {
               file,
               diagnostics: diagnostics.map((diag2) => formatDiag(file, project, diag2)),
@@ -575662,9 +575662,9 @@ ${nodeLocation}` : message2;
           throw new ArgumentError(argName, "Expected a non-negative value.");
       }
       errors.throwIfNegative = throwIfNegative;
-      function throwIfNullOrUndefined(value2, errorMessage2, node) {
+      function throwIfNullOrUndefined(value2, errorMessage, node) {
         if (value2 == null)
-          throw new InvalidOperationError(typeof errorMessage2 === "string" ? errorMessage2 : errorMessage2(), node);
+          throw new InvalidOperationError(typeof errorMessage === "string" ? errorMessage : errorMessage(), node);
         return value2;
       }
       errors.throwIfNullOrUndefined = throwIfNullOrUndefined;
@@ -575680,9 +575680,9 @@ ${nodeLocation}` : message2;
           throw new InvalidOperationError(`Expected ${actual} to equal ${expected}. ${description}`);
       }
       errors.throwIfNotEqual = throwIfNotEqual;
-      function throwIfTrue(value2, errorMessage2) {
+      function throwIfTrue(value2, errorMessage) {
         if (value2 === true)
-          throw new InvalidOperationError(errorMessage2);
+          throw new InvalidOperationError(errorMessage);
       }
       errors.throwIfTrue = throwIfTrue;
     })(exports.errors || (exports.errors = {}));
@@ -581649,8 +581649,8 @@ var require_ts_morph = __commonJS({
       filePath;
       oldText;
       newText;
-      constructor(filePath, oldText, newText, errorMessage2) {
-        super(errorMessage2);
+      constructor(filePath, oldText, newText, errorMessage) {
+        super(errorMessage);
         this.filePath = filePath;
         this.oldText = oldText;
         this.newText = newText;
@@ -614913,10 +614913,10 @@ var init_video_understand = __esm({
             for (let i2 = 0; i2 < frameFiles.length; i2++) {
               const framePath = join97(framesDir, frameFiles[i2]);
               const hash2 = imageHash(framePath);
-              const timestamp3 = duration > 0 ? i2 / Math.max(1, frameFiles.length - 1) * duration : i2 * frameInterval;
+              const timestamp2 = duration > 0 ? i2 / Math.max(1, frameFiles.length - 1) * duration : i2 * frameInterval;
               frames.push({
                 path: framePath,
-                timestamp: timestamp3,
+                timestamp: timestamp2,
                 hash: hash2,
                 isDuplicate: false
               });
@@ -614966,8 +614966,8 @@ var init_video_understand = __esm({
             frames: frames.filter((f2) => !f2.isDuplicate),
             alignedTimeline
           };
-          const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-          const resultFile = join97(outDir, `understanding-${timestamp2}.json`);
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+          const resultFile = join97(outDir, `understanding-${timestamp}.json`);
           writeFileSync46(resultFile, JSON.stringify(result, null, 2), "utf-8");
           try {
             const memDir = join97(this.workingDir, ".omnius", "memory");
@@ -621117,7 +621117,7 @@ import { z } from "zod";
 function validateManifest(data, source) {
   const result = manifestSchema.safeParse(data);
   if (!result.success) {
-    const errors = result.error.issues.map((issue3) => `  - ${issue3.path.join(".")}: ${issue3.message}`);
+    const errors = result.error.issues.map((issue2) => `  - ${issue2.path.join(".")}: ${issue2.message}`);
     const location = source ? ` in ${source}` : "";
     throw new Error(`Invalid plugin manifest${location}:
 ${errors.join("\n")}
@@ -623254,7 +623254,7 @@ var init_operational_world = __esm({
       issues: z16.array(OperationalValidationIssueSchema).max(1e4),
       checkedAt: z16.string().datetime()
     }).strict().superRefine((result, ctx3) => {
-      const hasErrors = result.issues.some((issue3) => issue3.severity === "error");
+      const hasErrors = result.issues.some((issue2) => issue2.severity === "error");
       if (result.valid !== (result.status === "pass")) {
         ctx3.addIssue({
           code: "custom",
@@ -624521,7 +624521,7 @@ var init_ralphLoop = __esm({
       // -------------------------------------------------------------------------
       // Private: error report builder
       // -------------------------------------------------------------------------
-      buildErrorReport(task, rawRequest, repoRoot, startedAt2, errorMessage2) {
+      buildErrorReport(task, rawRequest, repoRoot, startedAt2, errorMessage) {
         const fallbackTask = task ?? {
           id: `task-error-${Date.now()}`,
           goal: rawRequest.slice(0, 200),
@@ -624543,7 +624543,7 @@ var init_ralphLoop = __esm({
           subtaskExecutions: [],
           startedAt: startedAt2,
           completedAt: isoNow(),
-          summary: errorMessage2,
+          summary: errorMessage,
           filesChanged: []
         };
       }
@@ -633170,7 +633170,7 @@ function inspectDeliveryCoverageManifest(workspace) {
     if (parsed.success) {
       return { status: "valid", manifest: parsed.data, path: path16 };
     }
-    const error = parsed.error.issues.slice(0, 8).map((issue3) => `${issue3.path.join(".") || "manifest"}: ${issue3.message}`).join("; ").slice(0, 1600);
+    const error = parsed.error.issues.slice(0, 8).map((issue2) => `${issue2.path.join(".") || "manifest"}: ${issue2.message}`).join("; ").slice(0, 1600);
     return {
       status: "invalid",
       path: path16,
@@ -642770,11 +642770,11 @@ function recordContextWindowDump(input) {
   if (process.env["OMNIUS_DISABLE_CONTEXT_WINDOW_DUMPS"] === "1")
     return null;
   const cwd4 = resolve59(input.cwd || process.cwd());
-  const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const sessionId = safeId(input.sessionId || process.env["OMNIUS_SESSION_ID"] || "unknown-session");
   const runId = safeId(input.runId || input.sessionId || "unknown-run");
   const stable2 = [
-    timestamp2,
+    timestamp,
     input.source,
     input.stage,
     input.agentType,
@@ -642782,7 +642782,7 @@ function recordContextWindowDump(input) {
     String(input.turn ?? ""),
     String(input.attempt ?? "")
   ].join("|");
-  const id2 = `${timestamp2.replace(/[:.]/g, "-")}-${input.agentType}-${shortHash4(stable2)}`;
+  const id2 = `${timestamp.replace(/[:.]/g, "-")}-${input.agentType}-${shortHash4(stable2)}`;
   const metrics2 = analyzeContextWindowDumpRequest(input.request);
   const requestBudget = input.requestBudget && budgetMatchesOutboundRequest(input.requestBudget, input.request) ? input.requestBudget : compileOutboundRequestBudget({
     messages: Array.isArray(input.request["messages"]) ? input.request["messages"] : [],
@@ -642795,7 +642795,7 @@ function recordContextWindowDump(input) {
   const record = {
     schemaVersion: 1,
     id: id2,
-    timestamp: timestamp2,
+    timestamp,
     source: input.source,
     stage: input.stage,
     agentType: input.agentType,
@@ -644534,9 +644534,9 @@ function validateCandidateRepresentation(candidate, record, claimRecords) {
   if (isArtifactRecord(record)) {
     if (!candidate.artifact)
       return `artifact candidate ${candidate.id} lacks a durable artifact reference`;
-    const issue3 = referenceMatchesRecord(candidate.artifact, record);
-    if (issue3)
-      return `candidate ${candidate.id} ${issue3}`;
+    const issue2 = referenceMatchesRecord(candidate.artifact, record);
+    if (issue2)
+      return `candidate ${candidate.id} ${issue2}`;
   } else if (candidate.artifact) {
     return `non-artifact candidate ${candidate.id} may not claim an artifact reference`;
   }
@@ -644601,9 +644601,9 @@ function validateMemoryCompilationPlan(input) {
     return planHold(input, ["orientation exceeds bounded working-set limit"], planById);
   for (const [id2, candidate] of planById) {
     const record = candidateById.get(id2);
-    const issue3 = validateCandidateRepresentation(candidate, record, candidateById);
-    if (issue3)
-      return planHold(input, [issue3], planById);
+    const issue2 = validateCandidateRepresentation(candidate, record, candidateById);
+    if (issue2)
+      return planHold(input, [issue2], planById);
     if ((record.authority === "system" || record.authority === "user") && candidate.disposition !== "retain_full") {
       return planHold(input, [`authority record ${id2} must be retained in full`], planById);
     }
@@ -644712,10 +644712,10 @@ function recordDebugToolEvent(input) {
   });
   if (!shouldRecordToolEvent(input, diagnoses))
     return null;
-  const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const argsHash = shortHash5(argsPreview);
   const eventId = [
-    timestamp2.replace(/[:.]/g, "-"),
+    timestamp.replace(/[:.]/g, "-"),
     safeId2(input.toolName),
     argsHash
   ].join("-");
@@ -644736,7 +644736,7 @@ function recordDebugToolEvent(input) {
     schemaVersion: 1,
     id: eventId,
     kind: lifecycle === "started" ? "tool_attempt" : "tool_result",
-    timestamp: timestamp2,
+    timestamp,
     runId,
     sessionId,
     cwd: cwd4,
@@ -644794,10 +644794,10 @@ function recordDebugContextWindowDump(input) {
   const runId = safeId2(input.runId || input.record.runId || input.record.sessionId);
   const sessionId = safeId2(input.sessionId || input.record.sessionId || runId);
   const paths = debugRunPaths(cwd4, runId, input.stateDir);
-  const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const contextPath = join124(cwd4, ".omnius", "context-window-dumps", `${input.record.id}.json`);
   const eventId = [
-    timestamp2.replace(/[:.]/g, "-"),
+    timestamp.replace(/[:.]/g, "-"),
     "context",
     shortHash5(input.record.id)
   ].join("-");
@@ -644808,7 +644808,7 @@ function recordDebugContextWindowDump(input) {
     schemaVersion: 1,
     id: eventId,
     kind: "context_window_dump",
-    timestamp: timestamp2,
+    timestamp,
     runId,
     sessionId,
     cwd: cwd4,
@@ -644848,10 +644848,10 @@ function recordDebugTrajectoryCheckpoint(input) {
   const cwd4 = resolve60(input.cwd || process.cwd());
   const runId = safeId2(input.runId || input.sessionId || "unknown-run");
   const sessionId = safeId2(input.sessionId || runId);
-  const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const paths = debugRunPaths(cwd4, runId, input.stateDir);
   const eventId = [
-    timestamp2.replace(/[:.]/g, "-"),
+    timestamp.replace(/[:.]/g, "-"),
     "trajectory",
     shortHash5(checkpoint.id)
   ].join("-");
@@ -644865,7 +644865,7 @@ function recordDebugTrajectoryCheckpoint(input) {
     schemaVersion: 1,
     id: eventId,
     kind: "trajectory_checkpoint",
-    timestamp: timestamp2,
+    timestamp,
     runId,
     sessionId,
     cwd: cwd4,
@@ -647467,10 +647467,10 @@ function computeStalenessLoad(messages2, currentTurn, stalenessThresholds) {
   const staleSpanIds = [];
   const detailParts = [];
   for (const m2 of timed) {
-    const { span_id, token_count, timestamp: timestamp2, provenance } = m2.spanMeta;
+    const { span_id, token_count, timestamp, provenance } = m2.spanMeta;
     const tok = typeof token_count === "number" && !Number.isNaN(token_count) ? token_count : 0;
     totalTokens += tok;
-    const pos = (timestamp2 - minTs) / totalSpan;
+    const pos = (timestamp - minTs) / totalSpan;
     const estimatedTurn = 1 + pos * (currentTurn - 1);
     const turnAge = currentTurn - estimatedTurn;
     const type = classifyProvenance(provenance);
@@ -655034,13 +655034,13 @@ runtime_module_sha256=${record.runtimeProvenance.module.sha256 ?? "unknown"}`
             }
           };
           commitCompletionFinalization(stateDir, committed);
-          const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
           this.emit({
             type: "complete",
             content: input.summary,
             success: input.status === "completed",
             terminalReceiptId: committed.id,
-            timestamp: timestamp2
+            timestamp
           });
           this._onTypedEvent?.({
             type: "run_finished",
@@ -655048,7 +655048,7 @@ runtime_module_sha256=${record.runtimeProvenance.module.sha256 ?? "unknown"}`
             status: input.status,
             success: input.status === "completed",
             terminalReceiptId: committed.id,
-            timestamp: timestamp2
+            timestamp
           });
           return committed;
         } catch {
@@ -668745,8 +668745,8 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
               if (process.env["OMNIUS_DISABLE_ADAPTIVE_RETRIEVAL"] !== "1") {
                 const goalForSig = (this._taskState.goal || "").slice(0, 200);
                 const recentTools = this._toolSequence.slice(-5).join("|");
-                const { createHash: createHash82 } = await import("node:crypto");
-                const sig = createHash82("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
+                const { createHash: createHash81 } = await import("node:crypto");
+                const sig = createHash81("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
                 if (this._lastPprSig === sig && this._lastPprMemoryLines.length > 0) {
                   compacted.push({
                     role: "system",
@@ -673971,19 +673971,19 @@ ${terminalFeedback.slice(0, 4e3)}`,
           summary = summary ? `${summary}
 
 ${detail}` : detail;
-          const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
           this.emit({
             type: "complete",
             content: summary,
             success: false,
-            timestamp: timestamp2
+            timestamp
           });
           this._onTypedEvent?.({
             type: "run_finished",
             runId: this.currentArtifactRunId(),
             status: runStatus,
             success: false,
-            timestamp: timestamp2
+            timestamp
           });
         }
         this._emitMASTSummary("run-end");
@@ -677250,7 +677250,7 @@ Describe what you see and integrate this into your current approach.` : "[User s
         const postChars = combinedSummary.length + retainedMiddle.reduce((s2, m2) => s2 + _estimateMsgChars(m2), 0) + recent.reduce((s2, m2) => s2 + _estimateMsgChars(m2), 0) + head.reduce((s2, m2) => s2 + _estimateMsgChars(m2), 0);
         const postTokens = Math.ceil(postChars / 4);
         const savedTokens = preTokens - postTokens;
-        const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
         const removedMessages = messages2.slice(headEndIdx, recentStart).map((message2, offset) => ({ message: message2, index: headEndIdx + offset })).filter(({ index }) => analyst.retiredIds.has(`c_${index}`)).map(({ message: message2, index }) => {
           const content = typeof message2.content === "string" ? message2.content : JSON.stringify(message2.content);
           const isLegacy = this._isLegacyControlMessage(message2);
@@ -677268,7 +677268,7 @@ Describe what you see and integrate this into your current approach.` : "[User s
           id: `cmp-${this.currentArtifactRunId()}-${Date.now().toString(36)}`,
           runId: this.currentArtifactRunId(),
           sessionId: this._sessionId,
-          timestamp: timestamp2,
+          timestamp,
           strategy,
           manual: force,
           beforeTokens: preTokens,
@@ -677292,7 +677292,7 @@ Describe what you see and integrate this into your current approach.` : "[User s
         this.emit({
           type: "compaction",
           content: `Inference-compacted ${removedMessages.length} messages${strategyLabel}${forceLabel} | ~${preTokens.toLocaleString()} → ~${postTokens.toLocaleString()} tokens (saved ~${savedTokens.toLocaleString()})`,
-          timestamp: timestamp2,
+          timestamp,
           compaction: compactionAudit
         });
         const tier = this.options.modelTier ?? "large";
@@ -682701,14 +682701,14 @@ function text2(value2, max = 500) {
   return out ? out.slice(0, max) : "";
 }
 function legacyAgenticEventToRunEvent(runId, event) {
-  const timestamp2 = event.timestamp;
+  const timestamp = event.timestamp;
   if (event.type === "assistant_text") {
     return {
       type: "assistant_visible_text",
       runId,
       text: text2(event.content, 8e3),
       source: event["source"] === "task_complete_summary" ? "summary_fallback" : "model",
-      timestamp: timestamp2
+      timestamp
     };
   }
   if (event.type === "tool_call") {
@@ -682718,7 +682718,7 @@ function legacyAgenticEventToRunEvent(runId, event) {
       toolName: text2(event.toolName ?? event["name"], 120),
       callId: typeof event.callId === "string" ? event.callId : void 0,
       argsPreview: text2(event["args"] ?? event.content, 500),
-      timestamp: timestamp2
+      timestamp
     };
   }
   if (event.type === "tool_result") {
@@ -682729,7 +682729,7 @@ function legacyAgenticEventToRunEvent(runId, event) {
       callId: typeof event.callId === "string" ? event.callId : void 0,
       success: event.success === true,
       outputPreview: text2(event.content, 500),
-      timestamp: timestamp2
+      timestamp
     };
   }
   if (event.type === "trajectory_checkpoint") {
@@ -682741,7 +682741,7 @@ function legacyAgenticEventToRunEvent(runId, event) {
       ...typeof trajectory?.["assessment"] === "string" ? { assessment: text2(trajectory["assessment"], 80) } : {},
       ...typeof trajectory?.["nextAction"] === "string" ? { nextAction: text2(trajectory["nextAction"], 500) } : {},
       summary: text2(event.content, 900),
-      timestamp: timestamp2
+      timestamp
     };
   }
   if (event.type === "complete") {
@@ -682752,7 +682752,7 @@ function legacyAgenticEventToRunEvent(runId, event) {
       status: success ? "completed" : "incomplete",
       success,
       ...typeof event["terminalReceiptId"] === "string" ? { terminalReceiptId: event["terminalReceiptId"] } : {},
-      timestamp: timestamp2
+      timestamp
     };
   }
   return null;
@@ -701364,6 +701364,7 @@ var init_steering_stream_filter = __esm({
           if (whitespace > 0) this.buffer = this.buffer.slice(whitespace);
           if (!this.buffer) break;
           const upper = this.buffer.toUpperCase();
+          if (!final2 && upper === CLOSE_STEM) break;
           if (upper.startsWith(CLOSE_STEM)) {
             this.buffer = this.buffer.slice(CLOSE_STEM.length);
             if (this.buffer.startsWith("]")) this.buffer = this.buffer.slice(1);
@@ -703855,7 +703856,7 @@ var require_websocket3 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes32, createHash: createHash82 } = __require("crypto");
+    var { randomBytes: randomBytes32, createHash: createHash81 } = __require("crypto");
     var { Duplex: Duplex3, Readable: Readable2 } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate3();
@@ -704515,7 +704516,7 @@ var require_websocket3 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest4 = createHash82("sha1").update(key + GUID).digest("base64");
+        const digest4 = createHash81("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest4) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -704882,7 +704883,7 @@ var require_websocket_server2 = __commonJS({
     var EventEmitter15 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash82 } = __require("crypto");
+    var { createHash: createHash81 } = __require("crypto");
     var extension3 = require_extension3();
     var PerMessageDeflate3 = require_permessage_deflate3();
     var subprotocol3 = require_subprotocol2();
@@ -705183,7 +705184,7 @@ var require_websocket_server2 = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest4 = createHash82("sha1").update(key + GUID).digest("base64");
+        const digest4 = createHash81("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -718103,9 +718104,9 @@ function computeDedupeHash(task, savedAt) {
   return createHash67("sha256").update(`${task}|${savedAt}`).digest("hex").slice(0, 16);
 }
 function generateSessionId() {
-  const timestamp2 = Date.now().toString(36);
+  const timestamp = Date.now().toString(36);
   const random = Math.random().toString(36).slice(2, 8);
-  return `${timestamp2}-${random}`;
+  return `${timestamp}-${random}`;
 }
 function acquireLock(lockPath) {
   const startTime = Date.now();
@@ -721921,11 +721922,11 @@ function normalizeValueSignature(value2) {
 function trimMemoryValueMetadata(value2) {
   return value2.replace(/\b(?:confidence|weight|salience|score|noise_score|relevance)\s*[=:]\s*\d*\.?\d+\b/gi, "").replace(/\b(?:evidence|sources?|refs?)\s*[=:]\s*[\d,\s]+\b/gi, "").replace(/\bvalue_?hash\s*[=:]\s*[0-9a-f]{8,}\b/gi, "").replace(/[ \t]{2,}/g, " ").replace(/\s+([,.;])/g, "$1").trim();
 }
-function parseMemoryTimestamp(timestamp2) {
-  if (!timestamp2) return void 0;
-  const asNumber3 = Number(timestamp2);
+function parseMemoryTimestamp(timestamp) {
+  if (!timestamp) return void 0;
+  const asNumber3 = Number(timestamp);
   if (Number.isFinite(asNumber3) && asNumber3 > 0) return asNumber3;
-  const parsed = Date.parse(timestamp2);
+  const parsed = Date.parse(timestamp);
   return Number.isFinite(parsed) ? parsed : void 0;
 }
 function memoryContextCharBudget() {
@@ -737191,8 +737192,8 @@ async function showEpisodesMenu(options2) {
     renderError(`Failed to load episodes: ${e2}`);
   }
 }
-function formatTimeAgo(timestamp2) {
-  const seconds = Math.floor((Date.now() - timestamp2) / 1e3);
+function formatTimeAgo(timestamp) {
+  const seconds = Math.floor((Date.now() - timestamp) / 1e3);
   if (seconds < 60) return "just now";
   if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
   if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
@@ -739187,9 +739188,9 @@ function saveJobOutput(jobId, output2) {
     chmodSync10(jobOutDir, 448);
   } catch {
   }
-  const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const suffix = randomUUID30().slice(0, 6);
-  const outFile = join165(jobOutDir, `${timestamp2}-${suffix}.md`);
+  const outFile = join165(jobOutDir, `${timestamp}-${suffix}.md`);
   writeFileSync85(outFile, output2, "utf-8");
   secureFile(outFile);
   return outFile;
@@ -774066,1842 +774067,6 @@ var init_emotion_engine = __esm({
   }
 });
 
-// packages/cli/src/tui/telegram-context-packet-v2.ts
-import { createHash as createHash70 } from "node:crypto";
-function assertId(value2, field) {
-  if (!ID_PATTERN.test(value2)) {
-    throw new TelegramContextPacketValidationError(
-      `${field} must match ${ID_PATTERN.source}`
-    );
-  }
-}
-function normalizedInteger(value2, fallback, field) {
-  const resolved = value2 ?? fallback;
-  if (!Number.isSafeInteger(resolved)) {
-    throw new TelegramContextPacketValidationError(
-      `${field} must be a safe integer`
-    );
-  }
-  return resolved;
-}
-function normalizedBudget(value2, field) {
-  if (!Number.isSafeInteger(value2) || value2 < 0) {
-    throw new TelegramContextPacketValidationError(
-      `${field} must be a non-negative safe integer`
-    );
-  }
-  return value2;
-}
-function compareText(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-function compareBlocksForRender(left, right) {
-  return left.order - right.order || right.priority - left.priority || compareText(left.semanticId, right.semanticId);
-}
-function compareRecordsForRender(left, right) {
-  return left.blockOrder - right.blockOrder || right.blockPriority - left.blockPriority || compareText(left.semanticId, right.semanticId) || left.recordOrder - right.recordOrder || right.recordPriority - left.recordPriority || compareText(left.recordId, right.recordId);
-}
-function compareRecordsForAdmission(left, right) {
-  return right.blockPriority - left.blockPriority || right.recordPriority - left.recordPriority || left.blockOrder - right.blockOrder || left.recordOrder - right.recordOrder || compareText(left.semanticId, right.semanticId) || compareText(left.recordId, right.recordId);
-}
-function canonicalBlock(block) {
-  const records = [...block.records].map((record) => ({
-    recordId: record.recordId,
-    content: record.content,
-    order: record.order ?? 0,
-    priority: record.priority ?? 0
-  })).sort(
-    (left, right) => left.order - right.order || right.priority - left.priority || compareText(left.recordId, right.recordId)
-  );
-  return JSON.stringify({
-    semanticId: block.semanticId,
-    revision: block.revision,
-    stability: block.stability,
-    order: block.order ?? 0,
-    priority: block.priority ?? 0,
-    records
-  });
-}
-function normalizeBlock(block) {
-  assertId(block.semanticId, "semanticId");
-  const revision = normalizedInteger(block.revision, 0, "revision");
-  if (revision < 0) {
-    throw new TelegramContextPacketValidationError(
-      "revision must be non-negative"
-    );
-  }
-  if (block.stability !== "stable" && block.stability !== "dynamic") {
-    throw new TelegramContextPacketValidationError(
-      "stability must be stable or dynamic"
-    );
-  }
-  const order = normalizedInteger(block.order, 0, "block order");
-  const priority = normalizedInteger(block.priority, 0, "block priority");
-  const recordIds = /* @__PURE__ */ new Set();
-  const records = block.records.map((record) => {
-    assertId(record.recordId, "recordId");
-    if (recordIds.has(record.recordId)) {
-      throw new TelegramContextPacketValidationError(
-        `Duplicate recordId=${JSON.stringify(record.recordId)} in semanticId=${JSON.stringify(block.semanticId)}`
-      );
-    }
-    recordIds.add(record.recordId);
-    if (typeof record.content !== "string") {
-      throw new TelegramContextPacketValidationError(
-        `content for recordId=${JSON.stringify(record.recordId)} must be a string`
-      );
-    }
-    return {
-      semanticId: block.semanticId,
-      revision,
-      stability: block.stability,
-      blockOrder: order,
-      blockPriority: priority,
-      recordId: record.recordId,
-      content: record.content,
-      recordOrder: normalizedInteger(record.order, 0, "record order"),
-      recordPriority: normalizedInteger(record.priority, 0, "record priority")
-    };
-  });
-  records.sort(compareRecordsForRender);
-  return {
-    semanticId: block.semanticId,
-    revision,
-    stability: block.stability,
-    order,
-    priority,
-    records
-  };
-}
-function selectBlockRevisions(blocks) {
-  const selected = /* @__PURE__ */ new Map();
-  for (const block of blocks) {
-    const normalized4 = normalizeBlock(block);
-    const source = {
-      semanticId: normalized4.semanticId,
-      revision: normalized4.revision,
-      stability: normalized4.stability,
-      order: normalized4.order,
-      priority: normalized4.priority,
-      records: normalized4.records.map((record) => ({
-        recordId: record.recordId,
-        content: record.content,
-        order: record.recordOrder,
-        priority: record.recordPriority
-      }))
-    };
-    const canonical3 = canonicalBlock(source);
-    const current = selected.get(source.semanticId);
-    if (!current || source.revision > current.source.revision) {
-      selected.set(source.semanticId, { source, canonical: canonical3 });
-      continue;
-    }
-    if (source.revision < current.source.revision) continue;
-    if (canonical3 !== current.canonical) {
-      throw new TelegramContextPacketRevisionConflictError(
-        source.semanticId,
-        source.revision
-      );
-    }
-  }
-  return [...selected.values()].map(({ source }) => normalizeBlock(source)).sort(compareBlocksForRender);
-}
-function segmentHeader(segment) {
-  return JSON.stringify({
-    type: "telegram_context_packet_v2",
-    schemaVersion: TELEGRAM_CONTEXT_PACKET_SCHEMA_VERSION,
-    segment
-  });
-}
-function segmentFooter(segment) {
-  return JSON.stringify({
-    type: "telegram_context_packet_end_v2",
-    schemaVersion: TELEGRAM_CONTEXT_PACKET_SCHEMA_VERSION,
-    segment
-  });
-}
-function serializeRecord(record) {
-  return JSON.stringify({
-    type: "telegram_context_record_v2",
-    schemaVersion: TELEGRAM_CONTEXT_PACKET_SCHEMA_VERSION,
-    semanticId: record.semanticId,
-    revision: record.revision,
-    recordId: record.recordId,
-    content: record.content
-  });
-}
-function omittedRecordRef(record) {
-  return {
-    semanticId: record.semanticId,
-    revision: record.revision,
-    recordId: record.recordId
-  };
-}
-function buildOmissionReceipt(segment, omitted) {
-  if (omitted.length === 0) return void 0;
-  const omittedRecords = [...omitted].sort(compareRecordsForRender).map(omittedRecordRef);
-  const omittedSemanticIds = [
-    ...new Set(omittedRecords.map((record) => record.semanticId))
-  ].sort(compareText);
-  return {
-    type: "telegram_context_omission_receipt_v2",
-    schemaVersion: TELEGRAM_CONTEXT_PACKET_SCHEMA_VERSION,
-    segment,
-    reason: "char_budget",
-    omittedBlockCount: omittedSemanticIds.length,
-    omittedRecordCount: omittedRecords.length,
-    omittedDigest: createHash70("sha256").update(JSON.stringify(omittedRecords)).digest("hex"),
-    omittedSemanticIds,
-    omittedRecords
-  };
-}
-function serializeOmissionReceipt(receipt2) {
-  return JSON.stringify({
-    type: receipt2.type,
-    schemaVersion: receipt2.schemaVersion,
-    segment: receipt2.segment,
-    reason: receipt2.reason,
-    omittedBlockCount: receipt2.omittedBlockCount,
-    omittedRecordCount: receipt2.omittedRecordCount,
-    omittedDigest: receipt2.omittedDigest
-  });
-}
-function renderSegmentText(segment, included, omitted) {
-  const receipt2 = buildOmissionReceipt(segment, omitted);
-  const lines = [
-    segmentHeader(segment),
-    ...[...included].sort(compareRecordsForRender).map(serializeRecord),
-    ...receipt2 ? [serializeOmissionReceipt(receipt2)] : [],
-    segmentFooter(segment)
-  ];
-  return {
-    text: lines.join("\n"),
-    ...receipt2 ? { receipt: receipt2 } : {}
-  };
-}
-function compileSegment(segment, blocks, budgetChars) {
-  const records = blocks.flatMap((block) => block.records);
-  const admissionOrder = [...records].sort(compareRecordsForAdmission);
-  const included = /* @__PURE__ */ new Set();
-  const empty2 = renderSegmentText(segment, [], admissionOrder);
-  if (empty2.text.length > budgetChars) {
-    throw new TelegramContextPacketBudgetError(
-      segment,
-      budgetChars,
-      empty2.text.length
-    );
-  }
-  for (const candidate of admissionOrder) {
-    const tentativeIncluded = [...included, candidate];
-    const tentativeOmitted = admissionOrder.filter(
-      (record) => !included.has(record) && record !== candidate
-    );
-    const tentative = renderSegmentText(
-      segment,
-      tentativeIncluded,
-      tentativeOmitted
-    );
-    if (tentative.text.length <= budgetChars) included.add(candidate);
-  }
-  const includedRecords = records.filter((record) => included.has(record));
-  const omittedRecords = records.filter((record) => !included.has(record));
-  const rendered = renderSegmentText(segment, includedRecords, omittedRecords);
-  const compiledBlocks = blocks.flatMap((block) => {
-    const admitted = block.records.filter((record) => included.has(record));
-    if (admitted.length === 0) return [];
-    return [
-      {
-        semanticId: block.semanticId,
-        revision: block.revision,
-        stability: block.stability,
-        order: block.order,
-        priority: block.priority,
-        records: admitted.sort(compareRecordsForRender).map((record) => ({
-          semanticId: record.semanticId,
-          revision: record.revision,
-          recordId: record.recordId,
-          content: record.content,
-          order: record.recordOrder,
-          priority: record.recordPriority,
-          serializedChars: serializeRecord(record).length
-        }))
-      }
-    ];
-  });
-  return {
-    segment,
-    text: rendered.text,
-    charLength: rendered.text.length,
-    budgetChars,
-    blocks: compiledBlocks,
-    ...rendered.receipt ? { omissionReceipt: rendered.receipt } : {}
-  };
-}
-function compileTelegramContextPacketV2(input) {
-  const stableChars = normalizedBudget(
-    input.budgets.stableChars,
-    "stableChars"
-  );
-  const dynamicChars = normalizedBudget(
-    input.budgets.dynamicChars,
-    "dynamicChars"
-  );
-  const selected = selectBlockRevisions(input.blocks);
-  const stable2 = compileSegment(
-    "stable",
-    selected.filter((block) => block.stability === "stable"),
-    stableChars
-  );
-  const dynamic = compileSegment(
-    "dynamic",
-    selected.filter((block) => block.stability === "dynamic"),
-    dynamicChars
-  );
-  const selectedRevisions = Object.fromEntries(
-    [...selected].sort((left, right) => compareText(left.semanticId, right.semanticId)).map((block) => [block.semanticId, block.revision])
-  );
-  const combinedContext = `${stable2.text}
-${dynamic.text}`;
-  return {
-    schemaVersion: TELEGRAM_CONTEXT_PACKET_SCHEMA_VERSION,
-    stablePrefix: stable2.text,
-    stablePrefixHash: createHash70("sha256").update(stable2.text).digest("hex"),
-    dynamicContext: dynamic.text,
-    combinedContext,
-    selectedRevisions,
-    stable: stable2,
-    dynamic
-  };
-}
-var TELEGRAM_CONTEXT_PACKET_SCHEMA_VERSION, TelegramContextPacketValidationError, TelegramContextPacketRevisionConflictError, TelegramContextPacketBudgetError, ID_PATTERN;
-var init_telegram_context_packet_v2 = __esm({
-  "packages/cli/src/tui/telegram-context-packet-v2.ts"() {
-    TELEGRAM_CONTEXT_PACKET_SCHEMA_VERSION = 2;
-    TelegramContextPacketValidationError = class extends Error {
-      constructor(message2) {
-        super(message2);
-        this.name = "TelegramContextPacketValidationError";
-      }
-    };
-    TelegramContextPacketRevisionConflictError = class extends Error {
-      constructor(semanticId, revision) {
-        super(
-          `Conflicting Telegram context blocks use semanticId=${JSON.stringify(semanticId)} revision=${revision}`
-        );
-        this.name = "TelegramContextPacketRevisionConflictError";
-      }
-    };
-    TelegramContextPacketBudgetError = class extends Error {
-      segment;
-      budgetChars;
-      requiredChars;
-      constructor(segment, budgetChars, requiredChars) {
-        super(
-          `Telegram ${segment} context budget ${budgetChars} cannot fit the mandatory packet envelope and omission receipt (${requiredChars} chars required)`
-        );
-        this.name = "TelegramContextPacketBudgetError";
-        this.segment = segment;
-        this.budgetChars = budgetChars;
-        this.requiredChars = requiredChars;
-      }
-    };
-    ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,199}$/;
-  }
-});
-
-// packages/cli/src/tui/telegram-input-ownership.ts
-function nonEmpty2(value2, label) {
-  if (typeof value2 !== "string" || value2.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string`);
-  }
-  return value2;
-}
-function finiteInteger(value2, label) {
-  if (!Number.isSafeInteger(value2)) {
-    throw new TypeError(`${label} must be a safe integer`);
-  }
-  return value2;
-}
-function timestamp(value2) {
-  if (!Number.isFinite(value2) || value2 < 0) {
-    throw new TypeError("atMs must be a non-negative finite number");
-  }
-  return value2;
-}
-function createTelegramInputTargetBinding(target) {
-  return Object.freeze({
-    inputId: nonEmpty2(target.inputId, "inputId"),
-    sessionKey: nonEmpty2(target.sessionKey, "sessionKey"),
-    chatId: nonEmpty2(target.chatId, "chatId"),
-    messageId: finiteInteger(target.messageId, "messageId"),
-    messageThreadId: finiteInteger(target.messageThreadId, "messageThreadId"),
-    senderActorKey: nonEmpty2(target.senderActorKey, "senderActorKey")
-  });
-}
-function telegramInputTargetsEqual(left, right) {
-  return left.inputId === right.inputId && left.sessionKey === right.sessionKey && left.chatId === right.chatId && left.messageId === right.messageId && left.messageThreadId === right.messageThreadId && left.senderActorKey === right.senderActorKey;
-}
-function isTelegramInputTerminalLifecycle(state5) {
-  return TERMINAL_STATES.has(state5);
-}
-function freezeOwner(owner) {
-  const generation = finiteInteger(owner.generation, "owner.generation");
-  if (generation < 0) {
-    throw new TypeError("owner.generation must be non-negative");
-  }
-  return Object.freeze({
-    ownerId: nonEmpty2(owner.ownerId, "owner.ownerId"),
-    generation
-  });
-}
-function ownersEqual(left, right) {
-  return left.ownerId === right.ownerId && left.generation === right.generation;
-}
-function freezeEvent(state5, atMs, owner) {
-  return Object.freeze({ state: state5, atMs: timestamp(atMs), owner });
-}
-function freezeRecord(record) {
-  return Object.freeze({
-    ...record,
-    history: Object.freeze([...record.history])
-  });
-}
-function decisionsEqual(left, right) {
-  return left.decisionId === right.decisionId && left.contractFingerprint === right.contractFingerprint && left.contractVersion === right.contractVersion && left.disposition === right.disposition;
-}
-function deliveriesEqual(left, right) {
-  return left.deliveryId === right.deliveryId && left.decisionId === right.decisionId && left.kind === right.kind && left.transportReceiptId === right.transportReceiptId;
-}
-var TERMINAL_STATES, ALLOWED_TRANSITIONS, TelegramInputOwnershipLedger;
-var init_telegram_input_ownership = __esm({
-  "packages/cli/src/tui/telegram-input-ownership.ts"() {
-    TERMINAL_STATES = /* @__PURE__ */ new Set([
-      "consumed",
-      "superseded",
-      "failed"
-    ]);
-    ALLOWED_TRANSITIONS = {
-      received: /* @__PURE__ */ new Set([
-        "classified",
-        "queued",
-        "dispatched",
-        "decision_committed",
-        "superseded",
-        "failed"
-      ]),
-      classified: /* @__PURE__ */ new Set([
-        "queued",
-        "dispatched",
-        "decision_committed",
-        "superseded",
-        "failed"
-      ]),
-      queued: /* @__PURE__ */ new Set([
-        "dispatched",
-        "deferred",
-        "decision_committed",
-        "superseded",
-        "failed"
-      ]),
-      dispatched: /* @__PURE__ */ new Set([
-        "deferred",
-        "decision_committed",
-        "superseded",
-        "failed"
-      ]),
-      deferred: /* @__PURE__ */ new Set([
-        "queued",
-        "dispatched",
-        "decision_committed",
-        "superseded",
-        "failed"
-      ]),
-      decision_committed: /* @__PURE__ */ new Set([
-        "deferred",
-        "queued",
-        "dispatched",
-        "delivery_committed",
-        "consumed",
-        "superseded",
-        "failed"
-      ]),
-      delivery_committed: /* @__PURE__ */ new Set(["consumed"]),
-      consumed: /* @__PURE__ */ new Set(),
-      superseded: /* @__PURE__ */ new Set(),
-      failed: /* @__PURE__ */ new Set()
-    };
-    TelegramInputOwnershipLedger = class {
-      records = /* @__PURE__ */ new Map();
-      get(inputId) {
-        return this.records.get(inputId);
-      }
-      register(targetInput, ownerInput, atMs = Date.now()) {
-        const target = createTelegramInputTargetBinding(targetInput);
-        const owner = freezeOwner(ownerInput);
-        const existing = this.records.get(target.inputId);
-        if (existing) {
-          if (telegramInputTargetsEqual(existing.target, target)) {
-            return { status: "duplicate", record: existing };
-          }
-          return {
-            status: "contradiction",
-            record: existing,
-            reason: "inputId is already bound to a different immutable target"
-          };
-        }
-        const record = freezeRecord({
-          target,
-          owner,
-          lifecycle: "received",
-          revision: 0,
-          history: Object.freeze([freezeEvent("received", atMs, owner)])
-        });
-        this.records.set(target.inputId, record);
-        return { status: "applied", record };
-      }
-      claim(targetInput, ownerInput) {
-        const bound = this.boundRecord(targetInput);
-        if (bound.status !== "applied") return bound;
-        const record = bound.record;
-        const owner = freezeOwner(ownerInput);
-        if (ownersEqual(record.owner, owner)) {
-          return { status: "duplicate", record };
-        }
-        if (isTelegramInputTerminalLifecycle(record.lifecycle)) {
-          return {
-            status: "terminal",
-            record,
-            reason: "terminal input ownership cannot be transferred"
-          };
-        }
-        if (owner.generation < record.owner.generation) {
-          return {
-            status: "stale",
-            record,
-            reason: "owner generation is older than the authoritative claim"
-          };
-        }
-        if (owner.generation === record.owner.generation) {
-          return {
-            status: "contradiction",
-            record,
-            reason: "one owner generation cannot name two owners"
-          };
-        }
-        const next = freezeRecord({
-          ...record,
-          owner,
-          revision: record.revision + 1
-        });
-        this.records.set(targetInput.inputId, next);
-        return { status: "applied", record: next };
-      }
-      transition(targetInput, ownerInput, nextState, atMs = Date.now()) {
-        const authorized = this.authorizedRecord(targetInput, ownerInput);
-        if (authorized.status !== "applied") return authorized;
-        const record = authorized.record;
-        if (record.lifecycle === nextState) {
-          return { status: "duplicate", record };
-        }
-        if (isTelegramInputTerminalLifecycle(record.lifecycle)) {
-          return {
-            status: "terminal",
-            record,
-            reason: "terminal input lifecycle cannot advance"
-          };
-        }
-        if (!ALLOWED_TRANSITIONS[record.lifecycle].has(nextState)) {
-          return {
-            status: "invalid_transition",
-            record,
-            reason: `${record.lifecycle} cannot transition to ${nextState}`
-          };
-        }
-        return this.storeLifecycle(record, nextState, atMs);
-      }
-      commitDecision(targetInput, ownerInput, decisionInput, atMs = Date.now()) {
-        const bound = this.boundRecord(targetInput);
-        if (bound.status !== "applied") return bound;
-        const record = bound.record;
-        const decision2 = {
-          decisionId: nonEmpty2(decisionInput.decisionId, "decisionId"),
-          contractFingerprint: nonEmpty2(
-            decisionInput.contractFingerprint,
-            "contractFingerprint"
-          ),
-          contractVersion: decisionInput.contractVersion,
-          disposition: decisionInput.disposition
-        };
-        if (decision2.contractVersion !== 2) {
-          return {
-            status: "invalid_transition",
-            record,
-            reason: "only Telegram turn contract version 2 can be committed"
-          };
-        }
-        if (record.decision) {
-          return decisionsEqual(record.decision, decision2) ? { status: "duplicate", record } : {
-            status: "contradiction",
-            record,
-            reason: "an input can have only one committed decision"
-          };
-        }
-        const authorized = this.authorizedRecord(targetInput, ownerInput);
-        if (authorized.status !== "applied") return authorized;
-        if (isTelegramInputTerminalLifecycle(record.lifecycle)) {
-          return {
-            status: "terminal",
-            record,
-            reason: "a terminal input cannot accept a decision"
-          };
-        }
-        if (!ALLOWED_TRANSITIONS[record.lifecycle].has("decision_committed")) {
-          return {
-            status: "invalid_transition",
-            record,
-            reason: `${record.lifecycle} cannot commit a decision`
-          };
-        }
-        const committed = Object.freeze({
-          ...decision2,
-          committedBy: record.owner,
-          committedAtMs: timestamp(atMs)
-        });
-        const next = freezeRecord({
-          ...record,
-          decision: committed,
-          lifecycle: "decision_committed",
-          revision: record.revision + 1,
-          history: [
-            ...record.history,
-            freezeEvent("decision_committed", atMs, record.owner)
-          ]
-        });
-        this.records.set(record.target.inputId, next);
-        return { status: "applied", record: next };
-      }
-      commitDelivery(targetInput, ownerInput, deliveryInput, atMs = Date.now()) {
-        const bound = this.boundRecord(targetInput);
-        if (bound.status !== "applied") return bound;
-        const record = bound.record;
-        const delivery = {
-          deliveryId: nonEmpty2(deliveryInput.deliveryId, "deliveryId"),
-          decisionId: nonEmpty2(deliveryInput.decisionId, "decisionId"),
-          kind: deliveryInput.kind,
-          transportReceiptId: nonEmpty2(
-            deliveryInput.transportReceiptId,
-            "transportReceiptId"
-          )
-        };
-        if (record.delivery) {
-          return deliveriesEqual(record.delivery, delivery) ? { status: "duplicate", record } : {
-            status: "contradiction",
-            record,
-            reason: "an input can have only one committed delivery"
-          };
-        }
-        const authorized = this.authorizedRecord(targetInput, ownerInput);
-        if (authorized.status !== "applied") return authorized;
-        if (isTelegramInputTerminalLifecycle(record.lifecycle)) {
-          return {
-            status: "terminal",
-            record,
-            reason: "a terminal input cannot accept a delivery"
-          };
-        }
-        if (!record.decision || record.decision.decisionId !== delivery.decisionId) {
-          return {
-            status: "invalid_transition",
-            record,
-            reason: "delivery must cite the committed decision"
-          };
-        }
-        if (record.decision.disposition === "no_reply") {
-          return {
-            status: "invalid_transition",
-            record,
-            reason: "a no_reply decision cannot have a delivery"
-          };
-        }
-        if (record.decision.disposition === "chat_reply" && delivery.kind !== "visible_reply" || record.decision.disposition === "action" && delivery.kind !== "action_effect") {
-          return {
-            status: "contradiction",
-            record,
-            reason: "delivery kind contradicts the committed disposition"
-          };
-        }
-        const committed = Object.freeze({
-          ...delivery,
-          committedBy: record.owner,
-          committedAtMs: timestamp(atMs)
-        });
-        const next = freezeRecord({
-          ...record,
-          delivery: committed,
-          lifecycle: "delivery_committed",
-          revision: record.revision + 1,
-          history: [
-            ...record.history,
-            freezeEvent("delivery_committed", atMs, record.owner)
-          ]
-        });
-        this.records.set(record.target.inputId, next);
-        return { status: "applied", record: next };
-      }
-      complete(targetInput, ownerInput, terminal, atMs = Date.now()) {
-        const bound = this.boundRecord(targetInput);
-        if (bound.status !== "applied") return bound;
-        const record = bound.record;
-        if (record.terminal) {
-          return record.terminal === terminal ? { status: "duplicate", record } : {
-            status: "contradiction",
-            record,
-            reason: "an input can have only one terminal lifecycle result"
-          };
-        }
-        const authorized = this.authorizedRecord(targetInput, ownerInput);
-        if (authorized.status !== "applied") return authorized;
-        if (terminal === "consumed") {
-          if (!record.decision) {
-            return {
-              status: "invalid_transition",
-              record,
-              reason: "consumed input requires a committed decision"
-            };
-          }
-          if (record.decision.disposition !== "no_reply" && !record.delivery) {
-            return {
-              status: "invalid_transition",
-              record,
-              reason: "reply and action decisions require a delivery receipt"
-            };
-          }
-        }
-        if (!ALLOWED_TRANSITIONS[record.lifecycle].has(terminal)) {
-          return {
-            status: "invalid_transition",
-            record,
-            reason: `${record.lifecycle} cannot transition to ${terminal}`
-          };
-        }
-        return this.storeLifecycle(record, terminal, atMs, terminal);
-      }
-      boundRecord(targetInput) {
-        const existing = this.records.get(targetInput.inputId);
-        if (!existing) {
-          return { status: "unknown_input", reason: "input is not registered" };
-        }
-        let target;
-        try {
-          target = createTelegramInputTargetBinding(targetInput);
-        } catch (error) {
-          return {
-            status: "contradiction",
-            record: existing,
-            reason: error instanceof Error ? error.message : String(error)
-          };
-        }
-        if (!telegramInputTargetsEqual(existing.target, target)) {
-          return {
-            status: "contradiction",
-            record: existing,
-            reason: "operation target contradicts the immutable input binding"
-          };
-        }
-        return { status: "applied", record: existing };
-      }
-      authorizedRecord(targetInput, ownerInput) {
-        const bound = this.boundRecord(targetInput);
-        if (bound.status !== "applied") return bound;
-        const record = bound.record;
-        let owner;
-        try {
-          owner = freezeOwner(ownerInput);
-        } catch (error) {
-          return {
-            status: "contradiction",
-            record,
-            reason: error instanceof Error ? error.message : String(error)
-          };
-        }
-        if (ownersEqual(record.owner, owner)) return bound;
-        if (owner.generation < record.owner.generation) {
-          return {
-            status: "stale",
-            record,
-            reason: "operation belongs to an older owner generation"
-          };
-        }
-        return {
-          status: "contradiction",
-          record,
-          reason: "operation owner does not match the authoritative claim"
-        };
-      }
-      storeLifecycle(record, state5, atMs, terminal) {
-        const next = freezeRecord({
-          ...record,
-          lifecycle: state5,
-          terminal,
-          revision: record.revision + 1,
-          history: [...record.history, freezeEvent(state5, atMs, record.owner)]
-        });
-        this.records.set(record.target.inputId, next);
-        return { status: "applied", record: next };
-      }
-    };
-  }
-});
-
-// packages/cli/src/tui/telegram-cognition-queue.ts
-function positiveSafeInteger(value2, field) {
-  if (!Number.isSafeInteger(value2) || value2 <= 0) {
-    throw new TelegramCognitionQueueValidationError(
-      `${field} must be a positive safe integer`
-    );
-  }
-  return value2;
-}
-function boundedIdentity(value2, field) {
-  if (typeof value2 !== "string" || value2.length === 0 || value2.length > 300) {
-    throw new TelegramCognitionQueueValidationError(
-      `${field} must contain 1 to 300 characters`
-    );
-  }
-  return value2;
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function deferredOutcome() {
-  let resolve92;
-  const promise = new Promise((done) => {
-    resolve92 = done;
-  });
-  return { promise, resolve: resolve92 };
-}
-var TELEGRAM_COGNITION_AUTHORITY, TelegramCognitionQueueValidationError, JOB_KINDS, TelegramCognitionQueue;
-var init_telegram_cognition_queue = __esm({
-  "packages/cli/src/tui/telegram-cognition-queue.ts"() {
-    TELEGRAM_COGNITION_AUTHORITY = "internal_cognition_only";
-    TelegramCognitionQueueValidationError = class extends Error {
-      constructor(message2) {
-        super(message2);
-        this.name = "TelegramCognitionQueueValidationError";
-      }
-    };
-    JOB_KINDS = /* @__PURE__ */ new Set([
-      "social_state",
-      "memory",
-      "reflection",
-      "cognition_batch"
-    ]);
-    TelegramCognitionQueue = class {
-      maxConcurrentScopes;
-      maxQueuedJobs;
-      defaultTimeBudgetMs;
-      pending = [];
-      running = /* @__PURE__ */ new Map();
-      activeScopes = /* @__PURE__ */ new Set();
-      dedupe = /* @__PURE__ */ new Map();
-      jobsById = /* @__PURE__ */ new Map();
-      idleWaiters = /* @__PURE__ */ new Set();
-      totals = {
-        accepted: 0,
-        deduplicated: 0,
-        rejectedCapacity: 0,
-        rejectedClosed: 0,
-        started: 0,
-        succeeded: 0,
-        failed: 0,
-        timedOut: 0,
-        cancelled: 0
-      };
-      state = "open";
-      pumpScheduled = false;
-      nextJobSequence = 1;
-      constructor(options2) {
-        this.maxConcurrentScopes = positiveSafeInteger(
-          options2.maxConcurrentScopes,
-          "maxConcurrentScopes"
-        );
-        this.maxQueuedJobs = positiveSafeInteger(
-          options2.maxQueuedJobs,
-          "maxQueuedJobs"
-        );
-        this.defaultTimeBudgetMs = positiveSafeInteger(
-          options2.defaultTimeBudgetMs,
-          "defaultTimeBudgetMs"
-        );
-      }
-      enqueue(job) {
-        const scopeKey2 = boundedIdentity(job.scopeKey, "scopeKey");
-        const dedupeKey = boundedIdentity(job.dedupeKey, "dedupeKey");
-        if (!JOB_KINDS.has(job.kind)) {
-          throw new TelegramCognitionQueueValidationError(
-            `Unsupported cognition job kind: ${String(job.kind)}`
-          );
-        }
-        if (typeof job.execute !== "function") {
-          throw new TelegramCognitionQueueValidationError(
-            "execute must be a function"
-          );
-        }
-        const timeBudgetMs = positiveSafeInteger(
-          job.timeBudgetMs ?? this.defaultTimeBudgetMs,
-          "timeBudgetMs"
-        );
-        const dedupeIdentity = `${scopeKey2}\0${dedupeKey}`;
-        const existing = this.dedupe.get(dedupeIdentity);
-        if (existing) {
-          this.totals.deduplicated++;
-          return {
-            admission: "deduplicated",
-            jobId: existing.jobId,
-            scopeKey: scopeKey2,
-            dedupeKey,
-            completion: existing.completion
-          };
-        }
-        const jobId = boundedIdentity(
-          job.jobId ?? `tg-cognition-${this.nextJobSequence++}`,
-          "jobId"
-        );
-        if (this.jobsById.has(jobId)) {
-          throw new TelegramCognitionQueueValidationError(
-            `jobId is already active: ${jobId}`
-          );
-        }
-        if (this.state !== "open") {
-          this.totals.rejectedClosed++;
-          return this.rejectedReceipt(
-            "rejected_closed",
-            jobId,
-            scopeKey2,
-            dedupeKey,
-            job.kind,
-            "Telegram cognition queue is closing or closed"
-          );
-        }
-        this.pump();
-        const canStartNow = this.running.size < this.maxConcurrentScopes && !this.activeScopes.has(scopeKey2);
-        if (!canStartNow && this.pending.length >= this.maxQueuedJobs) {
-          this.totals.rejectedCapacity++;
-          return this.rejectedReceipt(
-            "rejected_capacity",
-            jobId,
-            scopeKey2,
-            dedupeKey,
-            job.kind,
-            "Telegram cognition queue capacity reached"
-          );
-        }
-        const completion = deferredOutcome();
-        const accepted = {
-          jobId,
-          scopeKey: scopeKey2,
-          dedupeKey,
-          dedupeIdentity,
-          kind: job.kind,
-          timeBudgetMs,
-          execute: job.execute,
-          enqueuedAtMs: Date.now(),
-          completion: completion.promise,
-          resolve: completion.resolve
-        };
-        this.dedupe.set(dedupeIdentity, accepted);
-        this.jobsById.set(jobId, accepted);
-        this.totals.accepted++;
-        if (canStartNow) this.start(accepted);
-        else this.pending.push(accepted);
-        return {
-          admission: "accepted",
-          jobId,
-          scopeKey: scopeKey2,
-          dedupeKey,
-          completion: completion.promise
-        };
-      }
-      cancel(jobId, reason = "cancelled") {
-        const job = this.jobsById.get(jobId);
-        if (!job) return false;
-        const pendingIndex = this.pending.indexOf(job);
-        if (pendingIndex >= 0) {
-          this.pending.splice(pendingIndex, 1);
-          this.finish(job, "cancelled", reason);
-          return true;
-        }
-        if (job.controller && !job.controller.signal.aborted) {
-          job.forcedStatus = "cancelled";
-          job.forcedReason = reason;
-          job.controller.abort(new Error(reason));
-          return true;
-        }
-        return false;
-      }
-      cancelScope(scopeKey2, reason = "scope cancelled") {
-        let cancelled = 0;
-        for (const job of [...this.pending, ...this.running.values()]) {
-          if (job.scopeKey === scopeKey2 && this.cancel(job.jobId, reason)) {
-            cancelled++;
-          }
-        }
-        return cancelled;
-      }
-      snapshot() {
-        const now2 = Date.now();
-        const queuedByScope = {};
-        for (const job of this.pending) {
-          queuedByScope[job.scopeKey] = (queuedByScope[job.scopeKey] ?? 0) + 1;
-        }
-        const oldest = this.pending.reduce(
-          (value2, job) => Math.min(value2, job.enqueuedAtMs),
-          Number.POSITIVE_INFINITY
-        );
-        return {
-          state: this.state,
-          maxConcurrentScopes: this.maxConcurrentScopes,
-          maxQueuedJobs: this.maxQueuedJobs,
-          defaultTimeBudgetMs: this.defaultTimeBudgetMs,
-          queuedJobs: this.pending.length,
-          runningJobs: this.running.size,
-          activeScopes: [...this.activeScopes].sort(),
-          queuedByScope: Object.fromEntries(
-            Object.entries(queuedByScope).sort(
-              ([left], [right]) => left < right ? -1 : left > right ? 1 : 0
-            )
-          ),
-          oldestQueuedAgeMs: Number.isFinite(oldest) ? Math.max(0, now2 - oldest) : 0,
-          totals: { ...this.totals }
-        };
-      }
-      waitForIdle() {
-        if (this.pending.length === 0 && this.running.size === 0) {
-          return Promise.resolve();
-        }
-        return new Promise((resolve92) => {
-          this.idleWaiters.add(resolve92);
-        });
-      }
-      async close(options2 = {}) {
-        if (this.state === "closed") return;
-        this.state = "closing";
-        const reason = options2.reason ?? "queue closed";
-        if (options2.cancelQueued) {
-          for (const job of [...this.pending]) this.cancel(job.jobId, reason);
-        }
-        if (options2.cancelRunning) {
-          for (const job of [...this.running.values()]) {
-            this.cancel(job.jobId, reason);
-          }
-        }
-        this.schedulePump();
-        await this.waitForIdle();
-        this.state = "closed";
-      }
-      rejectedReceipt(status, jobId, scopeKey2, dedupeKey, kind, error) {
-        const now2 = Date.now();
-        return {
-          admission: status,
-          jobId,
-          scopeKey: scopeKey2,
-          dedupeKey,
-          completion: Promise.resolve({
-            jobId,
-            scopeKey: scopeKey2,
-            dedupeKey,
-            kind,
-            status,
-            enqueuedAtMs: now2,
-            finishedAtMs: now2,
-            errorMessage: error
-          })
-        };
-      }
-      schedulePump() {
-        if (this.pumpScheduled) return;
-        this.pumpScheduled = true;
-        queueMicrotask(() => {
-          this.pumpScheduled = false;
-          this.pump();
-        });
-      }
-      pump() {
-        while (this.running.size < this.maxConcurrentScopes) {
-          const nextIndex = this.pending.findIndex(
-            (job2) => !this.activeScopes.has(job2.scopeKey)
-          );
-          if (nextIndex < 0) break;
-          const [job] = this.pending.splice(nextIndex, 1);
-          if (!job) break;
-          this.start(job);
-        }
-        this.maybeResolveIdle();
-      }
-      start(job) {
-        job.startedAtMs = Date.now();
-        job.controller = new AbortController();
-        this.running.set(job.jobId, job);
-        this.activeScopes.add(job.scopeKey);
-        this.totals.started++;
-        const deadlineAtMs = job.startedAtMs + job.timeBudgetMs;
-        const timer = setTimeout(() => {
-          if (!job.controller || job.controller.signal.aborted) return;
-          job.forcedStatus = "timed_out";
-          job.forcedReason = `time budget exceeded after ${job.timeBudgetMs}ms`;
-          job.controller.abort(new Error(job.forcedReason));
-        }, job.timeBudgetMs);
-        if (typeof timer.unref === "function") {
-          timer.unref();
-        }
-        const abortOutcome = new Promise((resolve92) => {
-          job.controller.signal.addEventListener(
-            "abort",
-            () => resolve92("aborted"),
-            {
-              once: true
-            }
-          );
-        });
-        const execution = Promise.resolve().then(
-          () => job.execute({
-            authority: TELEGRAM_COGNITION_AUTHORITY,
-            jobId: job.jobId,
-            scopeKey: job.scopeKey,
-            kind: job.kind,
-            signal: job.controller.signal,
-            deadlineAtMs
-          })
-        ).then(
-          () => ({ type: "succeeded" }),
-          (error) => ({ type: "failed", error })
-        );
-        void Promise.race([
-          execution,
-          abortOutcome.then(() => ({ type: "aborted" }))
-        ]).then((result) => {
-          clearTimeout(timer);
-          if (result.type === "aborted") {
-            this.finish(
-              job,
-              job.forcedStatus ?? "cancelled",
-              job.forcedReason ?? "cancelled"
-            );
-          } else if (result.type === "failed") {
-            this.finish(job, "failed", errorMessage(result.error));
-          } else {
-            this.finish(job, "succeeded");
-          }
-        }).catch((error) => {
-          clearTimeout(timer);
-          this.finish(job, "failed", errorMessage(error));
-        });
-        void execution.then(() => void 0);
-      }
-      finish(job, status, error) {
-        if (!this.jobsById.has(job.jobId)) return;
-        this.running.delete(job.jobId);
-        this.activeScopes.delete(job.scopeKey);
-        this.jobsById.delete(job.jobId);
-        if (this.dedupe.get(job.dedupeIdentity) === job) {
-          this.dedupe.delete(job.dedupeIdentity);
-        }
-        this.totals[status === "timed_out" ? "timedOut" : status]++;
-        const finishedAtMs = Date.now();
-        const startedAtMs = job.startedAtMs;
-        job.resolve({
-          jobId: job.jobId,
-          scopeKey: job.scopeKey,
-          dedupeKey: job.dedupeKey,
-          kind: job.kind,
-          status,
-          enqueuedAtMs: job.enqueuedAtMs,
-          ...startedAtMs !== void 0 ? {
-            startedAtMs,
-            queueWaitMs: Math.max(0, startedAtMs - job.enqueuedAtMs),
-            runDurationMs: Math.max(0, finishedAtMs - startedAtMs)
-          } : {},
-          finishedAtMs,
-          ...error ? { errorMessage: error } : {}
-        });
-        this.schedulePump();
-      }
-      maybeResolveIdle() {
-        if (this.pending.length > 0 || this.running.size > 0) return;
-        for (const resolve92 of this.idleWaiters) resolve92();
-        this.idleWaiters.clear();
-        if (this.state === "closing") this.state = "closed";
-      }
-    };
-  }
-});
-
-// packages/cli/src/tui/telegram-action-session-registry.ts
-function nonEmpty3(value2, label) {
-  if (typeof value2 !== "string" || value2.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string`);
-  }
-  return value2;
-}
-function positiveInteger3(value2, label) {
-  if (!Number.isSafeInteger(value2) || value2 <= 0) {
-    throw new TypeError(`${label} must be a positive safe integer`);
-  }
-  return value2;
-}
-function nonNegativeTime(value2) {
-  if (!Number.isFinite(value2) || value2 < 0) {
-    throw new TypeError(
-      "registry clock must return a non-negative finite number"
-    );
-  }
-  return value2;
-}
-function createTelegramActionSessionTarget(target) {
-  return Object.freeze({
-    chatSessionKey: nonEmpty3(target.chatSessionKey, "target.chatSessionKey"),
-    principalKey: nonEmpty3(target.principalKey, "target.principalKey")
-  });
-}
-function telegramActionSessionKey(targetInput) {
-  const target = createTelegramActionSessionTarget(targetInput);
-  return JSON.stringify([target.chatSessionKey, target.principalKey]);
-}
-var TelegramActionSessionLeaseError, DEFAULT_TTL_MS3, DEFAULT_MAX_ENTRIES, TelegramActionSessionRegistry;
-var init_telegram_action_session_registry = __esm({
-  "packages/cli/src/tui/telegram-action-session-registry.ts"() {
-    TelegramActionSessionLeaseError = class extends Error {
-      constructor(code8, message2) {
-        super(message2);
-        this.code = code8;
-        this.name = "TelegramActionSessionLeaseError";
-      }
-      code;
-    };
-    DEFAULT_TTL_MS3 = 15 * 6e4;
-    DEFAULT_MAX_ENTRIES = 32;
-    TelegramActionSessionRegistry = class {
-      entries = /* @__PURE__ */ new Map();
-      create;
-      ttlMs;
-      maxEntries;
-      now;
-      onEvict;
-      generationSequence = 0;
-      leaseSequence = 0;
-      closed = false;
-      constructor(options2) {
-        this.create = options2.create;
-        this.ttlMs = positiveInteger3(options2.ttlMs ?? DEFAULT_TTL_MS3, "ttlMs");
-        this.maxEntries = positiveInteger3(
-          options2.maxEntries ?? DEFAULT_MAX_ENTRIES,
-          "maxEntries"
-        );
-        this.now = options2.now ?? Date.now;
-        this.onEvict = options2.onEvict;
-      }
-      get size() {
-        return this.entries.size;
-      }
-      acquire(options2) {
-        if (this.closed) {
-          return {
-            status: "closed",
-            reason: "Telegram action session registry is closed"
-          };
-        }
-        const now2 = this.readNow();
-        this.pruneExpiredAt(now2);
-        const target = createTelegramActionSessionTarget(options2.target);
-        const key = telegramActionSessionKey(target);
-        const ownerId = nonEmpty3(options2.ownerId, "ownerId");
-        const compatibilityKey = nonEmpty3(
-          options2.compatibilityKey,
-          "compatibilityKey"
-        );
-        let entry = this.entries.get(key);
-        if (entry && entry.compatibilityKey !== compatibilityKey) {
-          if (entry.lease) {
-            return {
-              status: "busy",
-              reason: "active session has incompatible runner configuration",
-              current: this.snapshotEntry(entry)
-            };
-          }
-          this.evictEntry(entry, "incompatible");
-          entry = void 0;
-        }
-        if (!entry) {
-          while (this.entries.size >= this.maxEntries) {
-            const evicted = this.evictLeastRecentlyUsedIdle();
-            if (!evicted) {
-              return {
-                status: "capacity",
-                reason: "all bounded Telegram action sessions are active"
-              };
-            }
-          }
-          entry = this.createEntry(target, key, compatibilityKey, now2);
-          this.entries.set(key, entry);
-        }
-        if (entry.lease) {
-          return {
-            status: "busy",
-            reason: "Telegram action session already has an active lease",
-            current: this.snapshotEntry(entry)
-          };
-        }
-        const token = Object.freeze({
-          key,
-          generation: entry.generation,
-          leaseId: ++this.leaseSequence,
-          ownerId
-        });
-        entry.lease = {
-          token,
-          onEvent: options2.onEvent,
-          onTypedEvent: options2.onTypedEvent,
-          runStarted: false
-        };
-        entry.lastUsedAtMs = now2;
-        const lease = Object.freeze({
-          token,
-          target: entry.target,
-          run: (input) => this.runLease(token, input),
-          abort: () => this.abortLease(token),
-          release: () => this.releaseLease(token)
-        });
-        return { status: "acquired", lease };
-      }
-      pruneExpired() {
-        return this.pruneExpiredAt(this.readNow());
-      }
-      snapshot() {
-        return Object.freeze(
-          [...this.entries.values()].sort(
-            (left, right) => left.lastUsedAtMs - right.lastUsedAtMs || left.generation - right.generation
-          ).map((entry) => this.snapshotEntry(entry))
-        );
-      }
-      /** Abort active work, dispose every cached resource, and reject new leases. */
-      shutdown() {
-        if (this.closed) return;
-        this.closed = true;
-        for (const entry of [...this.entries.values()]) {
-          this.evictEntry(entry, "shutdown");
-        }
-      }
-      createEntry(target, key, compatibilityKey, now2) {
-        const generation = ++this.generationSequence;
-        let entry;
-        const resource = this.create(
-          Object.freeze({
-            key,
-            target,
-            generation,
-            onTypedEvent: (event) => {
-              if (entry) this.dispatchTypedEvent(entry, event);
-            }
-          })
-        );
-        if (!resource || !resource.runner) {
-          throw new TypeError("Telegram action session factory returned no runner");
-        }
-        entry = {
-          key,
-          target,
-          generation,
-          compatibilityKey,
-          runner: resource.runner,
-          dispose: resource.dispose,
-          createdAtMs: now2,
-          lastUsedAtMs: now2,
-          lease: null,
-          disposed: false
-        };
-        resource.runner.onEvent((event) => {
-          if (entry) this.dispatchEvent(entry, event);
-        });
-        return entry;
-      }
-      async runLease(token, input) {
-        const owned = this.ownedEntry(token);
-        if (!owned) {
-          throw new TelegramActionSessionLeaseError(
-            "stale_lease",
-            "Telegram action session lease is no longer authoritative"
-          );
-        }
-        if (owned.lease.runStarted) {
-          throw new TelegramActionSessionLeaseError(
-            "already_started",
-            "Telegram action session lease can run only once"
-          );
-        }
-        owned.lease.runStarted = true;
-        try {
-          await input.prepare?.(owned.entry.runner);
-          return await owned.entry.runner.run(
-            input.task,
-            input.context,
-            input.actualUserGoal
-          );
-        } finally {
-          this.finishLease(token);
-        }
-      }
-      abortLease(token) {
-        const owned = this.ownedEntry(token);
-        if (!owned) return false;
-        try {
-          owned.entry.runner.abort();
-        } catch {
-        }
-        return true;
-      }
-      releaseLease(token) {
-        const owned = this.ownedEntry(token);
-        if (!owned) return "stale";
-        if (owned.lease.runStarted) return "running";
-        owned.entry.lease = null;
-        owned.entry.lastUsedAtMs = this.readNow();
-        return "released";
-      }
-      finishLease(token) {
-        const owned = this.ownedEntry(token);
-        if (!owned) return;
-        owned.entry.lease = null;
-        owned.entry.lastUsedAtMs = this.readNow();
-      }
-      ownedEntry(token) {
-        const entry = this.entries.get(token.key);
-        if (!entry || entry.generation !== token.generation || !entry.lease || entry.lease.token !== token) {
-          return null;
-        }
-        return { entry, lease: entry.lease };
-      }
-      dispatchEvent(entry, event) {
-        const lease = entry.lease;
-        if (!lease?.runStarted || !lease.onEvent) return;
-        try {
-          lease.onEvent(event, lease.token);
-        } catch {
-        }
-      }
-      dispatchTypedEvent(entry, event) {
-        const lease = entry.lease;
-        if (!lease?.runStarted || !lease.onTypedEvent) return;
-        try {
-          lease.onTypedEvent(event, lease.token);
-        } catch {
-        }
-      }
-      pruneExpiredAt(now2) {
-        let evicted = 0;
-        for (const entry of [...this.entries.values()]) {
-          if (entry.lease || now2 - entry.lastUsedAtMs < this.ttlMs) continue;
-          this.evictEntry(entry, "ttl");
-          evicted++;
-        }
-        return evicted;
-      }
-      evictLeastRecentlyUsedIdle() {
-        const candidate = [...this.entries.values()].filter((entry) => !entry.lease).sort(
-          (left, right) => left.lastUsedAtMs - right.lastUsedAtMs || left.generation - right.generation
-        )[0];
-        if (!candidate) return false;
-        this.evictEntry(candidate, "lru");
-        return true;
-      }
-      evictEntry(entry, reason) {
-        if (entry.disposed) return;
-        entry.disposed = true;
-        const snapshot = this.snapshotEntry(entry);
-        entry.lease = null;
-        this.entries.delete(entry.key);
-        try {
-          entry.runner.abort();
-        } catch {
-        }
-        try {
-          entry.dispose?.();
-        } catch {
-        }
-        try {
-          this.onEvict?.(snapshot, reason);
-        } catch {
-        }
-      }
-      snapshotEntry(entry) {
-        return Object.freeze({
-          key: entry.key,
-          target: entry.target,
-          generation: entry.generation,
-          compatibilityKey: entry.compatibilityKey,
-          createdAtMs: entry.createdAtMs,
-          lastUsedAtMs: entry.lastUsedAtMs,
-          busy: Boolean(entry.lease),
-          ownerId: entry.lease?.token.ownerId,
-          leaseId: entry.lease?.token.leaseId,
-          runStarted: entry.lease?.runStarted ?? false
-        });
-      }
-      readNow() {
-        return nonNegativeTime(this.now());
-      }
-    };
-  }
-});
-
-// packages/cli/src/tui/telegram-turn-contract-v2.ts
-function isRecord2(value2) {
-  return Boolean(value2) && typeof value2 === "object" && !Array.isArray(value2);
-}
-function issue2(code8, path16, message2) {
-  return Object.freeze({ code: code8, path: path16, message: message2 });
-}
-function collectUnknownFields(value2, allowed, path16, issues) {
-  for (const key of Object.keys(value2)) {
-    if (!allowed.has(key)) {
-      issues.push(
-        issue2(
-          "unknown_field",
-          `${path16}.${key}`,
-          "field is not part of the V2 contract"
-        )
-      );
-    }
-  }
-}
-function readString2(value2, path16, issues) {
-  if (typeof value2 !== "string" || value2.trim().length === 0) {
-    issues.push(issue2("invalid_field", path16, "must be a non-empty string"));
-    return null;
-  }
-  return value2;
-}
-function readInteger2(value2, path16, issues) {
-  if (!Number.isSafeInteger(value2)) {
-    issues.push(issue2("invalid_field", path16, "must be a safe integer"));
-    return null;
-  }
-  return value2;
-}
-function readStringArray(value2, path16, issues) {
-  if (!Array.isArray(value2) || value2.some((item) => typeof item !== "string" || item.length === 0)) {
-    issues.push(
-      issue2("invalid_field", path16, "must be an array of non-empty strings")
-    );
-    return null;
-  }
-  if (new Set(value2).size !== value2.length) {
-    issues.push(
-      issue2("invalid_field", path16, "must not contain duplicate values")
-    );
-    return null;
-  }
-  return Object.freeze([...value2]);
-}
-function validateWireTarget(raw, expected, issues) {
-  if (!isRecord2(raw)) {
-    issues.push(issue2("invalid_field", "$.target", "must be an object"));
-    return null;
-  }
-  collectUnknownFields(
-    raw,
-    /* @__PURE__ */ new Set([
-      "input_id",
-      "session_key",
-      "chat_id",
-      "message_id",
-      "message_thread_id",
-      "sender_actor_key"
-    ]),
-    "$.target",
-    issues
-  );
-  const inputId = readString2(raw["input_id"], "$.target.input_id", issues);
-  const sessionKey = readString2(
-    raw["session_key"],
-    "$.target.session_key",
-    issues
-  );
-  const chatId = readString2(raw["chat_id"], "$.target.chat_id", issues);
-  const messageId = readInteger2(
-    raw["message_id"],
-    "$.target.message_id",
-    issues
-  );
-  const messageThreadId = readInteger2(
-    raw["message_thread_id"],
-    "$.target.message_thread_id",
-    issues
-  );
-  const senderActorKey = readString2(
-    raw["sender_actor_key"],
-    "$.target.sender_actor_key",
-    issues
-  );
-  if (inputId === null || sessionKey === null || chatId === null || messageId === null || messageThreadId === null || senderActorKey === null) {
-    return null;
-  }
-  const target = createTelegramInputTargetBinding({
-    inputId,
-    sessionKey,
-    chatId,
-    messageId,
-    messageThreadId,
-    senderActorKey
-  });
-  if (!telegramInputTargetsEqual(target, expected)) {
-    issues.push(
-      issue2(
-        "target_mismatch",
-        "$.target",
-        "target does not match the host-owned input binding"
-      )
-    );
-    return null;
-  }
-  return target;
-}
-function validateTelegramTurnContractV2(raw, context2) {
-  const issues = [];
-  if (!isRecord2(raw)) {
-    return Object.freeze({
-      ok: false,
-      value: null,
-      issues: Object.freeze([
-        issue2("not_object", "$", "turn must be an object")
-      ])
-    });
-  }
-  const rawKind = raw["kind"];
-  const kind = typeof rawKind === "string" && KINDS.has(rawKind) ? rawKind : null;
-  if (raw["version"] !== TELEGRAM_TURN_CONTRACT_V2_VERSION) {
-    issues.push(issue2("invalid_version", "$.version", "version must equal 2"));
-  }
-  if (!kind) {
-    issues.push(
-      issue2(
-        "invalid_kind",
-        "$.kind",
-        "kind must be no_reply, chat_reply, or action"
-      )
-    );
-  }
-  const allowed = new Set(COMMON_WIRE_KEYS);
-  if (kind === "chat_reply") allowed.add("reply");
-  if (kind === "action") allowed.add("objective");
-  collectUnknownFields(raw, allowed, "$", issues);
-  const expectedTarget = createTelegramInputTargetBinding(context2.target);
-  const inputId = readString2(raw["input_id"], "$.input_id", issues);
-  if (inputId !== null && inputId !== expectedTarget.inputId) {
-    issues.push(
-      issue2(
-        "target_mismatch",
-        "$.input_id",
-        "input_id does not match the host target"
-      )
-    );
-  }
-  const target = validateWireTarget(raw["target"], expectedTarget, issues);
-  if (inputId !== null && target && inputId !== target.inputId) {
-    issues.push(
-      issue2(
-        "target_mismatch",
-        "$.input_id",
-        "input_id contradicts target.input_id"
-      )
-    );
-  }
-  const confidence2 = raw["confidence"];
-  if (typeof confidence2 !== "number" || !Number.isFinite(confidence2) || confidence2 < 0 || confidence2 > 1) {
-    issues.push(
-      issue2(
-        "invalid_field",
-        "$.confidence",
-        "confidence must be between 0 and 1"
-      )
-    );
-  }
-  const reason = readString2(raw["reason"], "$.reason", issues);
-  const addressedActorKeys = readStringArray(
-    raw["addressed_actor_keys"],
-    "$.addressed_actor_keys",
-    issues
-  );
-  const evidenceIds = readStringArray(
-    raw["evidence_ids"],
-    "$.evidence_ids",
-    issues
-  );
-  const rawSelfRole = raw["self_role"];
-  const selfRole = typeof rawSelfRole === "string" && SELF_ROLES.has(rawSelfRole) ? rawSelfRole : null;
-  if (!selfRole) {
-    issues.push(issue2("invalid_field", "$.self_role", "self_role is invalid"));
-  }
-  const rawReplyBasis = raw["reply_basis"];
-  const replyBasis = typeof rawReplyBasis === "string" && REPLY_BASES.has(rawReplyBasis) ? rawReplyBasis : null;
-  if (!replyBasis) {
-    issues.push(
-      issue2("invalid_field", "$.reply_basis", "reply_basis is invalid")
-    );
-  }
-  const knownActors = new Set(context2.actorKeys);
-  for (const actorKey of addressedActorKeys ?? []) {
-    if (!knownActors.has(actorKey)) {
-      issues.push(
-        issue2(
-          "unknown_actor_key",
-          "$.addressed_actor_keys",
-          `unknown actor key: ${actorKey}`
-        )
-      );
-    }
-  }
-  const knownEvidence = new Set(context2.evidenceIds);
-  for (const evidenceId of evidenceIds ?? []) {
-    if (!knownEvidence.has(evidenceId)) {
-      issues.push(
-        issue2(
-          "unknown_evidence_id",
-          "$.evidence_ids",
-          `unknown evidence id: ${evidenceId}`
-        )
-      );
-    }
-  }
-  if (kind === "chat_reply" || kind === "action") {
-    if (selfRole === "observer" || selfRole === "uncertain") {
-      issues.push(
-        issue2(
-          "reply_not_authorized",
-          "$.self_role",
-          `${kind} requires an authorized self role`
-        )
-      );
-    }
-    if (replyBasis === "none" || replyBasis === "uncertain") {
-      issues.push(
-        issue2(
-          "reply_not_authorized",
-          "$.reply_basis",
-          `${kind} requires an affirmative reply basis`
-        )
-      );
-    }
-    if ((evidenceIds?.length ?? 0) === 0) {
-      issues.push(
-        issue2(
-          "reply_not_authorized",
-          "$.evidence_ids",
-          `${kind} requires host evidence`
-        )
-      );
-    }
-  }
-  if (context2.selfActorKey && selfRole === "addressee" && addressedActorKeys && !addressedActorKeys.includes(context2.selfActorKey)) {
-    issues.push(
-      issue2(
-        "reply_not_authorized",
-        "$.addressed_actor_keys",
-        "addressee role must include the host self actor"
-      )
-    );
-  }
-  if (context2.selfActorKey && selfRole === "observer" && addressedActorKeys?.includes(context2.selfActorKey)) {
-    issues.push(
-      issue2(
-        "reply_not_authorized",
-        "$.addressed_actor_keys",
-        "observer role contradicts a self addressee"
-      )
-    );
-  }
-  let reply = null;
-  let objective = null;
-  if (kind === "chat_reply") {
-    reply = readString2(raw["reply"], "$.reply", issues);
-  }
-  if (kind === "action") {
-    objective = readString2(raw["objective"], "$.objective", issues);
-  }
-  if (issues.length > 0 || !kind || !target || inputId === null || reason === null || !addressedActorKeys || !selfRole || !replyBasis || !evidenceIds || typeof confidence2 !== "number") {
-    return Object.freeze({
-      ok: false,
-      value: null,
-      issues: Object.freeze([...issues])
-    });
-  }
-  const common = {
-    version: TELEGRAM_TURN_CONTRACT_V2_VERSION,
-    inputId,
-    target,
-    confidence: confidence2,
-    reason,
-    addressedActorKeys,
-    selfRole,
-    replyBasis,
-    evidenceIds
-  };
-  const value2 = kind === "chat_reply" ? Object.freeze({ ...common, kind, reply }) : kind === "action" ? Object.freeze({ ...common, kind, objective }) : Object.freeze({ ...common, kind });
-  return Object.freeze({ ok: true, value: value2, issues: Object.freeze([]) });
-}
-function telegramTurnContractV2Fingerprint(contract) {
-  return JSON.stringify({
-    version: contract.version,
-    kind: contract.kind,
-    inputId: contract.inputId,
-    target: contract.target,
-    confidence: contract.confidence,
-    reason: contract.reason,
-    addressedActorKeys: [...contract.addressedActorKeys].sort(),
-    selfRole: contract.selfRole,
-    replyBasis: contract.replyBasis,
-    evidenceIds: [...contract.evidenceIds].sort(),
-    reply: contract.kind === "chat_reply" ? contract.reply : void 0,
-    objective: contract.kind === "action" ? contract.objective : void 0
-  });
-}
-var TELEGRAM_TURN_CONTRACT_V2_VERSION, SELF_ROLES, REPLY_BASES, KINDS, COMMON_WIRE_KEYS;
-var init_telegram_turn_contract_v2 = __esm({
-  "packages/cli/src/tui/telegram-turn-contract-v2.ts"() {
-    init_telegram_input_ownership();
-    TELEGRAM_TURN_CONTRACT_V2_VERSION = 2;
-    SELF_ROLES = /* @__PURE__ */ new Set([
-      "addressee",
-      "participant",
-      "observer",
-      "uncertain"
-    ]);
-    REPLY_BASES = /* @__PURE__ */ new Set([
-      "direct_turn",
-      "ongoing_self_task",
-      "social_intervention",
-      "none",
-      "uncertain"
-    ]);
-    KINDS = /* @__PURE__ */ new Set([
-      "no_reply",
-      "chat_reply",
-      "action"
-    ]);
-    COMMON_WIRE_KEYS = [
-      "version",
-      "kind",
-      "input_id",
-      "target",
-      "confidence",
-      "reason",
-      "addressed_actor_keys",
-      "self_role",
-      "reply_basis",
-      "evidence_ids"
-    ];
-  }
-});
-
 // packages/cli/src/tui/telegram-format.ts
 function escapeHtml2(text3) {
   return String(text3 ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -777503,7 +775668,7 @@ var init_telegram_command_menu = __esm({
 });
 
 // packages/cli/src/tui/telegram-public-media.ts
-import { createHash as createHash71, randomBytes as randomBytes27 } from "node:crypto";
+import { createHash as createHash70, randomBytes as randomBytes27 } from "node:crypto";
 import { lookup as dnsLookup2 } from "node:dns/promises";
 import { link, mkdir as mkdir23, unlink as unlink4, writeFile as writeFile27 } from "node:fs/promises";
 import { request as httpsRequest2 } from "node:https";
@@ -778124,7 +776289,7 @@ ${output2}`,
           responseContentType(response.headers),
           kind
         );
-        const sha25610 = createHash71("sha256").update(response.body).digest("hex");
+        const sha25610 = createHash70("sha256").update(response.body).digest("hex");
         if (this.acquiredFiles >= MAX_ACQUIRED_FILES_PER_RUN) {
           throw new Error(
             `Rejected media: this run already acquired ${MAX_ACQUIRED_FILES_PER_RUN} files.`
@@ -779667,7 +777832,7 @@ import {
   unlinkSync as unlinkSync43
 } from "node:fs";
 import { join as join184 } from "node:path";
-import { createHash as createHash72 } from "node:crypto";
+import { createHash as createHash71 } from "node:crypto";
 function safeFilePart(value2) {
   return value2.replace(/[^A-Za-z0-9_.-]+/g, "_").slice(0, 80) || "telegram";
 }
@@ -779675,7 +777840,7 @@ function daydreamRoot(repoRoot) {
   return join184(repoRoot, ".omnius", "telegram-daydreams");
 }
 function sessionDir(repoRoot, sessionKey) {
-  const hash2 = createHash72("sha1").update(sessionKey).digest("hex").slice(0, 20);
+  const hash2 = createHash71("sha1").update(sessionKey).digest("hex").slice(0, 20);
   return join184(daydreamRoot(repoRoot), safeFilePart(hash2));
 }
 function compactLine2(value2, max = 220) {
@@ -779786,7 +777951,7 @@ function buildReplyOpportunities(input, openQuestions) {
   return opportunities;
 }
 function daydreamOpportunityId(input, trigger) {
-  return createHash72("sha1").update(`${input.sessionKey}:${input.generatedAtMs}:${trigger}`).digest("hex").slice(0, 16);
+  return createHash71("sha1").update(`${input.sessionKey}:${input.generatedAtMs}:${trigger}`).digest("hex").slice(0, 16);
 }
 function clamp0116(value2) {
   if (!Number.isFinite(value2)) return 0;
@@ -780191,7 +778356,7 @@ function buildTelegramChannelDaydream(input, corpus, extraction, extractionCommi
   const seed = `${input.sessionKey}:${input.generatedAtMs}:${input.history.length}`;
   return {
     version: 3,
-    id: createHash72("sha1").update(seed).digest("hex").slice(0, 16),
+    id: createHash71("sha1").update(seed).digest("hex").slice(0, 16),
     sessionKey: input.sessionKey,
     chatId: input.chatId,
     chatTitle: input.chatTitle,
@@ -780503,12 +778668,12 @@ var init_telegram_channel_dmn = __esm({
 });
 
 // packages/cli/src/tui/telegram-reflection-corpus.ts
-import { createHash as createHash73 } from "node:crypto";
+import { createHash as createHash72 } from "node:crypto";
 function telegramReflectionMemoryDbPaths(repoRoot) {
   return omniusMemoryDbPaths(repoRoot);
 }
 function stableHash2(value2, length4 = 16) {
-  return createHash73("sha1").update(value2).digest("hex").slice(0, length4);
+  return createHash72("sha1").update(value2).digest("hex").slice(0, length4);
 }
 function clean5(value2) {
   return String(value2 ?? "").replace(/\s+/g, " ").trim();
@@ -781321,7 +779486,7 @@ var init_telegram_reflection_extraction = __esm({
 });
 
 // packages/cli/src/tui/telegram-social-state-types.ts
-import { createHash as createHash74 } from "node:crypto";
+import { createHash as createHash73 } from "node:crypto";
 function telegramSocialActorKey(actor) {
   if (!actor) return "unknown";
   if (typeof actor.userId === "number") return `user:${actor.userId}`;
@@ -781357,7 +779522,7 @@ function appendUnique(items, value2, max) {
   return next.slice(-max);
 }
 function hashTelegramSocialId(parts) {
-  return createHash74("sha1").update(parts.map((part) => String(part ?? "")).join(":")).digest("hex").slice(0, 16);
+  return createHash73("sha1").update(parts.map((part) => String(part ?? "")).join(":")).digest("hex").slice(0, 16);
 }
 function cleanUsername(value2) {
   if (typeof value2 !== "string") return void 0;
@@ -782612,7 +780777,7 @@ var init_telegram_social_state = __esm({
 });
 
 // packages/cli/src/tui/telegram-social-event-log.ts
-import { createHash as createHash75 } from "node:crypto";
+import { createHash as createHash74 } from "node:crypto";
 import {
   appendFileSync as appendFileSync21,
   existsSync as existsSync175,
@@ -782621,7 +780786,7 @@ import {
 } from "node:fs";
 import { join as join185, resolve as resolve82 } from "node:path";
 function stableEventId2(type, sessionKey, occurredAt, payload) {
-  return createHash75("sha256").update(JSON.stringify({ type, sessionKey, occurredAt, payload })).digest("hex").slice(0, 24);
+  return createHash74("sha256").update(JSON.stringify({ type, sessionKey, occurredAt, payload })).digest("hex").slice(0, 24);
 }
 function createTelegramSocialEvent(type, payload, recordedAt = Date.now()) {
   const sessionKey = String(payload.sessionKey);
@@ -782637,7 +780802,7 @@ function createTelegramSocialEvent(type, payload, recordedAt = Date.now()) {
   };
 }
 function telegramSocialEventLogPath(repoRoot, sessionKey) {
-  const scope = createHash75("sha256").update(sessionKey).digest("hex").slice(0, 24);
+  const scope = createHash74("sha256").update(sessionKey).digest("hex").slice(0, 24);
   return resolve82(repoRoot, ".omnius", "telegram-social-events", `${scope}.jsonl`);
 }
 function appendTelegramSocialEvent(repoRoot, event) {
@@ -782789,7 +780954,7 @@ var init_telegram_vision_router = __esm({
 });
 
 // packages/cli/src/tui/telegram-api-governor.ts
-function positiveInteger4(value2, fallback) {
+function positiveInteger3(value2, fallback) {
   return Number.isFinite(value2) && value2 > 0 ? Math.max(1, Math.floor(value2)) : fallback;
 }
 function nonNegativeInteger(value2, fallback) {
@@ -782896,11 +781061,11 @@ var init_telegram_api_governor = __esm({
       groupMessageStarts = /* @__PURE__ */ new Map();
       nextChatMessageAtMs = /* @__PURE__ */ new Map();
       constructor(options2 = {}) {
-        this.globalRequestsPerSecond = positiveInteger4(
+        this.globalRequestsPerSecond = positiveInteger3(
           options2.globalRequestsPerSecond,
           28
         );
-        this.globalMessagesPerSecond = positiveInteger4(
+        this.globalMessagesPerSecond = positiveInteger3(
           options2.globalMessagesPerSecond,
           28
         );
@@ -782908,15 +781073,15 @@ var init_telegram_api_governor = __esm({
           options2.perChatMessageIntervalMs,
           1050
         );
-        this.groupMessagesPerMinute = positiveInteger4(
+        this.groupMessagesPerMinute = positiveInteger3(
           options2.groupMessagesPerMinute,
           20
         );
-        this.maxConcurrentRequests = positiveInteger4(
+        this.maxConcurrentRequests = positiveInteger3(
           options2.maxConcurrentRequests,
           8
         );
-        this.maxQueuedRequests = positiveInteger4(options2.maxQueuedRequests, 2048);
+        this.maxQueuedRequests = positiveInteger3(options2.maxQueuedRequests, 2048);
         this.now = options2.now ?? Date.now;
       }
       run(request) {
@@ -783492,7 +781657,7 @@ import {
   mkdir as mkdirAsync,
   writeFile as writeFileAsync
 } from "node:fs/promises";
-import { createHash as createHash76, randomBytes as randomBytes29, randomInt } from "node:crypto";
+import { createHash as createHash75, randomBytes as randomBytes29, randomInt } from "node:crypto";
 function formatModelBytes(bytes2) {
   if (!Number.isFinite(bytes2) || bytes2 <= 0) return "0 B";
   const units = ["B", "KB", "MB", "GB", "TB"];
@@ -783955,8 +782120,6 @@ function parseTelegramInteractionDecision(text3, forcedRoute, options2 = {}) {
       const reason = String(
         parsed["reason"] ?? "live inference decision"
       ).slice(0, 240);
-      const replyTextRaw = parsed["reply"] ?? parsed["reply_text"];
-      const replyText = typeof replyTextRaw === "string" ? cleanTelegramVisibleReply(replyTextRaw).slice(0, 3900) : void 0;
       const inputIdRaw = parsed["input_id"] ?? parsed["inputId"];
       const addressedActorKeysRaw = parsed["addressed_actor_keys"] ?? parsed["addressedActorKeys"];
       const evidenceIdsRaw = parsed["evidence_ids"] ?? parsed["evidenceIds"];
@@ -783983,7 +782146,6 @@ function parseTelegramInteractionDecision(text3, forcedRoute, options2 = {}) {
         shouldReply,
         confidence: confidence2,
         reason,
-        replyText: replyText || void 0,
         inputId: typeof inputIdRaw === "string" ? inputIdRaw : void 0,
         addressedActorKeys,
         selfRole,
@@ -784805,7 +782967,7 @@ function buildTelegramRuntimeContext(now2 = /* @__PURE__ */ new Date(), repoRoot
   return buildConversationRuntimeContext(now2, repoRoot);
 }
 function telegramSessionIdFromKey(sessionKey) {
-  return `telegram-${createHash76("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
+  return `telegram-${createHash75("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
 }
 function normalizeTelegramSubAgentLimit(value2) {
   const parsed = typeof value2 === "number" ? value2 : typeof value2 === "string" && value2.trim() ? Number(value2.trim()) : TELEGRAM_SUB_AGENT_DEFAULT_LIMIT;
@@ -786217,11 +784379,6 @@ var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTAT
 var init_telegram_bridge = __esm({
   "packages/cli/src/tui/telegram-bridge.ts"() {
     init_conversation_context();
-    init_telegram_context_packet_v2();
-    init_telegram_input_ownership();
-    init_telegram_cognition_queue();
-    init_telegram_action_session_registry();
-    init_telegram_turn_contract_v2();
     init_telegram_format();
     init_async_process();
     init_dist8();
@@ -786581,7 +784738,6 @@ Telegram link integrity contract:
             "should_reply",
             "confidence",
             "reason",
-            "reply",
             "addressed_actor_keys",
             "self_role",
             "reply_basis",
@@ -786594,16 +784750,6 @@ Telegram link integrity contract:
             should_reply: { type: "boolean" },
             confidence: { type: "number", minimum: 0, maximum: 1 },
             reason: { type: "string" },
-            reply: {
-              anyOf: [
-                {
-                  type: "string",
-                  maxLength: 3900,
-                  description: "Exact Telegram reply text when route=chat and should_reply=true."
-                },
-                { type: "null" }
-              ]
-            },
             addressed_actor_keys: {
               type: "array",
               items: { type: "string" },
@@ -786697,7 +784843,7 @@ Telegram link integrity contract:
     TELEGRAM_MODERATION_APPROVAL_TTL_MS = 5 * 6e4;
     TELEGRAM_MODERATION_APPROVAL_RETENTION_MS = 24 * 60 * 6e4;
     TELEGRAM_MODERATION_APPROVAL_MAX_RECORDS = 64;
-    TELEGRAM_INTERACTION_DECISION_MINIMAL_SCHEMA = `{"input_id":"exact host input_id","route":"chat"|"action","should_reply":true|false,"confidence":0.0-1.0,"reason":"short reason","reply":"exact user-visible reply when route=chat and should_reply=true, otherwise null","addressed_actor_keys":["only actor keys from evidence packet"],"self_role":"addressee"|"participant"|"observer"|"uncertain","reply_basis":"direct_turn"|"ongoing_self_task"|"social_intervention"|"none"|"uncertain","evidence_ids":["only evidence ids from evidence packet"],"attention_state":"idle"|"observing"|"engaged"|"cooldown","attention_delta":-1.0..1.0,"next_check_after_messages":1..12,"reply_mode_preference":null|{"scope":"current_user_in_chat"|"current_user_global"|"current_group","reply_mode":"reply_then_notes"|"notes_then_reply"|"reply_only","confidence":0.0-1.0,"note":"explicit durable cadence preference"}}`;
+    TELEGRAM_INTERACTION_DECISION_MINIMAL_SCHEMA = `{"input_id":"exact host input_id","route":"chat"|"action","should_reply":true|false,"confidence":0.0-1.0,"reason":"short reason","addressed_actor_keys":["only actor keys from evidence packet"],"self_role":"addressee"|"participant"|"observer"|"uncertain","reply_basis":"direct_turn"|"ongoing_self_task"|"social_intervention"|"none"|"uncertain","evidence_ids":["only evidence ids from evidence packet"],"attention_state":"idle"|"observing"|"engaged"|"cooldown","attention_delta":-1.0..1.0,"next_check_after_messages":1..12,"reply_mode_preference":null|{"scope":"current_user_in_chat"|"current_user_global"|"current_group","reply_mode":"reply_then_notes"|"notes_then_reply"|"reply_only","confidence":0.0-1.0,"note":"explicit durable cadence preference"}}`;
     TELEGRAM_CHAT_REPLY_RESPONSE_FORMAT = {
       type: "json_schema",
       json_schema: {
@@ -787063,28 +785209,12 @@ Telegram link integrity contract:
       telegramModerationApprovalAuditPath;
       /** Active sub-agents by chat/guest session key */
       subAgents = /* @__PURE__ */ new Map();
-      /** Factories exist only during synchronous session acquisition. */
-      telegramActionSessionBlueprints = /* @__PURE__ */ new Map();
-      /** Reusable, single-owner action runners keyed by chat and principal. */
-      telegramActionSessions = null;
       /** Debounced live-context packets for messages arriving during a runner. */
       telegramSubAgentContextBuffers = /* @__PURE__ */ new Map();
       /** Append-only, durable ingress ledger for every agent-routed Telegram task input. */
       telegramIntakeRecords = /* @__PURE__ */ new Map();
       telegramIntakeMessages = /* @__PURE__ */ new Map();
       telegramIntakeWriteTail = Promise.resolve();
-      /** In-process authority mirror for exact input ownership and delivery idempotency. */
-      telegramInputOwnership = new TelegramInputOwnershipLedger();
-      /**
-       * Derived social/memory work runs after visible delivery. The queue has no
-       * Telegram send authority, serializes each chat scope, and cannot revise the
-       * already committed turn decision.
-       */
-      telegramCognitionQueue = new TelegramCognitionQueue({
-        maxConcurrentScopes: 2,
-        maxQueuedJobs: 128,
-        defaultTimeBudgetMs: 15e3
-      });
       /** Intent epochs isolate redirected/replaced work inside a long-lived chat session. */
       telegramTaskEpochs = /* @__PURE__ */ new Map();
       /** Active direct chat completions, counted with Telegram activity in the TUI */
@@ -787100,6 +785230,12 @@ Telegram link integrity contract:
       telegramActiveWorkSessions = /* @__PURE__ */ new Set();
       telegramActiveWorkGenerations = /* @__PURE__ */ new Map();
       telegramActiveWorkStartedAtMs = /* @__PURE__ */ new Map();
+      /**
+       * Native Telegram typing heartbeats owned by the outer work lifecycle.
+       * Group work starts one heartbeat before attention routing and keeps it
+       * alive through the selected reply path and final delivery.
+       */
+      telegramWorkTypingIntervals = /* @__PURE__ */ new Map();
       /** Queued Telegram sessions waiting for a global work slot. */
       telegramQueuedSessionWork = /* @__PURE__ */ new Map();
       telegramQueuedSessionCompletions = /* @__PURE__ */ new Map();
@@ -787591,7 +785727,7 @@ Telegram link integrity contract:
         return !!this.adminAuthChallenge && this.adminAuthChallenge.expiresAtMs > Date.now();
       }
       hashAdminAuthCode(code8) {
-        return createHash76("sha256").update(`omnius-telegram-admin:${code8.trim()}`).digest("hex");
+        return createHash75("sha256").update(`omnius-telegram-admin:${code8.trim()}`).digest("hex");
       }
       viewIdForMessage(msg) {
         return `telegram-${this.sessionKeyForMessage(msg).replace(/[^A-Za-z0-9_-]/g, "-")}`;
@@ -788049,6 +786185,9 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
           if (idleMs <= maxIdleMs) continue;
           const generation = this.telegramActiveWorkGenerations.get(sessionKey) ?? 0;
           this.telegramActiveWorkGenerations.set(sessionKey, generation + 1);
+          const typingInterval = this.telegramWorkTypingIntervals.get(sessionKey);
+          if (typingInterval) clearInterval(typingInterval);
+          this.telegramWorkTypingIntervals.delete(sessionKey);
           this.telegramActiveWorkSessions.delete(sessionKey);
           this.telegramActiveWorkStartedAtMs.delete(sessionKey);
           this.refreshActiveTelegramInteractionCount();
@@ -788183,6 +786322,18 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
         this.telegramActiveWorkSessions.add(work.sessionKey);
         this.telegramActiveWorkStartedAtMs.set(work.sessionKey, Date.now());
         const generation = this.nextTelegramWorkGeneration(work.sessionKey);
+        let workTypingInterval = null;
+        if (work.msg.chatType !== "private" && this.canUseChatActions(work.msg)) {
+          const staleTypingInterval = this.telegramWorkTypingIntervals.get(
+            work.sessionKey
+          );
+          if (staleTypingInterval) clearInterval(staleTypingInterval);
+          workTypingInterval = this.startTypingIndicator(
+            work.msg.chatId,
+            work.msg.messageThreadId
+          );
+          this.telegramWorkTypingIntervals.set(work.sessionKey, workTypingInterval);
+        }
         this.refreshActiveTelegramInteractionCount();
         const completion = this.telegramQueuedSessionCompletions.get(
           work.sessionKey
@@ -788197,6 +786348,10 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
           );
           completion?.reject(err);
         }).finally(() => {
+          if (workTypingInterval && this.telegramWorkTypingIntervals.get(work.sessionKey) === workTypingInterval) {
+            clearInterval(workTypingInterval);
+            this.telegramWorkTypingIntervals.delete(work.sessionKey);
+          }
           this.telegramQueuedSessionCompletions.delete(work.sessionKey);
           if (this.telegramWorkGenerationIsCurrent(work.sessionKey, generation)) {
             this.telegramActiveWorkSessions.delete(work.sessionKey);
@@ -788588,87 +786743,6 @@ ${context2}` : context2;
         const thread = msg.messageThreadId ?? 0;
         return `telegram:${this.sessionKeyForMessage(msg)}:${thread}:${msg.messageId ?? "unknown"}`;
       }
-      telegramInputTargetForMessage(msg) {
-        return {
-          inputId: this.telegramInputIdForMessage(msg),
-          sessionKey: this.sessionKeyForMessage(msg),
-          chatId: String(msg.chatId),
-          messageId: msg.messageId,
-          messageThreadId: msg.messageThreadId ?? 0,
-          senderActorKey: telegramSocialActorKey(
-            this.telegramMessageSocialActorInput(msg)
-          )
-        };
-      }
-      telegramInputOwnerForWork(sessionKey, generation) {
-        return {
-          ownerId: `telegram-work:${sessionKey}`,
-          generation
-        };
-      }
-      telegramTurnContractForDecision(msg, decision2) {
-        const packet = this.buildTelegramInteractionEvidencePacket(msg);
-        const target = this.telegramInputTargetForMessage(msg);
-        const kind = !decision2.shouldReply ? "no_reply" : decision2.route === "chat" ? "chat_reply" : "action";
-        const raw = {
-          version: 2,
-          kind,
-          input_id: target.inputId,
-          target: {
-            input_id: target.inputId,
-            session_key: target.sessionKey,
-            chat_id: target.chatId,
-            message_id: target.messageId,
-            message_thread_id: target.messageThreadId,
-            sender_actor_key: target.senderActorKey
-          },
-          confidence: decision2.confidence,
-          reason: decision2.reason,
-          addressed_actor_keys: decision2.addressedActorKeys ?? [],
-          self_role: decision2.selfRole ?? "uncertain",
-          reply_basis: decision2.replyBasis ?? "uncertain",
-          evidence_ids: decision2.evidenceIds ?? [],
-          ...kind === "chat_reply" && decision2.replyText ? { reply: decision2.replyText } : {},
-          ...kind === "action" ? { objective: decision2.reason } : {}
-        };
-        const validated = validateTelegramTurnContractV2(raw, {
-          target,
-          selfActorKey: packet.selfActorKey,
-          actorKeys: packet.actorKeys,
-          evidenceIds: packet.evidence.map((entry) => entry.id)
-        });
-        return validated.value;
-      }
-      async commitTelegramTurnDecision(msg, decision2, owner) {
-        const contract = this.telegramTurnContractForDecision(msg, decision2);
-        if (!contract) return null;
-        const target = this.telegramInputTargetForMessage(msg);
-        const result = this.telegramInputOwnership.commitDecision(target, owner, {
-          decisionId: decision2.decisionId ?? `tgdec-${telegramTurnContractV2Fingerprint(contract).slice(0, 20)}`,
-          contractFingerprint: telegramTurnContractV2Fingerprint(contract),
-          contractVersion: 2,
-          disposition: contract.kind
-        });
-        if (result.status === "applied" || result.status === "duplicate") {
-          await this.appendTelegramIntakeJournal(target.sessionKey, {
-            kind: "turn_contract_committed",
-            inputId: target.inputId,
-            decisionId: decision2.decisionId ?? result.record?.decision?.decisionId,
-            contractFingerprint: telegramTurnContractV2Fingerprint(contract),
-            disposition: contract.kind,
-            owner,
-            status: result.status
-          });
-          return contract;
-        }
-        this.tuiWrite(
-          () => renderTelegramSubAgentError(
-            msg.username,
-            `input ownership rejected turn contract (${result.status}): ${result.reason ?? "authority conflict"}`
-          )
-        );
-        return null;
-      }
       telegramTaskEpoch(sessionKey) {
         const current = this.telegramTaskEpochs.get(sessionKey);
         if (current !== void 0) return current;
@@ -788688,7 +786762,7 @@ ${context2}` : context2;
         };
       }
       telegramIntakePath(sessionKey) {
-        const digest4 = createHash76("sha256").update(sessionKey).digest("hex").slice(0, 20);
+        const digest4 = createHash75("sha256").update(sessionKey).digest("hex").slice(0, 20);
         return join187(
           this.repoRoot ?? process.cwd(),
           ".omnius",
@@ -788710,25 +786784,8 @@ ${context2}` : context2;
       async registerTelegramIntake(msg, triage) {
         const sessionKey = this.sessionKeyForMessage(msg);
         const inputId = this.telegramInputIdForMessage(msg);
-        const ownership = this.telegramInputOwnership.register(
-          this.telegramInputTargetForMessage(msg),
-          { ownerId: `telegram-ingress:${sessionKey}`, generation: 0 }
-        );
         const existing = this.telegramIntakeRecords.get(inputId);
-        if (ownership.status !== "applied") {
-          await this.appendTelegramIntakeJournal(sessionKey, {
-            kind: "intake_duplicate_or_conflict",
-            inputId,
-            status: ownership.status,
-            reason: ownership.reason,
-            observedTarget: this.telegramInputTargetForMessage(msg)
-          });
-          return {
-            record: existing,
-            ownershipStatus: ownership.status,
-            reason: ownership.reason
-          };
-        }
+        if (existing) return existing;
         const now2 = (/* @__PURE__ */ new Date()).toISOString();
         const record = {
           inputId,
@@ -788753,7 +786810,7 @@ ${context2}` : context2;
           record
         });
         await this.transitionTelegramIntake(record, "classified", triage.reason);
-        return { record, ownershipStatus: "applied" };
+        return record;
       }
       async transitionTelegramIntake(record, lifecycle, reason, links3 = {}) {
         const at = (/* @__PURE__ */ new Date()).toISOString();
@@ -790200,11 +788257,11 @@ ${antecedents.join("\n")}` : "Immediate antecedents: none.",
         return payload;
       }
       telegramConversationPath(sessionKey) {
-        const safe = createHash76("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash75("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join187(this.telegramConversationDir, `${safe}.json`);
       }
       telegramConversationLedgerPath(sessionKey) {
-        const safe = createHash76("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash75("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join187(this.telegramConversationDir, `${safe}.events.jsonl`);
       }
       telegramDb() {
@@ -790437,7 +788494,7 @@ ${antecedents.join("\n")}` : "Immediate antecedents: none.",
           relationships: Array.isArray(raw.relationships) ? raw.relationships.slice(0, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT).map((fact) => this.normalizeTelegramAssociativeFact(fact)) : [],
           actions: Array.isArray(raw.actions) ? raw.actions.slice(-TELEGRAM_ASSOCIATIVE_ACTION_LIMIT).map((action) => ({
             id: String(
-              action.id || createHash76("sha1").update(JSON.stringify(action)).digest("hex").slice(0, 12)
+              action.id || createHash75("sha1").update(JSON.stringify(action)).digest("hex").slice(0, 12)
             ),
             ts: typeof action.ts === "number" ? action.ts : Date.now(),
             role: action.role === "assistant" ? "assistant" : "user",
@@ -790456,7 +788513,7 @@ ${antecedents.join("\n")}` : "Immediate antecedents: none.",
         const now2 = Date.now();
         return {
           id: String(
-            raw.id || createHash76("sha1").update(text3 || String(now2)).digest("hex").slice(0, 12)
+            raw.id || createHash75("sha1").update(text3 || String(now2)).digest("hex").slice(0, 12)
           ),
           text: text3,
           tags: Array.isArray(raw.tags) ? raw.tags.map(String).slice(0, 16) : [],
@@ -790821,65 +788878,22 @@ ${antecedents.join("\n")}` : "Immediate antecedents: none.",
         };
       }
       deliverTelegramPostReplyNotes(sessionKey, msg, viewId, decision2, salienceSignals, daydreamOpportunities, visibleReplyText) {
-        const inputId = decision2.inputId || this.telegramInputIdForMessage(msg);
-        const decisionId = decision2.decisionId || "unbound";
-        const immutableDecision = {
-          ...decision2,
-          addressedActorKeys: decision2.addressedActorKeys ? [...decision2.addressedActorKeys] : void 0,
-          evidenceIds: decision2.evidenceIds ? [...decision2.evidenceIds] : void 0,
-          replyPreferenceUpdate: decision2.replyPreferenceUpdate ? { ...decision2.replyPreferenceUpdate } : void 0
-        };
-        const immutableMessage = {
-          ...msg,
-          mentionedUsernames: msg.mentionedUsernames ? [...msg.mentionedUsernames] : void 0,
-          mentionedActors: msg.mentionedActors ? msg.mentionedActors.map((actor) => ({ ...actor })) : void 0
-        };
-        const immutableSalience = [...salienceSignals];
-        const immutableOpportunities = daydreamOpportunities.map((item) => ({
-          ...item
-        }));
-        const receipt2 = this.telegramCognitionQueue.enqueue({
-          scopeKey: sessionKey,
-          dedupeKey: `post-reply:${inputId}:${decisionId}`,
-          kind: "cognition_batch",
-          execute: ({ signal }) => {
-            if (signal.aborted) return;
-            const postReplyDecision = this.synthesizeTelegramPostReplyDecision(
-              immutableDecision,
-              immutableMessage,
-              visibleReplyText
-            );
-            if (viewId && this.subAgentViewCallbacks) {
-              this.subAgentViewCallbacks.onWrite(
-                viewId,
-                "post-reply/internal notes:"
-              );
-            }
-            if (signal.aborted) return;
-            this.deliverTelegramAttentionDecision(
-              sessionKey,
-              immutableMessage,
-              viewId,
-              postReplyDecision,
-              immutableSalience,
-              immutableOpportunities
-            );
-          }
-        });
-        if (receipt2.admission === "rejected_capacity" || receipt2.admission === "rejected_closed") {
-          this.subAgentViewCallbacks?.onWrite(
-            viewId || this.viewIdForMessage(msg),
-            `post-reply cognition ${receipt2.admission.replace("rejected_", "rejected: ")}`
-          );
-          return;
+        const postReplyDecision = this.synthesizeTelegramPostReplyDecision(
+          decision2,
+          msg,
+          visibleReplyText
+        );
+        if (viewId && this.subAgentViewCallbacks) {
+          this.subAgentViewCallbacks.onWrite(viewId, "post-reply/internal notes:");
         }
-        void receipt2.completion.then((outcome) => {
-          if (outcome.status === "succeeded") return;
-          this.subAgentViewCallbacks?.onWrite(
-            viewId || this.viewIdForMessage(msg),
-            `post-reply cognition ${outcome.status}${outcome.errorMessage ? `: ${outcome.errorMessage}` : ""}`
-          );
-        });
+        this.deliverTelegramAttentionDecision(
+          sessionKey,
+          msg,
+          viewId,
+          postReplyDecision,
+          salienceSignals,
+          daydreamOpportunities
+        );
       }
       telegramTextDeliveryCapability(sessionKey, chatId, messageThreadId) {
         try {
@@ -791058,7 +789072,7 @@ ${antecedents.join("\n")}` : "Immediate antecedents: none.",
       telegramHistoryBackfillMessageId(sessionKey, entry, index) {
         if (typeof entry.messageId === "number" && Number.isFinite(entry.messageId))
           return entry.messageId;
-        const digest4 = createHash76("sha1").update(
+        const digest4 = createHash75("sha1").update(
           `${sessionKey}:${index}:${entry.role}:${entry.ts ?? ""}:${entry.text}`
         ).digest("hex").slice(0, 8);
         return -Number.parseInt(digest4, 16);
@@ -792332,7 +790346,7 @@ ${antecedents.join("\n")}` : "Immediate antecedents: none.",
         const now2 = entry.ts ?? Date.now();
         memory.updatedAt = now2;
         const speaker = telegramHistorySpeaker(entry);
-        const actionId = createHash76("sha1").update(
+        const actionId = createHash75("sha1").update(
           `${sessionKey}:${entry.role}:${entry.messageId ?? ""}:${now2}:${entry.text}`
         ).digest("hex").slice(0, 16);
         if (!memory.actions.some((action) => action.id === actionId)) {
@@ -792495,7 +790509,7 @@ ${antecedents.join("\n")}` : "Immediate antecedents: none.",
         let fact = facts.find((item) => item.text.toLowerCase() === key);
         if (!fact) {
           fact = {
-            id: createHash76("sha1").update(`${entry.chatId ?? ""}:${key}`).digest("hex").slice(0, 12),
+            id: createHash75("sha1").update(`${entry.chatId ?? ""}:${key}`).digest("hex").slice(0, 12),
             text: clean7,
             tags: telegramMemoryTags(clean7, entry.mediaSummary),
             speakers: [],
@@ -792580,7 +790594,7 @@ ${antecedents.join("\n")}` : "Immediate antecedents: none.",
           const titleTags = tags.slice(0, 4);
           const title = titleTags.length > 0 ? `${speaker} / ${titleTags.join(" ")}` : `${speaker} / conversation`;
           const card = {
-            id: createHash76("sha1").update(`${sessionKey}:${now2}:${speaker}:${text3}`).digest("hex").slice(0, 12),
+            id: createHash75("sha1").update(`${sessionKey}:${now2}:${speaker}:${text3}`).digest("hex").slice(0, 12),
             title,
             notes: [],
             tags: [],
@@ -794713,7 +792727,7 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
           }
         }
         if (issues.length > 0) return { decision: null, issues };
-        const decisionId = `tgdec-${createHash76("sha256").update(
+        const decisionId = `tgdec-${createHash75("sha256").update(
           JSON.stringify({
             inputId: packet.inputId,
             route: decision2.route,
@@ -794721,8 +792735,7 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
             addressed,
             selfRole: decision2.selfRole,
             replyBasis: decision2.replyBasis,
-            evidenceIds,
-            replyText: decision2.replyText
+            evidenceIds
           })
         ).digest("hex").slice(0, 20)}`;
         return { decision: { ...decision2, decisionId }, issues: [] };
@@ -794731,11 +792744,12 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
         return this.validateTelegramInteractionDecisionDetailed(decision2, packet).decision;
       }
       /**
-       * Materialize fields that are logical consequences of the model's chosen
-       * reply basis. The model still decides whether to reply and why. Once it
-       * chooses direct_turn, however, asking it to repeat "self is an addressee"
-       * in two additional fields creates three representations of one decision.
-       * A disagreement between those copies must not spend another inference.
+       * Materialize identity fields that are logical consequences of the model's
+       * selected reply basis. The model remains the sole owner of should_reply
+       * and reply_basis. Once it selects direct_turn, however, self_role and the
+       * self actor citation are redundant representations of the same decision.
+       * Reconcile those fields locally instead of rejecting an otherwise valid
+       * model-authored reply decision or spending a second inference on it.
        */
       normalizeTelegramInteractionDecisionImplications(decision2, packet) {
         if (decision2.replyBasis !== "direct_turn") return decision2;
@@ -794771,7 +792785,7 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
           ...validationIssues.length > 0 ? [
             `The host rejected the prior semantic contract for these exact reasons:`,
             ...validationIssues.map(
-              (issue3) => `- ${issue3.code}: ${issue3.message}`
+              (issue2) => `- ${issue2.code}: ${issue2.message}`
             ),
             `Correct every listed issue. Do not repeat a rejected identifier.`
           ] : [],
@@ -794828,7 +792842,7 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
               const cleaned = stripTelegramHiddenThinking(retryText).trim();
               diagnostics.strictRetryStatus = parsed && validation.issues.length > 0 ? "semantic-invalid" : cleaned ? "unparseable" : "empty";
               diagnostics.strictRetryValidationIssues = validation.issues.map(
-                (issue3) => issue3.code
+                (issue2) => issue2.code
               );
             }
             return null;
@@ -795057,6 +793071,9 @@ ${retryText}`,
             agent.typingInterval = null;
           }
           this.stopTelegramPublicProgressMessage(agent);
+          const workTypingInterval = this.telegramWorkTypingIntervals.get(sessionKey);
+          if (workTypingInterval) clearInterval(workTypingInterval);
+          this.telegramWorkTypingIntervals.delete(sessionKey);
           try {
             agent.runner?.abort?.();
           } catch {
@@ -795246,7 +793263,7 @@ ${stimulationProbe.context}`,
           reflectionContext = [
             "## Router fast-path note policy",
             "Do not generate silent_disposition, mental_note, memory_note, relationship_note, procedure_note, voice_note, scenario fields, or other internal notes in this router response.",
-            "Decide route, should_reply, confidence, reason, the exact reply for a tool-free chat turn, optional stimulation cadence, and optional explicit reply_mode_preference.",
+            "Only decide route, should_reply, confidence, reason, optional stimulation cadence, and optional explicit reply_mode_preference.",
             "If notes are needed, the bridge will synthesize or commit them after the visible reply according to the resolved reply mode."
           ].join("\n");
         } else {
@@ -795275,77 +793292,6 @@ ${stimulationProbe.context}`,
             `scenario_state_loop: ${reflectionNotes.scenarioStateLoop ?? "pending model-derived classifier output"}`
           ].join("\n");
         }
-        const routerContractContext = [
-          `Schema: ${TELEGRAM_INTERACTION_DECISION_MINIMAL_SCHEMA}`,
-          `Route meanings:`,
-          `- chat: a short conversational answer can be produced without tools.`,
-          `- action: tools, workspace context, media processing, web lookup, delegation, or a multi-step agent loop may be needed.`,
-          `Unified reply boundary: when route="chat" and should_reply=true, write the exact natural Telegram response in reply. This response is delivered directly, so do not describe a future reply, expose the contract, or include internal notes. Use reply=null for no_reply and action decisions.`
-        ].join("\n");
-        const routerContextBlocks = [
-          {
-            semanticId: "telegram.router.contract",
-            revision: 2,
-            stability: "stable",
-            order: 10,
-            priority: 100,
-            records: [
-              { recordId: "turn-contract", content: routerContractContext }
-            ]
-          },
-          {
-            semanticId: "telegram.router.persona",
-            revision: msg.messageId,
-            stability: "dynamic",
-            order: 20,
-            priority: 90,
-            records: [{ recordId: "persona", content: personaContext }]
-          },
-          {
-            semanticId: "telegram.router.reflection",
-            revision: msg.messageId,
-            stability: "dynamic",
-            order: 30,
-            priority: 70,
-            records: [{ recordId: "reflection", content: reflectionContext }]
-          },
-          {
-            semanticId: "telegram.router.observation",
-            revision: msg.messageId,
-            stability: "dynamic",
-            order: 40,
-            priority: 100,
-            records: [{ recordId: "evidence", content: observationContext }]
-          },
-          {
-            semanticId: "telegram.router.system-observations",
-            revision: msg.messageId,
-            stability: "dynamic",
-            order: 50,
-            priority: 60,
-            records: [
-              {
-                recordId: "observations",
-                content: formatSystemObservations(sessionKey)
-              }
-            ]
-          },
-          {
-            semanticId: "telegram.turn.current",
-            revision: msg.messageId,
-            stability: "dynamic",
-            order: 60,
-            priority: 110,
-            records: [{ recordId: "message-text", content: msg.text }]
-          }
-        ];
-        const routerContextPacket = compileTelegramContextPacketV2({
-          blocks: routerContextBlocks,
-          budgets: {
-            stableChars: 12e3,
-            dynamicChars: 48e3
-          }
-        });
         const userPrompt = [
           `You are the Telegram live routing and reply-discretion model.`,
           `Make the smallest sufficient live attention decision. Do not include internal notes unless explicitly supplied by deliberative mode context.`,
@@ -795356,6 +793302,12 @@ ${stimulationProbe.context}`,
           `Target binding: infer the addressees and this bot's role before should_reply. Another actor being addressed does not force silence; a reply can still be valid for an ongoing self-owned task or a socially useful intervention, but it must use that reply_basis and cite current evidence.`,
           `Authorization integrity: should_reply=true requires a non-none, non-uncertain reply_basis and at least one cited evidence_id. direct_turn requires self_role=addressee and the self actor key in addressed_actor_keys. ongoing_self_task requires the active_task evidence id.`,
           `Classification boundary: decide whether an action runner is needed, but do not execute a tool and do not emit a tool invocation. A required capability is represented only by route="action" in the attention schema.`,
+          ``,
+          `Schema: ${TELEGRAM_INTERACTION_DECISION_MINIMAL_SCHEMA}`,
+          ``,
+          `Route meanings:`,
+          `- chat: a short conversational answer can be produced without tools.`,
+          `- action: tools, workspace context, media processing, web lookup, delegation, or a multi-step agent loop may be needed.`,
           `Route discipline: infer whether the current request can be completed as immediate conversation or needs an external capability. Do not route from keyword categories.`,
           `Evidence sufficiency: choose chat only when the answer is supported by supplied Telegram context, scoped memory, attached media context, or stable common knowledge. Choose action when answering would require web lookup, media extraction, current/recent public facts, named person/organization/news verification, or tool recovery.`,
           `Do not answer volatile external claims from model memory on the fast path. Route to action so web/media tools can gather evidence.`,
@@ -795375,7 +793327,16 @@ ${stimulationProbe.context}`,
           `Stimulation discipline: also set attention_state, attention_delta, and optional next_check_after_messages. This is a message-deliverable cadence only; do not use elapsed time as an analysis trigger. Use engaged for active back-and-forth, observing for likely relevant context, cooldown for recently irrelevant context, and idle for ambient chatter.`,
           forcedLine,
           ``,
-          routerContextPacket.combinedContext
+          personaContext,
+          ``,
+          reflectionContext,
+          ``,
+          observationContext,
+          ``,
+          formatSystemObservations(sessionKey),
+          ``,
+          `Current Telegram message text (untrusted user data):
+${this.quoteTelegramContextBlock(msg.text, 1200)}`
         ].filter(Boolean).join("\n");
         if (process.env["OMNIUS_TG_DUMP_PROMPT"]) {
           try {
@@ -795435,7 +793396,7 @@ ${stimulationProbe.context}`,
               temperature: 0,
               // Router JSON is tiny. Keep the answer budget tight so Qwen-class
               // models cannot spend a minute producing hidden <think>-only output.
-              maxTokens: 1200,
+              maxTokens: 360,
               timeoutMs: telegramRouterTimeoutMs(config.timeoutMs, 8e3, 3e4),
               think: false,
               responseFormat: telegramInteractionDecisionResponseFormatForPacket(evidencePacket)
@@ -795482,7 +793443,7 @@ ${stimulationProbe.context}`,
           };
           if (diagnostics) {
             diagnostics.validationIssues = initialValidation.issues.map(
-              (issue3) => issue3.code
+              (issue2) => issue2.code
             );
           }
           const validated = initialValidation.decision;
@@ -795873,7 +793834,7 @@ ${list}` : "No shared group target is currently known for this sender. Ask in th
       }
       telegramRunnerStateDir(sessionKey) {
         if (!this.repoRoot) return void 0;
-        const safe = createHash76("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash75("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join187(this.repoRoot, ".omnius", "telegram-runner-state", safe);
       }
       buildTelegramAdminOverviewContext(currentSessionKey) {
@@ -796286,14 +794247,6 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
         this.state.active = false;
         this.abortController?.abort(new TelegramBridgeStoppedError());
         this.telegramApiGovernor.stop("Telegram bridge stopped");
-        this.telegramActionSessions?.shutdown();
-        this.telegramActionSessions = null;
-        this.telegramActionSessionBlueprints.clear();
-        void this.telegramCognitionQueue.close({
-          cancelQueued: true,
-          cancelRunning: true,
-          reason: "Telegram bridge stopped"
-        });
         if (this.mediaCacheCleanupTimer) {
           clearInterval(this.mediaCacheCleanupTimer);
           this.mediaCacheCleanupTimer = null;
@@ -796326,6 +794279,10 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
           );
         }
         this.telegramQueuedSessionCompletions.clear();
+        for (const interval of this.telegramWorkTypingIntervals.values()) {
+          clearInterval(interval);
+        }
+        this.telegramWorkTypingIntervals.clear();
         this.telegramActiveWorkSessions.clear();
         this.telegramActiveWorkGenerations.clear();
         this.telegramActiveWorkStartedAtMs.clear();
@@ -796468,17 +794425,21 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
       }
       // ── Typing indicator ──────────────────────────────────────────────────
       /** Start sending "typing" indicator every 4 seconds */
-      startTypingIndicator(chatId) {
-        this.sendChatAction(chatId, "typing").catch(() => {
+      startTypingIndicator(chatId, messageThreadId) {
+        this.sendChatAction(chatId, "typing", messageThreadId).catch(() => {
         });
         return setInterval(() => {
-          this.sendChatAction(chatId, "typing").catch(() => {
+          this.sendChatAction(chatId, "typing", messageThreadId).catch(() => {
           });
         }, 4e3);
       }
       /** Send a chat action (typing indicator) */
-      async sendChatAction(chatId, action) {
-        await this.apiCall("sendChatAction", { chat_id: chatId, action });
+      async sendChatAction(chatId, action, messageThreadId) {
+        await this.apiCall("sendChatAction", {
+          chat_id: chatId,
+          action,
+          ...messageThreadId !== void 0 ? { message_thread_id: messageThreadId } : {}
+        });
       }
       createTelegramGenerativeProgressBridge(chatId, msg) {
         if (chatId === void 0) return void 0;
@@ -797717,20 +795678,7 @@ Join: ${newUrl}`
           }
         }
         const intakeTriage = this.triageTelegramSteeringInput(msg);
-        const intakeRegistration = await this.registerTelegramIntake(
-          msg,
-          intakeTriage
-        );
-        if (intakeRegistration.ownershipStatus !== "applied" || !intakeRegistration.record) {
-          this.tuiWrite(
-            () => renderTelegramSubAgentEvent(
-              msg.username,
-              `input ${this.telegramInputIdForMessage(msg)} ignored after ${intakeRegistration.ownershipStatus}${intakeRegistration.reason ? `: ${intakeRegistration.reason}` : ""}`
-            )
-          );
-          return;
-        }
-        const intakeRecord = intakeRegistration.record;
+        const intakeRecord = await this.registerTelegramIntake(msg, intakeTriage);
         const existing = this.subAgents.get(sessionKey);
         if (existing && !existing.aborted) {
           const trustedPreemption = isAdminDM && (intakeRecord.intent === "cancel" || intakeRecord.intent === "redirect" || intakeRecord.intent === "replace");
@@ -797764,26 +795712,6 @@ Join: ${newUrl}`
         const isAdminDM = toolContext === "telegram-admin-dm";
         if (!this.telegramWorkGenerationIsCurrent(sessionKey, workGeneration))
           return;
-        const workOwner = this.telegramInputOwnerForWork(
-          sessionKey,
-          workGeneration
-        );
-        const primaryOwnership = this.telegramInputOwnership.claim(
-          this.telegramInputTargetForMessage(msg),
-          workOwner
-        );
-        if (primaryOwnership.status !== "applied" && primaryOwnership.status !== "duplicate") {
-          await Promise.all(
-            work.intakeRecords.map(
-              (intake) => this.transitionTelegramIntake(
-                intake,
-                "failed",
-                `Telegram input ownership rejected work admission (${primaryOwnership.status}): ${primaryOwnership.reason ?? "authority conflict"}`
-              )
-            )
-          );
-          return;
-        }
         await Promise.all(
           work.intakeRecords.map(
             (record) => this.transitionTelegramIntake(
@@ -797868,23 +795796,6 @@ Join: ${newUrl}`
           );
           return;
         }
-        const turnContract = await this.commitTelegramTurnDecision(
-          msg,
-          decision2,
-          workOwner
-        );
-        if (decision2.shouldReply && decision2.route === "chat" && decision2.replyText && !turnContract) {
-          await Promise.all(
-            work.intakeRecords.map(
-              (intake) => this.transitionTelegramIntake(
-                intake,
-                "failed",
-                "Telegram V2 chat contract failed exact-input ownership validation"
-              )
-            )
-          );
-          return;
-        }
         const replyMode = this.resolvedTelegramReplyMode(sessionKey, msg);
         const storedPreference = this.applyTelegramReplyPreferenceUpdate(
           sessionKey,
@@ -797937,20 +795848,6 @@ Join: ${newUrl}`
               )
             )
           );
-          if (turnContract?.kind === "no_reply") {
-            const terminal = this.telegramInputOwnership.complete(
-              this.telegramInputTargetForMessage(msg),
-              workOwner,
-              "consumed"
-            );
-            await this.appendTelegramIntakeJournal(sessionKey, {
-              kind: "turn_terminal_committed",
-              inputId: turnContract.inputId,
-              terminal: "consumed",
-              status: terminal.status,
-              owner: workOwner
-            });
-          }
           return;
         }
         const decisionContext = this.formatTelegramAttentionDecisionContext(
@@ -797977,8 +795874,8 @@ Join: ${newUrl}`
           return;
         }
         const subAgentProfile = decision2.route === "chat" ? "chat" : "action";
-        if (decision2.route === "chat") {
-          const visibleReplyDelivered = decision2.replyText ? await this.deliverTelegramContractReply(msg, decision2) : await this.handleTelegramChatCompletion(
+        if (decision2.route === "chat" && msg.chatType === "private") {
+          const visibleReplyDelivered = await this.handleTelegramChatCompletion(
             msg,
             toolContext,
             rapidContext,
@@ -798092,8 +795989,11 @@ Join: ${newUrl}`
           subAgent.viewId,
           `✈ Telegram message from @${msg.username}: ${msg.text}`
         );
-        if (this.canUseChatActions(msg)) {
-          subAgent.typingInterval = this.startTypingIndicator(msg.chatId);
+        if (this.canUseChatActions(msg) && !this.telegramWorkTypingIntervals.has(sessionKey)) {
+          subAgent.typingInterval = this.startTypingIndicator(
+            msg.chatId,
+            msg.messageThreadId
+          );
         }
         this.tuiWrite(
           () => renderTelegramSubAgentStart(msg.username, msg.text, isAdminDM)
@@ -798305,13 +796205,6 @@ Join: ${newUrl}`
             deliveredFinalText,
             Boolean(subAgent.liveMessageId && !msg.guestQueryId)
           );
-          if (sentMessageId !== null || msg.guestQueryId) {
-            await this.commitTelegramTurnDeliveryReceipt(
-              msg,
-              "action_effect",
-              sentMessageId !== null ? `telegram-message:${sentMessageId}:run:${subAgent.runId}` : `telegram-guest-query:${msg.guestQueryId}:run:${subAgent.runId}`
-            );
-          }
           this.tuiWrite(
             () => renderTelegramSubAgentComplete(msg.username, deliveredFinalText)
           );
@@ -798460,8 +796353,11 @@ ${errMsg}`
           `route: chat (${this.interactionMode}) with admin tools`
         );
         this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "running");
-        if (this.canUseChatActions(msg)) {
-          subAgent.typingInterval = this.startTypingIndicator(msg.chatId);
+        if (this.canUseChatActions(msg) && !this.telegramWorkTypingIntervals.has(sessionKey)) {
+          subAgent.typingInterval = this.startTypingIndicator(
+            msg.chatId,
+            msg.messageThreadId
+          );
         }
         this.tuiWrite(
           () => renderTelegramSubAgentEvent(
@@ -798686,96 +796582,6 @@ ${errMsg}`
         }
       }
       /** Fast Telegram chat path: direct streamed completion, no tool loop. */
-      async commitTelegramTurnDeliveryReceipt(msg, kind, transportReceiptId) {
-        const target = this.telegramInputTargetForMessage(msg);
-        const ownership = this.telegramInputOwnership.get(target.inputId);
-        if (!ownership?.decision) return false;
-        const expectedDisposition = kind === "visible_reply" ? "chat_reply" : "action";
-        if (ownership.decision.disposition !== expectedDisposition) return false;
-        const deliveryId = `tgdelivery-${createHash76("sha256").update(`${ownership.decision.decisionId}:${transportReceiptId}`).digest("hex").slice(0, 20)}`;
-        const delivery = this.telegramInputOwnership.commitDelivery(
-          target,
-          ownership.owner,
-          {
-            deliveryId,
-            decisionId: ownership.decision.decisionId,
-            kind,
-            transportReceiptId
-          }
-        );
-        const terminal = delivery.status === "applied" || delivery.status === "duplicate" ? this.telegramInputOwnership.complete(
-          target,
-          ownership.owner,
-          "consumed"
-        ) : void 0;
-        await this.appendTelegramIntakeJournal(target.sessionKey, {
-          kind: "turn_delivery_committed",
-          inputId: target.inputId,
-          decisionId: ownership.decision.decisionId,
-          deliveryId,
-          deliveryKind: kind,
-          transportReceiptId,
-          deliveryStatus: delivery.status,
-          terminalStatus: terminal?.status,
-          owner: ownership.owner
-        });
-        return (delivery.status === "applied" || delivery.status === "duplicate") && (terminal?.status === "applied" || terminal?.status === "duplicate");
-      }
-      /** Fast Telegram chat path: direct streamed completion, no tool loop. */
-      async deliverTelegramContractReply(msg, decision2) {
-        const cleaned = cleanTelegramVisibleReply(decision2.replyText ?? "");
-        if (!cleaned) return false;
-        const viewId = `${this.viewIdForMessage(msg)}-contract-reply`;
-        this.subAgentViewCallbacks?.onRegister(
-          viewId,
-          `✈ @${msg.username || "telegram"}`,
-          `Telegram unified chat reply: ${msg.text.slice(0, 160)}`
-        );
-        this.subAgentViewCallbacks?.onWrite(
-          viewId,
-          `delivering input-bound reply ${decision2.decisionId ?? decision2.inputId ?? "unbound"}`
-        );
-        this.subAgentViewCallbacks?.onStatus(viewId, "running");
-        try {
-          const sentMessageId = await this.sendOrEditFinalTelegramHTML(
-            msg,
-            convertMarkdownToTelegramHTML(cleaned),
-            null
-          );
-          if (sentMessageId === null && !msg.guestQueryId) {
-            throw new Error("Telegram unified reply produced no delivery receipt");
-          }
-          const deliveryCommitted = await this.commitTelegramTurnDeliveryReceipt(
-            msg,
-            "visible_reply",
-            sentMessageId !== null ? `telegram-message:${sentMessageId}` : `telegram-guest-query:${msg.guestQueryId}`
-          );
-          if (!deliveryCommitted) {
-            this.subAgentViewCallbacks?.onWrite(
-              viewId,
-              "delivery receipt authority conflict"
-            );
-          }
-          this.recordTelegramAssistantMessage(msg, cleaned, "chat", {
-            messageId: sentMessageId,
-            replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
-          });
-          this.subAgentViewCallbacks?.onWrite(viewId, `completed: ${cleaned}`);
-          this.subAgentViewCallbacks?.onStatus(viewId, "completed");
-          this.tuiWrite(
-            () => renderTelegramSubAgentComplete(msg.username, cleaned)
-          );
-          return true;
-        } catch (err) {
-          const errMsg = err instanceof Error ? err.message : String(err);
-          this.subAgentViewCallbacks?.onWrite(viewId, `delivery failed: ${errMsg}`);
-          this.subAgentViewCallbacks?.onStatus(viewId, "failed");
-          throw err;
-        } finally {
-          this.subAgentViewCallbacks?.onComplete(viewId);
-        }
-      }
-      /** Fast Telegram chat path: direct streamed completion, no tool loop. */
       async handleTelegramChatCompletion(msg, toolContext, additionalContext = "", authorizationContext = "") {
         if (toolContext === "telegram-admin-dm") {
           return this.handleTelegramAdminChatAgent(
@@ -798815,8 +796621,11 @@ ${errMsg}`
           `route: chat (${this.interactionMode})`
         );
         this.subAgentViewCallbacks?.onStatus(viewId, "running");
-        if (this.canUseChatActions(msg)) {
-          typingInterval = this.startTypingIndicator(msg.chatId);
+        if (this.canUseChatActions(msg) && !this.telegramWorkTypingIntervals.has(sessionKey)) {
+          typingInterval = this.startTypingIndicator(
+            msg.chatId,
+            msg.messageThreadId
+          );
         }
         this.tuiWrite(
           () => renderTelegramSubAgentEvent(
@@ -798925,11 +796734,6 @@ ${errMsg}`
           if (sentMessageId === null && !msg.guestQueryId) {
             throw new Error("Telegram final reply produced no delivery receipt");
           }
-          await this.commitTelegramTurnDeliveryReceipt(
-            msg,
-            "visible_reply",
-            sentMessageId !== null ? `telegram-message:${sentMessageId}` : `telegram-guest-query:${msg.guestQueryId}`
-          );
           if (sentMessageId !== null || msg.guestQueryId) {
             this.recordTelegramAssistantMessage(msg, cleaned, "chat", {
               messageId: sentMessageId,
@@ -799141,23 +796945,6 @@ ${conversationStream}`
           subAgent.currentStreamToolNames
         );
       }
-      ensureTelegramActionSessionRegistry() {
-        if (this.telegramActionSessions) return this.telegramActionSessions;
-        this.telegramActionSessions = new TelegramActionSessionRegistry({
-          ttlMs: 15 * 6e4,
-          maxEntries: 32,
-          create: ({ key, onTypedEvent }) => {
-            const createRunner = this.telegramActionSessionBlueprints.get(key);
-            if (!createRunner) {
-              throw new Error(
-                `Telegram action session ${key} has no active runner blueprint`
-              );
-            }
-            return { runner: createRunner(onTypedEvent) };
-          }
-        });
-        return this.telegramActionSessions;
-      }
       /** Run a sub-agent for a Telegram message */
       async runSubAgent(msg, subAgent, mediaContext = "", profile = "action", additionalContext = "", authorizationContext = "") {
         const config = this.agentConfig;
@@ -799198,7 +796985,122 @@ ${authorizationContext}` : "",
 
 ${creativeWorkspace}` : ""
         ].filter(Boolean).join("\n\n");
+        const backend = new OllamaAgenticBackend(
+          config.backendUrl,
+          config.model,
+          config.apiKey,
+          void 0,
+          config.providerProtocol,
+          config.providerId,
+          config.backendType
+        );
         const requestTimeoutMs = config.timeoutMs ?? 3e5;
+        const runner = new AgenticRunner(backend, {
+          surface: isAdminDM || isAdminGroup ? "telegram-admin" : "telegram-public",
+          interactionProfile: profile === "chat" ? "conversation" : "task",
+          // Admin DMs are operator-directed work sessions. A hard turn cap turns
+          // active tool progress into a false "completed" Telegram panel when the
+          // model has not reached task_complete yet. Public/group runs stay bounded.
+          maxTurns: isAdminDM ? 0 : isAdminGroup ? 12 : 8,
+          maxTokens: isAdminDM ? 8192 : 2048,
+          temperature: 0.3,
+          requestTimeoutMs,
+          taskTimeoutMs: isAdminDM ? Math.max(requestTimeoutMs * 3, 9e5) : requestTimeoutMs,
+          compactionThreshold: this.telegramFallbackCompactionThreshold(modelTier2),
+          contextWindowSize,
+          modelTier: modelTier2,
+          disableTodoCompletionGuard: true,
+          disableTodoPlanningNudges: true,
+          // The attention router already classified this private-admin turn as
+          // chat. Accept its first visible assistant answer as the terminal result
+          // instead of spending two more generations demanding task_complete.
+          // Action routes keep the normal explicit completion/evidence boundary.
+          acceptTextOnlyCompletion: isAdminDM && profile === "chat",
+          streamEnabled: true,
+          dynamicContext: runnerDynamicContext,
+          captureContextFrame: true,
+          stateDir: runnerStateDir,
+          sessionId: sessionContext.sessionId,
+          disablePersistentMemory: false,
+          disableCodebaseMap: !isAdminDM,
+          subAgent: !isAdminDM,
+          // Telegram sub-agents run tool-heavy workflows where qwen3 <think>
+          // reasoning is notorious for stalling: the model burns its token
+          // budget inside <think>...</think> and never closes the tag, producing
+          // empty content or 10+ minute replies after 24h. The runner's
+          // computeEffectiveThink() already kills thinking when hasTools=true,
+          // but we set it explicitly here as well so a future no-tools turn
+          // (compaction window, recovery prompt, watchdog probe) inherits the
+          // off default rather than the global config's value.
+          thinking: false,
+          // Surface-specific profile. PUBLIC/GROUP: bounded + fast + provenance
+          // guard off (truthfulness still enforced by the independent fabricated-
+          // provenance audit) so replies are quick and non-fabricated. ADMIN DM:
+          // evidence-heavy — provenance guard on + adversarial backward-pass
+          // approval on, persistence via unlimited maxTurns above. Both keep
+          // brute-force re-engagement and Adversary turn-extension OFF, which is
+          // how Telegram avoids the 60+ turn self-talk loops.
+          ...isAdminDM ? TELEGRAM_ADMIN_EVIDENCE_OPTIONS : TELEGRAM_PUBLIC_FAST_OPTIONS,
+          // ── WO #03 (Typed Gateway Event Stream): structured event feed ──
+          onTypedEvent: (event) => {
+            this.forwardTelegramRunnerIntakeLifecycle(event);
+            if (event.type === "steering_lifecycle" && event.reconciliation) {
+              upsertTelegramSteeringReconciliation(
+                subAgent.steeringReconciliations,
+                event.reconciliation
+              );
+              if (isAdminDM) {
+                const state5 = this.ensureTelegramAdminLivePanel(subAgent, msg);
+                state5.steeringReconciliations = [
+                  ...subAgent.steeringReconciliations.values()
+                ];
+                if (state5.activePage !== "response")
+                  state5.dirtyPages.response = true;
+              }
+            }
+            if (event.type === "run_finished") {
+              subAgent.runnerCompleted = event.success;
+              subAgent.runnerStatus = event.status;
+              subAgent.completionBoundarySeen = event.status === "completed";
+            }
+            if (event.type === "completion_incomplete_verification") {
+              subAgent.completionBoundarySeen = false;
+            }
+            if (event.type === "completion_accepted") {
+              subAgent.completionBoundarySeen = true;
+            }
+          }
+        });
+        runner.setWorkingDirectory(repoRoot);
+        subAgent.runner = runner;
+        if (subAgent.pendingIntakeRecords.length > 0) {
+          for (const queued of subAgent.pendingIntakeRecords) {
+            this.injectTelegramSteeringInput(
+              subAgent,
+              queued.intake,
+              queued.content
+            );
+            void this.transitionTelegramIntake(
+              queued.intake,
+              "accepted",
+              "initial Telegram intake handed to runner",
+              { runId: subAgent.runId }
+            );
+          }
+          this.tuiWrite(
+            () => renderTelegramSubAgentEvent(
+              msg.username,
+              `replayed ${subAgent.pendingIntakeRecords.length} typed intake record(s)`
+            )
+          );
+          subAgent.pendingIntakeRecords.length = 0;
+        }
+        if (subAgent.pendingContextPackets.length > 0) {
+          for (const packet of subAgent.pendingContextPackets) {
+            this.injectTelegramRuntimeGuidance(subAgent, packet);
+          }
+          subAgent.pendingContextPackets.length = 0;
+        }
         const tools = this.buildSubAgentTools(
           ctx3,
           repoRoot,
@@ -799215,102 +797117,12 @@ ${creativeWorkspace}` : ""
           }
           this.subAgentViewCallbacks?.onWrite(
             subAgent.viewId,
-            `tool surface: admin registry ready (${tools.length} tools; required capabilities registered: ${this.telegramAdminCoreToolNames().join(", ")})`
+            `tool surface: admin core ready (${tools.length} tools; ${this.telegramAdminCoreToolNames().join(", ")})`
           );
         }
-        const progressiveCoreTools = /* @__PURE__ */ new Set([
-          "task_complete",
-          "todo_read",
-          "todo_write",
-          "memory_read",
-          "memory_search",
-          "file_read",
-          "web_search",
-          "telegram",
-          "telegram_send_file"
-        ]);
-        const progressiveToolPolicy = {
-          profile: {
-            id: `telegram:${ctx3}`,
-            capabilities: [],
-            maximumAlwaysVisibleTools: 10,
-            maximumPromotedTools: 8
-          },
-          descriptors: [
-            ...tools.map((tool) => ({
-              name: tool.name,
-              role: tool.name === "task_complete" ? "completion" : tool.name === "telegram" ? "approval-boundary" : progressiveCoreTools.has(tool.name) ? "core" : "specialized"
-            })),
-            { name: "tool_search", role: "dispatcher" }
-          ]
-        };
-        const handleTypedEvent = (event) => {
-          this.forwardTelegramRunnerIntakeLifecycle(event);
-          if (event.type === "steering_lifecycle" && event.reconciliation) {
-            upsertTelegramSteeringReconciliation(
-              subAgent.steeringReconciliations,
-              event.reconciliation
-            );
-            if (isAdminDM) {
-              const state5 = this.ensureTelegramAdminLivePanel(subAgent, msg);
-              state5.steeringReconciliations = [
-                ...subAgent.steeringReconciliations.values()
-              ];
-              if (state5.activePage !== "response") state5.dirtyPages.response = true;
-            }
-          }
-          if (event.type === "run_finished") {
-            subAgent.runnerCompleted = event.success;
-            subAgent.runnerStatus = event.status;
-            subAgent.completionBoundarySeen = event.status === "completed";
-          }
-          if (event.type === "completion_incomplete_verification") {
-            subAgent.completionBoundarySeen = false;
-          }
-          if (event.type === "completion_accepted") {
-            subAgent.completionBoundarySeen = true;
-          }
-        };
-        const createRunner = (onTypedEvent) => {
-          const backend = new OllamaAgenticBackend(
-            config.backendUrl,
-            config.model,
-            config.apiKey,
-            void 0,
-            config.providerProtocol,
-            config.providerId,
-            config.backendType
-          );
-          return new AgenticRunner(backend, {
-            surface: isAdminDM || isAdminGroup ? "telegram-admin" : "telegram-public",
-            interactionProfile: profile === "chat" ? "conversation" : "task",
-            maxTurns: isAdminDM ? 0 : isAdminGroup ? 12 : 8,
-            maxTokens: isAdminDM ? 8192 : 2048,
-            temperature: 0.3,
-            requestTimeoutMs,
-            taskTimeoutMs: isAdminDM ? Math.max(requestTimeoutMs * 3, 9e5) : requestTimeoutMs,
-            compactionThreshold: this.telegramFallbackCompactionThreshold(modelTier2),
-            contextWindowSize,
-            modelTier: modelTier2,
-            disableTodoCompletionGuard: true,
-            disableTodoPlanningNudges: true,
-            acceptTextOnlyCompletion: isAdminDM && profile === "chat",
-            streamEnabled: true,
-            dynamicContext: profile === "action" ? "" : runnerDynamicContext,
-            progressiveToolPolicy,
-            captureContextFrame: true,
-            stateDir: runnerStateDir,
-            sessionId: sessionContext.sessionId,
-            disablePersistentMemory: false,
-            disableCodebaseMap: !isAdminDM,
-            subAgent: !isAdminDM,
-            thinking: false,
-            ...isAdminDM ? TELEGRAM_ADMIN_EVIDENCE_OPTIONS : TELEGRAM_PUBLIC_FAST_OPTIONS,
-            onTypedEvent
-          });
-        };
+        runner.registerTools(tools);
         const telegramSteeringFilter = new SteeringReconciliationStreamFilter();
-        const handleRunnerEvent = (event) => {
+        runner.onEvent((event) => {
           if (subAgent.aborted) return;
           subAgent.lastActivityMs = Date.now();
           let suppressExternalEvent = false;
@@ -799462,94 +797274,7 @@ ${creativeWorkspace}` : ""
               });
             }
           }
-        };
-        const prepareRunnerForTurn = (currentRunner) => {
-          currentRunner.prepareReusableRun({
-            dynamicContext: runnerDynamicContext,
-            tools,
-            workingDirectory: repoRoot
-          });
-          subAgent.runner = currentRunner;
-          if (subAgent.pendingIntakeRecords.length > 0) {
-            for (const queued of subAgent.pendingIntakeRecords) {
-              this.injectTelegramSteeringInput(
-                subAgent,
-                queued.intake,
-                queued.content
-              );
-              void this.transitionTelegramIntake(
-                queued.intake,
-                "accepted",
-                "initial Telegram intake handed to runner",
-                { runId: subAgent.runId }
-              );
-            }
-            this.tuiWrite(
-              () => renderTelegramSubAgentEvent(
-                msg.username,
-                `replayed ${subAgent.pendingIntakeRecords.length} typed intake record(s)`
-              )
-            );
-            subAgent.pendingIntakeRecords.length = 0;
-          }
-          if (subAgent.pendingContextPackets.length > 0) {
-            for (const packet of subAgent.pendingContextPackets) {
-              this.injectTelegramRuntimeGuidance(subAgent, packet);
-            }
-            subAgent.pendingContextPackets.length = 0;
-          }
-        };
-        let runner = null;
-        let actionLease = null;
-        if (profile === "action") {
-          const target = {
-            chatSessionKey: sessionContext.sessionKey,
-            principalKey: telegramSocialActorKey(
-              this.telegramMessageSocialActorInput(msg)
-            )
-          };
-          const key = telegramActionSessionKey(target);
-          const compatibilityKey = createHash76("sha256").update(
-            JSON.stringify({
-              schema: "telegram-action-runner.v1",
-              backendUrl: config.backendUrl,
-              backendType: config.backendType,
-              providerProtocol: config.providerProtocol,
-              providerId: config.providerId,
-              model: config.model,
-              surface: isAdminDM || isAdminGroup ? "telegram-admin" : "telegram-public",
-              profile,
-              stateDir: runnerStateDir ?? "",
-              sessionId: sessionContext.sessionId,
-              contextWindowSize,
-              modelTier: modelTier2,
-              toolNames: tools.map((tool) => tool.name).sort(),
-              toolExposure: progressiveToolPolicy.descriptors.map((descriptor2) => [descriptor2.name, descriptor2.role]).sort(([left], [right]) => left.localeCompare(right))
-            })
-          ).digest("hex");
-          this.telegramActionSessionBlueprints.set(key, createRunner);
-          try {
-            const acquired = this.ensureTelegramActionSessionRegistry().acquire({
-              target,
-              ownerId: subAgent.runId,
-              compatibilityKey,
-              onEvent: handleRunnerEvent,
-              onTypedEvent: handleTypedEvent
-            });
-            if (acquired.status !== "acquired") {
-              throw new Error(
-                `Telegram action session admission ${acquired.status}: ${acquired.reason}`
-              );
-            }
-            actionLease = acquired.lease;
-          } finally {
-            this.telegramActionSessionBlueprints.delete(key);
-          }
-        } else {
-          runner = createRunner(handleTypedEvent);
-          runner.onEvent(handleRunnerEvent);
-          prepareRunnerForTurn(runner);
-        }
+        });
         const chatLabel = isGroup ? ` in group "${msg.chatTitle || "unknown"}"` : "";
         const currentTelegramPrompt = this.formatTelegramCurrentMessageForPrompt(
           sessionContext.sessionKey,
@@ -799604,20 +797329,11 @@ ${additionalContext}`;
               toolContext: ctx3
             }
           },
-          () => {
-            const actualUserGoal = profile === "chat" ? msg.text : this.buildTelegramRunnerGoal(sessionContext.sessionKey, msg);
-            if (actionLease) {
-              return actionLease.run({
-                task: userPrompt,
-                actualUserGoal,
-                prepare: prepareRunnerForTurn
-              });
-            }
-            if (!runner) {
-              throw new Error("Telegram runner was not initialized");
-            }
-            return runner.run(userPrompt, void 0, actualUserGoal);
-          }
+          () => runner.run(
+            userPrompt,
+            void 0,
+            profile === "chat" ? msg.text : this.buildTelegramRunnerGoal(sessionContext.sessionKey, msg)
+          )
         );
         this.retainTelegramVisibleReplyFromCompletedStream(subAgent);
         subAgent.runnerCompleted = result.completed;
@@ -801757,7 +799473,7 @@ Scoped workspace: ${scopedRoot}`,
         );
       }
       telegramModerationActionDigest(action) {
-        return createHash76("sha256").update(JSON.stringify(action)).digest("hex");
+        return createHash75("sha256").update(JSON.stringify(action)).digest("hex");
       }
       async requireTelegramModerationGroup(chatId) {
         const result = await this.apiCall("getChat", { chat_id: chatId });
@@ -808492,7 +806208,7 @@ import { cwd } from "node:process";
 import { resolve as resolve85, join as join190, dirname as dirname69, extname as extname23, relative as relative24, sep as sep11 } from "node:path";
 import { createRequire as createRequire9 } from "node:module";
 import { fileURLToPath as fileURLToPath33 } from "node:url";
-import { createHash as createHash77 } from "node:crypto";
+import { createHash as createHash76 } from "node:crypto";
 import {
   readFileSync as readFileSync152,
   writeFileSync as writeFileSync103,
@@ -809365,7 +807081,7 @@ function truncateSubAgentViewText(s2, n2) {
   return s2.length > n2 ? `${s2.slice(0, n2)}…` : s2;
 }
 function childAgentTaskHash(task) {
-  return createHash77("sha256").update(task).digest("hex").slice(0, 12);
+  return createHash76("sha256").update(task).digest("hex").slice(0, 12);
 }
 function stripAnsiForParentContext(value2) {
   return value2.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
@@ -819196,13 +816912,13 @@ ${taskInput}`;
       writeContent(() => renderError(errMsg));
       if (failureStore) {
         try {
-          const { createHash: createHash82 } = await import("node:crypto");
+          const { createHash: createHash81 } = await import("node:crypto");
           failureStore.insert({
             taskId: "",
             sessionId: `${Date.now()}`,
             repoRoot,
             failureType: "runtime-error",
-            fingerprint: createHash82("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
+            fingerprint: createHash81("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
             filePath: null,
             errorMessage: errMsg.slice(0, 500),
             context: null,
@@ -821027,14 +818743,14 @@ var init_access_policy = __esm({
 });
 
 // packages/cli/src/api/project-preferences.ts
-import { createHash as createHash78 } from "node:crypto";
+import { createHash as createHash77 } from "node:crypto";
 import { existsSync as existsSync182, mkdirSync as mkdirSync117, readFileSync as readFileSync154, renameSync as renameSync31, writeFileSync as writeFileSync105, unlinkSync as unlinkSync46 } from "node:fs";
 import { homedir as homedir65 } from "node:os";
 import { join as join193, resolve as resolve89 } from "node:path";
 import { randomUUID as randomUUID34 } from "node:crypto";
 function projectKey(root) {
   const canonical3 = resolve89(root);
-  return createHash78("sha256").update(canonical3).digest("hex").slice(0, 16);
+  return createHash77("sha256").update(canonical3).digest("hex").slice(0, 16);
 }
 function projectDir(root) {
   return join193(PROJECTS_DIR, projectKey(root));
@@ -821125,7 +818841,7 @@ import { existsSync as existsSync183, mkdirSync as mkdirSync118, readFileSync as
 import { homedir as homedir66 } from "node:os";
 import { dirname as dirname70, join as join194 } from "node:path";
 import { fileURLToPath as fileURLToPath34 } from "node:url";
-import { createHash as createHash79 } from "node:crypto";
+import { createHash as createHash78 } from "node:crypto";
 function home() {
   return process.env["OMNIUS_HOME"]?.trim() || join194(homedir66(), ".omnius");
 }
@@ -821309,7 +819025,7 @@ async function ensureJetPackTorchvision(python2) {
       "OpenCLIP requires CUDA-compatible torchvision. Install the JetPack vendor torchvision for OMNIUS_VISION_PYTHON, or set OMNIUS_VISION_TORCHVISION_WHEEL to a local wheel and OMNIUS_VISION_TORCHVISION_WHEEL_SHA256 to its SHA-256. Generic PyPI torchvision is intentionally blocked."
     );
   }
-  const actualSha256 = createHash79("sha256").update(readFileSync155(wheel)).digest("hex");
+  const actualSha256 = createHash78("sha256").update(readFileSync155(wheel)).digest("hex");
   if (actualSha256 !== expectedSha256) {
     throw new VisionEmbeddingRuntimeError(
       "vision_runtime_not_ready",
@@ -822239,7 +819955,7 @@ var init_disk_task_output = __esm({
 });
 
 // packages/cli/src/api/http.ts
-import { createHash as createHash80 } from "node:crypto";
+import { createHash as createHash79 } from "node:crypto";
 function problemDetails(opts) {
   const p2 = {
     type: opts.type ?? "about:blank",
@@ -822302,7 +820018,7 @@ function paginated(items, page2, total) {
 }
 function computeEtag(payload) {
   const json2 = typeof payload === "string" ? payload : JSON.stringify(payload);
-  const hash2 = createHash80("sha1").update(json2).digest("hex").slice(0, 16);
+  const hash2 = createHash79("sha1").update(json2).digest("hex").slice(0, 16);
   return `W/"${hash2}"`;
 }
 function checkNotModified(req3, res, etag) {
@@ -846072,7 +843788,7 @@ import {
   readSync as readSync5,
   closeSync as closeSync12
 } from "node:fs";
-import { createHash as createHash81, randomBytes as randomBytes31, randomUUID as randomUUID35, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { createHash as createHash80, randomBytes as randomBytes31, randomUUID as randomUUID35, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 function memoryDbPaths3(baseDir = process.cwd()) {
   const dir = join206(baseDir, ".omnius");
   return {
@@ -846098,7 +843814,7 @@ function readServerPackageIdentity() {
           return {
             version: pkg.version ?? "0.0.0",
             packagePath: pkgPath,
-            packageHash: createHash81("sha256").update(raw).digest("hex")
+            packageHash: createHash80("sha256").update(raw).digest("hex")
           };
         }
       } catch {
@@ -855900,7 +853616,7 @@ function listScheduledTasks() {
                 );
                 const enabled2 = typeof t2?.enabled === "boolean" ? t2.enabled : true;
                 const realId = typeof t2?.id === "string" && t2.id ? t2.id : null;
-                const fallbackId = createHash81("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
+                const fallbackId = createHash80("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
                 const uid = realId || fallbackId;
                 const key = `${uid}`;
                 if (seen.has(key)) return;
@@ -856038,8 +853754,8 @@ function deleteScheduledById(id2) {
     if (typeof entry?.id === "string" && entry.id && !candidates.includes(entry.id))
       candidates.push(entry.id);
     try {
-      const { createHash: createHash82 } = require4("node:crypto");
-      const fallback = createHash82("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
+      const { createHash: createHash81 } = require4("node:crypto");
+      const fallback = createHash81("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
       if (!candidates.includes(fallback)) candidates.push(fallback);
     } catch {
     }
@@ -859299,8 +857015,8 @@ var scriptPath = process.argv[1] ?? "";
 var isMain2 = scriptPath.endsWith("index.js") || scriptPath.endsWith("index.ts") || scriptPath.endsWith("omnius-bin") || scriptPath.includes("omnius") || scriptPath.includes("/omnius");
 function crashLog(label, err) {
   const msg = err instanceof Error ? err.stack ?? err.message : String(err);
-  const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
-  const logLine = `[${timestamp2}] ${label}: ${msg}
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const logLine = `[${timestamp}] ${label}: ${msg}
 `;
   try {
     const { appendFileSync: appendFileSync25, mkdirSync: mkdirSync130 } = __require("node:fs");