@fitlab-ai/agent-infra 0.9.0 → 0.9.2

package/lib/platform/pull-requests.ts

@@ -1,10 +1,16 @@
 import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
 
 import { parseTaskFrontmatter } from '../task/frontmatter.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { extractSection } from '../task/sections.ts';
 import { captureTaskWriteMetadata, writeTask } from '../task/write.ts';
-import { resolvePlatformContext } from './context.ts';
+import {
+  inspectPlatformChangeRequest,
+  registerPlatformCapabilities
+} from './adapters.ts';
+import type { PlatformChangeRequestSnapshot } from './adapters.ts';
+import { parseGitHubRemote, resolvePlatformContext } from './context.ts';
 import { createGitHubClient } from './github-client.ts';
 import type { GitHubClient } from './github-client.ts';
 import { inspectPlatformIssue } from './issues.ts';
@@ -12,26 +18,13 @@ import { planPullRequestMetadata } from './pull-request-metadata.ts';
 import { platformResult } from './types.ts';
 import type { PlatformOperation, PlatformResult } from './types.ts';
 
-type PullRequestSnapshot = {
-  repository: string;
-  number: number;
-  nodeId: string;
-  url: string;
-  state: 'open' | 'closed';
-  title: string;
-  body: string;
-  draft: boolean;
-  head: { repository: string; ref: string; sha: string };
-  base: { repository: string; ref: string };
-  labels: string[];
-  assignees: string[];
-  milestone: string | null;
-};
+type PullRequestSnapshot = PlatformChangeRequestSnapshot;
 
 type PullRequestResult = PlatformResult & {
   task: { id: string | null; issueNumber: number | null; prNumber: number | null };
   pullRequest: PullRequestSnapshot | null;
 };
