@fitlab-ai/agent-infra 0.9.1 → 0.9.3

package/lib/platform/release-notes.ts

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 
 import { resolvePlatformContext } from './context.ts';
 import {
@@ -24,6 +25,86 @@ const unsupportedError = {
   retryable: false
 };
 
+const SHA256_PATTERN = /^sha256:[0-9a-f]{64}$/;
+
+function releaseNoteFailure(code: string, message: string) {
+  return {
+    status: 'failed' as const,
+    changed: false,
+    operation: null,
+    url: null,
+    error: { code, message, retryable: false }
+  };
+}
+
+function normalizeReleaseNoteBytes(input: Uint8Array): Buffer {
+  const text = new TextDecoder('utf-8', { fatal: true }).decode(input);
+  const normalized = text.replace(/\r\n?/g, '\n').replace(/\n*$/, '') + '\n';
+  return Buffer.from(normalized, 'utf8');
+}
+
+function releaseNoteSha256(bytes: Uint8Array): string {
+  return `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
+}
+
+function isWithin(parent: string, candidate: string): boolean {
+  const relative = path.relative(parent, candidate);
+  return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+
+function stageReleaseNotes(
+  input: { notesFile: string },
+  options: Pick<ReleaseNoteOptions, 'cwd'> = {}
+) {
+  if (!input.notesFile || input.notesFile === '-') {
+    return { status: 'failed' as const, changed: false, notesFile: null, sha256: null, byteLength: null, error: { code: 'RELEASE_NOTES_INPUT_INVALID', message: 'notes-file must identify an existing external file', retryable: false } };
+  }
+  const requestedPath = path.resolve(input.notesFile);
+  let notesFile: string;
+  let sourceStat: fs.Stats;
+  try {
+    if (fs.lstatSync(requestedPath).isSymbolicLink()) throw new Error('symbolic links are not allowed');
+    notesFile = fs.realpathSync(requestedPath);
+    sourceStat = fs.statSync(notesFile);
+    const worktree = fs.realpathSync(path.resolve(options.cwd || process.cwd()));
+    if (!sourceStat.isFile() || isWithin(worktree, notesFile)) throw new Error('path is not an external regular file');
+  } catch {
+    return { status: 'failed' as const, changed: false, notesFile: null, sha256: null, byteLength: null, error: { code: 'RELEASE_NOTES_PATH_INVALID', message: 'notes-file must be a regular file outside the current worktree and must not be a symbolic link', retryable: false } };
+  }
+
+  let original: Buffer;
+  let normalized: Buffer;
+  try {
+    original = fs.readFileSync(notesFile);
+    normalized = normalizeReleaseNoteBytes(original);
+  } catch {
+    return { status: 'failed' as const, changed: false, notesFile, sha256: null, byteLength: null, error: { code: 'RELEASE_NOTES_CONTENT_INVALID', message: 'notes-file must contain valid UTF-8', retryable: false } };
+  }
+
+  const changed = !original.equals(normalized);
+  if (changed) {
+    const temporary = path.join(
+      path.dirname(notesFile),
+      `.${path.basename(notesFile)}.${process.pid}.${Date.now()}.tmp`
+    );
+    try {
+      fs.writeFileSync(temporary, normalized, { flag: 'wx', mode: sourceStat.mode });
+      fs.renameSync(temporary, notesFile);
+    } catch {
+      fs.rmSync(temporary, { force: true });
+      return { status: 'failed' as const, changed: false, notesFile, sha256: null, byteLength: null, error: { code: 'RELEASE_NOTES_STAGE_FAILED', message: 'notes-file could not be staged atomically', retryable: false } };
+    }
+  }
+  return {
+    status: changed ? 'applied' as const : 'no-op' as const,
+    changed,
+    notesFile,
+    sha256: releaseNoteSha256(normalized),
+    byteLength: normalized.byteLength,
+    error: null
+  };
+}
+
 function baseResult(status: 'no-op' | 'failed' | 'blocked') {
   return {
     status,
@@ -148,11 +229,20 @@ function releaseNoteContext(
 }
 
 function publishReleaseNotes(
-  input: { tag: string; title: string; notesFile: string; dryRun?: boolean },
+  input: { tag: string; title: string; notesFile: string; expectedSha256: string; dryRun?: boolean },
   options: ReleaseNoteOptions = {}
 ) {
-  if (!input.tag || !input.title || !input.notesFile) {
-    return { status: 'failed' as const, changed: false, operation: null, url: null, error: { code: 'RELEASE_NOTES_INPUT_INVALID', message: 'tag, title, and notes-file are required', retryable: false } };
+  if (!input.tag || !input.title || !input.notesFile || !SHA256_PATTERN.test(input.expectedSha256)) {
+    return releaseNoteFailure('RELEASE_NOTES_INPUT_INVALID', 'tag, title, notes-file, and expected-sha256 are required');
+  }
+  let actualSha256: string;
+  try {
+    actualSha256 = releaseNoteSha256(fs.readFileSync(input.notesFile));
+  } catch {
+    return releaseNoteFailure('RELEASE_NOTES_FILE_UNREADABLE', 'notes-file could not be read');
+  }
+  if (actualSha256 !== input.expectedSha256) {
+    return releaseNoteFailure('RELEASE_NOTES_DIGEST_MISMATCH', 'notes-file does not match the confirmed SHA-256 digest');
   }
   const cwd = path.resolve(options.cwd || process.cwd());
   const platformType = options.platformType ?? configuredPlatform(cwd);
@@ -164,4 +254,10 @@ function publishReleaseNotes(
   return publishGitHubReleaseNotes({ ...input, repository: context.platform.repository }, { cwd, client: options.client });
 }
 
-export { publishReleaseNotes, releaseNoteContext };
+export {
+  normalizeReleaseNoteBytes,
+  publishReleaseNotes,
+  releaseNoteContext,
+  releaseNoteSha256,
+  stageReleaseNotes
+};

package/lib/platform/releases.ts

@@ -21,7 +21,7 @@ function inspectPlatformRelease(tag: string, options: ReleaseOptions = {}) {
     return { ...platformResult(result.error.retryable ? 'blocked' : 'failed'), platform: context.platform, release: null, workflows: [], error: result.error };
   }
   const release: ReleaseSnapshot = { tag: String(result.value.tagName || tag), published: !Boolean(result.value.isDraft), draft: Boolean(result.value.isDraft), url: result.value.url ? String(result.value.url) : null };
-  const runs = client.json<unknown[]>(['run', 'list', '--repo', context.platform.repository, '--limit', '100', '--json', 'name,headBranch,status,conclusion,url'], { cwd: options.cwd });
+  const runs = client.json<unknown[]>(['run', 'list', '--repo', context.platform.repository, '--limit', '100', '--json', 'name,workflowName,displayTitle,event,headBranch,headSha,status,conclusion,createdAt,databaseId,attempt,url'], { cwd: options.cwd });
   return { ...platformResult(runs.ok ? 'no-op' : runs.error.retryable ? 'blocked' : 'degraded'), platform: context.platform, release, workflows: runs.ok ? runs.value : [], error: runs.ok ? null : runs.error };
 }
 

package/lib/platform/verification-required.ts

@@ -2,10 +2,10 @@ import fs from "node:fs";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
 
+import { hasPlatformCapability } from "./adapters.ts";
 import { inspectRequiredChecks } from "./pr-checks.ts";
 import { resolvePlatformContext } from "./context.ts";
 import { resolveReviewedHeadRelation } from "./merged-pr-equivalence.ts";
-import { loadPostReviewConfig, resolvePostReviewGlobs } from "../task/review-fingerprint.ts";
 
 const CHECK_TYPE = "required-checks";
 const SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
@@ -57,10 +57,9 @@ export function evaluateRequiredChecks(context: any, shared: any): any {
     context.gitRoot && inspection.pullRequest?.head
       ? resolveReviewedHeadRelation({
           gitRoot: context.gitRoot,
-          localHead,
+          comparisonHead: localHead,
           lastReviewedCommit: reviewedHead,
-          pullRequest: inspection.pullRequest,
-          pathspecs: context.pathspecs || [":/"]
+          pullRequest: inspection.pullRequest
         })
       : localHead === reviewedHead && localHead === prHead
         ? { status: "strict" }
@@ -87,14 +86,18 @@ export function evaluateRequiredChecks(context: any, shared: any): any {
 export function check({ taskDir }: any, shared: any): any {
   const task = shared.loadTask(taskDir);
   if (!task.ok) return shared.failResult(CHECK_TYPE, task.message);
-  const platform = resolvePlatformContext({ cwd: shared.repoRoot });
-  if (platform.platform.type !== "github") {
-    return shared.passResult(CHECK_TYPE, "Skipped: this code platform does not provide required checks");
-  }
   const prFlow = readPrFlow(shared.repoRoot);
   if (prFlow === "disabled" || task.metadata.pr_status === "skipped" || !validPrNumber(task.metadata.pr_number)) {
     return evaluateRequiredChecks({ metadata: task.metadata, localHead: null, inspection: null, prFlow }, shared);
   }
+  const platform = resolvePlatformContext({ cwd: shared.repoRoot });
+  if (!hasPlatformCapability(platform.platform.type, "required-checks")) {
+    return shared.blockedResult(
+      CHECK_TYPE,
+      `Platform '${platform.platform.type || "none"}' does not provide required-checks inspection`,
+      "dependency_error"
+    );
+  }
   const localHead = readHead(shared.repoRoot);
   if (!localHead) return evaluateRequiredChecks({ metadata: task.metadata, localHead, inspection: null, prFlow }, shared);
   const inspection = inspectRequiredChecks(task.metadata.id, { cwd: shared.repoRoot });
@@ -103,7 +106,6 @@ export function check({ taskDir }: any, shared: any): any {
     localHead,
     inspection,
     prFlow,
-    gitRoot: shared.repoRoot,
-    pathspecs: resolvePostReviewGlobs({}, loadPostReviewConfig(shared.repoRoot))
+    gitRoot: shared.repoRoot
   }, shared);
 }

package/lib/pr-review/evidence-grading.ts

@@ -0,0 +1,318 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { parseTaskFrontmatter } from '../task/frontmatter.ts';
+
+// ---------------------------------------------------------------------------
+// Host resolution (PL-4): PR -> unique / ambiguous / none.
+// ---------------------------------------------------------------------------
+
+export type HostCandidate = {
+  taskId: string;
+  taskDir: string;
+  issueNumber: number | null;
+  prNumber: number | null;
+};
+
+export type HostResolution =
+  | { kind: 'unique'; taskId: string; taskDir: string; issueNumber: number; prNumber: number }
+  | { kind: 'ambiguous'; candidates: Array<{ taskId: string; issueNumber: number }> }
+  | { kind: 'none' };
+
+export type HostResolutionErrorCode = 'HOST_AMBIGUOUS' | 'HOST_RESOLUTION_INVALID';
+
+export class HostResolutionError extends Error {
+  code: HostResolutionErrorCode;
+
+  constructor(code: HostResolutionErrorCode, message: string) {
+    super(message);
+    this.name = 'HostResolutionError';
+    this.code = code;
+  }
+}
+
+function toPositiveNumber(value: unknown): number | null {
+  const n = Number(value);
+  return Number.isInteger(n) && n > 0 ? n : null;
+}
+
+/**
+ * Parse the PR body for closing-issue references. Handles the conventional
+ * `Closes #1` / `Fixes: #2, #3` shapes (case-insensitive, comma/space
+ * separated, optional keyword list on the same logical line).
+ */
+export function extractClosingIssueNumbers(body: string): number[] {
+  const result: number[] = [];
+  const seen = new Set<number>();
+  const linePattern = /(?:^|\n)[^\n]*\b(?:close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\b[^\n]*/gi;
+  let lineMatch: RegExpExecArray | null;
+  while ((lineMatch = linePattern.exec(body)) !== null) {
+    const line = lineMatch[0]!;
+    for (const numMatch of line.matchAll(/#(\d+)/g)) {
+      const n = Number(numMatch[1]!);
+      if (Number.isInteger(n) && n > 0 && !seen.has(n)) {
+        seen.add(n);
+        result.push(n);
+      }
+    }
+  }
+  return result;
+}
+
+/**
+ * Scan `.agents/workspace/active/{task-id}/task.md` files for tasks bound to the
+ * PR number or to one of the PR's closing issues. A task is emitted at most once;
+ * a direct `pr_number` hit takes priority over the issue-number reverse lookup.
+ */
+export function collectHostCandidates(input: {
+  prNumber: number;
+  closingIssues: number[];
+  workspaceRoot: string;
+}): HostCandidate[] {
+  const activeRoot = path.join(input.workspaceRoot, '.agents', 'workspace', 'active');
+  const candidates: HostCandidate[] = [];
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(activeRoot, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const taskDir = path.join(activeRoot, entry.name);
+    const taskMdPath = path.join(taskDir, 'task.md');
+    let content: string;
+    try {
+      content = fs.readFileSync(taskMdPath, 'utf8');
+    } catch {
+      continue;
+    }
+    const frontmatter = parseTaskFrontmatter(content);
+    const issueNumber = toPositiveNumber(frontmatter.issue_number);
+    const prNumber = toPositiveNumber(frontmatter.pr_number);
+    if (prNumber === input.prNumber) {
+      candidates.push({ taskId: entry.name, taskDir, issueNumber, prNumber });
+    } else if (issueNumber !== null && input.closingIssues.includes(issueNumber)) {
+      candidates.push({ taskId: entry.name, taskDir, issueNumber, prNumber });
+    }
+  }
+  return candidates;
+}
+
+/**
+ * Collapse a candidate list into a typed HostResolution. Zero candidates ->
+ * none; exactly one -> unique; more than one (no stable selection rule) ->
+ * ambiguous (fail closed, AN-6).
+ */
+export function resolveHostFromCandidates(candidates: HostCandidate[]): HostResolution {
+  if (candidates.length === 0) return { kind: 'none' };
+  if (candidates.length === 1) {
+    const candidate = candidates[0]!;
+    return {
+      kind: 'unique',
+      taskId: candidate.taskId,
+      taskDir: candidate.taskDir,
+      issueNumber: candidate.issueNumber ?? 0,
+      prNumber: candidate.prNumber ?? 0
+    };
+  }
+  return {
+    kind: 'ambiguous',
+    candidates: candidates.map((candidate) => ({ taskId: candidate.taskId, issueNumber: candidate.issueNumber ?? 0 }))
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Evidence presence, head state, scenarios, risk and mode (AN-5/6/7, PL-3/5/9).
+// ---------------------------------------------------------------------------
+
+export type ArtifactPresence = {
+  hasAnalysis: boolean;
+  hasPlan: boolean;
+  hasCode: boolean;
+  hasReviewAnalysis: boolean;
+  hasReviewPlan: boolean;
+  hasReviewCode: boolean;
+  hasPriorPrReview: boolean;
+};
+
+export type HeadState = {
+  currentHeadSha: string;
+  priorHeadSha: string | null;
+  issueNumberBound: boolean;
+  taskIssueMatches: boolean;
+  prNumberBound: boolean;
+  taskPrMatches: boolean;
+};
+
+export type EvidenceScenario = 'S1' | 'S2' | 'S3';
+export type Freshness = 'fresh' | 'stale' | 'n/a';
+export type Alignment = 'aligned' | 'misaligned' | 'n/a';
+export type RiskLevel = 'LOW' | 'MEDIUM' | 'HIGH';
+export type ReviewMode = 'verify' | 'audit' | 'reconstruct';
+
+export type RiskFactors = {
+  changeSize: 'LOW' | 'HIGH';
+  sensitivity: 'LOW' | 'HIGH';
+  structural: 'LOW' | 'HIGH';
+  testCoverage: 'LOW' | 'HIGH';
+  sourceCredibility: 'LOW' | 'HIGH';
+  recoveryImpact: 'LOW' | 'HIGH';
+};
+
+export type DecisionRecord = {
+  host: HostResolution;
+  scenario: EvidenceScenario;
+  freshness: Freshness;
+  alignment: Alignment;
+  risk: RiskLevel;
+  mode: ReviewMode;
+  firstReview: boolean;
+  reason: string;
+};
+
+function hasNoLifecycleArtifacts(presence: ArtifactPresence): boolean {
+  return !presence.hasAnalysis && !presence.hasPlan && !presence.hasCode &&
+    !presence.hasReviewAnalysis && !presence.hasReviewPlan && !presence.hasReviewCode &&
+    !presence.hasPriorPrReview;
+}
+
+function hasFullArtifacts(presence: ArtifactPresence): boolean {
+  return presence.hasAnalysis && presence.hasPlan && presence.hasCode &&
+    presence.hasReviewAnalysis && presence.hasReviewPlan && presence.hasReviewCode;
+}
+
+function isTrusted(head: HeadState): boolean {
+  return head.issueNumberBound && head.taskIssueMatches && (!head.prNumberBound || head.taskPrMatches);
+}
+
+/**
+ * Derive the S1(a) trust factor `taskIssueMatches` (PL-3) mechanically from
+ * resolved data: a unique host is trusted on the issue dimension only when the
+ * task's bound issue_number is among the PR's closing issues. Ambiguous/none
+ * hosts and tasks without a positive issue_number cannot be confirmed -> false
+ * (fail closed to S2/audit). `resolve-host` emits this value so the prompt layer
+ * does not derive the trust factor ad hoc (CD-2).
+ */
+export function deriveTaskIssueMatches(host: HostResolution, closingIssues: number[]): boolean {
+  return host.kind === 'unique' && host.issueNumber > 0 && closingIssues.includes(host.issueNumber);
+}
+
+/**
+ * S1 -> S2 -> S3 classification (analysis §6.1). The ambiguous host is rejected
+ * before classification (AN-6 fail closed). S3(a) is host.kind === 'none';
+ * S3(b) is a unique task with no lifecycle artifacts and no prior pr-review
+ * (PL-5/PL-9 symmetric: any review-only task falls to S2).
+ */
+export function classifyScenario(host: HostResolution, presence: ArtifactPresence, head: HeadState): EvidenceScenario {
+  if (host.kind === 'ambiguous') {
+    throw new HostResolutionError('HOST_AMBIGUOUS', 'multiple candidate hosts; resolve before evidence classification');
+  }
+  if (host.kind === 'none') return 'S3';
+  if (hasNoLifecycleArtifacts(presence)) return 'S3';
+  const priorHeadMatches = presence.hasPriorPrReview && head.priorHeadSha !== null && head.priorHeadSha === head.currentHeadSha;
+  if (hasFullArtifacts(presence) && priorHeadMatches && isTrusted(head)) return 'S1';
+  return 'S2';
+}
+
+/**
+ * Freshness is benchmarked against the prior `pr-review*` reviewed head SHA
+ * (analysis §6.2, AN-7). No prior review -> n/a/n/a (first-review special case).
+ */
+export function evaluateHead(head: HeadState): { freshness: Freshness; alignment: Alignment } {
+  if (head.priorHeadSha === null) return { freshness: 'n/a', alignment: 'n/a' };
+  const freshness: Freshness = head.priorHeadSha === head.currentHeadSha ? 'fresh' : 'stale';
+  const aligned = freshness === 'fresh' && isTrusted(head);
+  return { freshness, alignment: aligned ? 'aligned' : 'misaligned' };
+}
+
+/**
+ * Pure-evidence risk aggregation (analysis §6.3, AN-5): any priority factor
+ * (sensitivity / sourceCredibility) HIGH -> HIGH; otherwise any HIGH -> MEDIUM;
+ * all LOW -> LOW. Identity factors are structurally absent from the input type.
+ */
+export function gradeRisk(factors: RiskFactors): RiskLevel {
+  const priority = [factors.sensitivity, factors.sourceCredibility] as const;
+  if (priority.includes('HIGH')) return 'HIGH';
+  const values = Object.values(factors) as Array<'LOW' | 'HIGH'>;
+  if (values.includes('HIGH')) return 'MEDIUM';
+  return 'LOW';
+}
+
+/**
+ * verify / audit / reconstruct selection matrix (analysis §6.4). S3 ->
+ * reconstruct; S2 -> audit; S1 fresh+aligned -> verify (LOW/MEDIUM risk) or
+ * audit (HIGH risk); any other S1 combination falls back to audit.
+ */
+export function selectMode(scenario: EvidenceScenario, freshness: Freshness, alignment: Alignment, risk: RiskLevel): ReviewMode {
+  if (scenario === 'S3') return 'reconstruct';
+  if (scenario === 'S2') return 'audit';
+  if (freshness === 'fresh' && alignment === 'aligned') {
+    return risk === 'HIGH' ? 'audit' : 'verify';
+  }
+  return 'audit';
+}
+
+function buildReason(input: {
+  scenario: EvidenceScenario;
+  freshness: Freshness;
+  alignment: Alignment;
+  risk: RiskLevel;
+  mode: ReviewMode;
+  firstReview: boolean;
+  hasPriorPrReview: boolean;
+}): string {
+  const pieces: string[] = [];
+  if (input.firstReview) pieces.push('first review (no prior pr-review head)');
+  if (input.hasPriorPrReview) pieces.push(`prior head ${input.freshness}`);
+  if (input.freshness === 'fresh') pieces.push(`alignment ${input.alignment}`);
+  pieces.push(`evidence scenario ${input.scenario}`);
+  pieces.push(`risk ${input.risk}`);
+  pieces.push(`mode ${input.mode}`);
+  return pieces.join('; ');
+}
+
+/**
+ * Full decision pipeline: classify -> freshness/alignment -> risk -> mode,
+ * producing a traceable DecisionRecord (AC3). Ambiguous hosts are rejected
+ * before any classification runs (AN-6).
+ */
+export function decide(input: {
+  host: HostResolution;
+  presence: ArtifactPresence;
+  head: HeadState;
+  riskFactors: RiskFactors;
+}): DecisionRecord {
+  if (input.host.kind === 'ambiguous') {
+    throw new HostResolutionError('HOST_AMBIGUOUS', 'ambiguous host; resolve before evidence classification');
+  }
+  const scenario = classifyScenario(input.host, input.presence, input.head);
+  const { freshness, alignment } = evaluateHead(input.head);
+  const risk = gradeRisk(input.riskFactors);
+  const mode = selectMode(scenario, freshness, alignment, risk);
+  const firstReview = !input.presence.hasPriorPrReview;
+  return {
+    host: input.host,
+    scenario,
+    freshness,
+    alignment,
+    risk,
+    mode,
+    firstReview,
+    reason: buildReason({
+      scenario,
+      freshness,
+      alignment,
+      risk,
+      mode,
+      firstReview,
+      hasPriorPrReview: input.presence.hasPriorPrReview
+    })
+  };
+}
+
+export {
+  hasFullArtifacts,
+  hasNoLifecycleArtifacts,
+  isTrusted
+};

package/lib/prompt.ts

@@ -88,20 +88,33 @@ async function select(question: string, choices: string[], defaultValue?: string
 
 async function multiSelect(
   question: string,
-  choices: { id: string; label: string }[]
+  choices: { id: string; label: string }[],
+  defaultIds: readonly string[] = choices.map((choice) => choice.id)
 ): Promise<string[]> {
+  const choiceIds = new Set(choices.map((choice) => choice.id));
+  if (defaultIds.some((id) => !choiceIds.has(id))) {
+    throw new Error('Default selection contains an unknown id');
+  }
+  const normalizedDefaults = choices
+    .map((choice) => choice.id)
+    .filter((id) => defaultIds.includes(id));
   process.stdout.write(`  ${question}:\n`);
   const idWidth = Math.max(...choices.map((c) => c.id.length));
   choices.forEach((c, i) => {
     process.stdout.write(`      ${i + 1}) ${c.id.padEnd(idWidth)}  (${c.label})\n`);
   });
-  ask('Enter comma-separated numbers or ids to keep, or "none" to select nothing [default: all]: ');
+  const defaultLabel = normalizedDefaults.length === choices.length
+    ? 'all'
+    : normalizedDefaults.length === 0
+      ? 'none'
+      : normalizedDefaults.join(',');
+  ask(`Enter comma-separated numbers or ids to keep, or "none" to select nothing [default: ${defaultLabel}]: `);
 
   setupInterface();
 
   const line = await nextLine();
   // Strictly distinguish bare Enter (null/empty string) from whitespace input.
-  if (line === null || line === '') return choices.map((c) => c.id);
+  if (line === null || line === '') return normalizedDefaults;
   // Explicit empty selection: "none" means deliberately zero built-in choices.
   if (line.trim().toLowerCase() === 'none') return [];
 

package/lib/release/channels.ts

@@ -20,7 +20,10 @@ async function inspectHomebrewChannel(url: string, version: string, fetcher: Fet
     if (!response.ok) return { status: 'blocked' as const, published: null, version, error: { code: 'HOMEBREW_UNAVAILABLE', message: `formula endpoint returned ${response.status}` } };
     const formula = await response.text();
     const escaped = version.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    return { status: 'no-op' as const, published: new RegExp(`(?:version\\s+["']${escaped}["']|/v?${escaped}\\.)`).test(formula), version, error: null };
+    const formulaUrl = /^\s*url\s+["']([^"']+)["']\s*$/m.exec(formula)?.[1] ?? '';
+    const npmTarball = new RegExp(`^https://registry\\.npmjs\\.org/.+/-/[^/]+-${escaped}\\.tgz$`).test(formulaUrl);
+    const bottle = /^\s*bottle do\s*$/m.test(formula);
+    return { status: 'no-op' as const, published: npmTarball && bottle, version, error: null };
   } catch (error) {
     return { status: 'blocked' as const, published: null, version, error: { code: 'HOMEBREW_UNAVAILABLE', message: error instanceof Error ? error.message : String(error) } };
   }

package/lib/release/workflow.ts

@@ -1,8 +1,8 @@
 type ReleasePhase = 'unprepared' | 'prepared' | 'partially-published' | 'published' | 'post-pending' | 'complete';
-type ReleaseFacts = { localTag: boolean; localTagConflict?: boolean; remoteBranch: boolean; remoteTag: boolean; githubRelease: boolean | null; npm: boolean | null; homebrew: boolean | null; smoke: 'success' | 'pending' | 'failed' | null; postCommit: boolean };
+type ReleaseFacts = { localTag: boolean; localTagAncestor?: boolean; localTagConflict?: boolean; remoteBranch: boolean; remoteTag: boolean; githubRelease: boolean | null; npm: boolean | null; homebrew: boolean | null; smoke: 'success' | 'pending' | 'failed' | null; postCommit: boolean };
 
 function deriveReleasePhase(facts: ReleaseFacts): ReleasePhase {
-  if (!facts.localTag) return 'unprepared';
+  if (!facts.localTag && !facts.localTagAncestor) return 'unprepared';
   if (!facts.remoteBranch && !facts.remoteTag) return 'prepared';
   if (!facts.remoteBranch || !facts.remoteTag) return 'partially-published';
   if (facts.githubRelease !== true || facts.npm !== true || facts.homebrew !== true) return 'published';
@@ -17,8 +17,9 @@ function releaseSnapshot(version: string, facts: ReleaseFacts) {
 async function runReleaseAction(input: { version: string; action: 'inspect' | 'prepare' | 'publish' | 'post'; inspect: () => Promise<ReleaseFacts>; prepare?: () => Promise<void>; publish?: () => Promise<void>; post?: () => Promise<void> }) {
   const before = releaseSnapshot(input.version, await input.inspect());
   if (input.action === 'inspect') return { status: 'no-op' as const, changed: false, before, snapshot: before, error: null };
+  if (before.facts.localTagConflict) return { status: 'failed' as const, changed: false, before, snapshot: before, error: { code: 'GIT_TAG_CONFLICT', message: `Tag ${before.tag} is not reachable from HEAD` } };
   const allowed = input.action === 'prepare' ? before.phase === 'unprepared'
-    : input.action === 'publish' ? ['prepared', 'partially-published'].includes(before.phase)
+    : input.action === 'publish' ? before.facts.localTag && ['prepared', 'partially-published'].includes(before.phase)
       : ['published', 'post-pending'].includes(before.phase);
   if (!allowed) return { status: before.phase === 'complete' ? 'no-op' as const : 'failed' as const, changed: false, before, snapshot: before, error: before.phase === 'complete' ? null : { code: 'RELEASE_PHASE_INVALID', message: `Cannot ${input.action} from ${before.phase}` } };
   await input[input.action]?.();

package/lib/remove-dir.ts

@@ -0,0 +1,28 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function removeDirRecursive(dir: string): void {
+  if (!fs.existsSync(dir)) {
+    return;
+  }
+
+  const pending = [dir];
+  const directories: string[] = [];
+  while (pending.length > 0) {
+    const current = pending.pop()!;
+    const stat = fs.lstatSync(current);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+      fs.unlinkSync(current);
+      continue;
+    }
+
+    directories.push(current);
+    for (const entry of fs.readdirSync(current)) {
+      pending.push(path.join(current, entry));
+    }
+  }
+
+  for (const directory of directories.reverse()) {
+    fs.rmdirSync(directory);
+  }
+}

package/lib/run/tui.ts

@@ -1,6 +1,9 @@
-export type TuiName = 'claude' | 'codex' | 'gemini' | 'opencode';
+import { renderAgentClientInvocation } from '../agent-clients/invocation.ts';
+import { getAgentClientAdapter } from '../agent-clients/registry.ts';
 
-const TUI_NAMES = new Set(['claude', 'codex', 'gemini', 'opencode']);
+export type TuiName = 'claude' | 'codex' | 'antigravity' | 'opencode';
+
+const TUI_NAMES = new Set(['claude', 'codex', 'antigravity', 'opencode']);
 
 export type CommandConfig = {
   defaultTui?: unknown;
@@ -27,14 +30,18 @@ export function selectTui(
 
 export function renderPrompt(params: { tui: TuiName; skill: string; args: string[] }): string {
   const suffix = [params.skill, ...params.args].join(' ').trim();
-  if (params.tui === 'codex') return `$${suffix}`;
-  if (params.tui === 'gemini') return `/agent-infra:${suffix}`;
+  if (params.tui === 'codex') {
+    return renderAgentClientInvocation(getAgentClientAdapter('codex').invocation, {
+      skillName: params.skill,
+      args: params.args
+    });
+  }
   return `/${suffix}`;
 }
 
 export function buildTuiCommand(tui: TuiName, prompt: string): [string, string[]] {
   if (tui === 'claude') return ['claude', ['--dangerously-skip-permissions', '--print', prompt]];
-  if (tui === 'gemini') return ['gemini', ['--approval-mode', 'yolo', '--prompt', prompt]];
+  if (tui === 'antigravity') return ['agy', ['--dangerously-skip-permissions', '--print', prompt]];
   if (tui === 'opencode') return ['opencode', ['run', '--dangerously-skip-permissions', prompt]];
   return ['codex', ['exec', '--dangerously-bypass-approvals-and-sandbox', prompt]];
 }