throughline 0.6.0 → 0.6.2

package/src/factory-diagnostics.mjs

@@ -0,0 +1,118 @@
+export const FACTORY_DIAGNOSTICS_SCHEMA = 'throughline.native_factory_diagnostics.v1';
+export const DATABASE_SCHEMA = 'throughline.database.v8';
+
+const STATUSES = new Set(['ready', 'not_ready', 'not_applicable', 'unverified']);
+
+function statusOf(value, fallback = 'unverified') {
+  return STATUSES.has(value) ? value : fallback;
+}
+
+function publicReason(status) {
+  if (status === 'ready') return 'ready';
+  if (status === 'not_ready') return 'not_ready';
+  if (status === 'not_applicable') return 'not_applicable';
+  return 'diagnostic_unverified';
+}
+
+function aggregate(statuses) {
+  const normalized = statuses.map((status) => statusOf(status));
+  if (normalized.includes('not_ready')) return 'not_ready';
+  if (normalized.includes('unverified')) return 'unverified';
+  if (normalized.includes('ready')) return 'ready';
+  return 'not_applicable';
+}
+
+/**
+ * Native factory 用の公開可能な read-only readiness projection を組み立てる。
+ * 入力に path、本文、例外を含めても、それらは出力へ移送しない。
+ */
+export function buildFactoryDiagnostics({ version, database = {}, hooks = {}, thread = {} } = {}) {
+  const databaseStatus = statusOf(database.status);
+  const hooksStatus = statusOf(hooks.status);
+  const claudeConnectorStatus = statusOf(hooks.claudeStatus);
+  const threadStatus = statusOf(thread.status);
+  const rolloutAvailable = thread.rolloutAvailable === true;
+  const handoffMemory = database.handoffMemory === true;
+
+  const captureStatus =
+    threadStatus === 'not_applicable'
+      ? 'not_applicable'
+      : threadStatus === 'ready' && rolloutAvailable
+        ? 'ready'
+        : threadStatus === 'not_ready'
+          ? 'not_ready'
+          : 'unverified';
+  const restoreStatus =
+    databaseStatus === 'not_applicable'
+      ? 'not_applicable'
+      : databaseStatus === 'not_ready'
+        ? 'not_ready'
+        : databaseStatus === 'ready'
+          ? 'ready'
+          : 'unverified';
+  const restoreSmokeStatus = threadStatus === 'not_applicable' ? 'not_applicable' : 'unverified';
+  const handoffStatus =
+    threadStatus === 'not_applicable'
+      ? 'not_applicable'
+      : threadStatus === 'ready' && rolloutAvailable && databaseStatus === 'ready' && handoffMemory
+        ? 'ready'
+        : threadStatus === 'not_ready' || databaseStatus === 'not_ready' ||
+            (databaseStatus === 'ready' && !handoffMemory)
+          ? 'not_ready'
+          : 'unverified';
+
+  const stateSchemaStatus =
+    databaseStatus === 'ready'
+      ? 'ready'
+      : databaseStatus === 'not_applicable'
+        ? 'not_applicable'
+        : databaseStatus === 'not_ready'
+          ? 'not_ready'
+          : 'unverified';
+
+  return {
+    schema: FACTORY_DIAGNOSTICS_SCHEMA,
+    version: typeof version === 'string' && version.length > 0 ? version : 'unknown',
+    overall: {
+      status: aggregate([
+        stateSchemaStatus,
+        hooksStatus,
+        claudeConnectorStatus,
+        captureStatus,
+        restoreStatus,
+        handoffStatus,
+      ]),
+    },
+    databaseSchema: {
+      schema: DATABASE_SCHEMA,
+      status: stateSchemaStatus,
+      databaseSchemaVersion: Number.isInteger(database.schemaVersion) ? database.schemaVersion : null,
+      supportedDatabaseSchemaVersion: Number.isInteger(database.supportedSchemaVersion)
+        ? database.supportedSchemaVersion
+        : null,
+      reason: publicReason(stateSchemaStatus),
+    },
+    hooks: {
+      scope: 'codex',
+      status: hooksStatus,
+      reason: publicReason(hooksStatus),
+      events: {
+        userPromptSubmit: statusOf(hooks.events?.userPromptSubmit, hooksStatus),
+        postToolUse: statusOf(hooks.events?.postToolUse, hooksStatus),
+        stop: statusOf(hooks.events?.stop, hooksStatus),
+      },
+    },
+    readiness: {
+      capture: { status: captureStatus, reason: publicReason(captureStatus) },
+      restore: { status: restoreStatus, reason: publicReason(restoreStatus) },
+      handoff: { status: handoffStatus, reason: publicReason(handoffStatus) },
+    },
+    evidence: {
+      restoreSmoke: { status: restoreSmokeStatus, reason: publicReason(restoreSmokeStatus) },
+    },
+    connectors: {
+      claude: { status: claudeConnectorStatus, reason: publicReason(claudeConnectorStatus) },
+      codex: { status: hooksStatus, reason: publicReason(hooksStatus) },
+    },
+  };
+}