+type InspectionOptions = { cwd?: string; client?: unknown };
 type SharedOptions = { cwd?: string; client?: GitHubClient };
 type CreateOptions = SharedOptions & {
   agent: string;
@@ -55,7 +48,9 @@ type RemotePullRequest = {
   draft?: boolean;
   pull_request?: unknown;
   head?: { ref?: string; sha?: string; repo?: { full_name?: string } | null };
-  base?: { ref?: string; repo?: { full_name?: string } | null };
+  base?: { ref?: string; sha?: string; repo?: { full_name?: string } | null };
+  merged_at?: string | null;
+  merge_commit_sha?: string | null;
   labels?: Array<string | { name?: string }>;
   assignees?: Array<{ login?: string }>;
   milestone?: { title?: string } | null;
@@ -92,7 +87,9 @@ function normalizePullRequest(remote: RemotePullRequest, repository: string): Pu
     body: remote.body || '',
     draft: Boolean(remote.draft),
     head: { repository: headRepository, ref: remote.head.ref, sha: remote.head.sha },
-    base: { repository: baseRepository, ref: remote.base.ref },
+    base: { repository: baseRepository, ref: remote.base.ref, sha: remote.base.sha || '' },
+    mergedAt: remote.merged_at || null,
+    mergeCommitSha: remote.merge_commit_sha || null,
     labels: (remote.labels || []).map((label) => typeof label === 'string' ? label : label.name || '').filter(Boolean).sort(),
     assignees: (remote.assignees || []).map((assignee) => assignee.login || '').filter(Boolean).sort(),
     milestone: remote.milestone?.title || null
@@ -120,7 +117,7 @@ function selectPullRequest(remotes: RemotePullRequest[], repository: string, hea
   return { status: matches.length === 0 ? 'missing' : 'ambiguous', pullRequest: null };
 }
 
-function resolvedContext(taskRef: string, options: SharedOptions) {
+function resolvedContext(taskRef: string, options: InspectionOptions) {
   const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
   if (!resolved.ok) return { ok: false as const, output: result('failed', resolved.taskId, null, null, {
     error: { code: resolved.code, message: resolved.message, retryable: false }
@@ -131,7 +128,7 @@ function resolvedContext(taskRef: string, options: SharedOptions) {
   const pr = Number(frontmatter.pr_number);
   const issueNumber = Number.isInteger(issue) && issue > 0 ? issue : null;
   const prNumber = Number.isInteger(pr) && pr > 0 ? pr : null;
-  const client = options.client || createGitHubClient();
+  const client = (options.client as GitHubClient | undefined) || createGitHubClient();
   const context = resolvePlatformContext({ cwd: resolved.repoRoot, client });
   const usable = (context.status === 'no-op' || context.status === 'degraded') && context.platform.repository;
   if (!usable) return { ok: false as const, output: result(context.status, resolved.taskId, issueNumber, prNumber, {
@@ -149,6 +146,111 @@ function inspectGitHubPullRequest(client: GitHubClient, repository: string, numb
     : { ok: false as const, error: { code: 'PR_IDENTITY_INVALID', message: 'Remote resource is not a valid pull request', retryable: false } };
 }
 
+function configuredGitRemotes(cwd: string): Array<{ name: string; url: string; repository: string }> {
+  try {
+    return execFileSync('git', ['remote'], {
+      cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe']
+    }).split(/\r?\n/).filter(Boolean).flatMap((name) => {
+      try {
+        const url = execFileSync('git', ['config', '--get', `remote.${name}.url`], {
+          cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe']
+        }).trim();
+        const repository = parseGitHubRemote(url);
+        return repository ? [{ name, url, repository }] : [];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+
+function rewriteGitHubRemote(remote: string, repository: string): string | null {
+  const match = remote.trim().match(
+    /^(https?:\/\/github\.com\/|ssh:\/\/(?:git@)?github\.com\/|git@github\.com:)[^/\s]+\/[^/\s]+(?:\.git)?$/i
+  );
+  return match ? `${match[1]}${repository}.git` : null;
+}
+
+function resolveGitHubChangeRequestGitEvidence({
+  cwd,
+  repository,
+  pullRequest
+}: {
+  cwd: string;
+  repository: string;
+  pullRequest: PullRequestSnapshot;
+}) {
+  if (
+    pullRequest.repository !== repository ||
+    pullRequest.base.repository !== repository ||
+    pullRequest.number <= 0
+  ) {
+    return {
+      ok: false as const,
+      error: {
+        code: 'PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE',
+        message: 'Pull request repository identity is inconsistent',
+        retryable: false
+      }
+    };
+  }
+  const reviewedHeadRef = `refs/pull/${pullRequest.number}/head`;
+  const targetHeadRef = `refs/heads/${pullRequest.base.ref}`;
+  const refValid = (ref: string) => {
+    try {
+      execFileSync('git', ['check-ref-format', ref], {
+        cwd, encoding: 'utf8', stdio: ['ignore', 'ignore', 'ignore']
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (!refValid(reviewedHeadRef) || !refValid(targetHeadRef)) {
+    return {
+      ok: false as const,
+      error: {
+        code: 'PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE',
+        message: 'Pull request Git refs are invalid',
+        retryable: false
+      }
+    };
+  }
+
+  const remotes = configuredGitRemotes(cwd);
+  const exact = remotes
+    .filter((remote) => remote.repository === repository)
+    .sort((left, right) => Number(right.name === 'origin') - Number(left.name === 'origin') ||
+      left.name.localeCompare(right.name))[0];
+  const origin = remotes.find((remote) => remote.name === 'origin');
+  const remoteUrl = exact?.url || (origin ? rewriteGitHubRemote(origin.url, repository) : null);
+  if (!remoteUrl) {
+    return {
+      ok: false as const,
+      error: {
+        code: 'PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE',
+        message: `No GitHub remote can provide evidence for ${repository}`,
+        retryable: false
+      }
+    };
+  }
+  return {
+    ok: true as const,
+    value: { remoteUrl, reviewedHeadRef, targetHeadRef }
+  };
+}
+
+registerPlatformCapabilities('github', {
+  inspectChangeRequest({ client, repository, number, cwd }) {
+    return inspectGitHubPullRequest((client as GitHubClient | undefined) || createGitHubClient(), repository, number, cwd);
+  },
+  resolveChangeRequestGitEvidence(context) {
+    return resolveGitHubChangeRequestGitEvidence(context);
+  }
+});
+
 function locatePullRequest(base: ReturnType<typeof resolvedContext> & { ok: true }, head: string, target: string) {
   const repository = base.context.platform.repository!;
   const listed = base.client.json<RemotePullRequest[]>([
@@ -165,18 +267,30 @@ function locatePullRequest(base: ReturnType<typeof resolvedContext> & { ok: true
     } };
 }
 
-function inspectPlatformPullRequest(taskRef: string, options: SharedOptions = {}): PullRequestResult {
+function inspectPlatformPullRequest(taskRef: string, options: InspectionOptions = {}): PullRequestResult {
   const base = resolvedContext(taskRef, options);
   if (!base.ok) return base.output;
   if (!base.prNumber) return result('no-op', base.resolved.taskId, base.issueNumber, null, {
     platform: base.context.platform, capabilities: base.context.capabilities,
     error: { code: 'PR_NOT_LINKED', message: 'Task has no valid pr_number', retryable: false }
   });
-  const fetched = inspectGitHubPullRequest(base.client, base.context.platform.repository!, base.prNumber, base.resolved.repoRoot);
-  if (!fetched.ok) return result(fetched.error.retryable ? 'blocked' : 'failed', base.resolved.taskId, base.issueNumber, base.prNumber, {
-    platform: base.context.platform, capabilities: base.context.capabilities,
-    resource: { kind: 'pull-request', number: base.prNumber }, error: fetched.error
+  const fetched = inspectPlatformChangeRequest(base.context.platform.type, {
+    cwd: base.resolved.repoRoot,
+    repository: base.context.platform.repository!,
+    number: base.prNumber,
+    client: options.client || base.client
   });
+  if (!fetched.ok || !fetched.value) {
+    const error = fetched.error || {
+      code: 'PR_INSPECTION_INVALID',
+      message: 'Platform adapter returned no change-request snapshot',
+      retryable: false
+    };
+    return result(error.retryable ? 'blocked' : 'failed', base.resolved.taskId, base.issueNumber, base.prNumber, {
+      platform: base.context.platform, capabilities: base.context.capabilities,
+      resource: { kind: 'pull-request', number: base.prNumber }, error
+    });
+  }
   return result('no-op', base.resolved.taskId, base.issueNumber, base.prNumber, {
     platform: base.context.platform, capabilities: base.context.capabilities,
     resource: { kind: 'pull-request', number: base.prNumber }, pullRequest: fetched.value, error: null
@@ -374,6 +488,7 @@ export {
   inspectGitHubPullRequest,
   inspectPlatformPullRequest,
   normalizePullRequest,
+  resolveGitHubChangeRequestGitEvidence,
   selectPullRequest,
   syncPlatformPullRequest
 };

package/lib/platform/release-notes.ts

@@ -0,0 +1,167 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+import { resolvePlatformContext } from './context.ts';
+import {
+  fetchGitHubReleaseNoteData,
+  publishGitHubReleaseNotes
+} from './github-release-notes.ts';
+import type { ReleaseNoteActor } from './github-release-notes.ts';
+import type { GitHubClient } from './github-client.ts';
+
+type ReleaseNoteOptions = {
+  cwd?: string;
+  platformType?: string;
+  client?: GitHubClient;
+};
+
+type ReleaseNoteCommit = { oid: string; title: string; authors: ReleaseNoteActor[] };
+
+const unsupportedError = {
+  code: 'PLATFORM_RELEASE_NOTES_UNSUPPORTED',
+  message: 'Release notes are not supported for the configured platform',
+  retryable: false
+};
+
+function baseResult(status: 'no-op' | 'failed' | 'blocked') {
+  return {
+    status,
+    changed: false,
+    range: null,
+    history: [],
+    pullRequests: [],
+    commits: [] as ReleaseNoteCommit[],
+    error: status === 'no-op' ? unsupportedError : null
+  };
+}
+
+function git(cwd: string, args: string[]): string {
+  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+}
+
+function configuredPlatform(cwd: string): string | null {
+  try {
+    const value = JSON.parse(fs.readFileSync(path.join(cwd, '.agents', '.airc.json'), 'utf8'));
+    return typeof value?.platform?.type === 'string' ? value.platform.type : null;
+  } catch {
+    return null;
+  }
+}
+
+function releaseNoteContext(
+  input: { fromTag: string; toTag: string; branch: string; historyLimit?: number },
+  options: ReleaseNoteOptions = {}
+) {
+  const historyLimit = input.historyLimit ?? 3;
+  if (!input.fromTag || !input.toTag || !input.branch || !Number.isInteger(historyLimit) || historyLimit < 1 || historyLimit > 20) {
+    return { ...baseResult('failed'), error: { code: 'RELEASE_NOTES_INPUT_INVALID', message: 'from-tag, to-tag, branch, and a history limit from 1 to 20 are required', retryable: false } };
+  }
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const platformType = options.platformType ?? configuredPlatform(cwd);
+  if (platformType !== 'github') return baseResult('no-op');
+  let fromOid: string;
+  let toOid: string;
+  let fromTime: string;
+  let toTime: string;
+  let commitFacts: Array<{ oid: string; title: string }>;
+  try {
+    fromOid = git(cwd, ['rev-parse', '--verify', `${input.fromTag}^{commit}`]);
+    toOid = git(cwd, ['rev-parse', '--verify', `${input.toTag}^{commit}`]);
+    git(cwd, ['merge-base', '--is-ancestor', fromOid, toOid]);
+    fromTime = git(cwd, ['show', '-s', '--format=%cI', fromOid]);
+    toTime = git(cwd, ['show', '-s', '--format=%cI', toOid]);
+    const raw = git(cwd, ['log', '--reverse', '--no-merges', '--format=%H%x00%s', `${fromOid}..${toOid}`]);
+    commitFacts = raw ? raw.split('\n').map((line) => {
+      const [oid = '', title = ''] = line.split('\0');
+      return { oid, title };
+    }) : [];
+  } catch {
+    return { ...baseResult('failed'), error: { code: 'RELEASE_NOTES_RANGE_INVALID', message: 'The release tag range is missing or is not ancestral', retryable: false } };
+  }
+  const context = resolvePlatformContext({ cwd, platformType, client: options.client });
+  if (!context.platform.repository) {
+    return {
+      ...baseResult(context.status === 'blocked' ? 'blocked' : 'failed'),
+      error: context.error || { code: 'PLATFORM_CONTEXT_UNAVAILABLE', message: 'Platform repository is unavailable', retryable: context.status === 'blocked' }
+    };
+  }
+  const platform = fetchGitHubReleaseNoteData(
+    {
+      repository: context.platform.repository,
+      commitOids: commitFacts.map((item) => item.oid),
+      branch: input.branch,
+      historyLimit,
+      fromTime,
+      toTime
+    },
+    { cwd, client: options.client }
+  );
+  if (platform.status === 'blocked' || platform.status === 'failed' || !('authors' in platform)) {
+    return { ...baseResult(platform.status), error: platform.error };
+  }
+  const commits = commitFacts.map((commit) => {
+    const seen = new Set<string>();
+    const authors = (platform.authors.get(commit.oid) || []).filter((actor) => {
+      const key = actor.login || actor.email?.toLowerCase() || actor.name.toLowerCase();
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+    return { ...commit, authors };
+  });
+  const pullRequests = platform.pullRequests
+    .map((item) => ({
+      number: Number(item.number),
+      title: String(item.title || ''),
+      body: String(item.body || ''),
+      url: String(item.url || ''),
+      mergedAt: String(item.mergedAt || ''),
+      labels: Array.isArray(item.labels) ? item.labels.map((label) => String((label as { name?: string }).name || label)) : [],
+      author: item.author && typeof item.author === 'object'
+        ? { login: String((item.author as { login?: string }).login || '').toLowerCase(), bot: String((item.author as { login?: string }).login || '').endsWith('[bot]') }
+        : null,
+      closingIssues: Array.isArray(item.closingIssuesReferences)
+        ? item.closingIssuesReferences.map((issue) => {
+          const value = issue as Record<string, unknown>;
+          return {
+            number: Number(value.number),
+            title: String(value.title || ''),
+            url: String(value.url || ''),
+            labels: Array.isArray(value.labels) ? value.labels.map((label) => String((label as { name?: string }).name || label)) : [],
+            author: value.author && typeof value.author === 'object'
+              ? { login: String((value.author as { login?: string }).login || '').toLowerCase(), bot: String((value.author as { login?: string }).login || '').endsWith('[bot]') }
+              : null
+          };
+        }) : []
+    }))
+    .sort((left, right) => left.number - right.number);
+  return {
+    status: 'no-op' as const,
+    changed: false,
+    range: { fromTag: input.fromTag, toTag: input.toTag, fromOid, toOid },
+    history: platform.history,
+    pullRequests,
+    commits,
+    error: null
+  };
+}
+
+function publishReleaseNotes(
+  input: { tag: string; title: string; notesFile: 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 } };
+  }
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const platformType = options.platformType ?? configuredPlatform(cwd);
+  if (platformType !== 'github') return { status: 'no-op' as const, changed: false, operation: null, url: null, error: unsupportedError };
+  const context = resolvePlatformContext({ cwd, platformType, client: options.client });
+  if (!context.platform.repository) {
+    return { status: context.status === 'blocked' ? 'blocked' as const : 'failed' as const, changed: false, operation: null, url: null, error: context.error };
+  }
+  return publishGitHubReleaseNotes({ ...input, repository: context.platform.repository }, { cwd, client: options.client });
+}
+
+export { publishReleaseNotes, releaseNoteContext };

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,8 +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";
 
 const CHECK_TYPE = "required-checks";
 const SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
@@ -50,14 +52,30 @@ export function evaluateRequiredChecks(context: any, shared: any): any {
     return shared.failResult(CHECK_TYPE, inspection.error?.message || "Required checks are unavailable", "check_failed");
   }
 
-  const prHead = inspection.pullRequest?.headSha;
-  if (!prHead || localHead !== reviewedHead || localHead !== prHead) {
-    return shared.failResult(CHECK_TYPE, "Local HEAD, last reviewed commit, and PR head must match", "check_failed");
+  const prHead = inspection.pullRequest?.head?.sha || inspection.pullRequest?.headSha;
+  const relation = context.relation || (
+    context.gitRoot && inspection.pullRequest?.head
+      ? resolveReviewedHeadRelation({
+          gitRoot: context.gitRoot,
+          comparisonHead: localHead,
+          lastReviewedCommit: reviewedHead,
+          pullRequest: inspection.pullRequest
+        })
+      : localHead === reviewedHead && localHead === prHead
+        ? { status: "strict" }
+        : { status: "failed" }
+  );
+  if (relation.status !== "strict" && relation.status !== "merged-equivalent") {
+    const message = relation.message || "Local HEAD, last reviewed commit, and PR head must match";
+    return relation.status === "blocked"
+      ? shared.blockedResult(CHECK_TYPE, message, "dependency_error")
+      : shared.failResult(CHECK_TYPE, message, "check_failed");
   }
 
   const state = inspection.checks?.state;
   if (state === "passed" || state === "no-required") {
-    return shared.passResult(CHECK_TYPE, `Required checks are ${state} for PR head ${prHead}`);
+    const suffix = relation.status === "merged-equivalent" ? " via verified squash merge equivalence" : "";
+    return shared.passResult(CHECK_TYPE, `Required checks are ${state} for PR head ${prHead}${suffix}`);
   }
   if (state === "pending") {
     return shared.blockedResult(CHECK_TYPE, inspection.error?.message || "Required checks are pending", "check_pending");
@@ -68,16 +86,26 @@ 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 });
-  return evaluateRequiredChecks({ metadata: task.metadata, localHead, inspection, prFlow }, shared);
+  return evaluateRequiredChecks({
+    metadata: task.metadata,
+    localHead,
+    inspection,
+    prFlow,
+    gitRoot: shared.repoRoot
+  }, shared);
 }

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,3 +1,6 @@
+import { renderAgentClientInvocation } from '../agent-clients/invocation.ts';
+import { getAgentClientAdapter } from '../agent-clients/registry.ts';
+
 export type TuiName = 'claude' | 'codex' | 'gemini' | 'opencode';
 
 const TUI_NAMES = new Set(['claude', 'codex', 'gemini', 'opencode']);
@@ -27,7 +30,12 @@ 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 === 'codex') {
+    return renderAgentClientInvocation(getAgentClientAdapter('codex').invocation, {
+      skillName: params.skill,
+      args: params.args
+    });
+  }
   if (params.tui === 'gemini') return `/agent-infra:${suffix}`;
   return `/${suffix}`;
 }