elanous 0.2.27 → 0.2.29

package/src/git-fs/index.ts

@@ -13,7 +13,7 @@ import { spawnSync } from 'node:child_process';
 import { findGitDir, type LocatedGit } from './locate.js';
 import { readGitHead } from './read-head.js';
 import { GitFileWatcher } from './watcher.js';
-import { probeDirty, probeAheadBehind } from './dirty.js';
+import { probeDirty, probeAheadBehind, probeDirtyAsync, probeAheadBehindAsync } from './dirty.js';
 import { debug } from '../debug/log.js';
 import type {
   GitHeadInfo,
@@ -170,6 +170,47 @@ export function refreshDirty(
   };
 }
 
+const dirtyInFlight = new Map<CacheEntry, Promise<GitStatusView>>();
+
+function viewOf(entry: CacheEntry): GitStatusView {
+  return { head: entry.head, dirty: entry.dirty, aheadBehind: entry.aheadBehind, lastDirtyProbeAt: entry.lastDirtyProbeAt };
+}
+
+/** Non-blocking twin of `refreshDirty` for the TUI: the probes run as
+ *  async subprocesses so a slow `git status` (large worktree, loaded
+ *  host) never stalls key input. Same throttle; concurrent calls share
+ *  one probe, except that `force` (a known write just happened) never
+ *  reuses a probe that started before it. */
+export function refreshDirtyAsync(
+  cwd: string,
+  opts: { minIntervalMs?: number; force?: boolean } = {},
+): Promise<GitStatusView> {
+  let entry: CacheEntry | null;
+  try { entry = ensureEntry(cwd); } catch (error) { return Promise.reject(error); }
+  if (!entry) return Promise.resolve({ head: null, dirty: null, aheadBehind: null, lastDirtyProbeAt: 0 });
+  // An in-flight probe (possibly a forced, post-write one) is newer than the last stored view.
+  const running = dirtyInFlight.get(entry);
+  if (running && !opts.force) return running;
+  const min = opts.minIntervalMs ?? 2_000;
+  if (!opts.force && entry.lastDirtyProbeAt > 0 && Date.now() - entry.lastDirtyProbeAt < min) {
+    return Promise.resolve(viewOf(entry));
+  }
+  const target = entry;
+  const root = target.located.root;
+  const start = (): Promise<GitStatusView> => Promise.all([probeDirtyAsync(root), probeAheadBehindAsync(root)])
+    .then(([dirty, aheadBehind]) => {
+      target.dirty = dirty;
+      target.aheadBehind = aheadBehind;
+      target.lastDirtyProbeAt = Date.now();
+      return viewOf(target);
+    });
+  // A forced probe queues behind the running one so it reads the post-write tree.
+  const probe = (running ? running.then(start, start) : start())
+    .finally(() => { if (dirtyInFlight.get(target) === probe) dirtyInFlight.delete(target); });
+  dirtyInFlight.set(target, probe);
+  return probe;
+}
+
 /** Claude Code-style git snapshot for LLM system context.
  *  This is intentionally a point-in-time summary: good enough for
  *  baseline repo awareness, but callers should still use tools for
@@ -256,4 +297,5 @@ export function __resetGitFsCache(): void {
   for (const [, entry] of cache) entry.watcher.dispose();
   cache.clear();
   clearGitSnapshotCache();
+  dirtyInFlight.clear();
 }

package/src/github/pr-labels.ts

@@ -3,6 +3,12 @@ export const IDEA_APPROVAL_LIMIT = 10;
 export const IDEA_STALE_DAYS = 7;
 export const STALLED_DRAFT_HOURS = 24;
 export const CLAIM_IDLE_HOURS = 6;
+export const PR_LABEL_NAMES = {
+  running: 'elanous:running',
+  stalled: 'elanous:stalled',
+  superseded: 'elanous:superseded',
+  needsRebase: 'elanous:needs-rebase',
+} as const;
 
 export type PrLabelAxis = 'state' | 'addon' | 'origin' | 'risk';
 export type PrLabelApplier = 'harness' | 'launcher' | 'sweeper' | 'session' | 'human';
@@ -24,14 +30,14 @@ export interface PrLabelDefinition {
 }
 
 export const PR_LABELS = [
-  { name: 'elanous:running', axis: 'state', color: '1D76DB', description: 'Harness run or session is actively handling a draft PR', appliedBy: ['harness', 'session'], sweep: { action: 'mark-stalled', when: 'run-ended' } },
-  { name: 'elanous:stalled', axis: 'state', color: 'D93F0B', description: 'Incomplete draft requiring human attention', appliedBy: ['harness', 'sweeper'], sweep: { action: 'close', afterHours: STALLED_DRAFT_HOURS } },
+  { name: PR_LABEL_NAMES.running, axis: 'state', color: '1D76DB', description: 'Harness run or session is actively handling a draft PR', appliedBy: ['harness', 'session'], sweep: { action: 'mark-stalled', when: 'run-ended' } },
+  { name: PR_LABEL_NAMES.stalled, axis: 'state', color: 'D93F0B', description: 'Incomplete draft requiring human attention', appliedBy: ['harness', 'sweeper'], sweep: { action: 'close', afterHours: STALLED_DRAFT_HOURS } },
   { name: 'elanous:idea-approval', axis: 'state', color: '0E8A16', description: 'Completed, ready PR awaiting human approval', appliedBy: ['launcher'], sweep: { action: 'none' } },
-  { name: 'elanous:superseded', axis: 'state', color: '6A737D', description: 'Another PR has already merged the same work', appliedBy: ['sweeper', 'session'], sweep: { action: 'close' } },
+  { name: PR_LABEL_NAMES.superseded, axis: 'state', color: '6A737D', description: 'Another PR has already merged the same work', appliedBy: ['sweeper', 'session'], sweep: { action: 'close' } },
   { name: 'elanous:keep', axis: 'addon', color: 'BFDADC', description: 'Human requested that the PR be kept open', appliedBy: ['human'], sweep: { action: 'exclude' } },
   { name: 'elanous:release-hold', axis: 'addon', color: 'D4C5F9', description: 'Exclude from release notes until verified in production', appliedBy: ['launcher', 'session', 'human'], sweep: { action: 'none' } },
   { name: 'elanous:idea-stale', axis: 'addon', color: 'FBCA04', description: 'Approval pending beyond the notification threshold', appliedBy: ['sweeper'], sweep: { action: 'notify', afterDays: IDEA_STALE_DAYS } },
-  { name: 'elanous:needs-rebase', axis: 'addon', color: 'E99695', description: 'Approval blocked by conflicts or failing checks', appliedBy: ['sweeper'], sweep: { action: 'block-approval' } },
+  { name: PR_LABEL_NAMES.needsRebase, axis: 'addon', color: 'E99695', description: 'Approval blocked by conflicts or failing checks', appliedBy: ['sweeper', 'session'], sweep: { action: 'block-approval' } },
   { name: 'elanous:bench', axis: 'addon', color: 'C5DEF5', description: 'Bench arm output: never landed or swept; the owner harvests the winner onto main', appliedBy: ['harness'], sweep: { action: 'none' } },
   { name: 'elanous:harvestable', axis: 'addon', color: 'FBCA04', description: 'Pod terminal marked this PR for harvest', appliedBy: ['harness'], sweep: { action: 'close', afterHours: STALLED_DRAFT_HOURS } },
   { name: 'elanous:from-harness', axis: 'origin', color: 'C5DEF5', description: 'Launched from a harness goal', appliedBy: ['harness'], sweep: { action: 'none' } },

package/src/graph-runner/runner.ts

@@ -27,6 +27,44 @@ import { releaseResumeAcceptedRegressions, releaseResumeGateExecutor, releaseRes
 
 type BashRun = WorkflowDeps['runBash'];
 const DEFAULT_BASH_TIMEOUT_MS = 5 * 60 * 1_000;
+// Independent of graph YAML and recipe snapshots: an already-wrong saved binding must fail closed.
+const RELEASE_NODE_COMMANDS: Readonly<Record<string, { recipe: string; command?: string }>> = {
+  'version-release': { recipe: 'cmd:version-release', command: 'bun scripts/release-loop/version-node.ts release --json' },
+  cutoff: { recipe: 'cmd:cutoff', command: 'bun scripts/release-loop/node-verdict.ts cutoff' },
+  'checklist-gate': { recipe: 'cmd:checklist-gate', command: 'bun scripts/release-loop/checklist-gate-node.ts' },
+  prefetch: { recipe: 'cmd:docs', command: 'bun scripts/release-loop/docs-node.ts --json' },
+  gate: { recipe: 'cmd:gate', command: 'bun scripts/release-loop/gate-node.ts --json' },
+  'mac-smoke': { recipe: 'cmd:mac-smoke', command: 'bun scripts/release-loop/mac-smoke-node.ts' },
+  'export-check': { recipe: 'cmd:export-check', command: 'bun scripts/release-loop/export-check-node.ts' },
+  pwa: { recipe: 'cmd:pwa', command: 'bun scripts/release-loop/node-verdict.ts pwa' },
+  prepare: { recipe: 'cmd:prepare', command: 'bun scripts/release-loop/prepare-node.ts' },
+  upgrade: { recipe: 'cmd:upgrade', command: 'bun scripts/release-loop/upgrade-node.ts' },
+  tui: { recipe: 'cmd:docs', command: 'bun scripts/release-loop/docs-node.ts --json' },
+  docs: { recipe: 'cmd:docs', command: 'bun scripts/release-loop/docs-node.ts --json' },
+  'known-issues': { recipe: 'cmd:known-issues', command: 'bun scripts/release-loop/known-issues-node.ts' },
+  'notes-check': { recipe: 'cmd:notes-check', command: 'bun scripts/announce-loop/check-node.ts --json' },
+  'auto-approve': { recipe: 'cmd:auto-approve', command: 'bun scripts/release-loop/auto-approve-node.ts' },
+  'approve-publish': { recipe: 'approval:publish' },
+  publish: { recipe: 'cmd:publish-command', command: 'bun scripts/release-loop/publish-node.ts' },
+  'npm-publish': { recipe: 'cmd:npm-publish', command: 'bun scripts/release-loop/npm-publish-node.ts' },
+  'docs-land': { recipe: 'cmd:docs-land', command: 'bun scripts/release-loop/docs-land-node.ts' },
+  verify: { recipe: 'cmd:verify', command: 'bun scripts/release-loop/verify-node.ts' },
+  'vault-note': { recipe: 'cmd:vault-note', command: 'bun scripts/release-loop/vault-note-node.ts' },
+  'release-story': { recipe: 'cmd:release-story', command: 'bun scripts/release-story/draft.ts --graph' },
+  'ops-upgrade': { recipe: 'cmd:ops-upgrade', command: 'bun scripts/release-loop/ops-upgrade-node.ts' },
+  'version-dev-bump': { recipe: 'cmd:version-dev-bump', command: 'bun scripts/release-loop/version-node.ts dev-bump --json' },
+  'version-dev-bump-after-failure': { recipe: 'cmd:version-dev-bump', command: 'bun scripts/release-loop/version-node.ts dev-bump --json' },
+  done: { recipe: 'none' },
+  failed: { recipe: 'none' },
+};
+
+function assertReleaseCommandBinding(node: GraphNodeSpec, command: string | undefined, terminal: boolean): void {
+  const expected = RELEASE_NODE_COMMANDS[node.nodeId];
+  if (!expected || node.recipe !== expected.recipe || command !== expected.command ||
+    terminal !== (node.nodeId === 'done' || node.nodeId === 'failed')) {
+    throw new Error(`release node dispatch mismatch before execution: ${node.nodeId}`);
+  }
+}
 
 export interface GraphRunState {
   graphId: string;
@@ -54,7 +92,9 @@ export interface GraphRunState {
   graphPath?: string;
   variant?: { overlayId: string; goal: string; plan: GraphVariantPlan };
   parentRunId?: string;
-  unitCalls?: Array<{ node: string; unit: string; version: number; hash: string; childRunId: string; exit: string; steps: number }>;
+  /** The entry chosen by a parent call; absent for existing single-entry runs. */
+  entryNodeId?: string;
+  unitCalls?: Array<{ node: string; unit: string; version: number; hash: string; childRunId: string; exit: string; steps: number; entry?: string }>;
   growth?: GraphGrowth[];
   growthRejections?: Array<{ from: string; outcome: string; reason: string }>;
   growthPark?: { from: string; outcome: string; reason: string; decisionId: string; decisionRef: string; growth: GraphGrowth; command?: GrowthCommand; approval?: string };
