elanous 0.2.35 → 0.2.37

package/scripts/release-loop/known-issues-node.ts

@@ -22,7 +22,7 @@ const INTRO = 'The following issues are known in this release.';
 const resolved = /\b(?:fixed|resolved|no longer|has been addressed|is addressed|was addressed)\b/i;
 const unsafe = /[^\x20-\x7e]|#\d+|\/Users\/|\.test\.ts\b|\[(?:TC|MK|OP|UX|S|T|F|O)\]|\b(?:TC|MK|OP|UX)\s+track\b|\b(?:PR|pull request)\s*\d+\b|\b(?:scripts|src|test)\/\S+|\bfile:\/\/|(?<![\w:/])\/(?!\/)[\w.-]+(?:\/[\w.-]+)*|\b[A-Z]:\\(?:[^\s\\]+\\)*[^\s\\]+|\b(?:RFC|HANDOFF|MANUAL)-/i;
 
-type Issue = { id: string; title?: string; evidence?: string; note?: string };
+type Issue = { id: string; title?: string; evidence?: string; knownIssue?: string; note?: string };
 
 // Accepted regressions with the same public note describe one issue, even if several gates recorded it.
 function issueGroup(issue: Issue, checklistIssues: ReadonlySet<Issue>): string {
@@ -62,9 +62,9 @@ function generatedBullets(raw: string, sourceIds: string[]): string[] {
 }
 
 function coversIssue(bullet: string, issue: Issue, others: Issue[]): boolean {
-  const source = issue.title ?? issue.note ?? '';
+  const source = issue.knownIssue ?? issue.note ?? '';
   const words = source.toLowerCase().match(/[a-z]{5,}/g) ?? [];
-  const otherWords = new Set(others.flatMap((other) => ((other.title ?? other.note ?? '').toLowerCase().match(/[a-z]{5,}/g) ?? []).map((word) => word.slice(0, 5))));
+  const otherWords = new Set(others.flatMap((other) => ((other.knownIssue ?? other.note ?? '').toLowerCase().match(/[a-z]{5,}/g) ?? []).map((word) => word.slice(0, 5))));
   const publicWords = new Set((bullet.toLowerCase().match(/[a-z]{5,}/g) ?? []).map((word) => word.slice(0, 5)));
   const distinctive = [...new Set(words.map((word) => word.slice(0, 5)))].filter((word) => !otherWords.has(word));
   const negative = /\b(?:not|never|no|cannot|can't|doesn't|don't|won't|fails? to|isn't|aren't)\b/i;
@@ -130,7 +130,9 @@ export function runKnownIssues(context: GraphContext = readGraphContext(), run:
   if (context.outputs.docs?.branch !== `release-docs/${version}`) throw new Error('docs branch/version mismatch');
   const notes = join(worktree, 'release/public/docs/releases', `${version}.md`);
   if (!existsSync(notes)) throw new Error(`release notes missing: ${notes}`);
-  const checklist = issues(context.outputs['checklist-gate']?.knownIssues, 'checklist');
+  // A checklist title is an internal task label, not public issue copy. Missing dedicated copy
+  // means no public note row is generated for that checklist item.
+  const checklist = issues(context.outputs['checklist-gate']?.knownIssues, 'checklist').filter((issue) => typeof issue.knownIssue === 'string' && issue.knownIssue.trim()).map((issue) => ({ ...issue, title: issue.knownIssue!.trim() }));
   const accepted = issues(context.input.acceptedRegressions, 'accepted');
   const approved0233Batch = version === '0.2.33' && accepted.length === APPROVED_0233_INPUT.length
     && new Set(accepted.map((issue) => issue.id)).size === accepted.length

package/scripts/release-loop/node-verdict.ts

@@ -9,6 +9,7 @@ export type NodeVerdict = 'pass' | 'flaky' | 'fail';
 export interface GraphContext {
   nodeId?: string;
   runId?: string;
+  startedAt?: string;
   input: { version: string; previousVersion: string; [key: string]: unknown };
   outputs: Record<string, Record<string, unknown>>;
 }
@@ -24,6 +25,7 @@ export function readGraphContext(env: NodeJS.ProcessEnv = process.env): GraphCon
     || typeof input.previousVersion !== 'string' || !/^\d+\.\d+\.\d+$/.test(input.previousVersion)) throw new Error('version and previousVersion required');
   return { ...(typeof context.nodeId === 'string' ? { nodeId: context.nodeId } : {}),
     ...(typeof context.runId === 'string' ? { runId: context.runId } : {}),
+    ...(typeof context.startedAt === 'string' ? { startedAt: context.startedAt } : {}),
     input: input as GraphContext['input'], outputs: context.outputs && typeof context.outputs === 'object' ? context.outputs as GraphContext['outputs'] : {} };
 }
 

package/scripts/release-loop/notes-repair.ts

@@ -0,0 +1,216 @@
+import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, statSync, chmodSync, realpathSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { SPAWN_SYNC_MAX_BUFFER } from '../../src/util/spawn-sync-output.js';
+import { basename, dirname, join, relative, resolve, sep } from 'node:path';
+import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
+import { getProviderForConfig, type LLMMessage } from '../../src/llm.js';
+import { getUserConfig } from '../../src/user-config.js';
+import type { GraphContext } from './node-verdict.js';
+
+export const REPAIR_MODEL = 'openrouter/z-ai/glm-5.3';
+export type Translator = (line: string, model: string) => Promise<string>;
+export type RepairResult = { text: string; translatedLines: number[]; error?: string };
+
+function koreanProseLines(text: string): Array<{ index: number; line: string }> {
+  let fence: { char: string; length: number } | undefined;
+  return text.split(/\r?\n/).flatMap((line, index) => {
+    const marker = /^ {0,3}(`{3,}|~{3,})/.exec(line)?.[1];
+    if (marker) {
+      if (!fence) fence = { char: marker[0]!, length: marker.length };
+      else if (marker[0] === fence.char && marker.length >= fence.length) fence = undefined;
+      return [];
+    }
+    if (fence || !/[가-힣]/.test(line.replace(/(`+)[^`]*?\1/g, ''))) return [];
+    return [{ index, line }];
+  });
+}
+
+export async function repairKoreanMarkdown(text: string, translate: Translator, onlyLines?: ReadonlySet<number>): Promise<RepairResult> {
+  const lines = text.split(/\r?\n/);
+  const translatedLines: number[] = [];
+  for (const item of koreanProseLines(text).filter(({ index }) => !onlyLines || onlyLines.has(index + 1))) {
+    try {
+      // Keep inline code out of the model's editable surface and restore it byte-for-byte.
+      const code: string[] = [];
+      const protectedLine = item.line.replace(/(`+)[^`]*?\1/g, (match) => `⟦CODE${code.push(match) - 1}⟧`);
+      const value = (await translate(protectedLine, REPAIR_MODEL)).trim();
+      if (!value) throw new Error('translator returned empty text');
+      for (const [index] of code.entries()) {
+        const token = `⟦CODE${index}⟧`;
+        if (value.split(token).length !== 2) throw new Error('translator changed protected inline code');
+      }
+      const restored = value.replace(/⟦CODE(\d+)⟧/g, (_match, rawIndex: string) => {
+        const original = code[Number(rawIndex)];
+        if (original === undefined) throw new Error('translator changed protected inline code');
+        return original;
+      });
+      if (/[가-힣]/.test(restored.replace(/(`+)[^`]*?\1/g, ''))) throw new Error('translation still contains Korean prose');
+      lines[item.index] = restored;
+      translatedLines.push(item.index + 1);
+    } catch (error) {
+      return { text, translatedLines: [], error: `line ${item.index + 1}: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }
+  return { text: lines.join('\n'), translatedLines };
+}
+
+export const glmTranslator: Translator = async (line, model) => {
+  if (model !== REPAIR_MODEL) throw new Error(`unexpected translator model: ${model}`);
+  const config = getUserConfig();
+  const llmConfig = { ...config, llm: { ...config.llm, provider: 'openrouter' as const, model } };
+  const provider = getProviderForConfig(llmConfig, model);
+  if (provider.name !== 'openrouter' || !provider.available()) throw new Error('OpenRouter credentials unavailable for openrouter/z-ai/glm-5.3');
+  const messages: LLMMessage[] = [
+    { role: 'system', content: 'Translate the supplied single public release-note line into concise idiomatic English. Return only the translation. Preserve markdown structure, meaning, punctuation, and every placeholder exactly.' },
+    { role: 'user', content: line },
+  ];
+  let result = '';
+  for await (const chunk of provider.chat(messages, { model, temperature: 0, maxTokens: 512, remainingFallbacks: 0, promptCache: false })) result += chunk;
+  return result;
+};
+
+export function atomicallyRepairFiles(targets: Array<{ path: string; lines: number[] }>, translate: Translator = glmTranslator): Promise<{ files: string[]; translatedLines: number[]; error?: string }> {
+  return (async () => {
+    const changed: string[] = [];
+    const translatedLines: number[] = [];
+    const staged: Array<{ path: string; text: string }> = [];
+    for (const { path, lines: selectedLines } of targets) {
+      const original = readFileSync(path, 'utf8');
+      const result = await repairKoreanMarkdown(original, translate, new Set(selectedLines));
+      if (result.error) return { files: changed, translatedLines, error: `${path}: ${result.error}` };
+      if (result.text !== original) {
+        staged.push({ path, text: result.text });
+        changed.push(path);
+        translatedLines.push(...result.translatedLines);
+      }
+    }
+    for (const { path, text } of staged) {
+      const temp = join(dirname(path), `.${basename(path)}.${randomUUID()}.tmp`);
+      try { writeFileSync(temp, text); chmodSync(temp, statSync(path).mode); renameSync(temp, path); }
+      finally { if (existsSync(temp)) unlinkSync(temp); }
+    }
+    return { files: changed, translatedLines };
+  })();
+}
+
+type DocsReceipt = {
+  owner: { runId: string; attempt: number };
+  branch: string;
+  worktree: string;
+  outcome: 'pushed';
+  head: string;
+  result: Record<string, unknown>;
+};
+
+function git(tree: string, ...args: string[]): string {
+  const result = spawnSync('git', args, { cwd: tree, encoding: 'utf8', timeout: 30_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER });
+  if (result.status !== 0) throw new Error(`docs repair git ${args[0]} failed: ${(result.stderr || result.error || '').toString().trim()}`);
+  return result.stdout.trim();
+}
+
+function remoteHead(tree: string, branch: string): string {
+  const line = git(tree, 'ls-remote', '--heads', 'origin', `refs/heads/${branch}`);
+  const match = /^([0-9a-f]{40})\s+refs\/heads\/[^\s]+$/i.exec(line);
+  if (!match) throw new Error(`docs repair remote head missing or invalid: ${branch}`);
+  return match[1]!;
+}
+
+function publishReceipt(path: string, receipt: DocsReceipt): void {
+  const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try { writeFileSync(temp, JSON.stringify(receipt) + '\n'); renameSync(temp, path); }
+  finally { if (existsSync(temp)) unlinkSync(temp); }
+}
+
+function ownedDocsReceipt(context: GraphContext, docs: Record<string, unknown>, tree: string, stateRoot: string,
+  approvedPaths: string[]): { path: string; receipt: DocsReceipt } {
+  const runId = context.runId;
+  const owner = docs.artifactOwner as { runId?: unknown; attempt?: unknown } | undefined;
+  const branch = `release-docs/${context.input.version}`;
+  if (!runId || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(runId)
+    || !owner || owner.runId !== runId || !Number.isSafeInteger(owner.attempt) || docs.branch !== branch)
+    throw new Error('docs repair requires same-run docs branch ownership');
+  const path = join(stateRoot, 'release', context.input.version, 'docs-branch-owner.json');
+  let receipt = JSON.parse(readFileSync(path, 'utf8')) as DocsReceipt;
+  if (receipt?.outcome !== 'pushed' || receipt.owner?.runId !== runId || receipt.owner.attempt !== owner.attempt
+    || receipt.branch !== branch || realpathSync(receipt.worktree) !== tree || !/^[0-9a-f]{40}$/i.test(receipt.head)
+    || receipt.result?.outcome !== 'ok') throw new Error('docs repair ownership receipt does not match this run and attempt');
+  if (git(tree, 'branch', '--show-current') !== branch) throw new Error('docs repair branch differs from ownership receipt');
+  if (git(tree, 'status', '--porcelain')) throw new Error('docs repair worktree is not clean');
+  const local = git(tree, 'rev-parse', 'HEAD');
+  const remote = remoteHead(tree, branch);
+  if (local !== receipt.head) {
+    const parents = git(tree, 'rev-list', '--parents', '-n', '1', 'HEAD').split(' ');
+    const message = git(tree, 'log', '-1', '--format=%B', 'HEAD');
+    const changed = git(tree, 'diff-tree', '--no-commit-id', '--name-only', '-r', 'HEAD').split('\n').filter(Boolean);
+    const approved = approvedPaths.map((file) => relative(tree, realpathSync(file)));
+    if (parents.length !== 2 || parents[0] !== local || parents[1] !== receipt.head
+      || !message.split('\n').includes(`Release-Notes-Repair-Run: ${runId}`)
+      || !message.split('\n').includes(`Release-Notes-Repair-Attempt: ${owner.attempt}`)
+      || !changed.length || changed.some((name) => !approved.includes(name))
+      || (remote !== receipt.head && remote !== local))
+      throw new Error('docs repair local/remote head differs from ownership receipt');
+    if (remote === receipt.head) git(tree, 'push', 'origin', `HEAD:refs/heads/${branch}`);
+    if (remoteHead(tree, branch) !== local) throw new Error('docs repair recovery remote head verification failed');
+    receipt = { ...receipt, head: local };
+    publishReceipt(path, receipt);
+  } else if (remote !== receipt.head) throw new Error('docs repair local/remote head differs from ownership receipt');
+  return { path, receipt };
+}
+
+function publishDocsRepair(tree: string, files: string[], path: string, receipt: DocsReceipt): string {
+  const names = files.map((file) => relative(tree, realpathSync(file)));
+  git(tree, 'add', '--', ...names);
+  const staged = git(tree, 'diff', '--cached', '--name-only').split('\n').filter(Boolean);
+  if (staged.some((name) => !names.includes(name))) throw new Error('docs repair staged a file outside approved B11 targets');
+  if (!staged.length) return receipt.head;
+  git(tree, 'commit', '-m', `docs: repair release ${receipt.branch.split('/').at(-1)} notes`,
+    '-m', `Release-Notes-Repair-Run: ${receipt.owner.runId}\nRelease-Notes-Repair-Attempt: ${receipt.owner.attempt}`);
+  const head = git(tree, 'rev-parse', 'HEAD');
+  git(tree, 'push', 'origin', `HEAD:refs/heads/${receipt.branch}`);
+  if (remoteHead(tree, receipt.branch) !== head) throw new Error('docs repair remote head verification failed');
+  publishReceipt(path, { ...receipt, head });
+  return head;
+}
+
+export async function runNotesRepair(context: GraphContext, translate: Translator = glmTranslator,
+  deps: { stateRoot?: string } = {}): Promise<{
+  outcome: 'ok' | 'fail'; version: string; summary: string; files?: string[]; translatedLines?: number[]; head?: string; error?: string;
+}> {
+  try {
+    if (context.outputs['notes-repair']) throw new Error('B11 remains after the single permitted translation attempt');
+    const docs = context.outputs.docs;
+    if (docs?.outcome !== 'ok' || typeof docs.notes !== 'string' || typeof docs.worktree !== 'string') throw new Error('docs output required');
+    const findings = context.outputs['notes-check']?.findings;
+    if (!Array.isArray(findings)) throw new Error('notes-check findings required');
+    const allowed = new Set([docs.notes, ...(Array.isArray(docs.flipped) ? docs.flipped : [])]
+      .filter((path): path is string => typeof path === 'string').map((path) => realpathSync(resolve(path))));
+    const worktree = realpathSync(resolve(docs.worktree));
+    const targets = new Map<string, Set<number>>();
+    for (const raw of findings) {
+      if (!raw || typeof raw !== 'object') continue;
+      const finding = raw as { rule?: unknown; file?: unknown; line?: unknown };
+      if (finding.rule !== 'B11' || typeof finding.file !== 'string' || typeof finding.line !== 'number'
+        || !Number.isSafeInteger(finding.line) || finding.line < 1) continue;
+      const file = realpathSync(resolve(finding.file));
+      if (!file.startsWith(`${worktree}${sep}`) || !allowed.has(file)) throw new Error(`B11 target outside docs output: ${finding.file}`);
+      const lines = targets.get(finding.file) ?? new Set<number>();
+      lines.add(finding.line);
+      targets.set(finding.file, lines);
+    }
+    if (findings.some((finding) => !finding || typeof finding !== 'object' || (finding as { rule?: string }).rule !== 'B11'))
+      throw new Error('notes-check has non-B11 findings; translation cannot repair them');
+    if (!targets.size) throw new Error('notes-check failed without repairable B11 findings');
+    const files = [...targets].map(([path, lines]) => ({ path, lines: [...lines] }));
+    const { path: receiptPath, receipt } = ownedDocsReceipt(context, docs, worktree,
+      deps.stateRoot ?? effectiveInstanceRoot(), files.map((file) => file.path));
+    const result = await atomicallyRepairFiles(files, translate);
+    if (result.error) return { outcome: 'fail', version: context.input.version, summary: result.error, ...result };
+    const head = result.files.length ? publishDocsRepair(worktree, result.files, receiptPath, receipt) : receipt.head;
+    return { outcome: 'ok', version: context.input.version,
+      summary: `translated ${result.translatedLines.length} line(s)`, ...result, head };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { outcome: 'fail', version: context.input.version, summary: message, error: message };
+  }
+}

package/scripts/release-loop/prepare-node.ts

@@ -21,13 +21,43 @@ function readRegularManifest(path: string): Buffer {
   } finally { closeSync(fd); }
 }
 
+function releaseAttempt(root: string, version: string, runId: string): number {
+  const path = join(root, 'release', version, 'resume-attempts', `${runId}.json`);
+  if (!existsSync(path)) return 0;
+  let value: { version?: unknown; runId?: unknown; attempts?: unknown };
+  try { value = JSON.parse(readFileSync(path, 'utf8')) as typeof value; }
+  catch { throw new Error(`invalid release resume attempts: ${path}`); }
+  if (value.version !== version || value.runId !== runId || !Array.isArray(value.attempts)
+    || value.attempts.some((at) => typeof at !== 'string' || !Number.isFinite(Date.parse(at))))
+    throw new Error(`invalid release resume attempts: ${path}`);
+  return value.attempts.length;
+}
+
+/** Old releases predate the owner receipt; their own graph ledger can still prove the prepared output. */
+function preparedByRun(root: string, runId: string, out: string, commit: string): boolean {
+  try {
+    const ledger = JSON.parse(readFileSync(join(root, 'graph-runs', 'release-loop', `${runId}.json`), 'utf8')) as
+      { runId?: string; graphId?: string; nodes?: Array<{ nodeId?: string; ok?: boolean; output?: string }> };
+    if (ledger.runId !== runId || ledger.graphId !== 'release-loop') return false;
+    return ledger.nodes?.some((node) => {
+      if (node.nodeId !== 'prepare' || !node.ok || typeof node.output !== 'string') return false;
+      try {
+        const output = JSON.parse(node.output.trim().split('\n').at(-1) ?? '') as { out?: string; commit?: string; outcome?: string };
+        return output.outcome === 'ok' && output.out === out && output.commit === commit;
+      } catch { return false; }
+    }) ?? false;
+  } catch { return false; }
+}
+
 export function runPrepare(run: CommandRunner = runCommand, move: typeof renameSync = renameSync) {
   const context = readGraphContext();
   const { version, previousVersion } = context.input;
   if (!isReleaseVersion(version)) throw new Error(`invalid release version: ${version}`);
+  if (context.runId && !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(context.runId)) throw new Error('invalid release runId');
   const commit = nodeOutput(context, 'version-release', 'commit');
   for (const node of ['gate', 'pwa']) if (context.outputs[node]?.outcome !== 'ok') throw new Error(`${node} did not pass`);
   const root = effectiveInstanceRoot();
+  const attempt = context.runId ? releaseAttempt(root, version, context.runId) : undefined;
   const out = join(root, 'release', version, 'prepared');
   if ([join(root, 'release'), join(root, 'release', version)]
     .some((path) => lstatSync(path, { throwIfNoEntry: false })?.isSymbolicLink()))
@@ -41,22 +71,44 @@ export function runPrepare(run: CommandRunner = runCommand, move: typeof renameS
     // archive is left untouched for investigation; never erase it merely because the path is occupied.
     const old = context.outputs['version-release']?.refreshedFrom;
     const manifestPath = join(out, 'release.json');
-    if (typeof old !== 'string' || !/^[0-9a-f]{40}$/i.test(old) || old === commit
-      || !occupied.isDirectory() || !existsSync(manifestPath) || !lstatSync(manifestPath).isFile())
+    if (!occupied.isDirectory() || !existsSync(manifestPath) || !lstatSync(manifestPath).isFile())
       throw new Error(`prepare output already exists with unverified source: ${out}`);
     if (realpathSync(out) !== join(realpathSync(root), 'release', version, 'prepared'))
       throw new Error(`prepare output escapes release root: ${out}`);
     let manifest: { version?: unknown; sourceCommit?: unknown };
     try { staleManifestBytes = readRegularManifest(manifestPath); manifest = JSON.parse(staleManifestBytes.toString('utf8')) as typeof manifest; }
     catch { throw new Error(`prepare output already exists with unreadable manifest: ${out}`); }
-    if (manifest.version !== version || manifest.sourceCommit !== old)
+    const manifestSource = manifest.sourceCommit;
+    if (manifest.version !== version || typeof manifestSource !== 'string' || !/^[0-9a-f]{40}$/i.test(manifestSource)
+      || (manifestSource !== commit && manifestSource !== old))
       throw new Error(`prepare output already exists for another source: ${out}`);
+    const ownerPath = join(out, '.release-node-owner.json');
+    let owner: { runId?: string; commit?: string } | undefined;
+    if (existsSync(ownerPath)) {
+      try { owner = JSON.parse(readRegularManifest(ownerPath).toString('utf8')) as typeof owner; }
+      catch { throw new Error(`prepare output owner unreadable: ${out}`); }
+    }
+    const sameRun = !!context.runId && (owner?.runId === context.runId && owner.commit === manifestSource
+      || !owner && preparedByRun(root, context.runId, out, manifestSource));
+    if (manifestSource === commit && sameRun) {
+      const candidate = join(out, 'dist', 'elanous.tgz');
+      if (!existsSync(candidate)) throw new Error(`prepare output incomplete for same run: ${out}`);
+      return { outcome: 'ok' as const, verdict: 'pass' as const,
+        summary: `prepare ${version} · ${commit.slice(0, 12)} reused`, out, candidate, commit,
+        artifactOwner: { runId: context.runId, attempt, reused: true } };
+    }
+    // A different run's complete archive is never consumed. Without a verified owner, an archive at the
+    // current tip remains untouched; a refreshed old tip can still follow the existing guarded quarantine.
+    if (manifestSource === commit && !owner?.runId)
+      throw new Error(`prepare output already exists with unverified owner: ${out}`);
+    if (manifestSource !== commit && (typeof old !== 'string' || !/^[0-9a-f]{40}$/i.test(old) || old === commit))
+      throw new Error(`prepare output already exists with unverified source: ${out}`);
     staleParents = [join(root, 'release'), join(root, 'release', version)].map((path) => {
       const stat = lstatSync(path);
       if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error(`prepare output escapes release root: ${out}`);
       return { path, dev: stat.dev, ino: stat.ino, real: realpathSync(path) };
     });
-    staleSource = old;
+    staleSource = manifestSource;
   }
   const ref = `v${previousVersion}^{commit}`;
   const prev = run('git', ['rev-parse', '--verify', ref]);
@@ -119,7 +171,11 @@ export function runPrepare(run: CommandRunner = runCommand, move: typeof renameS
   if (command.status !== 0 || manifest?.version !== version || manifest.sourceCommit !== commit || manifest.distDir !== join(out, 'dist')) {
     throw new Error(`prepare incomplete (rc=${command.status}): ${lastResult(command)?.error ?? command.stderr.trim()}`);
   }
-  return { outcome: 'ok' as const, verdict: 'pass' as const, summary: `prepare ${version} · ${commit.slice(0, 12)}`, out, candidate: join(out, 'dist', 'elanous.tgz'), commit };
+  const artifactOwner = context.runId ? { runId: context.runId, attempt, commit } : undefined;
+  if (artifactOwner && existsSync(join(out, 'release.json')))
+    writeFileSync(join(out, '.release-node-owner.json'), JSON.stringify(artifactOwner) + '\n', { flag: 'wx', mode: 0o600 });
+  return { outcome: 'ok' as const, verdict: 'pass' as const, summary: `prepare ${version} · ${commit.slice(0, 12)}`, out, candidate: join(out, 'dist', 'elanous.tgz'), commit,
+    ...(artifactOwner ? { artifactOwner } : {}) };
 }
 
 if (import.meta.main) {

package/scripts/release-loop/resume-cap.ts

@@ -1,56 +1,36 @@
 import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { DecisionLedger } from '../../src/decisions/decision-ledger.js';
 import type { GraphRunState } from '../../src/graph-runner/runner.js';
 import { isReleaseVersion } from './release-version.js';
 
-export const RELEASE_RESUME_LIMIT = 2;
-
 /** Called under the OP seat flock, before any branch-tip or graph-run mutation. */
 export function reserveReleaseResumeAttempt(state: GraphRunState, root: string, options: {
   now?: () => Date;
-  openCard?: (version: string, runId: string, reason: string) => string;
-  /** Under the OP flock, check capacity before tip preflight without consuming an attempt. */
+  /** Under the OP flock, preview the next observed count before tip preflight. */
   checkOnly?: boolean;
-  /** A dry-run reports the cap without creating an OP decision card. */
-  noDecision?: boolean;
-} = {}): { attempt: number; path: string } {
+} = {}): { attempt: number; path: string; priorCountKnown: boolean } {
   const version = (state.input as { version?: unknown } | undefined)?.version;
   if (typeof version !== 'string' || !isReleaseVersion(version) || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(state.runId))
-    throw new Error('release resume cap requires a valid saved version and run id');
+    throw new Error('release resume count requires a valid saved version and run id');
   const path = join(root, 'release', version, 'resume-attempts', `${state.runId}.json`);
-  const card = options.openCard ?? ((v: string, id: string, reason: string) => {
-    const ref = `release-resume-cap:${v}:${id}`;
-    return new DecisionLedger({ stateDir: root, now: options.now }).raiseOnce({
-      title: `${v} release resume limit: ${id}`, category: 'scope',
-      scqa: { s: `Release ${v} run ${id} has reached its two-resume limit.`, c: reason,
-        q: 'Should this release be deferred or moved to the next version?' },
-      options: [{ key: 'a', label: 'Defer this release', consequence: 'Stop this run and reschedule the release.' },
-        { key: 'b', label: 'Move to next version', consequence: 'Stop this run and carry the work to a new release.' }],
-      recommendation: { skipped: true, reason: 'OP must choose the release disposition.' },
-      raisedBy: { agent: 'release-resume-cap', track: 'TC' }, refs: [ref],
-    }, ref).id;
-  });
-  const blocked = (reason: string): never => {
-    if (options.noDecision) throw new Error(`release resume limit reached: ${reason}`);
-    throw new Error(`release resume limit reached — decision ${card(version, state.runId, reason)}: ${reason}`);
-  };
-  if (options.noDecision && !options.checkOnly) throw new Error('noDecision requires checkOnly');
-  if (!existsSync(path) && state.resume) blocked('saved run was resumed before attempt counting; prior count is unknown');
-  const prior = existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) as unknown : { version, runId: state.runId, attempts: [] };
+  const hadLedger = existsSync(path);
+  const prior = hadLedger ? JSON.parse(readFileSync(path, 'utf8')) as unknown : { version, runId: state.runId, attempts: [] };
   if (!prior || typeof prior !== 'object' || Array.isArray(prior)) throw new Error('release resume attempts ledger invalid');
-  const saved = prior as { version?: unknown; runId?: unknown; attempts?: unknown };
+  const saved = prior as { version?: unknown; runId?: unknown; attempts?: unknown; priorCountKnown?: unknown };
   if (saved.version !== version || saved.runId !== state.runId || !Array.isArray(saved.attempts)
-    || saved.attempts.some(value => typeof value !== 'string' || !Number.isFinite(Date.parse(value))))
+    || saved.attempts.some(value => typeof value !== 'string' || !Number.isFinite(Date.parse(value)))
+    || (saved.priorCountKnown !== undefined && typeof saved.priorCountKnown !== 'boolean'))
     throw new Error('release resume attempts ledger invalid');
-  if (saved.attempts.length >= RELEASE_RESUME_LIMIT) blocked(`${saved.attempts.length} resumes already recorded`);
-  if (options.checkOnly) return { attempt: saved.attempts.length + 1, path };
+  // Existing ledgers predate this field and began before the first resume.
+  // A legacy resumed run with no ledger must carry its unknown history forward.
+  const priorCountKnown = hadLedger ? saved.priorCountKnown !== false : !state.resume;
+  if (options.checkOnly) return { attempt: saved.attempts.length + 1, path, priorCountKnown };
   const at = (options.now ?? (() => new Date()))().toISOString();
-  const next = { version, runId: state.runId, attempts: [...saved.attempts, at] };
+  const next = { version, runId: state.runId, priorCountKnown, attempts: [...saved.attempts, at] };
   mkdirSync(dirname(path), { recursive: true });
   const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
   try { writeFileSync(temp, `${JSON.stringify(next)}\n`, { mode: 0o600 }); renameSync(temp, path); }
   finally { try { unlinkSync(temp); } catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; } }
-  return { attempt: next.attempts.length, path };
+  return { attempt: next.attempts.length, path, priorCountKnown };
 }