@abelxiaoxing/cadence 1.0.1 → 1.0.3

package/src/worker.ts

@@ -1,91 +1,92 @@
-// Process-local logical Worker registry for private orchestration. A Worker
-// is pinned by the first accepted phase: logical ID, stage, role, the
-// provider/model/API/thinking identity, and the approved non-snapshot
-// contract. Later accepted Red/Green/optional Refactor phases receive fresh
-// snapshots and fresh phase-local auth for the SAME pinned identity. A failed
-// phase may be mechanically redispatched exactly once when its canonical
-// request is identical apart from refreshed snapshot hashes; a second failure
-// blocks that branch. No credential, transcript, or retry ledger is retained.
+// Process-local task registry for the private Implement runtime.
 
-import type { RequestEnvelope } from "./contracts.ts";
+import type {
+  CandidateFailure,
+  ImplementationPhase,
+  PhaseAttempt,
+  TaskBoundary,
+  TaskFailure,
+} from "./contracts.ts";
+import type { ConflictDeclaration } from "./scheduler.ts";
 
-export interface WorkerContract {
-  stage: string;
-  role: string;
-  id: string;
-  objective: string;
-  roots: string[];
-  agents: string;
-  contractText: string;
-  read: string[];
-  write: string[];
-  conflicts: string[];
-  resources: string[];
-  verificationLock?: string;
-  output: string;
+export type TaskState =
+  | {
+      kind: "ready";
+      phase: ImplementationPhase;
+      launchIndex: 0 | 1;
+      correction?: CandidateFailure;
+    }
+  | {
+      kind: "candidate-pending";
+      phase: ImplementationPhase;
+      launchIndex: 0 | 1;
+      originRequestId: string;
+      resultId: string;
+    }
+  | {
+      kind: "agents-checkpoint-pending";
+      finalPhase: "green" | "refactor";
+      attemptIndex: 0 | 1;
+    }
+  | { kind: "blocked"; phase: ImplementationPhase; failure: TaskFailure }
+  | { kind: "completed"; finalPhase: "green" | "refactor" };
+
+export interface TaskRecord {
+  key: string;
+  workspaceRoot: string;
+  workerIdentity: string;
+  boundary: TaskBoundary;
+  conflict: ConflictDeclaration;
+  state: TaskState;
 }
 
-export interface LogicalWorker {
-  identity: string;
-  contract: WorkerContract;
-  redispatchUsed: boolean;
+export function taskRecordKey(
+  workspaceRoot: string,
+  changeId: string,
+  taskId: string,
+): string {
+  return `${workspaceRoot}\0${changeId}\0${taskId}`;
 }
 
-// Pins the semantic scope of a logical Worker, excluding the phase label so a
-// later Red/Green/Refactor phase is recognized as the same Worker.
-export function contractOf(envelope: RequestEnvelope): WorkerContract {
+export function taskConflictOf(boundary: TaskBoundary): ConflictDeclaration {
+  const phases = [
+    boundary.phases.red,
+    boundary.phases.green,
+    ...(boundary.phases.refactor ? [boundary.phases.refactor] : []),
+  ];
+  const write = new Set(phases.flatMap((phase) => phase.write));
+  if (boundary.agents.impact !== "none" && boundary.agents.target) {
+    write.add(boundary.agents.target);
+  }
   return {
-    stage: envelope.stage,
-    role: envelope.role,
-    id: envelope.id,
-    objective: envelope.objective,
-    roots: [...envelope.roots],
-    agents: envelope.context.agents,
-    contractText: envelope.context.contract,
-    read: [...envelope.declared.read],
-    write: [...envelope.declared.write],
-    conflicts: [...envelope.declared.conflicts],
-    resources: [...envelope.declared.resources],
-    verificationLock: envelope.declared.verificationLock,
-    output: envelope.output,
+    taskId: boundary.taskId,
+    read: [...new Set(phases.flatMap((phase) => phase.read))],
+    write: [...write],
+    conflicts: [...boundary.scheduling.conflicts],
+    resources: [...boundary.scheduling.resources],
+    verificationLocks: [
+      ...new Set(
+        phases.flatMap((phase) =>
+          phase.verificationLock ? [phase.verificationLock] : [],
+        ),
+      ),
+    ],
   };
 }
 
-export function sameContract(a: WorkerContract, b: WorkerContract): boolean {
-  if (
-    a.stage !== b.stage ||
-    a.role !== b.role ||
-    a.id !== b.id ||
-    a.objective !== b.objective ||
-    a.agents !== b.agents ||
-    a.contractText !== b.contractText ||
-    a.output !== b.output ||
-    a.verificationLock !== b.verificationLock
-  )
-    return false;
-  return (
-    arrayEqual(a.roots, b.roots) &&
-    arrayEqual(a.read, b.read) &&
-    arrayEqual(a.write, b.write) &&
-    arrayEqual(a.conflicts, b.conflicts) &&
-    arrayEqual(a.resources, b.resources)
-  );
-}
-
-function arrayEqual(a: string[], b: string[]): boolean {
-  return a.length === b.length && a.every((value, index) => value === b[index]);
-}
-
-// Stable provider/model/API/thinking identity fingerprint for a phase. Each
-// child attempt re-derives it while the phase-local auth boundary is called
-// anew, so the identity stays pinned across fresh phases.
+// Stable provider/model/API identity fingerprint. Fresh auth may be acquired
+// for each phase, while the selected execution identity remains pinned.
 export function workerIdentity(model: {
   provider?: unknown;
+  api?: unknown;
   baseUrl?: unknown;
   id?: unknown;
   name?: unknown;
 }): string {
-  const parts: string[] = [`p:${String(model.provider ?? "")}`];
+  const parts: string[] = [
+    `p:${String(model.provider ?? "")}`,
+    `a:${String(model.api ?? "")}`,
+  ];
   if (model.baseUrl !== undefined) parts.push(`u:${String(model.baseUrl)}`);
   if (typeof model.id === "string") parts.push(`id:${model.id}`);
   if (typeof model.name === "string") parts.push(`n:${model.name}`);
@@ -93,27 +94,55 @@ export function workerIdentity(model: {
 }
 
 export class WorkerRegistry {
-  private readonly workers = new Map<string, LogicalWorker>();
+  private readonly tasks = new Map<string, TaskRecord>();
+
+  has(key: string): boolean {
+    return this.tasks.has(key);
+  }
 
-  has(id: string): boolean {
-    return this.workers.has(id);
+  get(key: string): TaskRecord | undefined {
+    return this.tasks.get(key);
   }
 
-  get(id: string): LogicalWorker | undefined {
-    return this.workers.get(id);
+  find(workspaceRoot: string, taskId: string): TaskRecord | undefined {
+    const matches = [...this.tasks.values()].filter(
+      (record) =>
+        record.workspaceRoot === workspaceRoot &&
+        record.boundary.taskId === taskId,
+    );
+    return matches.length === 1 ? matches[0] : undefined;
   }
 
-  pin(contract: WorkerContract, identity: string): LogicalWorker {
-    const worker: LogicalWorker = {
-      identity,
-      contract,
-      redispatchUsed: false,
+  open(
+    boundary: TaskBoundary,
+    identity: string,
+    workspaceRoot: string,
+    attempt: PhaseAttempt,
+  ): TaskRecord {
+    const key = taskRecordKey(
+      workspaceRoot,
+      boundary.changeId,
+      boundary.taskId,
+    );
+    if (this.tasks.has(key)) throw new Error("duplicate task open");
+    const storedBoundary = structuredClone(boundary);
+    const record: TaskRecord = {
+      key,
+      workspaceRoot,
+      workerIdentity: identity,
+      boundary: storedBoundary,
+      conflict: taskConflictOf(storedBoundary),
+      state: { kind: "ready", phase: attempt.phase, launchIndex: 0 },
     };
-    this.workers.set(contract.id, worker);
-    return worker;
+    this.tasks.set(key, record);
+    return record;
+  }
+
+  values(): TaskRecord[] {
+    return [...this.tasks.values()];
   }
 
   clear(): void {
-    this.workers.clear();
+    this.tasks.clear();
   }
 }