@fitlab-ai/agent-infra 0.9.11 → 0.9.13

package/lib/task/decision-details.ts

@@ -36,7 +36,6 @@ type DecisionDetailResolution =
 type DecisionDetailDuplicate = {
   id: string;
   blocks: DecisionDetailBlock[];
-  repairable: boolean;
 };
 
 type DecisionDetailInspection =
@@ -49,15 +48,6 @@ type DecisionDetailInspection =
       duplicates: DecisionDetailDuplicate[];
     };
 
-type DecisionDetailRepair =
-  | { ok: true; changed: boolean; content: string }
-  | {
-      ok: false;
-      code: 'DECISION_DETAIL_AMBIGUOUS';
-      message: string;
-      content: string;
-    };
-
 const DECISION_ID = /^(AN|PL|CD|HD)-[1-9]\d*(?=$|[\s:：])/i;
 const HEADING = /^ {0,3}(#{1,6})[ \t]+(.+?)\s*$/;
 const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/;
@@ -172,32 +162,8 @@ function resolveDecisionDetail(content: string, rowId: string, anchor: string):
   return { status: 'found', block: matches[0]! };
 }
 
-const INFORMAL_SHORT_HEADING = /^(?:AN|PL|CD|HD)-[1-9]\d*[：:]\s*(?:上一轮)?简短复核$/i;
-const INFORMAL_SHORT_FRAGMENT = /^简短(?:结论|说明)$/;
-
-function isInformalShortBlock(block: DecisionDetailBlock): boolean {
-  if (block.canonical || block.content.length > 600) return false;
-  if (!INFORMAL_SHORT_HEADING.test(block.heading)) return false;
-  const scanned = scanVisibleMarkdown(block.content);
-  const bodyLines = scanned.lines
-    .filter((line) => !scanned.headings.some((heading) => heading.start === line.start) && line.text.trim())
-    .map((line) => line.text);
-  if (bodyLines.length === 0 || bodyLines.length > 2) return false;
-  const fragments = bodyLines.map((line) => line.match(/^\s*[-*]\s+([^\s].*?)\s*$/)?.[1] ?? null);
-  if (fragments.some((fragment) => fragment === null)) return false;
-  return fragments.every((fragment) => INFORMAL_SHORT_FRAGMENT.test(fragment!));
-}
-
-function hasDirectPrecedingAnchor(block: DecisionDetailBlock, scanned: VisibleMarkdown): boolean {
-  return scanned.anchors.some((anchor) => (
-    anchor.end < block.start
-    && !scanned.lines.some((line) => line.start > anchor.end && line.start < block.start && line.text.trim())
-  ));
-}
-
 function inspectDecisionDetailDuplicates(content: string): DecisionDetailInspection {
   const blocks = parseDecisionDetailBlocks(content);
-  const scanned = scanVisibleMarkdown(content);
   const grouped = new Map<string, DecisionDetailBlock[]>();
   for (const block of blocks) {
     const key = block.id.toUpperCase();
@@ -208,16 +174,12 @@ function inspectDecisionDetailDuplicates(content: string): DecisionDetailInspect
   const duplicates: DecisionDetailDuplicate[] = [];
   for (const group of grouped.values()) {
     if (group.length < 2) continue;
-    const canonical = group.filter((block) => block.canonical);
-    const repairable = canonical.length === 1 && group.every((block) => (
-      block.canonical || (!hasDirectPrecedingAnchor(block, scanned) && isInformalShortBlock(block))
-    ));
-    duplicates.push({ id: canonical[0]?.id ?? group[0]!.id, blocks: group, repairable });
+    duplicates.push({ id: group[0]!.id, blocks: group });
   }
   if (duplicates.length === 0) return { ok: true, blocks };
   const summary = duplicates.map((duplicate) => {
     const types = duplicate.blocks.map((block) => block.canonical ? 'canonical' : 'informal').join(', ');
-    return `${duplicate.id} (${duplicate.blocks.length} blocks: ${types}${duplicate.repairable ? '; safe repair available' : ''})`;
+    return `${duplicate.id} (${duplicate.blocks.length} blocks: ${types})`;
   }).join(', ');
   return {
     ok: false,
@@ -228,26 +190,6 @@ function inspectDecisionDetailDuplicates(content: string): DecisionDetailInspect
   };
 }
 
-function repairDecisionDetailDuplicates(content: string): DecisionDetailRepair {
-  const inspection = inspectDecisionDetailDuplicates(content);
-  if (inspection.ok) return { ok: true, changed: false, content };
-  const unsafe = inspection.duplicates.filter((duplicate) => !duplicate.repairable);
-  if (unsafe.length > 0) {
-    return {
-      ok: false,
-      code: 'DECISION_DETAIL_AMBIGUOUS',
-      message: `Cannot safely repair duplicate decision detail ids: ${unsafe.map((duplicate) => duplicate.id).join(', ')}`,
-      content
-    };
-  }
-  const removals = inspection.duplicates.flatMap((duplicate) => duplicate.blocks.filter((block) => !block.canonical));
-  let repaired = content;
-  for (const block of removals.sort((left, right) => right.start - left.start)) {
-    repaired = repaired.slice(0, block.start) + repaired.slice(block.end);
-  }
-  return { ok: true, changed: repaired !== content, content: repaired };
-}
-
 type FieldKey = 'decision' | 'why' | 'impact' | 'risk' | 'analogy' | 'recommend' | 'reason' | 'implementation';
 
 const FIELD_KEYS: Record<string, FieldKey> = {
@@ -328,13 +270,15 @@ export {
   normalizeDecisionDetailForDisplay,
   parseDecisionDetailBlocks,
   parseDecisionEvidence,
-  repairDecisionDetailDuplicates,
-  resolveDecisionDetail
+  resolveDecisionDetail,
+  scanVisibleMarkdown
 };
 export type {
   DecisionDetailBlock,
   DecisionDetailDuplicate,
   DecisionDetailInspection,
-  DecisionDetailRepair,
-  DecisionDetailResolution
+  DecisionDetailResolution,
+  SourceLine,
+  VisibleHeading,
+  VisibleMarkdown
 };

package/lib/task/delivery-target.ts

@@ -0,0 +1,130 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+export type DeliveryTarget = Readonly<{
+  remote: string;
+  baseRef: string;
+}>;
+
+export type DeliveryTargetBindingInput = Readonly<{
+  defaults?: Partial<DeliveryTarget>;
+  existing?: Partial<DeliveryTarget>;
+  explicit?: Partial<DeliveryTarget>;
+}>;
+
+export type DeliveryTargetResult =
+  | { ok: true; value: DeliveryTarget }
+  | { ok: false; code: string; message: string };
+
+export type DiffBaseResult =
+  | { ok: true; diffBase: string }
+  | { ok: false; code: string; message: string };
+
+const REMOTE_RE = /^(?!-)(?!.*\.\.)(?!.*[~^:?*\\\s])[A-Za-z0-9._/-]+$/;
+const REF_RE = /^(?!-)(?!.*\.\.)(?!.*(?:^|\/)\.)(?!.*[~^:?*\\\s])[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/;
+
+function validateRemote(value: unknown): value is string {
+  return typeof value === 'string' && value.length > 0 && REMOTE_RE.test(value);
+}
+
+function validateBaseRef(value: unknown): value is string {
+  return typeof value === 'string' && value.length > 0 && !value.startsWith('refs/') && REF_RE.test(value);
+}
+
+function invalid(field: string, value: unknown): DeliveryTargetResult {
+  return { ok: false, code: 'DELIVERY_TARGET_INVALID', message: `${field} is invalid: ${String(value ?? '')}` };
+}
+
+function bindDeliveryTarget(input: DeliveryTargetBindingInput): DeliveryTargetResult {
+  const remote = input.existing?.remote ?? input.explicit?.remote ?? input.defaults?.remote;
+  const baseRef = input.existing?.baseRef ?? input.explicit?.baseRef ?? input.defaults?.baseRef;
+  if (input.existing?.remote !== undefined && input.explicit?.remote !== undefined && input.existing.remote !== input.explicit.remote) {
+    return { ok: false, code: 'DELIVERY_TARGET_CONFLICT', message: 'Explicit delivery remote does not match the task binding' };
+  }
+  if (input.existing?.baseRef !== undefined && input.explicit?.baseRef !== undefined && input.existing.baseRef !== input.explicit.baseRef) {
+    return { ok: false, code: 'DELIVERY_TARGET_CONFLICT', message: 'Explicit delivery base ref does not match the task binding' };
+  }
+  if (!validateRemote(remote)) return invalid('delivery remote', remote);
+  if (!validateBaseRef(baseRef)) return invalid('delivery base ref', baseRef);
+  return { ok: true, value: { remote, baseRef } };
+}
+
+function readDeliveryDefaults(repoRoot: string): DeliveryTargetResult {
+  try {
+    const configPath = path.join(repoRoot, '.agents', '.airc.json');
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8')) as Record<string, unknown>;
+    if (!config.delivery || typeof config.delivery !== 'object' || Array.isArray(config.delivery)) {
+      return { ok: false, code: 'DELIVERY_CONFIG_INVALID', message: 'delivery config must declare remote and baseRef' };
+    }
+    const delivery = config.delivery as Record<string, unknown>;
+    if (typeof delivery.remote !== 'string' || typeof delivery.baseRef !== 'string') {
+      return { ok: false, code: 'DELIVERY_CONFIG_INVALID', message: 'delivery config must declare remote and baseRef' };
+    }
+    return bindDeliveryTarget({
+      defaults: {
+        remote: delivery.remote,
+        baseRef: delivery.baseRef
+      }
+    });
+  } catch (error) {
+    return { ok: false, code: 'DELIVERY_CONFIG_INVALID', message: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function resolveDeliveryTarget(
+  repoRoot: string,
+  existing: Partial<DeliveryTarget> = {},
+  explicit: Partial<DeliveryTarget> = {}
+): DeliveryTargetResult {
+  const defaults = readDeliveryDefaults(repoRoot);
+  if (!defaults.ok) return defaults;
+  return bindDeliveryTarget({ defaults: defaults.value, existing, explicit });
+}
+
+function gitText(repoRoot: string, args: readonly string[]): string {
+  return execFileSync('git', [...args], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe']
+  }).trim();
+}
+
+function resolveTargetHead(repoRoot: string, target: DeliveryTarget): DeliveryTargetResult & { head?: string } {
+  try {
+    const output = gitText(repoRoot, ['ls-remote', '--refs', target.remote, `refs/heads/${target.baseRef}`]);
+    const head = output.split(/\s+/)[0] ?? '';
+    if (!/^[a-f0-9]{40}$/i.test(head)) {
+      return { ok: false, code: 'DELIVERY_TARGET_UNAVAILABLE', message: `Delivery target ${target.remote}/${target.baseRef} is unavailable` };
+    }
+    try { gitText(repoRoot, ['cat-file', '-e', `${head}^{commit}`]); }
+    catch {
+      return { ok: false, code: 'DELIVERY_TARGET_OBJECT_MISSING', message: `Delivery target commit ${head} is not available locally` };
+    }
+    return { ok: true, value: target, head };
+  } catch (error) {
+    return { ok: false, code: 'DELIVERY_TARGET_UNAVAILABLE', message: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function resolveDiffBase(repoRoot: string, reviewedHead: string, targetHead: string): DiffBaseResult {
+  try {
+    const diffBase = gitText(repoRoot, ['merge-base', reviewedHead, targetHead]);
+    if (!/^[a-f0-9]{40}$/i.test(diffBase)) {
+      return { ok: false, code: 'DELIVERY_DIFF_BASE_UNAVAILABLE', message: 'Git returned an invalid diff base' };
+    }
+    return { ok: true, diffBase };
+  } catch (error) {
+    return { ok: false, code: 'DELIVERY_DIFF_BASE_UNAVAILABLE', message: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export {
+  bindDeliveryTarget,
+  readDeliveryDefaults,
+  resolveDeliveryTarget,
+  resolveTargetHead,
+  resolveDiffBase,
+  validateBaseRef,
+  validateRemote
+};

package/lib/task/delivery.ts

@@ -0,0 +1,160 @@
+import fs from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+
+import { parseTaskFrontmatter } from './frontmatter.ts';
+import { resolveTaskRef } from './resolve-ref.ts';
+import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead, validateBaseRef, validateRemote } from './delivery-target.ts';
+import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead, extractReviewedHead, findAuthoritativeReviewCodeArtifact } from './review-fingerprint.ts';
+import { captureTaskWriteMetadata, writeTask } from './write.ts';
+import { withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.ts';
+
+export type DeliveryState = 'absent' | 'same' | 'known-old' | 'unknown-drift';
+
+export type DeliveryClassification = Readonly<{
+  state: DeliveryState;
+  shouldPush: boolean;
+}>;
+
+export type TaskBranchDeliveryResult = Readonly<{
+  status: 'applied' | 'no-op' | 'failed' | 'blocked' | 'planned';
+  changed: boolean;
+  taskId: string | null;
+  remoteHead: string | null;
+  localHead: string | null;
+  state: DeliveryState | null;
+  error: { code: string; message: string; retryable: boolean } | null;
+}>;
+
+function classifyDeliveryState(localHead: string, remoteHead: string | null, lastDelivered: string | null): DeliveryClassification {
+  if (remoteHead === null) return { state: 'absent', shouldPush: true };
+  if (remoteHead === localHead) return { state: 'same', shouldPush: false };
+  if (lastDelivered && remoteHead === lastDelivered) return { state: 'known-old', shouldPush: true };
+  return { state: 'unknown-drift', shouldPush: false };
+}
+
+function git(cwd: string, args: readonly string[]): { status: number | null; stdout: string; stderr: string } {
+  const result = spawnSync('git', [...args], { cwd, encoding: 'utf8' });
+  return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
+}
+
+function gitValue(cwd: string, args: readonly string[]): string | null {
+  const result = git(cwd, args);
+  return result.status === 0 ? result.stdout.trim() : null;
+}
+
+function validateBranch(cwd: string, branch: string): boolean {
+  return git(cwd, ['check-ref-format', `refs/heads/${branch}`]).status === 0;
+}
+
+function validateReviewTargetCompatibility(
+  repoRoot: string,
+  taskDir: string,
+  target: { remote: string; baseRef: string },
+  reviewedHead: string
+): { ok: true } | { ok: false; code: string; message: string } {
+  const artifact = findAuthoritativeReviewCodeArtifact(taskDir);
+  if (!artifact.ok || !artifact.path) return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: 'A current review-code artifact is required before delivery' };
+  let content: string;
+  try { content = fs.readFileSync(artifact.path, 'utf8'); }
+  catch (error) { return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: error instanceof Error ? error.message : String(error) }; }
+  const savedReviewedHead = extractReviewedHead(content) || extractReviewBaseline(content);
+  const savedTargetHead = extractReviewTargetHead(content);
+  const savedDiffBase = extractReviewDiffBase(content);
+  if (!savedReviewedHead || !savedTargetHead || !savedDiffBase) {
+    return { ok: false, code: 'DELIVERY_REVIEW_TARGET_INVALID', message: 'review-code must save reviewed head, target head, and diff base before delivery' };
+  }
+  if (savedReviewedHead !== reviewedHead) {
+    return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: 'review-code reviewed head does not match last_reviewed_commit' };
+  }
+  const saved = resolveDiffBase(repoRoot, reviewedHead, savedTargetHead);
+  if (!saved.ok || saved.diffBase !== savedDiffBase) {
+    return { ok: false, code: 'DELIVERY_REVIEW_TARGET_INVALID', message: saved.ok ? 'saved review diff base does not match saved target head' : saved.message };
+  }
+  const currentTarget = resolveTargetHead(repoRoot, target);
+  if (!currentTarget.ok) return { ok: false, code: currentTarget.code, message: currentTarget.message };
+  const current = resolveDiffBase(repoRoot, reviewedHead, currentTarget.head!);
+  if (!current.ok) return { ok: false, code: current.code, message: current.message };
+  if (current.diffBase !== savedDiffBase) {
+    return { ok: false, code: 'DELIVERY_REVIEW_TARGET_CHANGED', message: 'current delivery target changed the reviewed diff base; re-run review-code' };
+  }
+  return { ok: true };
+}
+
+function failure(taskId: string | null, code: string, message: string, retryable = false, status: 'failed' | 'blocked' = retryable ? 'blocked' : 'failed'): TaskBranchDeliveryResult {
+  return { status, changed: false, taskId, remoteHead: null, localHead: null, state: null, error: { code, message, retryable } };
+}
+
+function deliverUnlocked(
+  taskId: string,
+  taskDir: string,
+  repoRoot: string,
+  options: { agent: string; remote?: string; baseRef?: string; dryRun?: boolean }
+): TaskBranchDeliveryResult {
+  let frontmatter: ReturnType<typeof parseTaskFrontmatter>;
+  try { frontmatter = parseTaskFrontmatter(fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8')); }
+  catch (error) { return failure(taskId, 'TASK_CONTEXT_UNREADABLE', error instanceof Error ? error.message : String(error)); }
+  if (frontmatter.status !== 'active') return failure(taskId, 'TASK_STATE_INVALID', 'task branch delivery requires an active task');
+  const branch = frontmatter.branch ?? '';
+  if (!branch) return failure(taskId, 'DELIVERY_BRANCH_MISSING', 'task branch is missing');
+  if (!validateBranch(repoRoot, branch)) return failure(taskId, 'DELIVERY_BRANCH_INVALID', 'task branch is invalid');
+  if (!frontmatter.delivery_remote || !frontmatter.delivery_base_ref) {
+    return failure(taskId, 'DELIVERY_TARGET_MISSING', 'task delivery target is not bound; recreate or repair task metadata before delivery');
+  }
+  const target = resolveDeliveryTarget(repoRoot, {
+    remote: frontmatter.delivery_remote,
+    baseRef: frontmatter.delivery_base_ref
+  }, {
+    ...(options.remote === undefined ? {} : { remote: options.remote }),
+    ...(options.baseRef === undefined ? {} : { baseRef: options.baseRef })
+  });
+  if (!target.ok) return failure(taskId, target.code, target.message);
+  if (!validateRemote(target.value.remote) || !validateBaseRef(target.value.baseRef)) return failure(taskId, 'DELIVERY_TARGET_INVALID', 'task delivery target is invalid');
+  const localHead = gitValue(repoRoot, ['rev-parse', 'HEAD']);
+  if (!localHead) return failure(taskId, 'DELIVERY_LOCAL_HEAD_UNAVAILABLE', 'Unable to resolve local HEAD');
+  const status = git(repoRoot, ['status', '--porcelain=v1']);
+  if (status.status !== 0) return failure(taskId, 'DELIVERY_GIT_INSPECT_FAILED', status.stderr.trim() || 'Unable to inspect Git state');
+  if (status.stdout.trim()) return failure(taskId, 'DELIVERY_WORKTREE_DIRTY', 'Working tree must be clean before branch delivery');
+  const reviewed = frontmatter.last_reviewed_commit ?? '';
+  if (reviewed !== localHead) return failure(taskId, 'DELIVERY_REVIEW_REQUIRED', 'Local HEAD must equal last_reviewed_commit before delivery');
+  const reviewTarget = validateReviewTargetCompatibility(repoRoot, taskDir, target.value, reviewed);
+  if (!reviewTarget.ok) return failure(taskId, reviewTarget.code, reviewTarget.message, reviewTarget.code.includes('UNAVAILABLE'), reviewTarget.code.includes('UNAVAILABLE') ? 'blocked' : 'failed');
+  const ref = `refs/heads/${branch}`;
+  const remoteOutput = git(repoRoot, ['ls-remote', '--refs', target.value.remote, ref]);
+  if (remoteOutput.status !== 0) return failure(taskId, 'DELIVERY_REMOTE_UNAVAILABLE', remoteOutput.stderr.trim() || 'Unable to inspect the delivery remote', true);
+  const remoteHead = remoteOutput.stdout.trim().split(/\s+/)[0] || null;
+  const classification = classifyDeliveryState(localHead, remoteHead, frontmatter.delivery_remote_head ?? null);
+  if (classification.state === 'unknown-drift') return failure(taskId, 'DELIVERY_REMOTE_DRIFT', `Remote branch ${branch} has an unexpected head; refusing to overwrite it`);
+  if (options.dryRun) return { status: 'planned', changed: classification.shouldPush, taskId, remoteHead, localHead, state: classification.state, error: null };
+  if (classification.shouldPush) {
+    const args = classification.state === 'known-old'
+      ? ['push', `--force-with-lease=${ref}:${frontmatter.delivery_remote_head}`, target.value.remote, `HEAD:${ref}`]
+      : ['push', `--force-with-lease=${ref}:`, target.value.remote, `HEAD:${ref}`];
+    const pushed = git(repoRoot, args);
+    if (pushed.status !== 0) return failure(taskId, 'DELIVERY_PUSH_FAILED', pushed.stderr.trim() || 'Task branch delivery was rejected', true, 'blocked');
+  }
+  const verified = gitValue(repoRoot, ['ls-remote', '--refs', target.value.remote, ref])?.split(/\s+/)[0] ?? null;
+  if (verified !== localHead) return failure(taskId, 'DELIVERY_REMOTE_VERIFY_FAILED', `Expected remote head ${localHead}, received ${verified ?? 'unavailable'}`, true, 'blocked');
+  const written = writeTask({
+    taskRef: taskId,
+    expectedState: 'active',
+    mutations: [{ kind: 'frontmatter', set: { delivery_remote: target.value.remote, delivery_base_ref: target.value.baseRef, delivery_remote_head: localHead, assigned_to: options.agent } }]
+  }, { repoRoot, metadataProvider: captureTaskWriteMetadata });
+  if (written.status === 'failed') return failure(taskId, 'DELIVERY_TASK_SYNC_FAILED', written.error.message, true, 'blocked');
+  return { status: classification.shouldPush ? 'applied' : 'no-op', changed: classification.shouldPush || written.changed, taskId, remoteHead: localHead, localHead, state: classification.state, error: null };
+}
+
+function deliverTaskBranch(taskRef: string, options: { repoRoot?: string; agent: string; remote?: string; baseRef?: string; dryRun?: boolean }): TaskBranchDeliveryResult {
+  const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+  if (!resolved.ok) return failure(resolved.taskId, resolved.code, resolved.message);
+  try {
+    return withRepositoryMutationLock(resolved.repoRoot, () => withTaskExecutionLock(
+      resolved.repoRoot, resolved.taskId, 'task-delivery',
+      () => deliverUnlocked(resolved.taskId, resolved.taskDir, resolved.repoRoot, options)
+    ));
+  } catch (error) {
+    return failure(resolved.taskId, 'DELIVERY_LOCK_FAILED', error instanceof Error ? error.message : String(error), true, 'blocked');
+  }
+}
+
+export { classifyDeliveryState, deliverTaskBranch };