@@ -84,7 +124,7 @@ export interface GraphRunOptions {
   releaseGateExecutor?: { executor: string; host?: string };
   useCurrentGraph?: boolean;
   /** Internal unit invocation context, propagated only by runGraph. */
-  unitContext?: { parentRunId: string; ancestors: readonly string[]; remainingSteps: number };
+  unitContext?: { parentRunId: string; ancestors: readonly string[]; remainingSteps: number; entryNodeId?: string };
   /**
    * RELEASE-LEDGER-UNIVERSE — stamp every cmd: child with this run's ledger root (`ELANOUS_STATE_DIR`).
    * Without it a child launched from a non-leader tree (`bun scripts/...` with cwd = that tree) re-resolves
@@ -404,7 +444,14 @@ function nextNode(edges: readonly GraphEdgeSpec[], nodeId: string, exitOutcome:
 
 type ResolvedUnit = { path: string; template: GraphTemplateSpec; hash: string };
 
-function resolveUnit(call: string, callerPath: string): ResolvedUnit {
+export class UnitNotFoundError extends Error {
+  constructor(call: string) {
+    super(`unit not found: ${call}`);
+    this.name = 'UnitNotFoundError';
+  }
+}
+
+export function resolveUnit(call: string, callerPath: string): ResolvedUnit {
   const [id, requested] = call.split('@');
   const repo = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
   const directories = [join(dirname(callerPath), 'units'), dirname(callerPath), join(repo, 'graphs', 'units'), join(getElanousConfigDir(), 'graphs', 'units')];
@@ -424,16 +471,24 @@ function resolveUnit(call: string, callerPath: string): ResolvedUnit {
     if (matches.length > 1) throw new Error(`ambiguous unit: ${call}`);
     if (matches.length) return matches[0]!;
   }
-  throw new Error(`unit not found: ${call}`);
+  throw new UnitNotFoundError(call);
 }
 
-function validateUnitCalls(graph: GraphTemplateSpec, path: string, ancestors: readonly string[] = []): Map<string, ResolvedUnit> {
+export function validateUnitCalls(graph: GraphTemplateSpec, path: string, ancestors: readonly string[] = [], onMissing?: (call: string) => void): Map<string, ResolvedUnit> {
   if (ancestors.includes(graph.graphId)) throw new Error(`unit cycle: ${[...ancestors, graph.graphId].join(' -> ')}`);
   if (ancestors.length > 3) throw new Error('unit nesting exceeds depth 3');
   const result = new Map<string, ResolvedUnit>();
   for (const node of graph.nodes) {
     if (node.kind !== 'subgraph' || node.call === undefined) continue;
-    const unit = resolveUnit(node.call!, path);
+    let unit: ResolvedUnit;
+    try { unit = resolveUnit(node.call!, path); } catch (error) {
+      if (error instanceof UnitNotFoundError && onMissing) { onMissing(node.call!); continue; }
+      throw error;
+    }
+    const selectedEntry = node.callEntry ?? unit.template.entryNode;
+    if (!(unit.template.unit?.entries ?? [unit.template.entryNode]).includes(selectedEntry)) {
+      throw new Error(`unit entry mismatch: ${node.nodeId} -> ${selectedEntry}`);
+    }
     const contract = node.contract!;
     const edge = graph.edges.find(e => e.from === node.nodeId);
     if (!unit.template.unit || contract.inputs.length !== unit.template.unit.inputs.length ||
@@ -445,7 +500,7 @@ function validateUnitCalls(graph: GraphTemplateSpec, path: string, ancestors: re
       debug.log('graph.unit', 'contract-mismatch', { graphId: graph.graphId, nodeId: node.nodeId, call: node.call });
       throw new Error(`unit contract mismatch: ${node.nodeId} -> ${node.call}`);
     }
-    validateUnitCalls(unit.template, unit.path, [...ancestors, graph.graphId]);
+    validateUnitCalls(unit.template, unit.path, [...ancestors, graph.graphId], onMissing);
     result.set(node.nodeId, unit);
   }
   return result;
@@ -492,6 +547,13 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
   if (variant && !variant.ok) throw new Error(`graph variant rejected: ${JSON.stringify(variant.rejections)}`);
   if (variant?.ok) graph = variant.template;
   const units = validateUnitCalls(graph, path, options.unitContext?.ancestors);
+  const unitEntryNode = options.unitContext?.entryNodeId ?? saved?.entryNodeId ?? graph.entryNode;
+  if (saved?.entryNodeId !== undefined && options.unitContext?.entryNodeId !== undefined && saved.entryNodeId !== options.unitContext.entryNodeId) {
+    throw new Error('unit entry changed on resume');
+  }
+  if ((options.unitContext || saved?.entryNodeId !== undefined) && !(graph.unit?.entries ?? [graph.entryNode]).includes(unitEntryNode)) {
+    throw new Error(`unit entry mismatch: ${unitEntryNode}`);
+  }
   const variantSource = variant?.ok ? stringifyYaml({ ...document,
     nodes: graph.nodes.map((node, index) => ({
       ...((document.nodes as Record<string, unknown>[])[index] ?? {}), node_id: node.nodeId, kind: node.kind,
@@ -537,6 +599,14 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     if (!resolved.command && !resolved.prompt && !resolved.approval) throw new Error(`unknown command recipe for ${node.nodeId}: ${node.recipe}`);
   }
   const graphId = safeSegment(graph.graphId);
+  const isReleaseLoop = graphId === 'release-loop';
+  // A copied or saved release graph is still a release graph. Its path cannot grant or revoke
+  // permission to dispatch a command; only the graph identity and this independent table can.
+  const enforceReleaseCommandBindings = isReleaseLoop;
+  if (enforceReleaseCommandBindings) {
+    for (const node of graph.nodes) assertReleaseCommandBinding(node,
+      resolveNodeRecipe(node, recipes, catalogRoles).command?.command, graph.terminalNodes.includes(node.nodeId));
+  }
   if (saved && graphId !== saved.graphId) {
     if (options.fromNodeId && graphMode === 'current') throw new Error('graph or recipes changed since failed run');
     throw new Error(`run identity mismatch: ${saved.graphId}/${saved.runId}`);
@@ -562,7 +632,9 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     : { graphId, runId, startedAt: new Date().toISOString(), ...runnerOwner, status: 'running', path: [], nodes: [], sourceHash: approvalSourceHash,
       graphSnapshot: { graphSha: createHash('sha256').update(variantSource).digest('hex'), recipesSha: createHash('sha256').update(recipeSource).digest('hex') },
       graphPath: resolve(path), ...(variant?.ok ? { variant: { overlayId: variant.overlay.overlayId, ...options.variant! } } : {}),
-      ...(options.input === undefined ? {} : { input: options.input }), executed: 0, dryRun: options.dryRun === true, statePath };
+      ...(options.input === undefined ? {} : { input: options.input }),
+      ...(options.unitContext?.entryNodeId === undefined ? {} : { entryNodeId: options.unitContext.entryNodeId }),
+      executed: 0, dryRun: options.dryRun === true, statePath };
   if (options.resumeRunId && graphMode === 'snapshot' && state.sourceHash && state.sourceHash !== approvalSourceHash) {
     throw new Error('graph snapshot changed since run started');
   }
@@ -594,7 +666,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         const reported = lastJsonObject(prior.output)?.outcome;
         const next = nextNode(graph.edges, prior.nodeId, prior.ok ? 'ok' : 'fail', typeof reported === 'string' ? reported : undefined);
         if (next !== recorded.nodeId) throw new Error('saved run path does not follow graph edges');
-      } else if (recorded.nodeId !== graph.entryNode) throw new Error('saved run path does not start at entry node');
+      } else if (recorded.nodeId !== unitEntryNode) throw new Error('saved run path does not start at entry node');
       if (i < from && !recorded.ok) throw new Error('cannot preserve a failed predecessor when resuming');
       const approved = resolveNodeRecipe(spec, recipes, catalogRoles).approval;
       if (approved && i >= from) throw new Error('cannot restart across an approval decision');
@@ -736,7 +808,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
   if (options.resumeRunId && !options.fromNodeId) {
     const previousStatus = state.status;
     Object.assign(state, runnerOwner);
-    state.resume = { from: state.pending?.nodeId ?? state.path.at(-1) ?? graph.entryNode, at: new Date().toISOString(), previousStatus, graph: graphMode };
+    state.resume = { from: state.pending?.nodeId ?? state.path.at(-1) ?? unitEntryNode, at: new Date().toISOString(), previousStatus, graph: graphMode };
     persistOwnedRun(state, saved!);
   }
   if (options.resumeRunId) debug.log('graph.runs', 'resume', { graphId, runId, from: state.resume?.from, graph: graphMode });
@@ -751,7 +823,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     : baseLog;
   const visits = new Map<string, number>();
   for (const nodeId of state.path) visits.set(nodeId, (visits.get(nodeId) ?? 0) + 1);
-  let current: string | undefined = options.fromNodeId ?? state.pending?.nodeId ?? state.path.at(-1) ?? graph.entryNode;
+  let current: string | undefined = options.fromNodeId ?? state.pending?.nodeId ?? state.path.at(-1) ?? unitEntryNode;
   if (!options.resumeRunId) {
     mkdirSync(dirname(statePath), { recursive: true });
     if (readdirSync(dirname(statePath)).some((file) => file.startsWith(`${runId}.json.`) && file.endsWith('.decision.json'))) {
@@ -788,6 +860,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     }
     const resolved = resolveNodeRecipe(node, recipes, catalogRoles);
     const command = resolved.command;
+    if (enforceReleaseCommandBindings) assertReleaseCommandBinding(node, command?.command, graph.terminalNodes.includes(current));
     const prompt = resolved.prompt;
     const approval = resolved.approval ? { approval: approvalMessage(resolved.approval.approval, state.input) } : undefined;
     if (resumingPending && (!approval || approval.approval !== state.pending?.message)) {
@@ -837,7 +910,13 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       const redactCredentials = (text: string) => Object.values(credentials).filter(value => value.length > 0)
         .reduce((safe, value) => safe.replaceAll(value, '[REDACTED]'), text);
       const runBash: BashRun = async (body, opts) => {
+        // Hash the actual /bin/bash argv after interpolation. Keep the command text (which may contain
+        // credentials) out of logs, but leave enough to distinguish a replayed publish from npm/docs.
+        const argvSha256 = createHash('sha256').update(JSON.stringify(['/bin/bash', '-c', body])).digest('hex');
+        const fingerprint = { graphId, runId, nodeId: current!, recipe: node.recipe, argvSha256 };
+        debug.log('graph.run', 'command-dispatch', { ...fingerprint, pid: null });
         const execute = options.deps?.runBash ?? realRunBash((pid) => {
+          debug.log('graph.run', 'command-spawn', { ...fingerprint, pid });
           // Publish the child before its start time is known, so a concurrent stop refuses instead of failing
           // the ledger while an untracked node keeps working (REL8b review round 3).
           state.activeNode = { nodeId: current!, pid, pidStartedAt: UNVERIFIED_NODE_START };
@@ -906,7 +985,10 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       const alreadySpent = state.path.length + (state.unitCalls ?? []).reduce((sum, call) => sum + call.steps, 0);
       const remaining = options.unitContext ? options.unitContext.remainingSteps - alreadySpent : Infinity;
       const childRunId = randomUUID();
-      const info = { graphId, runId, nodeId: current, unit: unit.template.graphId, childRunId, parentRunId: runId };
+      const selectedEntry = node.callEntry ?? unit.template.entryNode;
+      const recordEntry = node.callEntry !== undefined || unit.template.unit?.entries !== undefined;
+      const info = { graphId, runId, nodeId: current, unit: unit.template.graphId, childRunId, parentRunId: runId,
+        ...(recordEntry ? { entry: selectedEntry } : {}) };
       let entered = false;
       try {
         for (const key of contract.inputs) if (!Object.hasOwn(inputs, key)) throw new Error(`unit input missing: ${current}.${key}`);
@@ -918,7 +1000,8 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         const child = await runGraph(unit.path, { runId: childRunId, input: inputs, dryRun: false,
           pinChildUniverse: options.pinChildUniverse,
           unitContext: { parentRunId: runId, ancestors: [...(options.unitContext?.ancestors ?? []), graphId],
-            remainingSteps: Math.min(node.budget!.innerSteps, remaining) }, deps: options.deps });
+            remainingSteps: Math.min(node.budget!.innerSteps, remaining),
+            ...(recordEntry ? { entryNodeId: selectedEntry } : {}) }, deps: options.deps });
         const steps = child.path.length + (child.unitCalls ?? []).reduce((sum, call) => sum + call.steps, 0);
         const childExit = child.status === 'done' || child.status === 'failed' ? child.path.at(-1) : undefined;
         // The last successful record carrying every contracted output is the source;
@@ -932,7 +1015,8 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         }, undefined) ?? {};
         state.unitCalls ??= [];
         state.unitCalls.push({ node: current, unit: unit.template.graphId, version: unit.template.version,
-          hash: unit.hash, childRunId, exit: childExit ?? child.status, steps });
+          hash: unit.hash, childRunId, exit: childExit ?? child.status, steps,
+          ...(recordEntry ? { entry: selectedEntry } : {}) });
         if (child.status === 'awaiting-approval') throw new Error(`unit cannot pause for approval: ${current}`);
         if (child.status === 'budget-exceeded' || steps > node.budget!.innerSteps || steps > remaining) {
           debug.log('graph.unit', 'budget-exhausted', { ...info, steps, innerSteps: node.budget!.innerSteps });
@@ -1005,6 +1089,10 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         ...(approval && state.pending ? { ...(state.pending.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending.decidedAt } : {}),
         startedAt: nodeStartedAt, endedAt: nodeEndedAt, seconds });
     }
+    if (isReleaseLoop && graph.terminalNodes.includes(current) && node.recipe === 'none' &&
+      (exit !== null || output !== undefined || error !== undefined || state.nodes.at(-1)?.executed)) {
+      throw new Error(`release terminal received command output: ${current}`);
+    }
     if (approval) {
       delete state.pending;
       delete state.approvalSourceHash;

package/src/harness/harness-clean.ts

@@ -201,6 +201,8 @@ export function planHarnessClean(input: {
   readWorktreeProvenance?: WorktreeProvenanceReader;
   /** provenance reader가 쓰는 git runner. planner 단독 테스트에서는 반드시 명시한다. */
   run?: GitRunner;
+  /** Allow reclaiming unowned worktrees only for merged-clean branches; default remains preservation. */
+  includeUnownedMergedClean?: boolean;
   /** 조회별 소요 시간(밀리초). 키는 `queryStatus` 조회 칸과 같다. 못 잰 칸은 생략한다. */
   queryTimings?: HarnessCleanQueryTimings;
 }): HarnessCleanPlan {
@@ -353,7 +355,15 @@ export function planHarnessClean(input: {
       continue;
     }
     const ladderReason = `assessment=${assessment.disposition}:${assessment.reason}`;
-    if (assessment.disposition !== 'reclaim-safe' || !ownership.recorded) {
+    const includeUnownedMergedClean = input.includeUnownedMergedClean === true
+      && mode === 'merged'
+      && mergedPr.has(branch)
+      && !openPr.has(branch)
+      && assessment.disposition === 'reclaim-safe'
+      && assessment.reason === 'merged-clean'
+      && !ownership.recorded
+      && ownership.status.startsWith('not-recorded:');
+    if (assessment.disposition !== 'reclaim-safe' || (!ownership.recorded && !includeUnownedMergedClean)) {
       preserve.push({ ...base, reason: `${ladderReason}; ownership=${ownership.status}` });
       continue;
     }
@@ -992,6 +1002,7 @@ export function execHarnessClean(opts: {
   mode: HarnessCleanMode;
   dryRun?: boolean;
   force?: boolean;
+  includeUnownedMergedClean?: boolean;
   branchPrefix?: string;
   repo?: string;
   window?: { offset: number; size: number };
@@ -1087,6 +1098,7 @@ export function execHarnessClean(opts: {
     readWorktreeProvenance: opts.readWorktreeProvenance,
     run,
     mode: opts.mode,
+    ...(opts.includeUnownedMergedClean ? { includeUnownedMergedClean: true } : {}),
     queryStatus,
     queryTimings: {
       worktrees: worktreesTimed.ms,
@@ -1286,10 +1298,16 @@ export function renderHarnessCleanReport(
     item.reason.includes('reclaim-safe:merged-no-worktree'),
   ).length;
   const branchOnlyReclaimedCount = res.plan.remove.filter((item) => item.reason.includes('branch-only')).length;
+  const isUnownedMergedClean = (item: CleanPlanItem): boolean =>
+    item.reason.includes('assessment=reclaim-safe:merged-clean') && item.reason.includes('ownership=not-recorded:');
+  const plannedUnownedMergedCleanCount = res.plan.remove.filter(isUnownedMergedClean).length;
+  const unownedMergedCleanCount = (res.dryRun ? res.plan.remove : res.removed).filter(isUnownedMergedClean).length;
+  const unownedMergedCleanSummary = plannedUnownedMergedCleanCount > 0
+    ? ` · 미소유 merged-clean ${res.dryRun ? '제거 예정' : '회수'} ${unownedMergedCleanCount}` : '';
   L.push(
     omittedPreserve > 0
-      ? `규모 매칭 ${matchedTotal} · 제거 계획 ${res.plan.remove.length} · 보존 ${res.plan.preserve.length} · 화면 ${displayedCount} (보존 ${omittedPreserve}개는 생략) · 브랜치만 회수 ${branchOnlyReclaimedCount} · 워크트리 없이 안전 ${mergedNoWorktreeCount}`
-      : `규모 매칭 ${matchedTotal} · 제거 계획 ${res.plan.remove.length} · 보존 ${res.plan.preserve.length} · 화면 ${displayedCount} · 브랜치만 회수 ${branchOnlyReclaimedCount} · 워크트리 없이 안전 ${mergedNoWorktreeCount}`,
+      ? `규모 매칭 ${matchedTotal} · 제거 계획 ${res.plan.remove.length} · 보존 ${res.plan.preserve.length} · 화면 ${displayedCount} (보존 ${omittedPreserve}개는 생략) · 브랜치만 회수 ${branchOnlyReclaimedCount} · 워크트리 없이 안전 ${mergedNoWorktreeCount}${unownedMergedCleanSummary}`
+      : `규모 매칭 ${matchedTotal} · 제거 계획 ${res.plan.remove.length} · 보존 ${res.plan.preserve.length} · 화면 ${displayedCount} · 브랜치만 회수 ${branchOnlyReclaimedCount} · 워크트리 없이 안전 ${mergedNoWorktreeCount}${unownedMergedCleanSummary}`,
   );
   if (res.plan.remove.length === 0) L.push('정리 대상 없음.');
   else {

package/src/harness/harness-cli-command.ts

@@ -305,6 +305,7 @@ function registerHarnessAskSayOptions(command: Command): Command {
     .addOption(new Option('--pod-memory <tier>', 'pod: 메모리 등급 — lite(2Gi · 문서·조사·네트워크 스킬 골 · OOM 이면 high 로 한 번 재시도) | standard(16Gi) | high(32Gi) · 없으면 골 문면 `Pod 메모리: <등급>` 한 줄 · 그것도 없으면 골이 apps/pwa/ 를 담을 때 high').choices(['lite', 'standard', 'high']))
     .option('--after <goal-or-pr>', 'pod: 선행 — 이 골 ID(16자) 또는 PR(#N) 이 병합될 때까지 Pod 발사가 큐에서 이유와 함께 기다린다(병합 없이 닫히면 blocked) · 골 문면 `선행: #N` 한 줄과 같다 · 대상 파일만 겹치면 선행이 아니다(경고만)')
     .option('--source <spec>', 'pod: 원천 — commit:<40자 sha> | pr:<정수> | worktree:<경로> | files:<경로>[,<경로>…] · `--substrate pod` 와 함께')
+    .option('--repair-commit-only <expected-head>', 'pod: 기존 PR head에서 수리한 커밋을 bundle로 반환(PR 생성 없음)')
     .option('--bench <id[:sha]>', '벤치 팔 — base 를 bench/<id>/base 로 고정(없으면 sha·생략 시 origin/main 으로 만든다 · 있으면 sha 일치 확인 · 불일치 거부) · 팔 가지 bench/<id>/<arm> · PR 라벨 elanous:bench · PR 직전 main 동기화 생략 · 원장 elanous bench ls <id>');
 }
 
@@ -397,7 +398,7 @@ function assertHarnessChildLlmModel(opts: HarnessAskSayChildLlmOptions): void {
 }
 
 /** Shared post-parse gate: validate child model before any ask/say early return (including `--dry-run`). */
-type HarnessSubstrateOpts = { substrate?: 'local' | 'pod'; podPool?: string; podMemory?: 'lite' | 'standard' | 'high'; after?: string; autoMerge?: boolean; base?: string; json?: boolean; target?: string; source?: string; seat?: QueueSeat };
+type HarnessSubstrateOpts = { substrate?: 'local' | 'pod'; podPool?: string; podMemory?: 'lite' | 'standard' | 'high'; after?: string; autoMerge?: boolean; base?: string; json?: boolean; target?: string; source?: string; repairCommitOnly?: string; seat?: QueueSeat };
 function resolveLaunchSubstrate(opts: HarnessSubstrateOpts): ResolvedHarnessSubstrate {
   const resolved = resolveHarnessSubstrate({ flag: opts, config: getUserConfig(), env: process.env });
   debug.log('harness.substrate', 'resolved', resolved);
@@ -693,7 +694,7 @@ async function onPod(opts: unknown, entrance: 'cli-harness-ask' | 'cli-harness-s
   const status = await dispatchHarnessOnPod({ entrance, input, podPool: pool, ...(authorOnPod && entrance === 'cli-harness-say' ? { authorOnPod: true } : {}),
     ...(child.childLlmProvider?.trim() ? { childLlmProvider: child.childLlmProvider.trim() } : {}),
     ...(child.childLlmModel?.trim() ? { childLlmModel: child.childLlmModel.trim() } : {}),
-    ...(child.childLlmEffort?.trim() ? { childLlmEffort: child.childLlmEffort.trim() } : {}), ...(authorOnPod && podAuthorGrade ? { authorGrade: podAuthorGrade.grade, authorGradeSource: podAuthorGrade.source } : {}), ...(dispatchRecorded ? { dispatchRecorded: true } : {}), ...(o.podMemory ? { podMemory: o.podMemory } : {}), ...((opts as HarnessAskSayChildLlmOptions).goalType ? { goalType: (opts as HarnessAskSayChildLlmOptions).goalType } : {}), ...(o.after ? { after: o.after } : {}), ...(o.autoMerge === false ? { autoMerge: false } : {}), ...(o.base ? { base: o.base } : {}), ...(o.json ? { json: true } : {}), ...(o.source ? { source: o.source } : {}), ...(o.seat ? { seat: o.seat } : {}) },
+    ...(child.childLlmEffort?.trim() ? { childLlmEffort: child.childLlmEffort.trim() } : {}), ...(authorOnPod && podAuthorGrade ? { authorGrade: podAuthorGrade.grade, authorGradeSource: podAuthorGrade.source } : {}), ...(dispatchRecorded ? { dispatchRecorded: true } : {}), ...(o.podMemory ? { podMemory: o.podMemory } : {}), ...((opts as HarnessAskSayChildLlmOptions).goalType ? { goalType: (opts as HarnessAskSayChildLlmOptions).goalType } : {}), ...(o.after ? { after: o.after } : {}), ...(o.autoMerge === false ? { autoMerge: false } : {}), ...(o.base ? { base: o.base } : {}), ...(o.json ? { json: true } : {}), ...(o.source ? { source: o.source } : {}), ...(o.repairCommitOnly ? { repairCommitOnly: o.repairCommitOnly } : {}), ...(o.seat ? { seat: o.seat } : {}) },
     { onOutput: (text) => {
       runId ??= harnessPodRunId(output + text);
       output = (output + text).slice(-16_000);
@@ -894,6 +895,8 @@ async function dispatchHarnessAskSay(
     if (isHarnessDryRun(opts)) {
       resolveLaunchSubstrate(opts);
       printHarnessLaunchDryRun(dryRunPreview);
+      const repair = opts as HarnessSubstrateOpts;
+      if (repair.repairCommitOnly) console.log(`[dry-run] repair forwarding: --pod-source ${repair.source} --repair-commit-only ${repair.repairCommitOnly} --no-auto-merge`);
       return;
     }
     ensureJourneyKey();
@@ -939,7 +942,7 @@ async function dispatchHarnessAskSay(
         ['--goal-type', opts.goalType], ...(dryRunPreview.entrance === 'cli-harness-say' ? [['--author-grade', opts.authorGradeSource === 'flag' ? opts.authorGrade : undefined] as [string, string | undefined]] : []), ['--child-llm-provider', opts.childLlmProvider],
         ['--child-llm-model', opts.childLlmModel], ['--child-llm-effort', opts.childLlmEffort],
         ['--pod-pool', (opts as HarnessSubstrateOpts).podPool], ['--pod-memory', (opts as HarnessSubstrateOpts).podMemory],
-        ['--after', (opts as HarnessSubstrateOpts).after], ['--source', (opts as HarnessSubstrateOpts).source],
+        ['--after', (opts as HarnessSubstrateOpts).after], ['--source', (opts as HarnessSubstrateOpts).source], ['--repair-commit-only', (opts as HarnessSubstrateOpts).repairCommitOnly],
       ];
       for (const [flag, value] of values) if (value !== undefined) flags.push(flag, value);
       if ((opts as HarnessSubstrateOpts).source !== undefined && resolved.substrate !== 'pod') {
@@ -1013,8 +1016,9 @@ async function dispatchHarnessAskSay(
       const previous = process.env.ELANOUS_HARNESS_SEAT;
       if (stampedSeat) process.env.ELANOUS_HARNESS_SEAT = stampedSeat;
       else delete process.env.ELANOUS_HARNESS_SEAT;
-      // 배치 노드 — 실행 칸(local | pod)이 그 출구 라벨이고, YAML 의 decompose 간선(on: substrate)이 그 값으로 갈린다.
-      passJourneyNode('dispatch', { ...journey, outcome: resolved.substrate });
+      // The source label selects the declared author or same-PR rework edge; substrate remains data for decompose.
+      passJourneyNode('dispatch', { ...journey, outcome: (stampedOpts as HarnessSubstrateOpts).repairCommitOnly ? 'pr-source' : 'fresh',
+        data: { substrate: resolved.substrate } });
       const benchRow = bench ? recordBenchLaunch(bench, stampedOpts, resolved.substrate, dryRunPreview.entrance, benchDeps) : undefined;
       try { await dispatch(resolved, stampedOpts); }
       finally {
@@ -3342,6 +3346,11 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
   if (ask) {
     registerHarnessAskSayOptions(harnessCmd.command('ask <goal-path>').description('골 문서 경로를 받아 구동한다'))
       .action(async (goalPath: string, opts: HarnessAskSayChildLlmOptions & HarnessDryRunOpts) => {
+        if ((opts as HarnessSubstrateOpts).repairCommitOnly !== undefined) {
+          console.error('--repair-commit-only is supported only by harness say');
+          process.exitCode = 2;
+          return;
+        }
         await dispatchHarnessAskSay(
           opts,
           {
@@ -3370,6 +3379,13 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
     registerHarnessAskSayOptions(harnessCmd.command('say <sentence...>').description('문장을 받아 구동한다'))
       .addOption(new Option('--author-grade <grade>', 'say 저작 등급 (full|lite)').choices(['full', 'lite']))
       .action(async (sentence: string[], opts: HarnessAskSayChildLlmOptions & HarnessDryRunOpts) => {
+        const repair = opts as HarnessSubstrateOpts;
+        if (repair.repairCommitOnly !== undefined && (repair.substrate !== 'pod' || !/^pr:[1-9]\d*$/.test(repair.source ?? '')
+          || !/^[0-9a-f]{40}$/.test(repair.repairCommitOnly) || repair.autoMerge !== false || repair.target !== undefined)) {
+          console.error('--repair-commit-only requires --substrate pod --source pr:N --no-auto-merge and a 40-hex expected head');
+          process.exitCode = 2;
+          return;
+        }
         const grade = resolveGoalAuthorGrade(opts.authorGrade, getUserConfig().harness?.authorGrade);
         const podSource = process.env.ELANOUS_POD_AUTHOR_ON_POD === '1' && process.env.ELANOUS_POD_AUTHOR_GRADE === grade.grade
           ? process.env.ELANOUS_POD_AUTHOR_GRADE_SOURCE : undefined;
@@ -3390,7 +3406,7 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
               return Promise.resolve();
             }
             return resolved.substrate === 'pod'
-              ? onPod(stampedOpts, 'cli-harness-say', sentence.join(' '), resolved.pool!, deps.podDispatchTask, harnessAuthorOnPod())
+              ? onPod(stampedOpts, 'cli-harness-say', sentence.join(' '), resolved.pool!, deps.podDispatchTask, !(opts as HarnessSubstrateOpts).repairCommitOnly && harnessAuthorOnPod())
               : (announceLocalChildProvider(stampedOpts), say(sentence, normalizeHarnessAskSayOptions(stampedOpts)));
           },
           deps.launchGate, queueDeps, immediateLaunch, queueDeps.launch ? undefined : immediateExit, deps.bench,

package/src/harness/harness-gc.ts

@@ -304,11 +304,37 @@ export function runHarnessGcTick(opts: HarnessGcOptions = {}, deps: HarnessGcDep
   } finally { release(); }
 }
 
-function cliArgs(args: string[]): HarnessGcOptions {
-  const opts: HarnessGcOptions = {};
+interface HarnessGcCliOptions extends HarnessGcOptions {
+  human: boolean;
+  json: boolean;
+}
+
+export function formatHarnessGcReport(result: HarnessGcResult): string {
+  const value = (count: number | undefined): string => count === undefined ? 'unknown' : String(count);
+  const lines = [
+    `Harness GC · ${result.outcome}${result.reason ? ` (${result.reason})` : ''}`,
+    `repos=${result.repos} removed=${result.removed} preserved=${result.preserved} deferred=${result.deferred} failed=${result.failed}`,
+    `unseenOutsideWindow=${value(result.unseenOutsideWindow)} unseenOutsidePrefix=${value(result.unseenOutsidePrefix)}`,
+    `orphanScanUnavailable=${result.orphanScanUnavailable} budgetMs=${result.budgetMs} elapsedMs=${result.elapsedMs} budgetExhausted=${result.budgetExhausted ?? false}`,
+  ];
+  if (result.repositories.length === 0) lines.push('orphanScan=not-requested (no repository result)');
+  for (const repo of result.repositories) {
+    lines.push(`repo=${repo.gitDir} orphanScan=${repo.orphanScan} removed=${repo.removed} preserved=${repo.preserved} deferred=${repo.deferred} failed=${repo.failed}`);
+  }
+  for (const failure of result.repoFailures ?? []) lines.push(`repoFailure=${failure.gitDir}: ${failure.error}`);
+  return lines.join('\n');
+}
+
+export function formatHarnessGcOutput(result: HarnessGcResult, format: Pick<HarnessGcCliOptions, 'human' | 'json'>): string {
+  return format.human && !format.json ? formatHarnessGcReport(result) : JSON.stringify(result);
+}
+
+function cliArgs(args: string[]): HarnessGcCliOptions {
+  const opts: HarnessGcCliOptions = { human: false, json: false };
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    if (arg === '--json') continue;
+    if (arg === '--json') { opts.json = true; continue; }
+    if (arg === '--human') { opts.human = true; continue; }
     if (arg === '--dry-run') { opts.dryRun = true; continue; }
     if (arg === '--repo') { (opts.repos ??= []).push(args[++i] ?? ''); continue; }
     const key = arg === '--window' ? 'window' : arg === '--max-remove' ? 'maxRemove' : arg === '--budget-ms' ? 'budgetMs' : null;
@@ -321,8 +347,9 @@ function cliArgs(args: string[]): HarnessGcOptions {
 
 if (import.meta.main) {
   try {
-    const result = runHarnessGcTick(cliArgs(process.argv.slice(2)));
-    console.log(JSON.stringify(result));
+    const opts = cliArgs(process.argv.slice(2));
+    const result = runHarnessGcTick(opts);
+    console.log(formatHarnessGcOutput(result, opts));
     if (result.outcome === 'fail') process.exitCode = 1;
   } catch (error) {
     console.log(JSON.stringify({ outcome: 'fail', reason: String(error) }));

package/src/harness/harness-pod-dispatch.ts

@@ -43,6 +43,8 @@ export interface HarnessPodDispatchInput {
   readonly json?: boolean;
   /** 사람이 고른 원천 spec — `commit:` · `pr:` · `worktree:` · `files:`. 검증은 발사 전. */
   readonly source?: string;
+  /** Existing PR head for a commit-only repair. Requires source pr:N. */
+  readonly repairCommitOnly?: string;
   /** `--child-llm-provider/--child-llm-model/--child-llm-effort` — carried to `self orchestrate` so the Pod child uses them (10-05 PODPROVIDER). */
   readonly childLlmProvider?: string;
   readonly childLlmModel?: string;
@@ -59,10 +61,11 @@ export function podOrchestrateArgs(input: HarnessPodDispatchInput, goalFile: str
     '--substrate', 'pod',
     ...(input.podPool ? ['--pod-pool', input.podPool] : []),
     // 하니스 기본(자동 병합)을 따른다 · 끄면 PR 까지 — 어느 쪽이든 Pod 가 사라져도 결과가 남는다.
-    ...(input.autoMerge === false ? ['--open-pr'] : ['--auto-merge']),
-    ...(input.base ? ['--base', input.base] : []),
+    ...(input.repairCommitOnly ? [] : input.autoMerge === false ? ['--open-pr'] : ['--auto-merge']),
+    ...(input.repairCommitOnly && input.source ? ['--base', `pr-${input.source.slice(3)}`] : input.base ? ['--base', input.base] : []),
     ...(input.json ? ['--json'] : []),
     ...(input.source ? ['--pod-source', input.source] : []),
+    ...(input.repairCommitOnly ? ['--repair-commit-only', input.repairCommitOnly] : []),
     ...(input.childLlmProvider?.trim() ? ['--child-llm-provider', input.childLlmProvider.trim()] : []),
     ...(input.childLlmModel?.trim() ? ['--child-llm-model', input.childLlmModel.trim()] : []),
     ...(input.childLlmEffort?.trim() ? ['--child-llm-effort', input.childLlmEffort.trim()] : []),
@@ -85,6 +88,10 @@ export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDi
       return 2;
     }
   }
+  if (input.repairCommitOnly && (!/^pr:[1-9]\d*$/.test(input.source ?? '') || !/^[0-9a-f]{40}$/.test(input.repairCommitOnly) || input.autoMerge === true)) {
+    debug.log('harness.substrate', 'repair-refused', { entrance: input.entrance, reason: 'requires pr source, 40-hex head, and no auto-merge' });
+    return 2;
+  }
   const env = { ...process.env, ...oldDoorInternalEnv('self-orchestrate') };
   // POD-OBS(10-06): 자식 orchestrate 는 트리 파생 우주에서 돈다 — Pod 원장 재방출을 «발사한 집»의 logs.db 에도 남기게 경로를 넘긴다.
   env[POD_REEMIT_LOGS_DB_ENV] = logsDbPath();
@@ -146,7 +153,7 @@ export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDi
     memoryLimit: podMemoryLimitFor(goalText, env).limit });
   delete env.ELANOUS_POD_AFTER;
   if (input.after) env.ELANOUS_POD_AFTER = input.after;
-  if (input.authorOnPod) env.ELANOUS_POD_AUTHOR_ON_POD = '1';
+  if (input.authorOnPod && !input.repairCommitOnly) env.ELANOUS_POD_AUTHOR_ON_POD = '1';
   else delete env.ELANOUS_POD_AUTHOR_ON_POD;
   if (input.authorOnPod && input.authorGrade) {
     env.ELANOUS_POD_AUTHOR_GRADE = input.authorGrade;
@@ -157,7 +164,7 @@ export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDi
     delete env.ELANOUS_POD_AUTHOR_GRADE;
     delete env.ELANOUS_POD_AUTHOR_GRADE_SOURCE;
   }
-  if (input.entrance === 'cli-harness-ask') {
+  if (input.entrance === 'cli-harness-ask' && !input.repairCommitOnly) {
     const root = findGitDir(cwd)?.root;
     const path = resolve(cwd, input.input);
     const relativePath = root ? relative(realpathSync(root), realpathSync(path)) : '';