@fitlab-ai/agent-infra 0.11.3 → 0.11.4

package/lib/task/events.ts

@@ -35,14 +35,15 @@ import type { TaskOperationSummary, TaskWriteErrorCode, TaskWriteOptions } from
 import { allowsManualOverride } from './guard-override.ts';
 import { validateLocalArtifact } from './local-artifact-finalization.ts';
 import type { LocalArtifactFamily } from './local-artifact-finalization.ts';
-import { buildLifecycleFacts, canStart } from './capabilities.ts';
+import { buildLifecycleFacts, canStart, effectiveReworkTarget } from './capabilities.ts';
 import type { ExplicitTrigger, LifecycleAction, TriggerInitiator, TriggerReason } from './capabilities.ts';
 import { createInvalidationOperation, invalidationMutation, parseInvalidationDocument, targetIdFor, upsertInvalidation } from './invalidation.ts';
 import type { InvalidationTargetKind } from './invalidation.ts';
 import { reconcileTaskInvalidation } from './invalidation-command.ts';
 import { consumeReworkIntents, parseReworkIntentDocument, reworkIntentMutation, supersedeReworkIntents } from './rework-intent.ts';
-import { ARTIFACT_FAMILIES, expectedQualificationRelations, parseQualificationAudit, parseTaskQualification, upstreamArtifactDigest, validateQualificationAudit } from './qualification-audit.ts';
-import type { QualificationAudit, UpstreamRelation } from './qualification-audit.ts';
+import type { ReworkTarget } from './rework-intent.ts';
+import { ARTIFACT_FAMILIES, parseQualificationAudit, parseTaskQualification, upstreamArtifactDigest } from './qualification-audit.ts';
+import type { QualificationAudit } from './qualification-audit.ts';
 import { getArtifactSchema } from './artifact-schema.ts';
 import { canonicalSemanticDigest, inspectArtifactContract } from './artifact-operations.ts';
 import {
@@ -52,6 +53,7 @@ import {
   type LifecycleRecoveryAttestationV1
 } from './control-authority.ts';
 import { readManualValidationCompletion } from './manual-validation-completion.ts';
+import { parseLifecyclePathDecision } from './lifecycle-path.ts';
 
 const eventCatalog = [
   'analyze.started', 'analyze.awaiting-input', 'analyze.completed',
@@ -107,17 +109,39 @@ type TaskEventResult = {
   operations: readonly TaskOperationSummary[]; error: TaskEventError | null;
 };
 
-function approvedCleanReviewedCommit(reviewContent: string, verdict: Verdict | undefined, repoRoot: string): string | null {
+function branchWorktree(repoRoot: string, branch: string): string | null {
+  if (!branch) return repoRoot;
+  try {
+    const records = execFileSync('git', ['worktree', 'list', '--porcelain'], {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe']
+    }).trim().split(/\r?\n\r?\n/);
+    const expectedRef = `refs/heads/${branch}`;
+    for (const record of records) {
+      const worktree = /^worktree (.+)$/m.exec(record)?.[1];
+      const branchRef = /^branch (.+)$/m.exec(record)?.[1];
+      if (worktree && branchRef === expectedRef) return worktree;
+    }
+  } catch {
+    // A missing worktree must not anchor a review to an unrelated repository.
+  }
+  return null;
+}
+
+function approvedCleanReviewedCommit(reviewContent: string, verdict: Verdict | undefined, repoRoot: string, branch: string): string | null {
   if (verdict !== 'approved') return null;
   const reviewedHead = extractReviewedHead(reviewContent) || extractReviewBaseline(reviewContent);
   const reviewedTree = extractReviewedSnapshotTree(reviewContent);
   if (!/^[a-f0-9]{40}$/.test(reviewedHead) || !/^[a-f0-9]{40}$/.test(reviewedTree)) return null;
+  const worktree = branchWorktree(repoRoot, branch);
+  if (!worktree) return null;
   try {
-    const currentHead = execFileSync('git', ['-C', repoRoot, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim();
+    const currentHead = execFileSync('git', ['-C', worktree, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim();
     if (currentHead !== reviewedHead) return null;
-    const currentTree = execFileSync('git', ['-C', repoRoot, 'rev-parse', 'HEAD^{tree}'], { encoding: 'utf8' }).trim();
+    const currentTree = execFileSync('git', ['-C', worktree, 'rev-parse', 'HEAD^{tree}'], { encoding: 'utf8' }).trim();
     if (currentTree !== reviewedTree) return null;
-    execFileSync('git', ['-C', repoRoot, 'diff-index', '--quiet', 'HEAD', '--']);
+    execFileSync('git', ['-C', worktree, 'diff-index', '--quiet', 'HEAD', '--']);
     return reviewedHead;
   } catch {
     return null;
@@ -329,7 +353,13 @@ function failed(request: TaskEventRequest, error: TaskEventError, extra: Partial
 
 function normalizeStarted(request: TaskEventRequest, repoRoot: string): { request: TaskEventRequest; context: ArtifactContextResult } | { error: TaskEventError; context: ArtifactContextResult } {
   const family = eventParts(request.event).family;
-  const context = resolveArtifactContext(request.taskRef, FAMILY[family].artifact, { repoRoot });
+  const context = resolveArtifactContext(request.taskRef, FAMILY[family].artifact, {
+    repoRoot,
+    reasonCode: request.reasonCode,
+    sourceFinding: request.sourceFinding,
+    sourceArtifact: request.sourceArtifact,
+    sourceSha256: request.sourceSha256
+  });
   if (context.status !== 'ready' || !context.next) {
     return { error: { code: context.error?.code ?? 'EVENT_ARTIFACT_CONFLICT', message: context.error?.message ?? context.codeMode?.message ?? 'artifact context is not writable' }, context };
   }
@@ -386,25 +416,6 @@ function reviewInputFamily(family: EventFamily): ArtifactFamily {
   return family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
 }
 
-function relationForStartedInput(family: EventFamily, input: ArtifactIdentity): UpstreamRelation['relation'] {
-  if (family.startsWith('review-')) {
-    return input.family === reviewInputFamily(family) ? 'reviewed-input' : 'approval-context';
-  }
-  const consumer = family === 'analyze' ? 'analysis' : family;
-  if ((consumer === 'plan' && input.family === 'analysis') || (consumer === 'code' && input.family === 'plan')) return 'required-input';
-  return 'review-context';
-}
-
-function qualificationRelationsForStarted(family: EventFamily, inputs: readonly ArtifactIdentity[]): UpstreamRelation[] {
-  return inputs.map((input) => ({
-    upstreamFamily: input.family as UpstreamRelation['upstreamFamily'],
-    upstreamArtifact: input.name,
-    upstreamRound: input.round,
-    upstreamSha256: sha256File(input.path),
-    relation: relationForStartedInput(family, input)
-  }));
-}
-
 function lifecycleAction(family: EventFamily): LifecycleAction {
   return family === 'analyze' ? 'analysis' : family;
 }
@@ -586,7 +597,20 @@ function reworkIntentMutationForCompletion(
       try { return [[name, sha256File(path.join(taskDir, name))]]; }
       catch { return []; }
     }));
-    next = consumeReworkIntents(next, family === 'analyze' ? 'analysis' : family, hashes, timestamp).intents;
+    const action = family === 'analyze' ? 'analysis' : family;
+    let target: ReworkTarget = action;
+    if (family === 'analyze') {
+      const previousAnalysis = fs.readdirSync(taskDir)
+        .map((name) => parseArtifactName(name))
+        .filter((identity) => identity?.family === 'analysis' && identity.name !== artifact.name)
+        .sort((left, right) => right!.round - left!.round || left!.name.localeCompare(right!.name))[0];
+      const pathState = previousAnalysis
+        ? parseLifecyclePathDecision(fs.readFileSync(path.join(taskDir, previousAnalysis.name), 'utf8'))
+        : undefined;
+      const pending = next.find((intent) => intent.status === 'pending');
+      if (pending && effectiveReworkTarget(pending.target, pathState) === action) target = pending.target;
+    }
+    next = consumeReworkIntents(next, target, hashes, timestamp).intents;
   }
   if (family === 'review-analysis' || family === 'review-plan' || family === 'review-code') {
     next = supersedeReworkIntents(next, artifact.name, hash, timestamp).intents;
@@ -614,13 +638,15 @@ function buildCompletionReceipt(
       ? frontmatter.code_input_artifact : existing?.input ?? '';
     const startedSha256 = typeof frontmatter.code_input_sha256 === 'string'
       ? frontmatter.code_input_sha256 : existing?.inputSha256 ?? '';
-    if (!startedInput || !startedSha256) return { ok: false, message: 'code.started plan input context is missing' };
-    const plan = inspectArtifactDirectory(taskDir, 'plan');
-    if (plan.status !== 'ready' || !plan.latest || plan.latest.name !== startedInput) {
-      return { ok: false, message: `code input '${startedInput}' is not the latest plan artifact` };
+    if (!startedInput || !startedSha256) return { ok: false, message: 'code.started lifecycle input context is missing' };
+    const inputIdentity = parseArtifactName(startedInput);
+    if (!inputIdentity || !['analysis', 'plan'].includes(inputIdentity.family)) return { ok: false, message: `code input '${startedInput}' has an invalid family` };
+    const lifecycleInput = inspectArtifactDirectory(taskDir, inputIdentity.family);
+    if (lifecycleInput.status !== 'ready' || !lifecycleInput.latest || lifecycleInput.latest.name !== startedInput) {
+      return { ok: false, message: `code input '${startedInput}' is not the latest ${inputIdentity.family} artifact` };
     }
     try {
-      const inputSha256 = sha256File(plan.latest.path);
+      const inputSha256 = sha256File(lifecycleInput.latest.path);
       if (inputSha256 !== startedSha256) return { ok: false, message: `code input ${startedInput} changed after code.started` };
       return {
         ok: true,
@@ -630,7 +656,7 @@ function buildCompletionReceipt(
         }
       };
     } catch (error) {
-      return { ok: false, message: `cannot hash code input plan: ${error instanceof Error ? error.message : String(error)}` };
+      return { ok: false, message: `cannot hash code lifecycle input: ${error instanceof Error ? error.message : String(error)}` };
     }
   }
   if (!family.startsWith('review-')) return null;
@@ -774,6 +800,12 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
       normalized = { ...request, round: openIdentity.round, artifact: artifactName(FAMILY[initialParts.family].artifact, openIdentity.round), fixFor: openIdentity.fixFor, implementationInput: openIdentity.implementationInput };
       return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, typeof frontmatter.current_step === 'string' ? frontmatter.current_step : '', identity(normalized), openIdentity.row.started, frontmatter, null);
     }
+    if (rows.some((item) => item.started && !item.done)) {
+      return failed(request, {
+        code: 'EVENT_TRANSITION_INVALID',
+        message: 'EXECUTION_BUSY: another lifecycle execution is open'
+      }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
+    }
     const result = normalizeStarted(request, resolved.repoRoot);
     artifactContext = result.context;
     if ('error' in result) return failed(request, result.error, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, artifactContext });
@@ -836,25 +868,13 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
     if (eventIdentity.family.startsWith('review-')) {
       try { reviewContent = fs.readFileSync(completedArtifact.path, 'utf8'); }
       catch (error) {
-        return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `cannot read qualification audit from ${completedArtifact.name}: ${error instanceof Error ? error.message : String(error)}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+        return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `cannot read ${completedArtifact.name}: ${error instanceof Error ? error.message : String(error)}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
       }
       const schema = getArtifactSchema(eventIdentity.family);
       const structure = schema ? inspectArtifactContract(reviewContent, schema) : null;
       if (structure && !structure.ok) {
         return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `shared artifact structure invalid: ${structure.diagnostics.map((item) => `${item.code}: ${item.message}`).join('; ')}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
       }
-      const expected = expectedQualificationRelations(content, eventIdentity.family as 'review-analysis' | 'review-plan' | 'review-code');
-      if (!expected.ok) {
-        return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `${expected.code}: ${expected.message}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
-      }
-      const qualification = validateQualificationAudit(content, reviewContent, {
-        family: eventIdentity.family as 'review-analysis' | 'review-plan' | 'review-code',
-        artifact: completedArtifact.name,
-        expectedUpstreamRelations: expected.relations
-      });
-      if (!qualification.ok) {
-        return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `${qualification.code}: ${qualification.message}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
-      }
     }
     if (eventIdentity.family === 'analyze' || eventIdentity.family === 'plan' || eventIdentity.family === 'code') {
       const localFamily = eventIdentity.family === 'analyze'
@@ -866,9 +886,7 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
         return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `cannot read ${completedArtifact.name}: ${String(error)}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
       }
       const local = validateLocalArtifact(artifactContent, {
-        family: localFamily,
-        taskContent: content,
-        artifact: completedArtifact.name
+        family: localFamily
       });
       if (!local.ok) {
         return failed(normalized, {
@@ -903,7 +921,9 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
     const capabilityOverride = capability.reasonCode === 'TASK_NOT_ACTIVE'
       ? stateOverride
       : allowsManualOverride(options.manualOverride, 'task-event', 'EVENT_TRANSITION_INVALID');
-    if (!capability.allowed && !capabilityOverride) {
+    const safetyFailure = capability.reasonCode === 'TASK_NOT_ACTIVE'
+      || capability.reasonCode === 'LIFECYCLE_EXECUTION_OPEN';
+    if (!capability.allowed && (normalized.initiator === 'orchestrator' || safetyFailure) && !capabilityOverride) {
       const code = capability.reasonCode === 'INVALIDATION_INCOMPLETE' ? 'TASK_INVALIDATION_BLOCKED' : 'EVENT_TRANSITION_INVALID';
       return failed(normalized, { code, message: `${capability.reasonCode}: ${capability.evidence.join(', ')}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
     }
@@ -916,10 +936,11 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   );
   if (findingCountError) return failed(normalized, findingCountError, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
   let orchestrationCompletion: OrchestrationStageCompletion | null = null;
-  if (eventIdentity.phase === 'completed' && eventIdentity.family !== 'manual-validation' && eventIdentity.family !== 'validation-run') {
+  if (eventIdentity.phase === 'completed' && normalized.orchestrated
+    && eventIdentity.family !== 'manual-validation' && eventIdentity.family !== 'validation-run') {
     const orchestrationStage = eventIdentity.family === 'analyze' ? 'analysis' : eventIdentity.family;
     const execution = validateLifecycleExecution(normalized.taskRef, {
-      mode: normalized.orchestrated ? 'orchestrated' : 'standalone',
+      mode: 'orchestrated',
       identity: {
         stage: orchestrationStage,
         round: normalized.round!,
@@ -984,16 +1005,9 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   const frontmatterSet: Record<string, string> = { current_step: step, assigned_to: normalized.agent };
   if (currentFact) frontmatterSet.completion_facts = JSON.stringify(replaceCompletionFact(completionFacts(frontmatter), currentFact));
   let frontmatterRemove: string[] | undefined;
-  if (eventIdentity.phase === 'started' && artifactContext) {
-    try {
-      frontmatterSet.qualification_input_relations = JSON.stringify(qualificationRelationsForStarted(eventIdentity.family, artifactContext.inputs));
-    } catch (error) {
-      return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `cannot capture qualification input relations: ${error instanceof Error ? error.message : String(error)}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
-    }
-  }
   if (eventIdentity.phase === 'started' && eventIdentity.family === 'code') {
-    const planInput = artifactContext?.inputs.find((input) => input.family === 'plan');
-    if (!planInput) return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: 'code.started plan input context is unavailable' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
+    const planInput = artifactContext?.inputs.find((input) => input.family === 'plan' || input.family === 'analysis');
+    if (!planInput) return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: 'code.started lifecycle input context is unavailable' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
     try {
       frontmatterSet.code_input_artifact = planInput.name;
       frontmatterSet.code_input_sha256 = sha256File(planInput.path);
@@ -1016,11 +1030,15 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
     frontmatterRemove = ['review_input_artifact', 'review_input_sha256'];
   }
   if (eventIdentity.phase === 'completed' && eventIdentity.family === 'review-code' && reviewContent !== null) {
-    const reviewedCommit = approvedCleanReviewedCommit(reviewContent, normalized.verdict, resolved.repoRoot);
+    const reviewedCommit = approvedCleanReviewedCommit(
+      reviewContent,
+      normalized.verdict,
+      resolved.repoRoot,
+      typeof frontmatter.branch === 'string' ? frontmatter.branch : ''
+    );
     if (reviewedCommit) frontmatterSet.last_reviewed_commit = reviewedCommit;
     else if (normalized.verdict === 'approved') frontmatterSet.last_reviewed_commit = '';
   }
-  if (eventIdentity.phase === 'completed') frontmatterRemove = [...(frontmatterRemove ?? []), 'qualification_input_relations'];
   if (eventIdentity.phase === 'started' && normalized.implementationInput) frontmatterSet.last_reviewed_commit = '';
   const mutations: Parameters<typeof writeTask>[0]['mutations'][number][] = [
     { kind: 'frontmatter', set: frontmatterSet, remove: frontmatterRemove }