@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/lib/process-data/normalize.ts

@@ -1,198 +1,13 @@
 import { sha256 } from './store.ts';
-import { normalizeAgentToken } from '../agent-clients/tokens.ts';
 
 import type { CapturedObject, JsonValue, NormalizedKind, NormalizedRecord } from './types.ts';
 
 const TASK_ID_RE = /TASK-\d{8}-\d{6}/;
-const ACTIVITY_RE = /^- (\d{4}-\d{2}-\d{2} [^ ]+) — \*\*(.+?)\*\* by ([^ ]+) — (.+)$/gm;
-const LEDGER_RE = /^\|\s*((?:AN|PL|CD)-\d+)\s*\|\s*(analysis|plan|code)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|$/gm;
-const RULING_RE = /^###\s+(HDR-\d+)\s*$([\s\S]*?)(?=^###\s+|^##\s+|(?![\s\S]))/gm;
-const CONFLICT_STATUSES = new Set(['open', 'accepted', 'adjusted', 'refuted', 'cannot-judge', 'needs-human-decision']);
 
 function recordId(kind: NormalizedKind, identity: string, suffix = ''): string {
   return `${kind}:${sha256(`${identity}\0${suffix}`).slice(0, 24)}`;
 }
 
-function canonicalActor(raw: string): string | null {
-  const lowered = raw.toLowerCase();
-  return normalizeAgentToken(lowered);
-}
-
-function nextOccurrence(occurrences: Map<string, number>, identity: string): string {
-  const occurrence = (occurrences.get(identity) ?? 0) + 1;
-  occurrences.set(identity, occurrence);
-  return occurrence === 1 ? '' : `occurrence=${occurrence}`;
-}
-
-function normalizePlatformPage(object: CapturedObject): NormalizedRecord[] {
-  if (!object.content) return [];
-  try {
-    const page = JSON.parse(object.content) as unknown;
-    if (!Array.isArray(page)) return [];
-    return page.map((entry, index) => {
-      const value = entry as Record<string, unknown>;
-      const identity = String(value.id ?? value.node_id ?? value.sha ?? value.number ?? `${object.sourceIdentity}:${index}`);
-      const platformIdentity = /\/issues\?/.test(object.sourceIdentity) && typeof value.number === 'number'
-        ? `issue:${value.number}`
-        : /\/pulls\?/.test(object.sourceIdentity) && typeof value.number === 'number'
-          ? `pr:${value.number}`
-          : /\/issues\/\d+\/comments/.test(object.sourceIdentity)
-            ? `issue-comment:${identity}`
-            : /\/pulls\/\d+\/reviews/.test(object.sourceIdentity)
-              ? `review:${identity}`
-              : /\/pulls\/\d+\/commits/.test(object.sourceIdentity)
-                ? `commit:${identity}`
-                : `platform:${identity}`;
-      const binding = typeof value.body === 'string' ? value.body.match(TASK_ID_RE)?.[0] : undefined;
-      return {
-        recordId: recordId('platform-resource', object.sourceIdentity, identity),
-        kind: 'platform-resource',
-        sourceIdentity: platformIdentity,
-        sourceSha256: object.sha256,
-        ...(binding ? { binding } : {}),
-        data: entry as JsonValue
-      };
-    });
-  } catch {
-    return [];
-  }
-}
-
-function normalizeObjects(objects: CapturedObject[]): NormalizedRecord[] {
-  const records: NormalizedRecord[] = [];
-  for (const object of objects) {
-    if (object.disposition?.state && object.disposition.state !== 'included') {
-      records.push({
-        recordId: recordId('missing', object.sourceIdentity),
-        kind: 'missing',
-        sourceIdentity: object.sourceIdentity,
-        sourceSha256: object.sha256,
-        data: object.disposition.state === 'excluded-sensitive'
-          ? { reason: 'privacy-excluded', ruleId: object.disposition.ruleId }
-          : { reason: object.disposition.reason }
-      });
-      continue;
-    }
-    if (object.sourceKind === 'github-rest') {
-      records.push(...normalizePlatformPage(object));
-      continue;
-    }
-    if (object.sourceKind === 'operational-report') {
-      records.push({
-        recordId: recordId('operational-report', object.sourceIdentity),
-        kind: 'operational-report',
-        sourceIdentity: object.sourceIdentity,
-        sourceSha256: object.sha256
-      });
-      continue;
-    }
-    if (object.sourceKind === 'structured-telemetry') {
-      let data: JsonValue = { availability: 'unknown' };
-      try {
-        data = JSON.parse(object.content ?? '{}') as JsonValue;
-      } catch {
-        data = { availability: 'unavailable', reason: 'invalid receipt JSON' };
-      }
-      records.push({
-        recordId: recordId('telemetry', object.sourceIdentity),
-        kind: 'telemetry',
-        sourceIdentity: object.sourceIdentity,
-        sourceSha256: object.sha256,
-        data
-      });
-      continue;
-    }
-
-    const taskId = object.sourceIdentity.match(TASK_ID_RE)?.[0];
-    if (/\/task\.md$/.test(object.sourceIdentity) && taskId) {
-      const activityOccurrences = new Map<string, number>();
-      const findingOccurrences = new Map<string, number>();
-      const issueNumber = object.content?.match(/^issue_number:\s*(\d+)$/m)?.[1];
-      const agentInfraVersion = object.content?.match(/^agent_infra_version:\s*(\S+)$/m)?.[1];
-      records.push({
-        recordId: recordId('task', taskId),
-        kind: 'task',
-        sourceIdentity: taskId,
-        sourceSha256: object.sha256,
-        ...(issueNumber ? { binding: `issue:${issueNumber}` } : {}),
-        data: {
-          agentInfraVersion: agentInfraVersion
-            ? { state: 'known', value: agentInfraVersion }
-            : { state: 'unknown', reason: 'legacy-task-missing-agent-infra-version' }
-        }
-      });
-      for (const match of object.content?.matchAll(ACTIVITY_RE) ?? []) {
-        const rawActor = match[3]!;
-        const identity = `${match[1]}:${match[2]}`;
-        const occurrence = nextOccurrence(activityOccurrences, identity);
-        records.push({
-          recordId: recordId('lifecycle-event', taskId, occurrence ? `${identity}\0${occurrence}` : identity),
-          kind: 'lifecycle-event',
-          sourceIdentity: `${taskId}#activity=${match[1]}`,
-          sourceSha256: object.sha256,
-          data: {
-            timestamp: match[1]!,
-            action: match[2]!,
-            actorRaw: rawActor,
-            actorCanonical: canonicalActor(rawActor),
-            note: match[4]!
-          }
-        });
-      }
-      for (const match of object.content?.matchAll(LEDGER_RE) ?? []) {
-        const findingId = match[1]!.trim();
-        const stage = match[2]!.trim();
-        const round = match[3]!.trim();
-        const severity = match[4]!.trim();
-        const status = match[5]!.trim();
-        const evidence = match[6]!.trim();
-        const identity = `${taskId}#finding=${findingId}`;
-        const occurrence = nextOccurrence(findingOccurrences, identity);
-        const data = { findingId, stage, round, severity, status, evidence };
-        records.push({
-          recordId: recordId('review-finding', identity, occurrence),
-          kind: 'review-finding',
-          sourceIdentity: identity,
-          sourceSha256: object.sha256,
-          binding: taskId,
-          data
-        });
-        if (status && CONFLICT_STATUSES.has(status)) {
-          records.push({
-            recordId: recordId('conflict', identity, occurrence),
-            kind: 'conflict',
-            sourceIdentity: `${identity}#status=${status}`,
-            sourceSha256: object.sha256,
-            binding: taskId,
-            data
-          });
-        }
-      }
-      for (const match of object.content?.matchAll(RULING_RE) ?? []) {
-        const rulingId = match[1]!;
-        const identity = `${taskId}#ruling=${rulingId}`;
-        records.push({
-          recordId: recordId('human-ruling', identity),
-          kind: 'human-ruling',
-          sourceIdentity: identity,
-          sourceSha256: object.sha256,
-          binding: taskId,
-          data: { rulingId, evidence: match[2]!.trim() }
-        });
-      }
-      continue;
-    }
-    records.push({
-      recordId: recordId('artifact', object.sourceIdentity),
-      kind: 'artifact',
-      sourceIdentity: object.sourceIdentity,
-      sourceSha256: object.sha256,
-      ...(taskId ? { binding: taskId } : {})
-    });
-  }
-  return records.sort((left, right) => left.recordId.localeCompare(right.recordId));
-}
-
 function normalizeResources(objects: CapturedObject[]): NormalizedRecord[] {
   const records: NormalizedRecord[] = [];
   for (const object of objects) {
@@ -221,4 +36,4 @@ function normalizeResources(objects: CapturedObject[]): NormalizedRecord[] {
   return records.sort((left, right) => left.recordId.localeCompare(right.recordId));
 }
 
-export { normalizeObjects, normalizeResources };
+export { normalizeResources };

package/lib/process-data/privacy.ts

@@ -1,6 +1,4 @@
-import { sha256 } from './store.ts';
-
-import type { CapturedObject, PrivacyDisposition, SourceKind } from './types.ts';
+import type { PrivacyDisposition } from './types.ts';
 
 type ScannedDisposition =
   | Extract<PrivacyDisposition, { state: 'included' }>
@@ -23,19 +21,4 @@ function inspectPrivacy(content: string): ScannedDisposition {
   return { state: 'included' };
 }
 
-function captureText(sourceKind: SourceKind, sourceIdentity: string, content: string): CapturedObject {
-  const bytes = Buffer.byteLength(content);
-  const digest = sha256(Buffer.from(content, 'utf8'));
-  const disposition = inspectPrivacy(content);
-  return disposition.state === 'included'
-    ? { sourceKind, sourceIdentity, sha256: digest, bytes, content, disposition }
-    : { sourceKind, sourceIdentity, sha256: digest, bytes, disposition };
-}
-
-function redactExcerpt(content: string, maxBytes = 4096): string | null {
-  if (inspectPrivacy(content).state !== 'included') return null;
-  const buffer = Buffer.from(content, 'utf8');
-  return buffer.subarray(0, maxBytes).toString('utf8').replace(/\b(token|password|secret)=\S+/gi, '$1=[REDACTED]');
-}
-
-export { captureText, inspectPrivacy, redactExcerpt };
+export { inspectPrivacy };

package/lib/process-data/sources.ts

@@ -1,10 +1,6 @@
-import fs from 'node:fs';
-import path from 'node:path';
 
 import { createGitHubClient } from '../platform/github-client.ts';
-import { enumerateAllTaskDirs } from '../task/resolve-ref.ts';
-import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.ts';
-import { captureText, inspectPrivacy, redactExcerpt } from './privacy.ts';
+import { inspectPrivacy } from './privacy.ts';
 import { canonicalJsonBytes, sha256 } from './store.ts';
 
 import type { GitHubClient } from '../platform/github-client.ts';
@@ -16,23 +12,6 @@ import type {
   RestPageEvidence
 } from './types.ts';
 
-type RestPage = { evidence: RestPageEvidence; bytes: Buffer };
-type RestCollection<T> = { items: T[]; evidence: RestCollectionEvidence; pageObjects: CapturedObject[] };
-
-type FetchRestCollectionOptions<T> = {
-  client: GitHubClient;
-  endpoint: string;
-  identify: (item: T) => string;
-  select?: (item: T) => T;
-  perPage?: number;
-};
-
-type GitHubCapture = {
-  repository: string;
-  objects: CapturedObject[];
-  endpoints: RestCollectionEvidence[];
-};
-
 type GitHubBoundaryCapture = {
   repository: string;
   preflightDate: string;
@@ -60,209 +39,6 @@ type EndpointDescriptor = {
   includeResource?: (item: unknown) => boolean;
 };
 
-function endpointForPage(endpoint: string, page: number, perPage: number): string {
-  const parsed = new URL(endpoint, 'https://api.github.invalid/');
-  if (parsed.searchParams.has('page') || parsed.searchParams.has('per_page')) {
-    throw new Error('endpoint must not predefine page or per_page');
-  }
-  parsed.searchParams.set('per_page', String(perPage));
-  parsed.searchParams.set('page', String(page));
-  return `${parsed.pathname.replace(/^\//, '')}${parsed.search}`;
-}
-
-function fetchRestCollection<T>(options: FetchRestCollectionOptions<T>): ProcessResult<RestCollection<T>> {
-  const perPage = options.perPage ?? 100;
-  if (!Number.isInteger(perPage) || perPage < 1 || perPage > 100) {
-    return { ok: false, error: { code: 'PAGINATION_INVALID', message: 'perPage must be between 1 and 100' } };
-  }
-  let pageIndex = 1;
-  let previousHash: string | null = null;
-  const identities = new Set<string>();
-  const items: T[] = [];
-  const pages: RestPage[] = [];
-
-  while (true) {
-    let url: string;
-    try {
-      url = endpointForPage(options.endpoint, pageIndex, perPage);
-    } catch (error) {
-      return { ok: false, error: { code: 'PAGINATION_INVALID', message: String(error) } };
-    }
-    const response = options.client.json<unknown>(['api', url]);
-    if (!response.ok) return { ok: false, error: response.error };
-    if (!Array.isArray(response.value) || response.value.length > perPage) {
-      return {
-        ok: false,
-        error: { code: 'INVALID_PLATFORM_RESPONSE', message: `GitHub page ${pageIndex} is not a valid array page` }
-      };
-    }
-    let selected: T[];
-    try {
-      selected = (response.value as T[]).map((entry) => options.select ? options.select(entry) : entry);
-    } catch (error) {
-      return { ok: false, error: { code: 'INVALID_PLATFORM_RESPONSE', message: String(error) } };
-    }
-    let bytes: Buffer;
-    try {
-      bytes = canonicalJsonBytes(selected);
-    } catch (error) {
-      return { ok: false, error: { code: 'INVALID_PLATFORM_RESPONSE', message: String(error) } };
-    }
-    const canonicalSha256 = sha256(bytes);
-    if (previousHash === canonicalSha256 && response.value.length > 0) {
-      return {
-        ok: false,
-        error: { code: 'PAGINATION_UNSTABLE', message: `GitHub page ${pageIndex} repeats the previous page` }
-      };
-    }
-    for (const entry of selected) {
-      const identity = options.identify(entry);
-      if (!identity || identities.has(identity)) {
-        return {
-          ok: false,
-          error: { code: 'PAGINATION_UNSTABLE', message: `duplicate or empty identity on page ${pageIndex}` }
-        };
-      }
-      identities.add(identity);
-      items.push(entry);
-    }
-    pages.push({ evidence: { index: pageIndex, itemCount: response.value.length, canonicalSha256 }, bytes });
-    previousHash = canonicalSha256;
-    if (response.value.length < perPage) break;
-    pageIndex += 1;
-  }
-
-  const evidence: RestCollectionEvidence = {
-    endpoint: options.endpoint,
-    requestCount: pages.length,
-    dataPageCount: pages.filter((page) => page.evidence.itemCount > 0).length,
-    itemCount: items.length,
-    termination: 'short-page',
-    pages: pages.map((page) => page.evidence)
-  };
-  return {
-    ok: true,
-    value: {
-      items,
-      evidence,
-      pageObjects: pages.map((page) => ({
-        sourceKind: 'github-rest',
-        sourceIdentity: `${options.endpoint}#page=${page.evidence.index}`,
-        sha256: page.evidence.canonicalSha256,
-        bytes: page.bytes.length,
-        content: page.bytes.toString('utf8'),
-        disposition: { state: 'included' }
-      }))
-    }
-  };
-}
-
-function relativeIdentity(repoRoot: string, filePath: string): string {
-  const workspaceRoot = resolveProjectTaskWorkspaceRoot(repoRoot);
-  const taskRelative = path.relative(workspaceRoot, filePath);
-  if (taskRelative && !taskRelative.startsWith('..') && !path.isAbsolute(taskRelative)) {
-    return path.posix.join('task-workspace', taskRelative.split(path.sep).join('/'));
-  }
-  const relative = path.relative(repoRoot, filePath);
-  if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) throw new Error(`path escapes repository: ${filePath}`);
-  return relative.split(path.sep).join('/');
-}
-
-function readStableFile(repoRoot: string, filePath: string, sourceKind: CapturedObject['sourceKind']): CapturedObject {
-  const before = fs.lstatSync(filePath);
-  if (!before.isFile() || before.isSymbolicLink()) throw new Error(`unsafe source file: ${filePath}`);
-  const content = fs.readFileSync(filePath, 'utf8');
-  const after = fs.lstatSync(filePath);
-  if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs) {
-    throw new Error(`source changed while reading: ${filePath}`);
-  }
-  return captureText(sourceKind, relativeIdentity(repoRoot, filePath), content);
-}
-
-function listFiles(directory: string): string[] {
-  if (!fs.existsSync(directory)) return [];
-  const output: string[] = [];
-  const walk = (current: string) => {
-    for (const entry of fs.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      const candidate = path.join(current, entry.name);
-      if (entry.isSymbolicLink()) throw new Error(`symlink source is not allowed: ${candidate}`);
-      if (entry.isDirectory()) walk(candidate);
-      else if (entry.isFile()) output.push(candidate);
-    }
-  };
-  walk(directory);
-  return output;
-}
-
-function structuredReceipt(repoRoot: string, filePath: string): CapturedObject {
-  const raw = readStableFile(repoRoot, filePath, 'structured-telemetry');
-  if (!raw.content) return raw;
-  try {
-    const parsed = JSON.parse(raw.content) as Record<string, unknown>;
-    const fields = ['client', 'model', 'reasoning', 'stage', 'toolCategory', 'time', 'status', 'retry', 'error', 'fallback'];
-    const selected = Object.fromEntries(
-      fields.filter((field) => parsed[field] !== undefined).map((field) => [field, jsonClone(parsed[field])])
-    );
-    selected.sourceSha256 = raw.sha256;
-    return captureText('structured-telemetry', raw.sourceIdentity, canonicalJsonBytes(selected).toString('utf8'));
-  } catch {
-    return { ...raw, content: undefined, disposition: { state: 'unavailable', reason: 'invalid receipt JSON' } };
-  }
-}
-
-function unavailableLog(repoRoot: string, filePath: string, includeExcerpts: boolean): CapturedObject {
-  const raw = readStableFile(repoRoot, filePath, 'local-file');
-  if (raw.disposition?.state === 'excluded-sensitive') return raw;
-  const recognizedBody = /\/(?:sessions?|tools?)(?:\/|[-_])/i.test(raw.sourceIdentity);
-  if (includeExcerpts && recognizedBody && raw.content) {
-    const excerpt = redactExcerpt(raw.content);
-    if (excerpt !== null) return captureText('local-file', `${raw.sourceIdentity}#excerpt`, excerpt);
-  }
-  return {
-    sourceKind: 'local-file',
-    sourceIdentity: raw.sourceIdentity,
-    sha256: raw.sha256,
-    bytes: raw.bytes,
-    disposition: { state: 'unavailable', reason: recognizedBody ? 'body-excerpts-disabled' : 'unknown-log-format' }
-  };
-}
-
-function collectLocalObjects(repoRoot: string, options: { includeExcerpts?: boolean } = {}): ProcessResult<CapturedObject[]> {
-  try {
-    const objects: CapturedObject[] = [];
-    for (const task of enumerateAllTaskDirs(repoRoot)) {
-      for (const filePath of listFiles(task.taskDir)) {
-        if (!/\.(?:md|json)$/i.test(filePath)) continue;
-        objects.push(readStableFile(repoRoot, filePath, 'local-file'));
-      }
-    }
-    const logsRoot = path.join(repoRoot, '.agents', 'workspace', 'logs');
-    for (const filePath of listFiles(logsRoot)) {
-      if (!/\.(?:md|json)$/i.test(filePath)) continue;
-      const identity = relativeIdentity(repoRoot, filePath);
-      if (/\/entropy-check\/.*\.md$/i.test(identity)) {
-        objects.push(readStableFile(repoRoot, filePath, 'operational-report'));
-      } else if (/\/(?:delegation|orchestration)(?:\/|[-_]).*\.json$/i.test(identity)) {
-        objects.push(structuredReceipt(repoRoot, filePath));
-      } else {
-        objects.push(unavailableLog(repoRoot, filePath, options.includeExcerpts === true));
-      }
-    }
-    return { ok: true, value: objects.sort((a, b) => a.sourceIdentity.localeCompare(b.sourceIdentity)) };
-  } catch (error) {
-    return { ok: false, error: { code: 'LOCAL_SOURCE_UNSTABLE', message: error instanceof Error ? error.message : String(error) } };
-  }
-}
-
-function githubIdentity(item: unknown): string {
-  if (!item || typeof item !== 'object') return '';
-  const record = item as Record<string, unknown>;
-  for (const key of ['id', 'node_id', 'sha', 'number']) {
-    if (typeof record[key] === 'string' || typeof record[key] === 'number') return `${key}:${String(record[key])}`;
-  }
-  return '';
-}
-
 function jsonClone(value: unknown): unknown {
   return JSON.parse(JSON.stringify(value)) as unknown;
 }
@@ -360,62 +136,6 @@ function projectGitHubTimelineItem(item: unknown): unknown {
   return output;
 }
 
-function collectGitHubObjects(repoRoot: string, client: GitHubClient = createGitHubClient()): ProcessResult<GitHubCapture> {
-  const repoResult = client.json<{ nameWithOwner?: string }>(['repo', 'view', '--json', 'nameWithOwner'], { cwd: repoRoot });
-  if (!repoResult.ok) return { ok: false, error: repoResult.error };
-  const repository = repoResult.value.nameWithOwner;
-  if (!repository || !/^[^/]+\/[^/]+$/.test(repository)) {
-    return { ok: false, error: { code: 'INVALID_PLATFORM_RESPONSE', message: 'GitHub repository identity is missing' } };
-  }
-  const objects: CapturedObject[] = [];
-  const evidence: RestCollectionEvidence[] = [];
-  const captureEndpoint = (endpoint: string) => {
-    const result = fetchRestCollection({
-      client,
-      endpoint,
-      identify: githubIdentity,
-      select: (item) => projectGitHubItem(item) as unknown
-    });
-    if (!result.ok) return result;
-    objects.push(...result.value.pageObjects);
-    evidence.push(result.value.evidence);
-    return result;
-  };
-
-  const issues = captureEndpoint(`repos/${repository}/issues?state=all&sort=created&direction=asc`);
-  if (!issues.ok) return issues;
-  const pulls = captureEndpoint(`repos/${repository}/pulls?state=all&sort=created&direction=asc`);
-  if (!pulls.ok) return pulls;
-
-  for (const issue of issues.value.items) {
-    const number = (issue as Record<string, unknown>).number;
-    if (typeof number !== 'number') return { ok: false, error: { code: 'INVALID_PLATFORM_RESPONSE', message: 'Issue number is missing' } };
-    const comments = captureEndpoint(`repos/${repository}/issues/${number}/comments`);
-    if (!comments.ok) return comments;
-  }
-  for (const pull of pulls.value.items) {
-    const record = pull as Record<string, unknown>;
-    const number = record.number;
-    const head = record.head as Record<string, unknown> | undefined;
-    const headSha = head?.sha;
-    if (typeof number !== 'number' || typeof headSha !== 'string') {
-      return { ok: false, error: { code: 'INVALID_PLATFORM_RESPONSE', message: 'Pull request identity or head SHA is missing' } };
-    }
-    for (const suffix of ['comments', 'reviews', 'commits']) {
-      const nested = captureEndpoint(`repos/${repository}/pulls/${number}/${suffix}`);
-      if (!nested.ok) return nested;
-    }
-    const current = client.json<unknown>(['api', `repos/${repository}/pulls/${number}`]);
-    if (!current.ok) return { ok: false, error: current.error };
-    const projected = projectGitHubItem(current.value) as Record<string, unknown>;
-    const currentHead = projected.head as Record<string, unknown> | undefined;
-    if (currentHead?.sha !== headSha) {
-      return { ok: false, error: { code: 'SOURCE_DRIFT', message: `Pull request ${number} head changed during capture` } };
-    }
-  }
-  return { ok: true, value: { repository, objects, endpoints: evidence } };
-}
-
 function resolveGitHubRepository(repoRoot: string, client: GitHubClient = createGitHubClient()): ProcessResult<string> {
   const result = client.json<{ nameWithOwner?: string }>(['repo', 'view', '--json', 'nameWithOwner'], { cwd: repoRoot });
   if (!result.ok) return { ok: false, error: result.error };
@@ -803,5 +523,5 @@ function collectGitHubBoundary(repoRoot: string, options: BoundaryCaptureOptions
   };
 }
 
-export { collectGitHubBoundary, collectGitHubObjects, collectLocalObjects, fetchRestCollection, projectGitHubItem, projectGitHubTimelineItem, resolveGitHubRepository };
-export type { BoundaryCaptureOptions, FetchRestCollectionOptions, GitHubBoundaryCapture, GitHubCapture, RestCollection };
+export { collectGitHubBoundary, projectGitHubItem, projectGitHubTimelineItem, resolveGitHubRepository };
+export type { BoundaryCaptureOptions, GitHubBoundaryCapture };

package/lib/render.ts

@@ -62,21 +62,6 @@ function containsPlaceholders(src: string): boolean {
   return content.includes('{{project}}') || content.includes('{{org}}');
 }
 
-function variantExt(relativePath: string): string {
-  return path.extname(relativePath);
-}
-
-function variantBase(relativePath: string): string {
-  const ext = variantExt(relativePath);
-  return relativePath.slice(0, -ext.length);
-}
-
-function withVariant(relativePath: string, variant: string): string {
-  const ext = variantExt(relativePath);
-  const base = variantBase(relativePath);
-  return `${base}.${variant}${ext}`;
-}
-
 function stripVariant(relativePath: string, variant: string): string {
   return relativePath.replace(new RegExp(`\\.${variant.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.`), '.');
 }

package/lib/run/index.ts

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { loadServerConfig } from '../server/config.ts';
 import { resolveSandboxTarget, type SandboxWorkspaceIdentity } from '../sandbox/workspace-identity.ts';
 import { createRunId, runInSandbox, type SandboxRunMetadata } from '../sandbox/capture.ts';
-import { loadShortIdByTaskId, normalizeShortIdInput } from '../task/short-id.ts';
+import { normalizeShortIdInput } from '../task/short-id.ts';
 import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.ts';
 import { buildTuiCommand, renderPrompt, selectTui } from './tui.ts';
 import { getSkillRunSpec } from './skills.ts';
@@ -101,11 +101,21 @@ function extractHostOptions(args: string[]): {
   return { positionals, forwarded, skill, taskRef, tui, recreate };
 }
 
+function parseCreateTaskArgs(skill: string, options: ReturnType<typeof extractHostOptions>): ParsedRunArgs {
+  const { taskRef, recreate, positionals, forwarded, tui } = options;
+  if (taskRef !== null) throw new Error("create-task does not accept '--task'");
+  if (recreate) throw new Error('--recreate is only valid for sandbox task runs');
+  const createArgs = [...positionals, ...forwarded];
+  if (createArgs.length === 0) throw new Error('create-task requires a description');
+  return { skill, taskRef: null, args: createArgs, tui };
+}
+
 export function parseRunArgs(args: string[]): ParsedRunArgs {
   if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
     throw new Error(USAGE);
   }
-  const { positionals, forwarded, skill, taskRef, tui, recreate } = extractHostOptions(args);
+  const options = extractHostOptions(args);
+  const { positionals, forwarded, skill, taskRef, tui, recreate } = options;
   if (!skill) throw new Error("option '--skill' is required");
   const spec = getSkillRunSpec(skill);
   if (!spec) throw new Error(`Unknown skill '${skill}'`);
@@ -114,11 +124,7 @@ export function parseRunArgs(args: string[]): ParsedRunArgs {
     throw new Error(`Unsupported run route '${routeSelector}'`);
   }
   if (spec.kind === 'create') {
-    if (taskRef !== null) throw new Error("create-task does not accept '--task'");
-    if (recreate) throw new Error('--recreate is only valid for sandbox task runs');
-    const createArgs = [...positionals, ...forwarded];
-    if (createArgs.length === 0) throw new Error('create-task requires a description');
-    return { skill, taskRef: null, args: createArgs, tui };
+    return parseCreateTaskArgs(skill, options);
   }
   if (positionals.length > 0) {
     throw new Error('ai run requires --skill and --task; positional host arguments are not supported');

package/lib/run/skills.ts

@@ -28,7 +28,3 @@ export function getSkillRunSpec(skill: string): SkillRunSpec | null {
   }
   return null;
 }
-
-export function allowedSkillNames(): string[] {
-  return ['create-task', ...TASK_SKILLS].sort();
-}