@fitlab-ai/agent-infra 0.9.3 → 0.9.4

package/lib/task/implementation-inputs.ts

@@ -8,7 +8,7 @@ const COLUMNS = [
 const TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}$/;
 const ARTIFACT_RE = /^code(?:-r(?:[2-9]|[1-9]\d+))?\.md$/;
 
-type ImplementationInputStatus = 'pending' | 'not-required' | 'consumed';
+type ImplementationInputStatus = 'declared' | 'pending' | 'not-required' | 'consumed';
 type ImplementationInput = {
   id: string;
   ledgerId: string;
@@ -25,18 +25,18 @@ type ImplementationInputDraft = {
   needsImplementation: boolean;
   decidedAt: string;
 };
+type ImplementationInputDeclaration = Omit<ImplementationInputDraft, 'decidedAt'>;
 
 function validateInput(row: ImplementationInput): void {
   if (!/^II-[1-9]\d*$/.test(row.id)) throw new Error(`implementation input id '${row.id}' is invalid`);
   if (!row.ledgerId || !row.decisionEvidence || /[\r\n]/.test(row.ledgerId) || /[\r\n]/.test(row.decisionEvidence)) throw new Error(`implementation input ${row.id} has incomplete decision identity`);
   if (row.stage !== 'code') throw new Error(`implementation input ${row.id} has invalid stage`);
-  if (!TIMESTAMP_RE.test(row.decidedAt) || !Number.isFinite(Date.parse(row.decidedAt.replace(' ', 'T')))) {
-    throw new Error(`implementation input ${row.id} has invalid decided_at`);
-  }
+  const hasValidTimestamp = TIMESTAMP_RE.test(row.decidedAt) && Number.isFinite(Date.parse(row.decidedAt.replace(' ', 'T')));
   const valid =
-    (row.needsImplementation && row.status === 'pending' && row.consumedBy === '') ||
-    (!row.needsImplementation && row.status === 'not-required' && row.consumedBy === '') ||
-    (row.needsImplementation && row.status === 'consumed' && ARTIFACT_RE.test(row.consumedBy));
+    (row.status === 'declared' && row.decidedAt === '' && row.consumedBy === '') ||
+    (hasValidTimestamp && row.needsImplementation && row.status === 'pending' && row.consumedBy === '') ||
+    (hasValidTimestamp && !row.needsImplementation && row.status === 'not-required' && row.consumedBy === '') ||
+    (hasValidTimestamp && row.needsImplementation && row.status === 'consumed' && ARTIFACT_RE.test(row.consumedBy));
   if (!valid) throw new Error(`implementation input ${row.id} has an invalid state combination`);
 }
 
@@ -79,6 +79,57 @@ function createImplementationInput(rows: readonly ImplementationInput[], draft:
   return row;
 }
 
+function declareImplementationInput(
+  rows: readonly ImplementationInput[], draft: ImplementationInputDeclaration
+): ImplementationInput {
+  const existing = rows.filter((row) => row.ledgerId === draft.ledgerId && row.status === 'declared');
+  if (existing.length > 1) throw new Error(`implementation input declaration for '${draft.ledgerId}' conflicts with existing rows`);
+  if (existing.length === 1) {
+    const row = existing[0]!;
+    if (row.decisionEvidence !== draft.decisionEvidence || row.needsImplementation !== draft.needsImplementation) {
+      throw new Error(`implementation input declaration for '${draft.ledgerId}' conflicts with the existing row`);
+    }
+    return row;
+  }
+  const row: ImplementationInput = {
+    id: nextId(rows), ledgerId: draft.ledgerId, decisionEvidence: draft.decisionEvidence,
+    stage: 'code', needsImplementation: draft.needsImplementation, decidedAt: '',
+    status: 'declared', consumedBy: ''
+  };
+  validateInput(row);
+  return row;
+}
+
+function selectDeclaredImplementationInput(
+  rows: readonly ImplementationInput[], ledgerId: string, decisionEvidence: string
+): ImplementationInput | null {
+  const forLedger = rows.filter((row) => row.ledgerId === ledgerId && row.status === 'declared');
+  if (forLedger.length > 1) throw new Error(`implementation input declaration for '${ledgerId}' is ambiguous`);
+  if (forLedger.length === 0) return null;
+  if (forLedger[0]!.decisionEvidence !== decisionEvidence) {
+    throw new Error(`implementation input declaration for '${ledgerId}' has conflicting evidence`);
+  }
+  return forLedger[0]!;
+}
+
+function finalizeImplementationInput(
+  rows: readonly ImplementationInput[], id: string, decisionEvidence: string, decidedAt: string
+): ImplementationInput[] {
+  let found = false;
+  const next = rows.map((row) => {
+    if (row.id !== id) return row;
+    found = true;
+    if (row.status !== 'declared') throw new Error(`implementation input ${id} is not declared`);
+    return {
+      ...row, decisionEvidence, decidedAt,
+      status: row.needsImplementation ? 'pending' as const : 'not-required' as const
+    };
+  });
+  if (!found) throw new Error(`implementation input ${id} was not found`);
+  next.forEach(validateInput);
+  return next;
+}
+
 function selectPendingImplementationInput(
   rows: readonly ImplementationInput[], reviewCompletedAt: string
 ): ImplementationInput | null {
@@ -130,8 +181,11 @@ export {
   SECTION_ALIASES as IMPLEMENTATION_INPUT_ALIASES,
   createImplementationInput,
   consumeImplementationInput,
+  declareImplementationInput,
+  finalizeImplementationInput,
   parseImplementationInputs,
   renderImplementationInputs,
+  selectDeclaredImplementationInput,
   selectPendingImplementationInput
 };
-export type { ImplementationInput, ImplementationInputDraft, ImplementationInputStatus };
+export type { ImplementationInput, ImplementationInputDeclaration, ImplementationInputDraft, ImplementationInputStatus };

package/lib/task/ledger-intents.ts

@@ -1,6 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+import {
+  declareImplementationInput,
+  IMPLEMENTATION_INPUT_ALIASES,
+  parseImplementationInputs,
+  renderImplementationInputs
+} from './implementation-inputs.ts';
 import { LEDGER_COLUMNS, LEDGER_HEADINGS, nextHdId, parseLedger, validateLedgerRows } from './ledger.ts';
 import type { LedgerRow, ReviewStage } from './ledger.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
@@ -13,9 +19,9 @@ type ReviewDisposition = 'confirmed' | 'closed' | 'open' | 'needs-human-decision
 type LedgerIntent =
   | { kind: 'finding-upsert'; taskRef: string; stage: ReviewStage; reviewArtifact: string; ordinal: number; severity: ReviewSeverity; evidence: string; dryRun?: boolean }
   | { kind: 'finding-respond'; taskRef: string; id: string; round: number; status: ExecutorResponse; evidence: string; dryRun?: boolean }
-  | { kind: 'finding-review'; taskRef: string; id: string; status: ReviewDisposition; evidence: string; dryRun?: boolean }
+  | { kind: 'finding-review'; taskRef: string; id: string; status: ReviewDisposition; evidence: string; needsImplementation?: boolean; dryRun?: boolean }
   | { kind: 'decision-next-id'; taskRef: string }
-  | { kind: 'decision-upsert'; taskRef: string; id: string; stage: ReviewStage; artifact: string; dryRun?: boolean };
+  | { kind: 'decision-upsert'; taskRef: string; id: string; stage: ReviewStage; artifact: string; needsImplementation?: boolean; dryRun?: boolean };
 
 type LedgerIntentError = { code: string; message: string };
 type LedgerIntentResult = {
@@ -97,6 +103,15 @@ function ledgerSectionMutation(content: string): TaskMutation[] {
   }];
 }
 
+function implementationInputMutation(content: string, rows: Parameters<typeof renderImplementationInputs>[0]): TaskMutation {
+  const english = /^##\s+Activity Log\s*$/m.test(content);
+  return {
+    kind: 'section', aliases: IMPLEMENTATION_INPUT_ALIASES,
+    heading: english ? 'Implementation Inputs' : '实现输入',
+    body: renderImplementationInputs(rows)
+  };
+}
+
 function mapWrite(intent: LedgerIntent, entityId: string, before: LedgerRow | null, after: LedgerRow, result: ReturnType<typeof writeTask>): LedgerIntentResult {
   if (result.status === 'failed') return failed(intent, result.error.code, result.error.message, result.taskId, entityId);
   return { status: result.status, changed: result.changed, intent: intent.kind, taskId: result.taskId, entityId, before, after, operations: result.operations, error: null };
@@ -189,9 +204,34 @@ function applyLedgerIntent(intent: LedgerIntent, options: TaskWriteOptions = {})
     }
   }
 
