@linzumi/cli 1.0.232 → 1.0.233

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.232",
+  "version": "1.0.233",
   "description": "Linzumi CLI \u2014 point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {

package/scripts/build-core-reconnect-resume-parity-oracle.mjs

@@ -54,7 +54,10 @@ import {
   fetchThreadTranscriptForRehydrationForTest,
   resumeCodexThreadForReconnect,
 } from './src/runner';
-import { withCodexCompletionSnapshotRequestTimeout } from './src/channelSession';
+import {
+  resumeOrRehydrateCodexThread,
+  withCodexCompletionSnapshotRequestTimeout,
+} from './src/channelSession';
 
 // Scripted codex JSON-RPC request seam: replies are consumed in call
 // order; every call is traced with its params. An exhausted script
@@ -127,6 +130,62 @@ async function runResumeCase(input) {
   return { trace };
 }
 
+// I200 hosted-agent narrow resume: the same shared core as reconnect, but
+// with the deliberately narrow missing-rollout-only recovery gate and the
+// path-specific loud error prefix/final log used by
+// narrowExistingLinzumiAgentThread.
+async function runNarrowCase(input) {
+  process.env.LINZUMI_CODEX_START_REQUEST_TIMEOUT_MS = String(
+    input.timeoutMs
+  );
+  const trace = [];
+  const request = scriptedRequest(input.requestScript ?? [], trace);
+  const rehydration = {
+    forceRehydrate: false,
+    buildRehydrationText: async (resumeFailure) => {
+      trace.push({ t: 'buildText', resumeFailure });
+      return input.textScript?.text;
+    },
+    buildRehydrationItems:
+      input.itemsScript === undefined
+        ? undefined
+        : async (resumeFailure) => {
+            trace.push({ t: 'buildItems', resumeFailure });
+            return input.itemsScript.items;
+          },
+    log: (event, payload) => trace.push({ t: 'log', event, payload }),
+  };
+  const outcome = await resumeOrRehydrateCodexThread({
+    codex: { request },
+    codexThreadId: input.codexThreadId,
+    resumeOverrides: input.resumeOverrides ?? {},
+    rebuildWhen: 'missing-rollout-only',
+    rehydration,
+  }).then(
+    (value) => {
+      trace.push({
+        t: 'log',
+        event: 'linzumi.agent_thread_narrowed',
+        payload: {
+          codex_thread_id: input.codexThreadId,
+          approval_policy: 'never',
+          sandbox: 'read-only',
+          rehydrated: value.mode === 'rehydrated',
+        },
+      });
+      return { ok: true, value };
+    },
+    (error) => ({
+      ok: false,
+      message:
+        'failed to narrow existing @linzumi Codex thread: ' +
+        (error instanceof Error ? error.message : String(error)),
+    })
+  );
+  trace.push({ t: 'outcome', outcome });
+  return { trace };
+}
+
 // Scripted Phoenix push seam shared by the two fetch legs.
 function scriptedPush(script, trace) {
   let index = 0;
@@ -223,6 +282,8 @@ async function runCase(input) {
   switch (input.kind) {
     case 'resumeRun':
       return runResumeCase(input);
+    case 'narrowRun':
+      return runNarrowCase(input);
     case 'fetchMessagesRun':
       return runFetchMessagesCase(input);
     case 'fetchTranscriptRun':

package/scripts/build.mjs

@@ -296,6 +296,12 @@ try {
       '    ok: false,\n' +
       "    failure: 'the cross-harness failover transpiler bridge was not bundled into this build',\n" +
       '  };\n' +
+      '}\n' +
+      'export async function seedCanonicalTranscriptIntoClaudeSession() {\n' +
+      '  return {\n' +
+      '    ok: false,\n' +
+      "    failure: 'the canonical Claude rehydration bridge was not bundled into this build',\n" +
+      '  };\n' +
       '}\n'
   );
 }