@fitlab-ai/agent-infra 0.9.4 → 0.9.6

package/lib/task/commit-finalization.ts

@@ -2,15 +2,22 @@ import { execFileSync, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { locateActivityLog, appendActivityEntry, pairEntries } from './activity-log.ts';
+import {
+  locateActivityLog,
+  appendActivityEntry,
+  pairEntries,
+  parseCommitAttemptStarted
+} from './activity-log.ts';
+import type { CommitAttempt } from './activity-log.ts';
 import { commitIntentPath, digest, readCommitIntent } from './commit-intent.ts';
 import type { CommitIntent } from './commit-intent.ts';
 import { parseTypedTaskFrontmatter } from './frontmatter.ts';
-import { parseReviewSummary } from './review-artifacts.ts';
+import { artifactName, maxRound, parseReviewSummary } from './review-artifacts.ts';
 import {
   extractReviewBaseline,
   extractReviewedSnapshotTree,
-  findAuthoritativeReviewCodeArtifact
+  findAuthoritativeReviewCodeArtifact,
+  parseReviewedGitTree
 } from './review-fingerprint.ts';
 import type { TaskMutation } from './write.ts';
 
@@ -20,6 +27,7 @@ type CommitFinalizationDisposition =
   | 'recoverable'
   | 'invalid'
   | 'conflict'
+  | 'retryable-start'
   | 'orphaned-start';
 
 type CommitFinalizationCode =
@@ -35,10 +43,12 @@ type CommitFinalizationInspection = Readonly<{
   currentHead: string;
   committedHead: string | null;
   commitNote: string | null;
+  activityNote: string | null;
   needsAnchor: boolean;
   needsLog: boolean;
   intent: CommitIntent | null;
   intentDigest: string | null;
+  attempt: CommitAttempt | null;
 }>;
 
 type CreatePrCommitGate = Readonly<{
@@ -78,6 +88,28 @@ function isAncestor(repoRoot: string, ancestor: string, descendant: string): boo
   }).status === 0;
 }
 
+function hasMatchingApprovedReview(
+  taskDir: string,
+  beforeRound: number,
+  baseline: string,
+  tree: string
+): boolean {
+  const entries = fs.readdirSync(taskDir);
+  for (let round = Math.min(beforeRound - 1, maxRound(entries, 'review-code')); round >= 1; round -= 1) {
+    const file = path.join(taskDir, artifactName('review-code', round));
+    if (!fs.existsSync(file)) continue;
+    const content = fs.readFileSync(file, 'utf8');
+    const summary = parseReviewSummary(content);
+    if (
+      summary.ok
+      && summary.summary.verdict === 'Approved'
+      && extractReviewBaseline(content) === baseline
+      && extractReviewedSnapshotTree(content) === tree
+    ) return true;
+  }
+  return false;
+}
+
 function outcome(
   disposition: CommitFinalizationDisposition,
   overrides: Partial<CommitFinalizationInspection> = {}
@@ -89,10 +121,12 @@ function outcome(
     currentHead: '',
     committedHead: null,
     commitNote: null,
+    activityNote: null,
     needsAnchor: false,
     needsLog: false,
     intent: null,
     intentDigest: null,
+    attempt: null,
     ...overrides
   };
 }
