@linzumi/cli 1.0.22 → 1.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "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/record-agent-replay-fixtures.ts

@@ -4,6 +4,13 @@
   Relationship: Automatic raw fixture capture entrypoint. It drives real Codex
   app-server and Claude Code SDK sessions against the prepared fixture
   playground and lets the existing live recorder write provider-native NDJSON.
+
+- Date: 2026-07-02
+  Spec: plans/2026-07-02-claude-plan-mode-observability-v2-implementation-plan.md
+  Relationship: Adds the claude-plan-mode capture lane - a real Claude Code
+  session started in permissionMode 'plan' with hook events on, auto-approving
+  the ExitPlanMode plan review so the fixture records the full observable
+  plan-mode lifecycle (status permissionMode frames, ExitPlanMode call/result).
 */
 import { mkdtemp, cp, mkdir, readFile, writeFile, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
@@ -21,7 +28,7 @@ import { recordLiveAgentReplay } from '../src/agentReplayLiveRecorder';
 import { type JsonObject, type JsonValue } from '../src/protocol';
 import { preflightGstackClaudeSmokeSetup } from '../src/gstackReplayPreflight';
 
-type Provider = 'codex' | 'claude' | 'gstack-claude-smoke';
+type Provider = 'codex' | 'claude' | 'gstack-claude-smoke' | 'claude-plan-mode';
 
 type CaptureOptions = {
   readonly providers: readonly Provider[];
@@ -122,6 +129,9 @@ async function main(): Promise<void> {
       case 'gstack-claude-smoke':
         await runClaudeCapture(options, runDir, prompt, 'gstack');
         break;
+      case 'claude-plan-mode':
+        await runClaudeCapture(options, runDir, prompt, 'plan-mode');
+        break;
     }
 
     recordLiveAgentReplay({
@@ -211,6 +221,8 @@ function providersFromArg(value: string): readonly Provider[] {
       return ['claude'];
     case 'gstack-claude-smoke':
       return ['gstack-claude-smoke'];
+    case 'claude-plan-mode':
+      return ['claude-plan-mode'];
     default:
       throw new Error(`unsupported --provider value: ${value}`);
   }
@@ -272,6 +284,8 @@ function fixturePromptHeading(provider: Provider): string {
       return 'Claude Code Prompt';
     case 'gstack-claude-smoke':
       return 'Gstack Claude Smoke Prompt';
+    case 'claude-plan-mode':
+      return 'Claude Plan Mode Prompt';
   }
 }
 
@@ -283,6 +297,7 @@ async function preflightCaptureProvider(
   switch (provider) {
     case 'codex':
     case 'claude':
+    case 'claude-plan-mode':
       return { type: 'none' };
     case 'gstack-claude-smoke':
       return {
@@ -520,7 +535,7 @@ async function runClaudeCapture(
   options: CaptureOptions,
   cwd: string,
   prompt: string,
-  profile: 'generic' | 'gstack'
+  profile: 'generic' | 'gstack' | 'plan-mode'
 ): Promise<void> {
   const stream = claudeQuery({
     prompt,
@@ -535,9 +550,24 @@ async function runClaudeCapture(
       ...(profile === 'gstack'
         ? { includeHookEvents: true, env: gstackClaudeCaptureEnv(process.env) }
         : {}),
+      // Plan-mode lane: start IN plan mode so the fixture records the status
+      // permissionMode frames and the ExitPlanMode call/result lifecycle. The
+      // canUseTool bridge auto-approves everything (the playground is a
+      // throwaway temp copy and plan mode already blocks writes), so the plan
+      // review resolves deterministically without a human.
+      ...(profile === 'plan-mode'
+        ? {
+            permissionMode: 'plan' as PermissionMode,
+            includeHookEvents: true,
+            canUseTool: async (
+              _toolName: string,
+              input: Record<string, unknown>
+            ) => ({ behavior: 'allow' as const, updatedInput: input }),
+          }
+        : {}),
       settingSources: ['user', 'project', 'local'],
       systemPrompt: { type: 'preset', preset: 'claude_code' },
-      ...(options.claudePermissionMode === undefined
+      ...(options.claudePermissionMode === undefined || profile === 'plan-mode'
         ? {}
         : {
             permissionMode: options.claudePermissionMode,

package/scripts/replay-agent-backend.ts

@@ -490,6 +490,12 @@ async function registerReplayFixtureUser(
       body: JSON.stringify({
         display_name: username,
         e2e_fixture: true,
+        // updateViewerFeatureFlag requires a developer user (#2149 gate); the
+        // fixture-registration path marks the throwaway user via this param
+        // (auth_controller maybe_mark_e2e_fixture_developer), which is only
+        // honored when KANDAN_E2E_FIXTURE_REGISTRATION enabled the stub-mode
+        // dev backend.
+        e2e_fixture_developer: true,
         email: `${username}@example.test`,
         password: `pw-${username}`,
         username,
@@ -892,10 +898,11 @@ async function evaluateBackendReplayOracles(
   const output =
     processedState === undefined
       ? { sourceSeq: undefined, items: [] as BackendReplayThreadOutputItem[] }
-      : await queryBackendReplayThreadOutput(
+      : await queryBackendReplayThreadOutputSettled(
           options,
           start.threadId,
-          processedState.seq
+          processedState.seq,
+          provider
         );
   checks.push({
     id: 'thread-output-present',
@@ -963,6 +970,7 @@ async function evaluateBackendReplayOracles(
       featureId: options.oracleFeatureId ?? options.requiredFeatureId,
       provider,
       outputItems: output.items,
+      requireLane: options.oracleFeatureId !== undefined,
     })
   );
 
@@ -1045,6 +1053,60 @@ async function queryBackendReplayThreadOutput(
   };
 }
 
+// The terminal message state can land before the async row projection
+// finishes, so a single post-terminal query races the projection (observed:
+// the same fixture produced different row subsets run to run). Poll until the
+// projected output is quiescent - and, when a feature oracle is requested,
+// until its checks pass - before snapshotting.
+async function queryBackendReplayThreadOutputSettled(
+  options: BackendReplayOptions,
+  threadId: string,
+  sourceSeq: number,
+  provider: 'codex' | 'claude-code'
+): Promise<{
+  readonly sourceSeq: number;
+  readonly items: readonly BackendReplayThreadOutputItem[];
+}> {
+  const timeoutMs = 30_000;
+  const pollIntervalMs = 250;
+  const startedAtMs = Date.now();
+  const featureId = options.oracleFeatureId ?? options.requiredFeatureId;
+  let last = await queryBackendReplayThreadOutput(options, threadId, sourceSeq);
+  // Content-keyed stability: a row can flip streaming -> completed (or grow
+  // fields) without changing the count, so count-only comparison could
+  // snapshot mid-stream rows as settled.
+  let lastFingerprint = JSON.stringify(last.items);
+  let stableRounds = 0;
+
+  while (Date.now() - startedAtMs < timeoutMs) {
+    const featureSatisfied =
+      featureId === undefined ||
+      featureBackendReplayOracleChecks({
+        featureId,
+        provider,
+        outputItems: last.items,
+        requireLane: options.oracleFeatureId !== undefined,
+      }).every((check) => check.status === 'passed');
+
+    if (featureSatisfied && stableRounds >= 2) {
+      return last;
+    }
+
+    await new Promise((resolvePoll) => setTimeout(resolvePoll, pollIntervalMs));
+    const next = await queryBackendReplayThreadOutput(
+      options,
+      threadId,
+      sourceSeq
+    );
+    const nextFingerprint = JSON.stringify(next.items);
+    stableRounds = nextFingerprint === lastFingerprint ? stableRounds + 1 : 0;
+    lastFingerprint = nextFingerprint;
+    last = next;
+  }
+
+  return last;
+}
+
 function backendReplayGraphqlVariables(
   options: BackendReplayOptions,
   threadId: string

package/scripts/replay-agent-fixture.ts

@@ -115,6 +115,7 @@ function combineDiagnostics(
 ): ReturnType<typeof collectAgentReplayDiagnostics> {
   return {
     droppedEvents: diagnostics.flatMap((entry) => entry.droppedEvents),
+    debugOnlyEvents: diagnostics.flatMap((entry) => entry.debugOnlyEvents),
   };
 }