@linzumi/cli 1.0.115 → 1.0.117

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.115",
+  "version": "1.0.117",
   "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/analyze_enter_to_typing_latency.mjs

@@ -86,8 +86,14 @@ for await (const line of rl) {
     state = { pending: null };
     threads.set(threadId, state);
   }
-  const event = entry.event;
-  if (event === 'kandan.message_queued') {
+  // N2.4-prep (naming-consistency program wave N2): match the CANONICAL
+  // event names first with the legacy spellings as the permanent fallback -
+  // dual-emit window logs carry the legacy name (plus an event_canonical
+  // twin field), post-flip logs carry the canonical name only, and archived
+  // logs stay legacy forever (D45). codex.turn_starting is a retained D42
+  // true-harness name (not renamed).
+  const event = entry.event_canonical ?? entry.event;
+  if (event === 'linzumi.message_queued' || event === 'kandan.message_queued') {
     state.pending = { atMs, seq: entry.seq, blocked: [], spawn: false };
   } else if (state.pending !== null) {
     if (event === 'codex.turn_starting') {
@@ -99,7 +105,10 @@ for await (const line of rl) {
         spawn: state.pending.spawn,
       });
       state.pending = null;
-    } else if (event === 'kandan.queue_drain_blocked') {
+    } else if (
+      event === 'linzumi.queue_drain_blocked' ||
+      event === 'kandan.queue_drain_blocked'
+    ) {
       state.pending.blocked.push(entry.reason);
     } else if (event === 'runner.thread_process_starting') {
       state.pending.spawn = true;

package/scripts/build-onboarding-demo-evidence.mjs

@@ -0,0 +1,186 @@
+// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
+// (M3 cluster 13, onboarding - visual evidence).
+// Relationship: Builds the TS TWIN of the onboarding demo entrypoint
+// (packages/linzumi-cli-rescript/src/onboarding/CommanderOnboardingDemoMain.res):
+// the REAL runSignupFlow mounted on the live terminal - real
+// @inquirer/prompts rendering, the real raw-keypress project picker, the
+// REAL createSignupServerClient speaking HTTP to the SAME in-process
+// ScriptedAuthServer (imported from the ReScript package's compiled
+// module - one server implementation, zero drift), replaying the SAME
+// commanderOnboardingDemoScenario.json. scripts/onboarding_evidence_
+// capture.sh drives both entrypoints with the same tmux key schedule and
+// byte-compares the captures.
+//
+// Determinism: the scenario is dummy data; the only wall-clock effects
+// (config-file timestamps) never reach the terminal (the demo runs with
+// debugLaunchPayload off unless --debug-signup is passed for ad-hoc use).
+import { mkdir, readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { build } from 'esbuild';
+
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+const driverSource = `
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { runSignupFlow, signupSuggestTasksForProjectForTest, signupPromptCancelMessage } from './src/signupFlow';
+import { createSignupServerClient } from './src/signupServerClient';
+// The ONE scripted-server implementation: the ReScript package's cluster 3
+// double, imported as plain ESM.
+import * as ScriptedAuthServer from '../linzumi-cli-rescript/src/parity/ScriptedAuthServer.res.mjs';
+
+const scenarioPath = join(
+  '${packageRoot}',
+  '..',
+  'linzumi-cli-rescript',
+  'src',
+  'onboarding',
+  'commanderOnboardingDemoScenario.json'
+);
+const scenario = JSON.parse(readFileSync(scenarioPath, 'utf8'));
+
+function reviveProjects(projects) {
+  return (projects ?? []).map((project) => ({
+    path: project.path,
+    language: project.language,
+    source: project.source,
+    ...(project.gitHead === undefined || project.gitHead === null
+      ? {}
+      : { gitHead: project.gitHead }),
+  }));
+}
+
+const jsonResponse = (value) =>
+  ScriptedAuthServer.jsonResponse(200, JSON.stringify(value ?? {}));
+
+async function main() {
+  const args = process.argv.slice(2);
+  const mock = args.includes('--mock');
+  const handle = await ScriptedAuthServer.start({
+    routes: [
+      {
+        method: 'POST',
+        path: '/api/v2/signup/email-code/start',
+        responses: [jsonResponse(scenario.server.emailCodeStart)],
+      },
+      {
+        method: 'POST',
+        path: '/api/v2/signup/email-code/verify',
+        responses: [jsonResponse(scenario.server.emailCodeVerify)],
+      },
+      {
+        method: 'POST',
+        path: '/api/v2/signup/mission-control/complete',
+        responses: [jsonResponse(scenario.server.missionControlComplete)],
+      },
+      {
+        method: 'POST',
+        path: '/api/v2/signup/mission-control/start-tasks',
+        responses: [jsonResponse(scenario.server.missionControlStartTasks)],
+      },
+    ],
+  });
+  const serviceUrl = handle.baseUrl;
+  const preflight = scenario.preflight ?? {};
+  const tools = preflight.tools ?? {};
+  const demoHome = process.env.LINZUMI_ONBOARDING_DEMO_HOME ?? process.env.HOME ?? '/tmp';
+  const noopCacheStore = { read: () => undefined, write: () => {} };
+  try {
+    await runSignupFlow({
+      // Real stdio: the prompts default to the REAL inquirer surface and
+      // the raw-keypress picker (deps.prompts stays undefined).
+      input: process.stdin,
+      output: process.stdout,
+      preflight: {
+        cwd: demoHome,
+        homeDir: demoHome,
+        probeTool: async (command) => {
+          const tool = tools[command];
+          if (tool === undefined) {
+            return { command, available: false };
+          }
+          return { command, available: tool.available, version: tool.version ?? undefined };
+        },
+        readGitEmail: async () => preflight.gitEmail ?? undefined,
+        discoverCodeRoots: async () => preflight.codeRoots ?? [],
+        checkBrowserHandoff: async () => preflight.browserHandoff !== false,
+      },
+      projectDiscovery: {
+        discoverProjects: async () => reviveProjects(scenario.projects),
+      },
+      taskSuggestion: {
+        suggestTasks: (project, output) =>
+          signupSuggestTasksForProjectForTest({
+            project,
+            output,
+            taskCacheStore: noopCacheStore,
+            codexTaskRunner: async () => scenario.suggestedTasks ?? [],
+          }),
+      },
+      forceSignup: args.includes('--force-signup'),
+      serviceUrl,
+      openBrowser: false,
+      debugLaunchPayload: args.includes('--debug-signup'),
+      signupServerClient: mock ? false : createSignupServerClient({ serviceUrl }),
+      commanderLauncher: async () => ({
+        status: 'started',
+        runnerId: scenario.launch?.runnerId ?? 'demo-commander',
+        restartCommand:
+          scenario.launch?.restartCommand ?? 'npx -y @linzumi/cli@latest connect',
+        instanceId: 'demo-instance',
+      }),
+    });
+    await handle.stop();
+    process.exit(0);
+  } catch (error) {
+    await handle.stop();
+    const message = error instanceof Error ? error.message : String(error);
+    process.stdout.write((signupPromptCancelMessage(error) ?? message) + '\\n');
+    process.exit(1);
+  }
+}
+
+main();
+`;
+
+await mkdir(join(packageRoot, '.differential'), { recursive: true });
+
+// The build-auth-parity-oracle.mjs banner convention (inquirer's CJS deps
+// require node builtins at module scope).
+const banner = {
+  js: "import { createRequire as __onboardingDemoCreateRequire } from 'node:module';\nconst require = __onboardingDemoCreateRequire(import.meta.url);",
+};
+
+await build({
+  banner,
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'onboarding-demo-evidence-driver.ts',
+    loader: 'ts',
+  },
+  bundle: true,
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  outfile: join(packageRoot, '.differential/onboarding-demo-evidence.mjs'),
+  minify: false,
+  sourcemap: false,
+  legalComments: 'none',
+  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
+});
+
+// Keep the scenario honest: fail the build loudly if the shared file is
+// missing (the twin reads it at RUNTIME from the sibling package).
+await readFile(
+  join(
+    packageRoot,
+    '..',
+    'linzumi-cli-rescript',
+    'src',
+    'onboarding',
+    'commanderOnboardingDemoScenario.json'
+  ),
+  'utf8'
+);

package/scripts/build-onboarding-discovery-parity-oracle.mjs

@@ -0,0 +1,380 @@
+// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
+// (M3 cluster 13, onboarding - the DISCOVERY STACK slice).
+// Relationship: Builds the TS-side PARITY ORACLE for the onboarding
+// discovery port. The oracle bundles the REAL TS discovery modules -
+// onboardingProjectDiscovery.ts, onboardingConversationDiscovery.ts,
+// onboardingDiscoveryAgent.ts, onboardingDiscoveryChildProcess.ts,
+// onboardingPlaceResponsiveness.ts - plus the agent builder's REAL seam
+// modules (codexHome.ts, mcpConfig.ts, safeWorkingDir.ts, probed so the
+// ReScript port's injected deps carry the SAME real values) behind the
+// cluster 1/2 one-shot BATCH driver (a JSON array of cases on stdin, a
+// JSON array of results on stdout).
+//
+// CHILD ROLE MODE: when LINZUMI_ONBOARDING_DISCOVERY_ROLE is set in the
+// environment the oracle becomes a REAL discovery child running the REAL
+// runOnboardingDiscoveryChildRole over process stdin/stdout - exactly the
+// CLI entry's dispatch (src/index.ts main) - so EITHER impl's parent can
+// spawn this bundle as its discovery child (the cross-impl process legs).
+//
+// Determinism: both impls scan the SAME conformance-built scratch trees
+// (absolute paths ride the cases; nothing is normalized here - the
+// conformance normalizes wall-clock durations on both sides identically).
+//
+// SECRETS: synthetic case payloads only; .differential/ is gitignored.
+import { mkdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { build } from 'esbuild';
+
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+const driverSource = `
+import {
+  discoverCurrentGitProject,
+  defaultLocalProjectSourceRootsForTest,
+} from './src/onboardingProjectDiscovery';
+import {
+  cleanConversationTitleForTest,
+  discoverLocalConversations,
+  readLocalConversationImportMessages,
+} from './src/onboardingConversationDiscovery';
+import {
+  conversationDiscoveryPrompt,
+  onboardingDiscoveryAgentPlans,
+  onboardingDiscoveryAgentProcess,
+  onboardingDiscoveryAgentProcessesForTest,
+  projectDiscoveryPrompt,
+} from './src/onboardingDiscoveryAgent';
+import {
+  discoverCurrentGitProjectInChildProcess,
+  discoverLocalConversationsInChildProcess,
+  onboardingDiscoveryRoleEnvKey,
+  runOnboardingDiscoveryChildRole,
+} from './src/onboardingDiscoveryChildProcess';
+import {
+  isPlaceResponsive,
+  probeWorkerSourceForTest,
+} from './src/onboardingPlaceResponsiveness';
+import {
+  codexCredentialStoreFileArgs,
+  ensureIsolatedCodexHome,
+} from './src/codexHome';
+import { codexMcpConfigArgs, linzumiMcpServerConfig } from './src/mcpConfig';
+import { assessDangerousCwd } from './src/safeWorkingDir';
+
+function outcome(run) {
+  try {
+    const value = run();
+    return value === undefined ? { defined: false } : { defined: true, value };
+  } catch (error) {
+    return {
+      threw: true,
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+const savedEnv = {};
+
+function setCaseEnv(env) {
+  for (const [key, value] of Object.entries(env ?? {})) {
+    savedEnv[key] = process.env[key];
+    if (value === null) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+}
+
+function restoreCaseEnv() {
+  for (const [key, value] of Object.entries(savedEnv)) {
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+    delete savedEnv[key];
+  }
+}
+
+function scriptedResponsiveness(testCase, probeCalls) {
+  if (testCase.unresponsivePlaces === undefined && testCase.probeTimeoutMs === undefined) {
+    return undefined;
+  }
+  const unresponsive = new Set(testCase.unresponsivePlaces ?? []);
+  return {
+    timeoutMs: testCase.probeTimeoutMs,
+    probe: (path, timeoutMs) => {
+      probeCalls.push({ path, timeoutMs });
+      return !unresponsive.has(path);
+    },
+  };
+}
+
+function handleProjectDiscovery(testCase) {
+  const probeCalls = [];
+  setCaseEnv(testCase.env);
+  try {
+    const summary = discoverCurrentGitProject({
+      cwd: testCase.args.cwd,
+      nowMs: testCase.args.nowMs ?? undefined,
+      homeDir: testCase.args.homeDir ?? undefined,
+      sourceRoots: testCase.args.sourceRoots ?? undefined,
+      selectedScanRoots: testCase.args.selectedScanRoots ?? undefined,
+      includeRuntimeCwdHint: testCase.args.includeRuntimeCwdHint ?? undefined,
+      sourceRootMaxDepth: testCase.args.sourceRootMaxDepth ?? undefined,
+      sourceRootScanBudgetMs: testCase.args.sourceRootScanBudgetMs ?? undefined,
+      sourceRootMaxDirectoryVisits:
+        testCase.args.sourceRootMaxDirectoryVisits ?? undefined,
+      sourceRootMaxProjectEnrichments:
+        testCase.args.sourceRootMaxProjectEnrichments ?? undefined,
+      placeResponsiveness: scriptedResponsiveness(testCase, probeCalls),
+    });
+    return { summary, probeCalls };
+  } finally {
+    restoreCaseEnv();
+  }
+}
+
+function handleConversationDiscovery(testCase) {
+  return {
+    summary: discoverLocalConversations({
+      homeDir: testCase.homeDir ?? undefined,
+      env: testCase.env ?? undefined,
+      nowMs: testCase.nowMs ?? undefined,
+      candidateLimit: testCase.candidateLimit ?? undefined,
+    }),
+  };
+}
+
+function handleImportMessages(testCase) {
+  return outcome(() =>
+    readLocalConversationImportMessages({
+      source: testCase.source,
+      importKey: 'oracle-import-key',
+      path: testCase.path,
+      displayName: 'oracle-display-name',
+      activityAt: undefined,
+      metadata: {},
+    })
+  );
+}
+
+// The REAL seam values the ReScript port's injected deps must carry: the
+// credential-store args, the composed MCP config args, and the
+// dangerous-cwd verdict - probed from the same modules the TS builder
+// calls internally.
+function handleAgentSeams(testCase) {
+  const assessment = assessDangerousCwd(testCase.cwd);
+  return {
+    credentialStoreFileArgs: codexCredentialStoreFileArgs(),
+    mcpConfigArgs:
+      testCase.mcp === undefined
+        ? null
+        : codexMcpConfigArgs(
+            linzumiMcpServerConfig({
+              command: testCase.mcp.command,
+              argsPrefix: testCase.mcp.argsPrefix,
+              kandanUrl: testCase.mcp.serviceUrl,
+              authFilePath: testCase.mcp.authFilePath,
+              ownerUsername: testCase.mcp.ownerUsername ?? undefined,
+              operatingMode: testCase.mcp.operatingMode,
+              toolScope: testCase.mcp.toolScope,
+              cwd: testCase.mcp.cwd,
+            })
+          ),
+    dangerousReason: assessment.dangerous ? assessment.reason : null,
+  };
+}
+
+function handleAgentProcess(testCase) {
+  return outcome(() =>
+    onboardingDiscoveryAgentProcess({
+      kind: testCase.kind,
+      workerId: testCase.workerId,
+      workerLabel: testCase.workerLabel,
+      codexBin: testCase.codexBin,
+      cwd: testCase.cwd,
+      kandanUrl: testCase.serviceUrl,
+      runnerId: testCase.commanderId,
+      workspaceSlug: testCase.workspaceSlug,
+      ownerUsername: testCase.ownerUsername ?? undefined,
+      model: testCase.model ?? undefined,
+      authFilePath: testCase.authFilePath,
+      prompt: testCase.prompt,
+      linzumiCommand: testCase.mcpCommand,
+      codexHome: testCase.codexHome,
+    })
+  );
+}
+
+function handleProcessesForTest(testCase) {
+  setCaseEnv(testCase.env);
+  try {
+    return outcome(() =>
+      onboardingDiscoveryAgentProcessesForTest({
+        codexBin: testCase.codexBin,
+        cwd: testCase.cwd,
+        kandanUrl: testCase.serviceUrl,
+        runnerId: testCase.commanderId,
+        workspaceSlug: testCase.workspaceSlug,
+        ownerUsername: testCase.ownerUsername ?? undefined,
+        model: testCase.model ?? undefined,
+      })
+    );
+  } finally {
+    restoreCaseEnv();
+  }
+}
+
+async function handleChildParent(testCase) {
+  const logs = [];
+  const log = (event, payload) => logs.push({ event, payload });
+  setCaseEnv(testCase.env);
+  try {
+    const deps = {
+      log,
+      timeoutMs: testCase.timeoutMs ?? undefined,
+      entryPath: testCase.entryPath ?? undefined,
+      execPath: testCase.execPath ?? undefined,
+    };
+    const summary =
+      testCase.kind === 'projects'
+        ? await discoverCurrentGitProjectInChildProcess(testCase.args ?? { cwd: process.cwd() }, deps)
+        : await discoverLocalConversationsInChildProcess(deps);
+    return { summary, logs };
+  } finally {
+    restoreCaseEnv();
+  }
+}
+
+function handleProbeInjected(testCase) {
+  const calls = [];
+  const result = isPlaceResponsive(testCase.path, {
+    timeoutMs: testCase.timeoutMs ?? undefined,
+    probe: (path, timeoutMs) => {
+      calls.push({ path, timeoutMs });
+      return testCase.verdict;
+    },
+  });
+  return { result, calls };
+}
+
+async function handle(testCase) {
+  switch (testCase.op) {
+    case 'projectDiscovery':
+      return handleProjectDiscovery(testCase);
+    case 'defaultSourceRoots':
+      return outcome(() =>
+        defaultLocalProjectSourceRootsForTest({
+          cwd: testCase.cwd,
+          homeDir: testCase.homeDir ?? undefined,
+          selectedScanRoots: testCase.selectedScanRoots ?? undefined,
+        })
+      );
+    case 'conversationDiscovery':
+      return handleConversationDiscovery(testCase);
+    case 'importMessages':
+      return handleImportMessages(testCase);
+    case 'cleanTitle':
+      return outcome(() =>
+        cleanConversationTitleForTest(testCase.value ?? undefined)
+      );
+    case 'agentPlans':
+      return outcome(() =>
+        onboardingDiscoveryAgentPlans({
+          cwd: testCase.cwd,
+          runnerId: testCase.commanderId,
+          workspaceSlug: testCase.workspaceSlug,
+        })
+      );
+    case 'projectPrompt':
+      return outcome(() =>
+        projectDiscoveryPrompt({
+          runnerId: testCase.commanderId,
+          workspaceSlug: testCase.workspaceSlug,
+          cwd: testCase.cwd ?? undefined,
+          scope: testCase.scope ?? undefined,
+        })
+      );
+    case 'conversationPrompt':
+      return outcome(() =>
+        conversationDiscoveryPrompt({
+          runnerId: testCase.commanderId,
+          workspaceSlug: testCase.workspaceSlug,
+          source: testCase.source ?? undefined,
+        })
+      );
+    case 'agentSeams':
+      return handleAgentSeams(testCase);
+    case 'agentProcess':
+      return handleAgentProcess(testCase);
+    case 'processesForTest':
+      return handleProcessesForTest(testCase);
+    case 'childParent':
+      return handleChildParent(testCase);
+    case 'probeSource':
+      return {
+        source: probeWorkerSourceForTest(),
+        roleEnvKey: onboardingDiscoveryRoleEnvKey,
+      };
+    case 'probeInjected':
+      return handleProbeInjected(testCase);
+    case 'probeReal':
+      return { result: isPlaceResponsive(testCase.path) };
+    case 'isolatedCodexHome':
+      setCaseEnv(testCase.env);
+      try {
+        return outcome(() => ensureIsolatedCodexHome());
+      } finally {
+        restoreCaseEnv();
+      }
+    default:
+      return { threw: true, message: 'unknown op ' + String(testCase.op) };
+  }
+}
+
+const roleValue = process.env[onboardingDiscoveryRoleEnvKey];
+if (roleValue !== undefined && roleValue !== '') {
+  // The CLI entry's dispatch, verbatim: this bundle IS a real discovery
+  // child for whichever parent implementation spawned it.
+  process.exitCode = await runOnboardingDiscoveryChildRole(
+    roleValue,
+    process.stdin,
+    process.stdout
+  );
+} else {
+  let stdin = '';
+  process.stdin.setEncoding('utf8');
+  for await (const chunk of process.stdin) {
+    stdin += chunk;
+  }
+  const cases = JSON.parse(stdin);
+  const results = [];
+  for (const testCase of cases) {
+    results.push(await handle(testCase));
+  }
+  process.stdout.write(JSON.stringify(results));
+}
+`;
+
+await mkdir(join(packageRoot, '.differential'), { recursive: true });
+
+await build({
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'onboarding-discovery-parity-driver.ts',
+    loader: 'ts',
+  },
+  bundle: true,
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  outfile: join(packageRoot, '.differential/onboarding-discovery-parity-oracle.mjs'),
+  minify: false,
+  sourcemap: false,
+  legalComments: 'none',
+  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
+});