happy-stacks 0.6.12 → 0.6.13

package/docs/commit-audits/happy/_tools/generate-pr-assignment.mjs

@@ -0,0 +1,430 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const ROOT = process.cwd();
+const AUDIT_DIR = path.join(ROOT, 'docs', 'commit-audits', 'happy');
+
+const INDEX_JSON = path.join(AUDIT_DIR, 'leeroy-wip.commit-index.json');
+const OUT_TSV = path.join(AUDIT_DIR, 'leeroy-wip.pr-assignment.draft.tsv');
+
+const PRS = [
+  { id: 'PR01', title: 'Foundations / DevX' },
+  { id: 'PR02', title: 'UI modal/overlay/popover + Expo web modal behavior' },
+  { id: 'PR03', title: 'i18n foundation sweep (optional)' },
+  { id: 'PR04', title: 'Auth + storage scoping' },
+  { id: 'PR05', title: 'Persistence / drafts' },
+  { id: 'PR06', title: 'Settings: API keys + experiments + settings screens' },
+  { id: 'PR07', title: 'Env var templates + preview/resolution end-to-end' },
+  { id: 'PR08', title: 'Profiles feature' },
+  { id: 'PR09', title: 'Secrets / vault feature' },
+  { id: 'PR10', title: 'Permission framework (Claude/cloud baseline)' },
+  { id: 'PR11', title: 'Agent permissions (Codex/Gemini): permission modes + allowlists' },
+  { id: 'PR12', title: 'AskUserQuestion + ExitPlan native handling' },
+  { id: 'PR39', title: 'Tool UX: normalization + specialized views + tracing' },
+  { id: 'PR13', title: 'MessageQueueV1 + Pending messages end-to-end' },
+  { id: 'PR14', title: 'Capabilities end-to-end (protocol + wiring + reliability)' },
+  { id: 'PR15', title: 'preview-env end-to-end' },
+  { id: 'PR16', title: 'Daemon reliability (ownership + reattach/restart safety)' },
+  { id: 'PR17', title: 'CLI reliability (waiters + reconnection + backoff semantics)' },
+  { id: 'PR18', title: 'TMUX end-to-end (headless sessions + attach + settings)' },
+  { id: 'PR19', title: 'Resume end-to-end' },
+  { id: 'PR20', title: 'Claude session reliability (switching + transcript/scanner + local runner)' },
+  { id: 'PR21', title: 'Codex MCP tool-call result correctness' },
+  { id: 'PR22', title: 'Server-light flavor (variant + schema/prisma sync)' },
+  { id: 'PR23', title: 'Server serves UI + public files safely' },
+  { id: 'PR24', title: 'Storage S3 validation' },
+  { id: 'PR25', title: 'Misc small UX polish (only if truly isolated)' },
+  { id: 'PR26', title: 'New session wizard end-to-end' },
+  { id: 'PR27', title: 'Sync robustness (transport/error parsing + backoff semantics)' },
+  { id: 'PR28', title: 'Model modes (per-session selection + persistence)' },
+  { id: 'PR29', title: 'Sessions & message list UX' },
+  { id: 'PR30', title: 'Agent error surfaces (Codex/Gemini)' },
+  { id: 'PR31', title: 'Terminal switching reliability (remote↔local)' },
+  { id: 'PR32', title: 'Codex approvals + MCP tool interactions (execpolicy + elicitation)' },
+  { id: 'PR33', title: 'Codex special commands (/clear session reset)' },
+  { id: 'PR35', title: 'Friends: UX + reliability (search errors + follow-ups)' },
+  { id: 'PR36', title: 'ACP agents end-to-end (runtimes + replay + tool normalization)' },
+  { id: 'PR37', title: 'Agent registry end-to-end (selection + settings + UX helpers)' },
+  { id: 'PR38', title: 'UI list primitives + pending UI polish' },
+];
+
+const PR_TITLE = new Map(PRS.map((p) => [p.id, p.title]));
+
+function tsv(value) {
+  if (value == null) return '';
+  return String(value).replace(/\t/g, ' ').replace(/\r?\n/g, ' ');
+}
+
+function classify(commit) {
+  const subject = (commit.subject ?? '').toLowerCase();
+  const bucket = commit.topicBucket ?? 'unknown';
+  const scopeTag = commit.scopeTag ?? '';
+  const files = (commit.files ?? []).map((f) => f.path);
+  const anyFile = (re) => files.some((p) => re.test(p));
+
+  // Model modes (per-session selection/persistence)
+  if (subject.includes('model mode') || subject.includes('model modes') || anyFile(/modelMode|modelModes/i)) {
+    return { pr: 'PR28', confidence: 'high', reason: `model-modes keyword/file` };
+  }
+
+  // Foundations
+  if (['crypto', 'deps', 'config', 'format', 'typecheck', 'dev', 'runtime', 'logging', 'test'].includes(bucket)) {
+    return { pr: 'PR01', confidence: 'high', reason: `bucket=${bucket}` };
+  }
+
+  // ACP agents (CLI/runtime + replay + normalization)
+  if (bucket === 'acp') {
+    return { pr: 'PR36', confidence: 'high', reason: `bucket=${bucket}` };
+  }
+
+  // Agent registry (Expo app)
+  if (bucket === 'agents') {
+    return { pr: 'PR37', confidence: 'high', reason: `bucket=${bucket}` };
+  }
+
+  // UI list primitives / pending UI polish
+  if (bucket === 'list') {
+    return { pr: 'PR38', confidence: 'high', reason: `bucket=${bucket}` };
+  }
+
+  // i18n (optional early sweep) — mark medium so we can decide to fold later.
+  if (bucket === 'i18n' || subject.includes('localize') || subject.includes('translate')) {
+    return { pr: 'PR03', confidence: 'medium', reason: `i18n bucket/keyword` };
+  }
+
+  // Auth + storage scoping
+  if (bucket === 'auth') {
+    return { pr: 'PR04', confidence: 'high', reason: `auth bucket` };
+  }
+  if (bucket === 'persistence') {
+    return { pr: 'PR05', confidence: 'high', reason: `persistence bucket` };
+  }
+  if (bucket === 'settings') {
+    return { pr: 'PR06', confidence: 'medium', reason: `settings bucket` };
+  }
+  if (bucket === 'env') {
+    return { pr: 'PR07', confidence: 'high', reason: `env bucket` };
+  }
+
+  // New session wizard feature
+  if (bucket === 'new-session' || bucket === 'new' || bucket === 'machine') {
+    return { pr: 'PR26', confidence: 'high', reason: `new-session/new/machine bucket` };
+  }
+
+  // Expo-router / web modals / postinstall patching
+  if (bucket === 'expo-app' || bucket === 'expo') {
+    return { pr: 'PR02', confidence: 'medium', reason: `expo bucket` };
+  }
+
+  // Agent error surfaces (Codex/Gemini) — keep separate from modal/overlay primitives.
+  if (
+    (subject.includes('codex') && subject.includes('error')) ||
+    (subject.includes('gemini') && subject.includes('error')) ||
+    anyFile(/formatCodexEventForUi|formatGeminiErrorForUi|formatErrorForUi/i)
+  ) {
+    return { pr: 'PR30', confidence: 'medium', reason: `agent error surfaces keyword/file` };
+  }
+
+  // Codex approvals + MCP tool interactions (execpolicy/elicitation/tool-call UX)
+  if (
+    subject.includes('execpolicy') ||
+    subject.includes('elicitation') ||
+    subject.includes('exec policy') ||
+    subject.includes('mcp tool call')
+  ) {
+    return { pr: 'PR32', confidence: 'medium', reason: `codex approval/mcp keyword` };
+  }
+
+  // MCP bridge runner compatibility (bun/node) — keep with Codex approvals + MCP tool interactions
+  if (subject.includes('mcp bridge') || anyFile(/bin\/happy-mcp\.mjs/i)) {
+    return { pr: 'PR32', confidence: 'high', reason: `mcp bridge keyword/file` };
+  }
+
+  // UI primitives + nav/UX surfaces (including a11y)
+  if (['ui', 'modal', 'popover', 'agent-input', 'web', 'a11y', 'command-palette', 'autocomplete', 'experiments', 'zen'].includes(bucket)) {
+    return { pr: 'PR02', confidence: 'medium', reason: `ui-system bucket=${bucket}` };
+  }
+
+  // Friends search UX (stable error codes + localized failures)
+  if (subject.includes('search error') || anyFile(/hooks\/useSearch\.ts|friends\/search\.tsx/i)) {
+    return { pr: 'PR35', confidence: 'high', reason: `search keyword/file` };
+  }
+  if (bucket === 'friends' || bucket === 'inbox') {
+    return { pr: 'PR35', confidence: 'high', reason: `bucket=${bucket}` };
+  }
+
+  // Sessions list UX
+  if (bucket === 'sessions') {
+    return { pr: 'PR29', confidence: 'high', reason: `sessions bucket` };
+  }
+
+  // Resume UX / machine installer surfaces (avoid routing to generic UI primitives)
+  if (subject.includes('codex resume') || subject.includes('inactive resume') || subject.includes('resume session') || subject.includes('resume-server')) {
+    return { pr: 'PR19', confidence: 'medium', reason: `resume keyword` };
+  }
+
+  // Capabilities UI tests / migration
+  if (subject.includes('useclidetection') || subject.includes('capabilities snapshot')) {
+    return { pr: 'PR14', confidence: 'medium', reason: `capabilities UI keyword` };
+  }
+
+  // Profiles
+  if (bucket === 'profiles' || bucket === 'api-keys') {
+    return { pr: 'PR08', confidence: 'high', reason: `profiles/api-keys bucket` };
+  }
+
+  // Secrets
+  if (bucket === 'secrets' || subject.includes('secret') || subject.includes('vault')) {
+    return { pr: 'PR09', confidence: 'medium', reason: `secrets keyword/bucket` };
+  }
+
+  // Permissions
+  if (bucket === 'permission') {
+    return { pr: 'PR10', confidence: 'medium', reason: `permission bucket` };
+  }
+  if (subject.includes('permission mode for codex') || subject.includes('gemini permission') || subject.includes('codex permission')) {
+    return { pr: 'PR11', confidence: 'medium', reason: `agent-specific permission keyword` };
+  }
+  if (subject.includes('permission mode')) {
+    if (bucket === 'claude') return { pr: 'PR10', confidence: 'medium', reason: `claude permission-mode keyword` };
+    if (bucket === 'codex' || bucket === 'gemini') return { pr: 'PR11', confidence: 'medium', reason: `agent-specific permission-mode keyword` };
+  }
+
+  // Tools
+  if (bucket === 'tools' || subject.includes('askuserquestion') || subject.includes('exitplan') || subject.includes('tool')) {
+    // AskUserQuestion / ExitPlan are the protocol/interaction feature (keep separate from generic tool rendering).
+    if (subject.includes('askuserquestion') || subject.includes('exitplan')) {
+      return { pr: 'PR12', confidence: 'high', reason: `askuserquestion/exitplan keyword` };
+    }
+
+    // Everything else under tools is a tool-UX slice: normalization, specialized views, tracing, fixtures.
+    if (subject.includes('tool-trace') || subject.includes('tool trace') || subject.includes('normalize')) {
+      return { pr: 'PR39', confidence: 'high', reason: `tool tracing/normalization keyword` };
+    }
+    if (anyFile(/\/toolTrace\//i) || anyFile(/components\/tools\//i)) {
+      return { pr: 'PR39', confidence: 'high', reason: `tool UX files` };
+    }
+
+    return { pr: 'PR39', confidence: 'medium', reason: `tools bucket fallback` };
+  }
+
+  // Queue/pending
+  if (bucket === 'queue' || (bucket === 'sync' && subject.includes('messagequeue'))) {
+    return { pr: 'PR13', confidence: 'high', reason: `queue bucket/keyword` };
+  }
+  if (subject.includes('pending message') || subject.includes('messagequeuev1')) {
+    return { pr: 'PR13', confidence: 'medium', reason: `pending/queue keyword` };
+  }
+
+  // Sync robustness (non-feature-specific)
+  if (bucket === 'sync') {
+    if (subject.includes('permission mode')) return { pr: 'PR10', confidence: 'medium', reason: `sync permission mode` };
+    if (subject.includes('invalidate') || subject.includes('json') || subject.includes('disconnect') || subject.includes('backoff')) {
+      return { pr: 'PR27', confidence: 'medium', reason: `sync robustness keyword` };
+    }
+    // Fall back to PR27; we can later move items into feature PRs when mapping precisely.
+    return { pr: 'PR27', confidence: 'low', reason: `sync bucket fallback` };
+  }
+
+  // Capabilities
+  if (bucket === 'cli-detection' || bucket === 'detect-cli' || subject.includes('capabilities')) {
+    return { pr: 'PR14', confidence: 'high', reason: `capabilities bucket/keyword` };
+  }
+  if (bucket === 'hooks' && (subject.includes('capabilities') || subject.includes('useclidetection') || subject.includes('cache'))) {
+    return { pr: 'PR14', confidence: 'medium', reason: `capabilities-related hooks` };
+  }
+
+  // preview-env
+  if (subject.includes('preview-env') || anyFile(/previewEnv/i)) {
+    return { pr: 'PR15', confidence: 'high', reason: `preview-env keyword/file` };
+  }
+
+  // Daemon reliability
+  if (bucket === 'daemon' || bucket === 'pr107') {
+    return { pr: 'PR16', confidence: 'medium', reason: `daemon bucket` };
+  }
+
+  // Terminal switching / Ink reliability (non-tmux-specific)
+  if (
+    bucket === 'ink' ||
+    (bucket === 'terminal' && (subject.includes('switch') || subject.includes('stdin') || subject.includes('remote') || subject.includes('signal'))) ||
+    (subject.includes('forward') && subject.includes('signal'))
+  ) {
+    return { pr: 'PR31', confidence: 'medium', reason: `terminal switching keyword/bucket` };
+  }
+
+  // CLI reliability (broad)
+  if (bucket === 'utils' || bucket === 'common' || bucket === 'happy-cli') {
+    return { pr: 'PR17', confidence: 'medium', reason: `cli reliability bucket=${bucket}` };
+  }
+  if (bucket === 'cli' || bucket === 'rpc' || bucket === 'socket' || bucket === 'reducer' || bucket === 'app') {
+    // broad; attempt to route some to capabilities/queue/tmux/resume based on paths
+    if (anyFile(/terminal/i) || anyFile(/tmux/i)) return { pr: 'PR18', confidence: 'medium', reason: `terminal/tmux files` };
+    if (anyFile(/messageQueueV1/i) || subject.includes('messagequeue')) return { pr: 'PR13', confidence: 'medium', reason: `queue files` };
+    if (subject.includes('resume') || bucket === 'resume') return { pr: 'PR19', confidence: 'medium', reason: `resume keyword/bucket` };
+    if (subject.includes('capabilities')) return { pr: 'PR14', confidence: 'medium', reason: `capabilities keyword` };
+    return { pr: 'PR17', confidence: 'low', reason: `fallback cli/rpc/app bucket=${bucket}` };
+  }
+
+  // TMUX/Terminal
+  if (bucket === 'terminal' || bucket === 'tmux') {
+    return { pr: 'PR18', confidence: 'high', reason: `terminal/tmux/ink bucket` };
+  }
+
+  // Resume
+  if (bucket === 'resume' || bucket === 'session' || bucket === 'sessions' || bucket === 'scanner' || bucket === 'offline') {
+    return { pr: 'PR19', confidence: 'high', reason: `resume/session bucket` };
+  }
+
+  // Claude transcript scanning
+  if (bucket === 'claude' && (subject.includes('scanner') || subject.includes('transcript'))) {
+    return { pr: 'PR20', confidence: 'medium', reason: `claude scanner/transcript keyword` };
+  }
+
+  // Claude (non-scanner): usually terminal/remote-local switching or resume-related; route by keywords.
+  if (bucket === 'claude') {
+    if (subject.includes('switch') || subject.includes('remote') || subject.includes('local')) {
+      return { pr: 'PR20', confidence: 'medium', reason: `claude remote/local switching` };
+    }
+    return { pr: 'PR19', confidence: 'low', reason: `claude fallback to resume` };
+  }
+
+  // Codex tool-call result correctness
+  if (bucket === 'codex' && subject.includes('mcp tool')) {
+    return { pr: 'PR21', confidence: 'medium', reason: `codex mcp keyword` };
+  }
+
+  // Codex special commands (/clear, etc)
+  if (
+    bucket === 'codex' &&
+    (subject.includes('/clear') || subject.includes('special command') || subject.includes('session reset'))
+  ) {
+    return { pr: 'PR33', confidence: 'high', reason: `codex special command keyword` };
+  }
+
+  // Codex (non tool-call-result): treat as part of resume/installer feature.
+  if (bucket === 'codex' || bucket === 'gemini') {
+    if (subject.includes('permission')) return { pr: 'PR11', confidence: 'low', reason: `codex/gemini permission keyword` };
+    if (subject.includes('error') || subject.includes('format')) return { pr: 'PR30', confidence: 'low', reason: `agent error surfaces keyword` };
+    return { pr: 'PR19', confidence: 'low', reason: `codex/gemini fallback to resume` };
+  }
+
+  // Previously-tagged fork commits must be upstreamed per decision; treat them as resume.
+  if (bucket === 'fork') {
+    return { pr: 'PR19', confidence: 'medium', reason: `fork-tagged commit routed to resume for upstreaming` };
+  }
+
+  // Server-light
+  if (bucket === 'server-light' || subject.includes('server-light')) {
+    return { pr: 'PR22', confidence: 'high', reason: `server-light bucket/keyword` };
+  }
+  if (bucket === 'server') {
+    if (subject.includes('light') || subject.includes('sqlite') || subject.includes('schema') || subject.includes('prisma')) {
+      return { pr: 'PR22', confidence: 'medium', reason: `server light/schema/prisma keyword` };
+    }
+    if (subject.includes('ui') || subject.includes('public file') || subject.includes('index')) {
+      return { pr: 'PR23', confidence: 'medium', reason: `server serves UI/public files` };
+    }
+    // Misc server tweaks that are primarily typecheck/test infra can be treated as foundations.
+    if (subject.includes('typecheck') || subject.includes('tsconfig') || subject.includes('test(')) {
+      return { pr: 'PR01', confidence: 'low', reason: `server infra/test keyword` };
+    }
+    return { pr: 'PR23', confidence: 'low', reason: `server fallback` };
+  }
+  // Legacy per-file heuristics for server (kept for safety if bucket tagging is inconsistent).
+  if (anyFile(/schemaSync|enums\.generated|storage\/prisma/i)) {
+    return { pr: 'PR22', confidence: 'medium', reason: `schema/prisma files` };
+  }
+  if (anyFile(/flavors\/light\/files|enableErrorHandlers/i)) {
+    return { pr: 'PR23', confidence: 'medium', reason: `serve UI/public files (by file)` };
+  }
+
+  // Storage S3
+  if (bucket === 'storage' || anyFile(/server\/sources\/storage\/files\./i)) {
+    return { pr: 'PR24', confidence: 'high', reason: `storage bucket/file` };
+  }
+
+  // happy bucket is mostly capabilities/hook plumbing or test/dev scaffolding.
+  if (bucket === 'happy') {
+    if (subject.includes('useclidetection') || subject.includes('capabilities') || anyFile(/useCLIDetection|useMachineCapabilitiesCache/i)) {
+      return { pr: 'PR14', confidence: 'medium', reason: `happy capabilities/hook keyword` };
+    }
+    return { pr: 'PR01', confidence: 'low', reason: `happy bucket fallback` };
+  }
+
+  // Default: this is a signal to refine mapping further (ideally PR25 ends empty or very small).
+  return { pr: 'PR25', confidence: 'low', reason: `unclassified bucket=${bucket}` };
+}
+
+async function main() {
+  const raw = JSON.parse(await fs.readFile(INDEX_JSON, 'utf8'));
+  const commits = raw.commits ?? [];
+
+  const rows = [];
+  for (const c of commits) {
+    const { pr, confidence, reason } = classify(c);
+    rows.push({
+      n: String(c.n).padStart(3, '0'),
+      shaShort: c.shaShort ?? '',
+      topicBucket: c.topicBucket ?? '',
+      scopeTag: c.scopeTag ?? '',
+      subject: c.subject ?? '',
+      verdict: c.verdictKind ?? '',
+      filesChanged: c.filesChanged ?? '',
+      pr,
+      prTitle: PR_TITLE.get(pr) ?? '',
+      confidence,
+      reason,
+    });
+  }
+
+  const header = [
+    'n',
+    'shaShort',
+    'topicBucket',
+    'scopeTag',
+    'subject',
+    'verdict',
+    'filesChanged',
+    'proposedPr',
+    'proposedPrTitle',
+    'confidence',
+    'reason',
+    'notes',
+  ].join('\t');
+
+  const out = [
+    '# GENERATED FILE - do not edit by hand.',
+    '# Regenerate: node docs/commit-audits/happy/_tools/generate-pr-assignment.mjs',
+    header,
+    ...rows.map((r) =>
+      [
+        r.n,
+        r.shaShort,
+        r.topicBucket,
+        r.scopeTag,
+        r.subject,
+        r.verdict,
+        r.filesChanged,
+        r.pr,
+        r.prTitle,
+        r.confidence,
+        r.reason,
+        '',
+      ]
+        .map(tsv)
+        .join('\t'),
+    ),
+    '',
+  ].join('\n');
+
+  await fs.writeFile(OUT_TSV, out, 'utf8');
+  // eslint-disable-next-line no-console
+  console.log(`[audit] wrote: ${path.relative(ROOT, OUT_TSV)}`);
+}
+
+main().catch((err) => {
+  // eslint-disable-next-line no-console
+  console.error(err);
+  process.exitCode = 1;
+});

package/docs/commit-audits/happy/_tools/init-pr-assignment-working.mjs

@@ -0,0 +1,107 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const ROOT = process.cwd();
+const AUDIT_DIR = path.join(ROOT, 'docs', 'commit-audits', 'happy');
+
+const DRAFT_TSV = path.join(AUDIT_DIR, 'leeroy-wip.pr-assignment.draft.tsv');
+const WORKING_TSV = path.join(AUDIT_DIR, 'leeroy-wip.pr-assignment.working.tsv');
+
+function tsv(value) {
+  if (value == null) return '';
+  return String(value).replace(/\t/g, ' ').replace(/\r?\n/g, ' ');
+}
+
+function parseTsvLines(text) {
+  const lines = text.split('\n').filter((l) => l.trim().length > 0);
+  const dataLines = lines.filter((l) => !l.startsWith('#'));
+  if (dataLines.length < 2) {
+    throw new Error('Draft TSV is missing header/rows.');
+  }
+  const header = dataLines[0].split('\t');
+  const rows = dataLines.slice(1).map((l) => l.split('\t'));
+  return { header, rows };
+}
+
+async function main() {
+  const args = new Set(process.argv.slice(2));
+  const force = args.has('--force');
+
+  if (!force) {
+    try {
+      await fs.access(WORKING_TSV);
+      // eslint-disable-next-line no-console
+      console.log(`[audit] exists: ${path.relative(ROOT, WORKING_TSV)} (use --force to overwrite)`);
+      return;
+    } catch {
+      // continue
+    }
+  }
+
+  const draft = await fs.readFile(DRAFT_TSV, 'utf8');
+  const { header, rows } = parseTsvLines(draft);
+
+  const colIndex = new Map(header.map((h, i) => [h, i]));
+  const required = ['n', 'shaShort', 'topicBucket', 'scopeTag', 'subject', 'verdict', 'filesChanged', 'proposedPr', 'proposedPrTitle'];
+  for (const r of required) {
+    if (!colIndex.has(r)) throw new Error(`Draft TSV missing column: ${r}`);
+  }
+
+  const outHeader = [
+    ...header,
+    'finalPr',
+    'finalTitle',
+    'needsSplit',
+    'translationHandling',
+    'manualReviewedForPrPlan',
+    'plannedAt',
+    'plannerNotes',
+  ];
+
+  const outRows = rows.map((r) => {
+    const proposedPr = r[colIndex.get('proposedPr')];
+    const proposedTitle = r[colIndex.get('proposedPrTitle')];
+    const verdict = (r[colIndex.get('verdict')] ?? '').toLowerCase();
+    const needsSplit = verdict === 'split' ? 'yes' : '';
+
+    const topicBucket = (r[colIndex.get('topicBucket')] ?? '').toLowerCase();
+    const translationHandling = topicBucket === 'i18n' ? 'move-to-feature-pr' : 'in-feature-pr';
+
+    // We initialize finalPr/title to the proposal; manual review will override.
+    return [
+      ...r,
+      proposedPr,
+      proposedTitle,
+      needsSplit,
+      translationHandling,
+      'no',
+      '',
+      '',
+    ].map(tsv);
+  });
+
+  const out = [
+    '# WORKING FILE - safe to edit by hand.',
+    '# Seeded from: leeroy-wip.pr-assignment.draft.tsv',
+    '# Regenerate seed (overwrites): node docs/commit-audits/happy/_tools/init-pr-assignment-working.mjs --force',
+    '# Guidance:',
+    '# - Set finalPr/finalTitle per commit after reading its full manual-review section.',
+    '# - Set manualReviewedForPrPlan=yes only after you have read the entire section for that commit in leeroy-wip.commit-manual-review.md.',
+    '# - Keep translationHandling=in-feature-pr unless you explicitly decide otherwise for a specific commit.',
+    '',
+    outHeader.join('\t'),
+    ...outRows.map((cols) => cols.join('\t')),
+    '',
+  ].join('\n');
+
+  await fs.writeFile(WORKING_TSV, out, 'utf8');
+  // eslint-disable-next-line no-console
+  console.log(`[audit] wrote: ${path.relative(ROOT, WORKING_TSV)}`);
+}
+
+main().catch((err) => {
+  // eslint-disable-next-line no-console
+  console.error(err);
+  process.exitCode = 1;
+});
+