package/src/factory-diagnostics.test.mjs

@@ -0,0 +1,97 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  FACTORY_DIAGNOSTICS_SCHEMA,
+  buildFactoryDiagnostics,
+} from './factory-diagnostics.mjs';
+
+test('factory diagnostics: 未設定の native factory は not_applicable を成功へ丸めない', () => {
+  const result = buildFactoryDiagnostics({
+    version: '0.6.1',
+    database: { status: 'not_applicable', reason: 'db_not_found', schemaVersion: null, handoffMemory: false },
+    hooks: { status: 'not_applicable', claudeStatus: 'not_applicable', reason: 'hooks_not_registered', events: {} },
+    thread: { status: 'not_applicable', reason: 'codex_thread_not_detected', rolloutAvailable: false },
+  });
+
+  assert.equal(result.schema, FACTORY_DIAGNOSTICS_SCHEMA);
+  assert.equal(result.overall.status, 'not_applicable');
+  assert.equal(result.readiness.capture.status, 'not_applicable');
+  assert.equal(result.readiness.restore.status, 'not_applicable');
+  assert.equal(result.readiness.handoff.status, 'not_applicable');
+});
+
+test('factory diagnostics: restore は実行していない smoke を ready にしない', () => {
+  const result = buildFactoryDiagnostics({
+    version: '0.6.1',
+    database: { status: 'ready', reason: 'db_schema_supported', schemaVersion: 8, handoffMemory: true },
+    hooks: {
+      status: 'ready',
+      claudeStatus: 'ready',
+      reason: 'managed_hooks_ready',
+      events: {
+        userPromptSubmit: 'ready',
+        postToolUse: 'ready',
+        stop: 'ready',
+      },
+    },
+    thread: { status: 'ready', reason: 'thread_and_rollout_detected', rolloutAvailable: true },
+  });
+
+  assert.equal(result.readiness.capture.status, 'ready');
+  assert.equal(result.readiness.handoff.status, 'ready');
+  assert.equal(result.readiness.restore.status, 'ready');
+  assert.equal(result.evidence.restoreSmoke.status, 'unverified');
+  assert.equal(result.overall.status, 'ready');
+});
+
+test('factory diagnostics: JSON に本文、秘密、絶対 path、生 state を含めない', () => {
+  const secret = 'sk-test-very-secret';
+  const body = 'ユーザーの prompt 本文';
+  const absolutePath = '/Users/example/.throughline/state/session.json';
+  const result = buildFactoryDiagnostics({
+    version: '0.6.1',
+    database: {
+      status: 'unverified',
+      reason: `db_open_failed:${secret}:${absolutePath}`,
+      schemaVersion: 8,
+      handoffMemory: false,
+      rawState: { body, secret, absolutePath },
+    },
+    hooks: { status: 'unverified', claudeStatus: 'unverified', reason: `config_unreadable:${absolutePath}`, events: {} },
+    thread: { status: 'unverified', reason: `rollout_unreadable:${body}`, rolloutAvailable: false },
+  });
+
+  const json = JSON.stringify(result);
+  assert.doesNotMatch(json, new RegExp(secret));
+  assert.doesNotMatch(json, new RegExp(body));
+  assert.doesNotMatch(json, new RegExp(absolutePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+  assert.equal(result.databaseSchema.reason, 'diagnostic_unverified');
+  assert.equal(result.hooks.reason, 'diagnostic_unverified');
+  assert.equal(result.readiness.capture.reason, 'diagnostic_unverified');
+});
+
+test('factory diagnostics: known not_readyをunverifiedで隠さずDB schemaをoverallへ含める', () => {
+  const result = buildFactoryDiagnostics({
+    version: '0.6.1',
+    database: { status: 'not_ready', schemaVersion: 7, handoffMemory: false },
+    hooks: { status: 'ready', claudeStatus: 'ready', events: {} },
+    thread: { status: 'ready', rolloutAvailable: true },
+  });
+
+  assert.equal(result.databaseSchema.status, 'not_ready');
+  assert.equal(result.readiness.restore.status, 'not_ready');
+  assert.equal(result.overall.status, 'not_ready');
+});
+
+test('factory diagnostics: project不一致threadのmemoryをhandoff readyにしない', () => {
+  const result = buildFactoryDiagnostics({
+    version: '0.6.1',
+    database: { status: 'ready', schemaVersion: 8, supportedSchemaVersion: 8, handoffMemory: true },
+    hooks: { status: 'ready', claudeStatus: 'ready', events: {} },
+    thread: { status: 'not_ready', rolloutAvailable: false },
+  });
+
+  assert.equal(result.readiness.handoff.status, 'not_ready');
+  assert.equal(result.overall.status, 'not_ready');
+});

package/src/haiku-summarizer.mjs

@@ -36,7 +36,6 @@
  *   2. それでも失敗したら L2 全文を L1 に入れる（情報欠損ゼロ）
  */
 
-import { spawnSync } from 'child_process';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir, tmpdir } from 'os';
@@ -45,6 +44,7 @@ import {
   CODEX_SIDECAR_STATUS,
   runCodexSidecarCommand,
 } from './codex-sidecar.mjs';
+import { spawnPortableSync } from './portable-spawn-sync.mjs';
 
 const MODEL = 'claude-haiku-4-5-20251001';
 const MAX_RETRIES = 2;
@@ -206,11 +206,10 @@ function summarizeWithHaiku(l2Text, prompt, env) {
 
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
     try {
-      const result = spawnSync('claude', ['-p', '--model', MODEL, prompt], {
+      const result = spawnPortableSync('claude', ['-p', '--model', MODEL, prompt], {
         input: l2Text,
         encoding: 'utf8',
         timeout: TIMEOUT_MS,
-        shell: process.platform === 'win32', // Windows は claude.cmd ラッパー
         env: childEnv,
         cwd: HAIKU_WORKDIR, // ← これが再帰防止の本丸
       });
@@ -247,7 +246,7 @@ function summarizeWithCodexCli(l2Text, { projectPath, env }) {
   const command = env.THROUGHLINE_CODEX_CLI_BIN ?? 'codex';
   const prompt = buildCodexPrompt(l2Text);
   const childEnv = { ...env, [CODEX_SUMMARIZER_GUARD_ENV]: '1' };
-  const result = spawnSync(
+  const result = spawnPortableSync(
     command,
     [
       'exec',
@@ -265,7 +264,6 @@ function summarizeWithCodexCli(l2Text, { projectPath, env }) {
       input: l2Text,
       encoding: 'utf8',
       timeout: CODEX_CLI_TIMEOUT_MS,
-      shell: process.platform === 'win32',
       env: childEnv,
       cwd: projectPath,
     },

package/src/haiku-summarizer.test.mjs

@@ -2,14 +2,29 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { delimiter, join } from 'node:path';
 import { summarizeToL1 } from './haiku-summarizer.mjs';
 
 function makeBin(dir, name, body) {
-  const path = join(dir, name);
-  writeFileSync(path, body);
-  chmodSync(path, 0o755);
-  return path;
+  const script = join(dir, `${name}.mjs`);
+  writeFileSync(script, body);
+  if (process.platform === 'win32') {
+    const command = join(dir, `${name}.cmd`);
+    writeFileSync(command, `@echo off\r\n${JSON.stringify(process.execPath)} ${JSON.stringify(script)} %*\r\n`);
+    writeFileSync(join(dir, `${name}.ps1`), `& ${JSON.stringify(process.execPath)} ${JSON.stringify(script)} @args\nexit $LASTEXITCODE\n`);
+    return command;
+  }
+  const command = join(dir, name);
+  writeFileSync(command, `#!/bin/sh\nexec ${JSON.stringify(process.execPath)} ${JSON.stringify(script)} "$@"\n`);
+  chmodSync(command, 0o755);
+  return command;
+}
+
+function envWithPrependedPath(dir) {
+  const env = { ...process.env };
+  const pathKey = Object.keys(env).find((key) => key.toLowerCase() === 'path') ?? 'PATH';
+  env[pathKey] = `${dir}${delimiter}${env[pathKey] ?? ''}`;
+  return env;
 }
 
 test('summarizeToL1: returns empty fallback for blank input', () => {
@@ -44,13 +59,11 @@ test('summarizeToL1: uses codex-sidecar when diagnostics and run both succeed',
     const sidecar = makeBin(
       dir,
       'codex-sidecar',
-      `#!/usr/bin/env bash
-if [ "$1" = "diagnostics" ]; then
-  printf '{"status":"ok"}\\n'
-  exit 0
-fi
-printf '{"status":"ok","summary":"sidecar summary"}\\n'
-exit 0
+      `if (process.argv[2] === 'diagnostics') {
+  process.stdout.write('{"status":"ok"}\\n');
+} else {
+  process.stdout.write('{"status":"ok","summary":"sidecar summary"}\\n');
+}
 `,
     );
 
@@ -78,13 +91,11 @@ test('summarizeToL1: accepts stable SidecarResult summary without status field',
     const sidecar = makeBin(
       dir,
       'codex-sidecar',
-      `#!/usr/bin/env bash
-if [ "$1" = "diagnostics" ]; then
-  printf '{"status":"ok"}\\n'
-  exit 0
-fi
-printf '{"summary":"stable sidecar summary","confidence":{"level":"high"},"recommendedNextAction":"continue"}\\n'
-exit 0
+      `if (process.argv[2] === 'diagnostics') {
+  process.stdout.write('{"status":"ok"}\\n');
+} else {
+  process.stdout.write('{"summary":"stable sidecar summary","confidence":{"level":"high"},"recommendedNextAction":"continue"}\\n');
+}
 `,
     );
 
@@ -112,9 +123,8 @@ test('summarizeToL1: when sidecar is disabled, keeps current Haiku-compatible pa
     makeBin(
       dir,
       'claude',
-      `#!/usr/bin/env bash
-cat >/dev/null
-printf 'haiku summary\\n'
+      `for await (const _chunk of process.stdin) {}
+process.stdout.write('haiku summary\\n');
 `,
     );
 
@@ -122,8 +132,7 @@ printf 'haiku summary\\n'
       hostMode: 'claude-primary',
       projectPath: '/repo',
       env: {
-        ...process.env,
-        PATH: `${dir}:${process.env.PATH ?? ''}`,
+        ...envWithPrependedPath(dir),
         THROUGHLINE_CODEX_SIDECAR_DISABLED: '1',
       },
     });
@@ -143,21 +152,19 @@ test('summarizeToL1: sidecar run failure keeps current Haiku-compatible path', (
     const sidecar = makeBin(
       dir,
       'codex-sidecar',
-      `#!/usr/bin/env bash
-if [ "$1" = "diagnostics" ]; then
-  printf '{"status":"ok"}\\n'
-  exit 0
-fi
-printf 'sidecar failed\\n' >&2
-exit 42
+      `if (process.argv[2] === 'diagnostics') {
+  process.stdout.write('{"status":"ok"}\\n');
+} else {
+  process.stderr.write('sidecar failed\\n');
+  process.exit(42);
+}
 `,
     );
     makeBin(
       dir,
       'claude',
-      `#!/usr/bin/env bash
-cat >/dev/null
-printf 'haiku after sidecar failure\\n'
+      `for await (const _chunk of process.stdin) {}
+process.stdout.write('haiku after sidecar failure\\n');
 `,
     );
 
@@ -165,8 +172,7 @@ printf 'haiku after sidecar failure\\n'
       hostMode: 'claude-primary',
       projectPath: '/repo',
       env: {
-        ...process.env,
-        PATH: `${dir}:${process.env.PATH ?? ''}`,
+        ...envWithPrependedPath(dir),
         THROUGHLINE_CODEX_SIDECAR_BIN: sidecar,
       },
     });
@@ -199,10 +205,12 @@ test('summarizeToL1: codex-primary uses Codex CLI backend', () => {
     const codex = makeBin(
       dir,
       'codex',
-      `#!/usr/bin/env bash
-printf '%s\\n' "$@" > "${argsFile}"
-cat > "${stdinFile}"
-printf 'codex summary\\n'
+      `import { writeFileSync } from 'node:fs';
+writeFileSync(${JSON.stringify(argsFile)}, process.argv.slice(2).join('\\n') + '\\n');
+let input = '';
+for await (const chunk of process.stdin) input += chunk;
+writeFileSync(${JSON.stringify(stdinFile)}, input);
+process.stdout.write('codex summary\\n');
 `,
     );
 
@@ -244,16 +252,14 @@ test('summarizeToL1: codex-primary failure is not hidden by fallback', () => {
     const codex = makeBin(
       dir,
       'codex',
-      `#!/usr/bin/env bash
-printf 'codex failed\\n' >&2
-exit 42
+      `process.stderr.write('codex failed\\n');
+process.exit(42);
 `,
     );
     makeBin(
       dir,
       'claude',
-      `#!/usr/bin/env bash
-printf 'should not run\\n'
+      `process.stdout.write('should not run\\n');
 `,
     );
 
@@ -263,8 +269,7 @@ printf 'should not run\\n'
           hostMode: 'codex-primary',
           projectPath: dir,
           env: {
-            ...process.env,
-            PATH: `${dir}:${process.env.PATH ?? ''}`,
+            ...envWithPrependedPath(dir),
             THROUGHLINE_CODEX_CLI_BIN: codex,
           },
         }),

package/src/hook-entrypoints.test.mjs

@@ -408,7 +408,9 @@ test('process-turn subprocess backfills all completed logical turns from a multi
   }
 });
 
-test('session-start backfills a derived predecessor transcript without a state file', () => {
+test('session-start backfills a derived predecessor transcript without a state file', {
+  skip: process.platform === 'win32' ? 'Windowsはstate file transcriptPath fallback契約' : undefined,
+}, () => {
   const home = makeTempHome();
   const project = makeTempProject();
   const predecessorId = 'missing-stop-predecessor';