+  let implementationMutation: TaskMutation | null = null;
+  if (intent.kind === 'decision-upsert' || intent.kind === 'finding-review') {
+    const stage = intent.kind === 'decision-upsert' ? intent.stage : after.stage;
+    const escalates = intent.kind === 'decision-upsert' || intent.status === 'needs-human-decision';
+    if (stage === 'code' && escalates && intent.needsImplementation === undefined) {
+      return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'code-stage decisions require --needs-implementation true|false', resolved.taskId, after.id);
+    }
+    if ((stage !== 'code' || !escalates) && intent.needsImplementation !== undefined) {
+      return failed(intent, 'LEDGER_PAYLOAD_INVALID', '--needs-implementation is only valid for code-stage escalation', resolved.taskId, after.id);
+    }
+    if (stage === 'code' && escalates) {
+      try {
+        const parsed = parseImplementationInputs(content);
+        const declaration = declareImplementationInput(parsed.rows, {
+          ledgerId: after.id, decisionEvidence: after.evidence,
+          needsImplementation: intent.needsImplementation!
+        });
+        const nextRows = parsed.rows.includes(declaration) ? parsed.rows : [...parsed.rows, declaration];
+        implementationMutation = implementationInputMutation(content, nextRows);
+      } catch (error) {
+        return failed(intent, 'LEDGER_DOCUMENT_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId, after.id);
+      }
+    }
+  }
+
   const result = writeTask({
     taskRef: intent.taskRef, expectedState: 'active',
-    mutations: [...ledgerSectionMutation(content), rowMutation(after)],
+    mutations: [...ledgerSectionMutation(content), rowMutation(after), ...(implementationMutation ? [implementationMutation] : [])],
     dryRun: 'dryRun' in intent ? intent.dryRun : false
   }, { ...options, taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state } });
   return mapWrite(intent, after.id, before, after, result);