@@ -128,6 +162,16 @@ function inspectCommitFinalization(
   const openRows = commitRows.filter((row) => row.started !== '' && row.done === '');
   const file = commitIntentPath(taskDir);
   if (!fs.existsSync(file)) {
+    if (openRows.length === 1) {
+      const attempt = parseCommitAttemptStarted(openRows[0]!.note);
+      if (attempt && attempt.baseline === currentHead) {
+        return outcome('retryable-start', {
+          message: 'a structured Commit attempt can be safely reused',
+          currentHead,
+          attempt
+        });
+      }
+    }
     if (openRows.length > 0) {
       return outcome('orphaned-start', {
         code: 'COMMIT_FINALIZATION_EVIDENCE_MISSING',
@@ -192,6 +236,12 @@ function inspectCommitFinalization(
     });
   }
 
+  const commitNote = git(repoRoot, ['show', '-s', '--format=%h%x20%s', intent.committedHead]);
+  const matchingDone = commitRows.filter((row) => row.done !== '' && row.note === commitNote);
+  const pushOnlyRetry = intent.phase === 'pushed'
+    && intent.baselineHead === intent.committedHead
+    && matchingDone.length === 1
+    && openRows.length === 1;
   const review = findAuthoritativeReviewCodeArtifact(taskDir);
   let needsAnchor = false;
   if (review.ok && review.path) {
@@ -204,11 +254,20 @@ function inspectCommitFinalization(
     const summary = parseReviewSummary(reviewContent);
     const reviewBaseline = extractReviewBaseline(reviewContent);
     const reviewTree = extractReviewedSnapshotTree(reviewContent);
-    if (!summary.ok || summary.summary.verdict !== 'Approved' || !commitExists(repoRoot, reviewBaseline) || !SHA_RE.test(reviewTree)) {
+    if (!summary.ok || summary.summary.verdict !== 'Approved' || !commitExists(repoRoot, reviewBaseline) || !parseReviewedGitTree(reviewTree)) {
       return invalid('authoritative review-code evidence is not a valid approved snapshot', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
     }
     const committedTree = git(repoRoot, ['rev-parse', `${intent.committedHead}^{tree}`]);
-    if (reviewBaseline !== intent.baselineHead || reviewTree !== committedTree) {
+    const matchingCurrentReview = reviewBaseline === intent.baselineHead && reviewTree === committedTree;
+    if (
+      !matchingCurrentReview
+      && !hasMatchingApprovedReview(
+        taskDir,
+        review.round,
+        intent.baselineHead,
+        committedTree
+      )
+    ) {
       return outcome('conflict', {
         ...shared,
         code: 'COMMIT_FINALIZATION_CONFLICT',
@@ -217,18 +276,16 @@ function inspectCommitFinalization(
     }
 
     const anchor = String(metadata.last_reviewed_commit ?? '').trim();
-    if (anchor && anchor !== intent.committedHead) {
+    if (anchor && anchor !== intent.committedHead && anchor !== intent.baselineHead) {
       return outcome('conflict', {
         ...shared,
         code: 'COMMIT_FINALIZATION_CONFLICT',
         message: 'task review anchor conflicts with the committed intent'
       });
     }
-    needsAnchor = anchor === '';
+    needsAnchor = anchor !== intent.committedHead;
   }
-  const commitNote = git(repoRoot, ['show', '-s', '--format=%h%x20%s', intent.committedHead]);
-  const matchingDone = commitRows.filter((row) => row.done !== '' && row.note === commitNote);
-  const needsLog = matchingDone.length === 0 && openRows.length === 1;
+  const needsLog = (matchingDone.length === 0 && openRows.length === 1) || pushOnlyRetry;
   if (!(needsLog || (matchingDone.length === 1 && openRows.length === 0))) {
     return outcome('conflict', {
       ...shared,
@@ -241,6 +298,7 @@ function inspectCommitFinalization(
     ...shared,
     message: 'commit finalization can be recovered',
     commitNote,
+    activityNote: pushOnlyRetry ? `Pushed ${commitNote}` : commitNote,
     needsAnchor,
     needsLog
   });
@@ -252,7 +310,12 @@ function planCommitTaskFinalization(
   agent: string,
   timestamp: string
 ): CommitTaskFinalizationPlan {
-  if (inspection.disposition !== 'recoverable' || !inspection.committedHead || !inspection.commitNote) {
+  if (
+    inspection.disposition !== 'recoverable'
+    || !inspection.committedHead
+    || !inspection.commitNote
+    || !inspection.activityNote
+  ) {
     throw new Error('commit finalization task mutations require a recoverable inspection');
   }
   const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
@@ -273,7 +336,7 @@ function planCommitTaskFinalization(
         time: timestamp,
         step: 'Commit',
         agent,
-        note: inspection.commitNote
+        note: inspection.activityNote
       })
     });
   }

package/lib/task/create-service.ts

@@ -0,0 +1,171 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { syncPlatformComment } from '../platform/issue-comments.ts';
+import { createPlatformIssue, syncPlatformIssue } from '../platform/issues.ts';
+import type { PlatformResult } from '../platform/types.ts';
+import { VERSION } from '../version.ts';
+import { applyWorkflowWarningIntent } from './workflow-warning-intents.ts';
+import { createLocalTask, type TaskCreateCandidateV1 } from './create.ts';
+import { verifyTaskEvent } from './verification.ts';
+
+type TaskCreateStatus = 'applied' | 'no-op' | 'degraded' | 'failed' | 'blocked';
+type TaskCreateOperation = { name: string; status: string; reasonCode: string | null };
+type TaskCreateWarning = { code: string; severity: string; action: string };
+type TaskCreateResult = Readonly<{
+  status: TaskCreateStatus;
+  changed: boolean;
+  task: { id: string | null; shortId: string | null };
+  issue: { number: number; url: string } | null;
+  operations: readonly TaskCreateOperation[];
+  warnings: readonly TaskCreateWarning[];
+  error: { code: string; message: string; retryable: boolean } | null;
+}>;
+
+type CreateTaskOptions = Readonly<{
+  repoRoot: string;
+  agentInfraVersion?: string;
+  dependencies?: Partial<TaskCreateDependencies>;
+}>;
+
+type TaskCreateDependencies = Readonly<{
+  createIssue: typeof createPlatformIssue;
+  syncIssue: typeof syncPlatformIssue;
+  syncComment: typeof syncPlatformComment;
+  addWarning: typeof applyWorkflowWarningIntent;
+}>;
+
+const DEFAULT_DEPENDENCIES: TaskCreateDependencies = {
+  createIssue: createPlatformIssue,
+  syncIssue: syncPlatformIssue,
+  syncComment: syncPlatformComment,
+  addWarning: applyWorkflowWarningIntent
+};
+
+function verifyCreatedTask(repoRoot: string, taskId: string): { operation: TaskCreateOperation; error: TaskCreateResult['error'] } {
+  const verification = verifyTaskEvent(
+    { taskRef: taskId, event: 'create-task.completed' },
+    { repoRoot }
+  );
+  if (verification.status === 'pass') {
+    return { operation: { name: 'task:verify', status: 'pass', reasonCode: null }, error: null };
+  }
+  const blocked = verification.status === 'blocked';
+  return {
+    operation: {
+      name: 'task:verify', status: verification.status,
+      reasonCode: verification.error?.code ?? 'TASK_CREATE_VERIFICATION_FAILED'
+    },
+    error: {
+      code: verification.error?.code ?? 'TASK_CREATE_VERIFICATION_FAILED',
+      message: `Created task did not pass the ${verification.event} gate`,
+      retryable: blocked
+    }
+  };
+}
+
+function platformOperations(prefix: string, operations: readonly { name: string; status: string; reasonCode?: string | null }[]): TaskCreateOperation[] {
+  return operations.map((operation) => ({
+    name: `${prefix}:${operation.name}`,
+    status: operation.status,
+    reasonCode: operation.reasonCode ?? null
+  }));
+}
+
+function issueFromTask(repoRoot: string, taskId: string): { number: number; url: string } | null {
+  const content = fs.readFileSync(path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md'), 'utf8');
+  const match = /^issue_number:\s*(\d+)\s*$/m.exec(content);
+  return match ? { number: Number(match[1]), url: '' } : null;
+}
+
+function createTask(value: unknown, options: CreateTaskOptions): TaskCreateResult {
+  const dependencies = { ...DEFAULT_DEPENDENCIES, ...options.dependencies };
+  let candidate: TaskCreateCandidateV1;
+  let local;
+  try {
+    candidate = value as TaskCreateCandidateV1;
+    local = createLocalTask(candidate, {
+      repoRoot: options.repoRoot,
+      agentInfraVersion: options.agentInfraVersion ?? VERSION
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_FAILED';
+    return {
+      status: 'failed', changed: false, task: { id: null, shortId: null }, issue: null,
+      operations: [], warnings: [], error: { code, message, retryable: code === 'TASK_CREATE_LOCK_TIMEOUT' }
+    };
+  }
+
+  const operations: TaskCreateOperation[] = [{
+    name: 'task:local', status: local.status, reasonCode: null
+  }];
+  let issue = issueFromTask(options.repoRoot, local.task.id);
+  const created = dependencies.createIssue(local.task.id, { cwd: options.repoRoot, agent: candidate.agent });
+  operations.push(...platformOperations('platform-create', created.operations));
+  if (created.issue) issue = { number: created.issue.number, url: created.issue.url };
+
+  let platformFailure: PlatformResult | null = created.status === 'failed' || created.status === 'blocked' ? created : null;
+  if (!platformFailure && (created.task.issueNumber || issue)) {
+    const synced = dependencies.syncIssue(local.task.id, {
+      cwd: options.repoRoot,
+      agent: candidate.agent,
+      status: 'waiting-for-triage',
+      assignees: 'current',
+      milestone: 'initial',
+      issueType: true,
+      fields: true
+    });
+    operations.push(...platformOperations('platform-sync', synced.operations));
+    if (synced.issue) issue = { number: synced.issue.number, url: synced.issue.url };
+    if (synced.status === 'failed' || synced.status === 'blocked') platformFailure = synced;
+    if (!platformFailure) {
+      const commented = dependencies.syncComment(local.task.id, { cwd: options.repoRoot, kind: 'task', agent: candidate.agent });
+      operations.push(...platformOperations('platform-comment', commented.operations));
+      if (commented.status === 'failed' || commented.status === 'blocked') platformFailure = commented;
+    }
+  }
+
+  if (platformFailure) {
+    const error = platformFailure.error ?? { code: 'ISSUE_CREATE_FAILED', message: 'Platform operation failed', retryable: false };
+    dependencies.addWarning({
+      kind: 'add', taskRef: local.task.id, step: 'create-task', severity: 'ACTION_REQUIRED',
+      code: 'ISSUE_CREATE_FAILED', target: 'issue', message: `${error.code}: ${error.message}`,
+      action: 'Fix platform authentication or connectivity, then retry Issue creation for this task.'
+    }, { repoRoot: options.repoRoot });
+    const verified = verifyCreatedTask(options.repoRoot, local.task.id);
+    operations.push(verified.operation);
+    if (verified.error) return {
+      status: verified.error.retryable ? 'blocked' : 'failed', changed: local.changed,
+      task: local.task, issue, operations, warnings: [], error: verified.error
+    };
+    return {
+      status: platformFailure.status === 'blocked' ? 'blocked' : 'degraded',
+      changed: local.changed,
+      task: local.task,
+      issue,
+      operations,
+      warnings: [{ code: 'ISSUE_CREATE_FAILED', severity: 'ACTION_REQUIRED', action: 'Retry Issue creation after fixing the platform failure.' }],
+      error
+    };
+  }
+
+  const verified = verifyCreatedTask(options.repoRoot, local.task.id);
+  operations.push(verified.operation);
+  if (verified.error) return {
+    status: verified.error.retryable ? 'blocked' : 'failed', changed: local.changed,
+    task: local.task, issue, operations, warnings: [], error: verified.error
+  };
+  return {
+    status: local.status,
+    changed: local.changed,
+    task: local.task,
+    issue,
+    operations,
+    warnings: [],
+    error: null
+  };
+}
+
+export { createTask };
+export type { CreateTaskOptions, TaskCreateDependencies, TaskCreateOperation, TaskCreateResult, TaskCreateStatus, TaskCreateWarning };