@abelxiaoxing/cadence 1.0.1 → 1.0.2

package/src/scheduler.ts

@@ -59,6 +59,7 @@ function conflictEdgeMatches(
 ): boolean {
   return conflicts.some(
     (edge) =>
+      edge === other.taskId ||
       edge === other.id ||
       other.declared.read.includes(edge) ||
       other.declared.write.includes(edge),

package/src/scoped-tools.ts

@@ -31,6 +31,7 @@ export interface ScopedToolDef {
 
 interface Options {
   roots: string[];
+  allowedPaths?: string[];
   observer?: (obs: Observation) => void;
 }
 
@@ -38,7 +39,11 @@ type PathResult =
   | { ok: true; abs: string; rel: string }
   | { ok: false; error: string };
 
-function resolveScoped(roots: string[], input: unknown): PathResult {
+function resolveScoped(
+  roots: string[],
+  input: unknown,
+  allowedPaths?: string[],
+): PathResult {
   if (typeof input !== "string" || input.length === 0) {
     return { ok: false, error: "missing path" };
   }
@@ -54,11 +59,21 @@ function resolveScoped(roots: string[], input: unknown): PathResult {
   if (input.startsWith("./") || input.includes("//") || input.endsWith("/.")) {
     return { ok: false, error: "noncanonical path rejected" };
   }
+  let insideRoot = false;
   for (const root of roots) {
     const abs = resolve(root, input);
     const inside =
       abs === root || abs.startsWith(root.endsWith("/") ? root : `${root}/`);
     if (!inside) continue;
+    insideRoot = true;
+    if (
+      allowedPaths &&
+      !allowedPaths.some(
+        (allowed) => abs === allowed || abs.startsWith(`${allowed}/`),
+      )
+    ) {
+      continue;
+    }
     // Hidden directories are rejected unless the root itself is the hidden scope.
     const hiddenRoot =
       basename(realpathSync(root)) === ".git" ||
@@ -89,7 +104,12 @@ function resolveScoped(roots: string[], input: unknown): PathResult {
     }
     return { ok: true, abs: abs, rel: relative(root, abs) || "." };
   }
-  return { ok: false, error: "path is outside every approved root" };
+  return {
+    ok: false,
+    error: insideRoot
+      ? "path is outside the declared read/write scope"
+      : "path is outside every approved root",
+  };
 }
 
 function existsSync(p: string): boolean {
@@ -113,6 +133,7 @@ function utf8Text(abs: string): string | null {
 
 export function createScopedTools(opts: Options): ScopedToolDef[] {
   const roots = opts.roots.map((r) => resolve(r));
+  const allowedPaths = opts.allowedPaths?.map((p) => resolve(p));
   const observe = opts.observer ?? (() => {});
 
   const readTool: ScopedToolDef = {
@@ -120,7 +141,7 @@ export function createScopedTools(opts: Options): ScopedToolDef[] {
     description:
       "Read a regular UTF-8 text file within the approved scope (max 2,000 lines / 50 KiB).",
     async execute(params) {
-      const resolved = resolveScoped(roots, params.path);
+      const resolved = resolveScoped(roots, params.path, allowedPaths);
       if (!resolved.ok) return { ok: false, error: resolved.error };
       let st: Stats | undefined;
       try {
@@ -167,7 +188,7 @@ export function createScopedTools(opts: Options): ScopedToolDef[] {
           error: `pattern exceeds ${TOOL_LIMITS.maxGrepPattern} characters`,
         };
       }
-      const resolved = resolveScoped(roots, params.path ?? ".");
+      const resolved = resolveScoped(roots, params.path ?? ".", allowedPaths);
       if (!resolved.ok) return { ok: false, error: resolved.error };
       let regex: RegExp;
       try {
@@ -207,7 +228,7 @@ export function createScopedTools(opts: Options): ScopedToolDef[] {
     description:
       "List a directory within the approved scope (max 20,000 entries, stable code-unit order).",
     async execute(params) {
-      const resolved = resolveScoped(roots, params.path ?? ".");
+      const resolved = resolveScoped(roots, params.path ?? ".", allowedPaths);
       if (!resolved.ok) return { ok: false, error: resolved.error };
       let st: Stats | undefined;
       try {
@@ -236,7 +257,7 @@ export function createScopedTools(opts: Options): ScopedToolDef[] {
     description:
       "Recursively list paths within the approved scope (max 20,000 entries, stable code-unit order).",
     async execute(params) {
-      const resolved = resolveScoped(roots, params.path ?? ".");
+      const resolved = resolveScoped(roots, params.path ?? ".", allowedPaths);
       if (!resolved.ok) return { ok: false, error: resolved.error };
       let st: Stats | undefined;
       try {

package/src/submit-tool.ts

@@ -63,6 +63,7 @@ export interface SubmitClassification {
 
 export function createSubmitTool(input: {
   requestId: string;
+  taskId?: string;
   role: string;
   phase: string;
   output: "evidence" | "diff";
@@ -98,7 +99,8 @@ export function createSubmitTool(input: {
       if (value.id !== input.requestId) identity.request = false;
       if (value.role !== input.role) identity.role = false;
       if (input.output === "diff") {
-        if (value.taskId !== input.requestId) identity.task = false;
+        if (value.taskId !== (input.taskId ?? input.requestId))
+          identity.task = false;
         if (value.phase !== input.phase) identity.phase = false;
       }
       const validation =

package/src/worker.ts

@@ -1,77 +1,149 @@
 // 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.
+// is keyed by stable task identity. Its immutable task contract is separate
+// from the current phase request, snapshot, verification, and launch budget.
+// No credential, transcript, provider diagnostic, or unbounded retry ledger
+// is retained.
 
-import type { RequestEnvelope } from "./contracts.ts";
+import type { RequestEnvelope, VerificationContract } from "./contracts.ts";
 
 export interface WorkerContract {
   stage: string;
   role: string;
-  id: string;
+  taskId: string;
   objective: string;
   roots: string[];
   agents: string;
   contractText: string;
   read: string[];
-  write: string[];
   conflicts: string[];
   resources: string[];
-  verificationLock?: string;
   output: string;
+  currentPhase: WorkerPhaseContract;
+}
+
+export interface WorkerTaskContract {
+  stage: string;
+  role: string;
+  taskId: string;
+  objective: string;
+  roots: string[];
+  agents: string;
+  contractText: string;
+  read: string[];
+  conflicts: string[];
+  resources: string[];
+  output: string;
+}
+
+export interface WorkerPhaseContract {
+  requestId: string;
+  phase: string;
+  readSet: string[];
+  writeSet: string[];
+  conflicts: string[];
+  resources: string[];
+  verificationLock?: string;
+  snapshot?: unknown;
+  verification?: VerificationContract;
+  correctionIndex: 0 | 1;
 }
 
 export interface LogicalWorker {
   identity: string;
-  contract: WorkerContract;
-  redispatchUsed: boolean;
+  taskContract: WorkerTaskContract;
+  currentPhase: WorkerPhaseContract;
+  state: WorkerState;
 }
 
-// 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 type WorkerState =
+  | { kind: "ready" }
+  | { kind: "candidate-pending" }
+  | { kind: "phase-applied" }
+  | { kind: "artifact-correction-pending"; rejection: string }
+  | { kind: "stale-redispatch-pending" }
+  | { kind: "blocked"; reason: "artifact" | "mechanical" };
+
 export function contractOf(envelope: RequestEnvelope): WorkerContract {
   return {
     stage: envelope.stage,
     role: envelope.role,
-    id: envelope.id,
+    taskId: envelope.taskId ?? 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,
+    currentPhase: phaseOf(envelope, 0),
   };
 }
 
-export function sameContract(a: WorkerContract, b: WorkerContract): boolean {
+export function sameContract(
+  a: WorkerTaskContract,
+  b: WorkerTaskContract,
+): boolean {
   if (
     a.stage !== b.stage ||
     a.role !== b.role ||
-    a.id !== b.id ||
+    a.taskId !== b.taskId ||
     a.objective !== b.objective ||
     a.agents !== b.agents ||
     a.contractText !== b.contractText ||
-    a.output !== b.output ||
-    a.verificationLock !== b.verificationLock
+    a.output !== b.output
   )
     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)
   );
 }
 
+export function samePhaseContract(
+  a: WorkerPhaseContract,
+  b: WorkerPhaseContract,
+): boolean {
+  return (
+    a.phase === b.phase &&
+    arrayEqual(a.readSet, b.readSet) &&
+    arrayEqual(a.writeSet, b.writeSet) &&
+    arrayEqual(a.conflicts, b.conflicts) &&
+    arrayEqual(a.resources, b.resources) &&
+    a.verificationLock === b.verificationLock &&
+    JSON.stringify(a.verification) === JSON.stringify(b.verification)
+  );
+}
+
+function phaseOf(
+  envelope: RequestEnvelope,
+  correctionIndex: 0 | 1,
+): WorkerPhaseContract {
+  return {
+    requestId: envelope.id,
+    phase: envelope.phase,
+    readSet: [...envelope.declared.read],
+    writeSet: [...envelope.declared.write],
+    conflicts: [...envelope.declared.conflicts],
+    resources: [...envelope.declared.resources],
+    verificationLock: envelope.declared.verificationLock,
+    snapshot:
+      envelope.snapshot === undefined
+        ? undefined
+        : structuredClone(envelope.snapshot),
+    verification:
+      envelope.verification === undefined
+        ? undefined
+        : {
+            ...envelope.verification,
+            argv: [...envelope.verification.argv],
+          },
+    correctionIndex,
+  };
+}
+
 function arrayEqual(a: string[], b: string[]): boolean {
   return a.length === b.length && a.every((value, index) => value === b[index]);
 }
@@ -104,12 +176,30 @@ export class WorkerRegistry {
   }
 
   pin(contract: WorkerContract, identity: string): LogicalWorker {
+    const currentPhase = clonePhase(contract.currentPhase);
     const worker: LogicalWorker = {
       identity,
-      contract,
-      redispatchUsed: false,
+      taskContract: cloneTask(contract),
+      currentPhase,
+      state: { kind: "ready" },
     };
-    this.workers.set(contract.id, worker);
+    this.workers.set(contract.taskId, worker);
+    return worker;
+  }
+
+  setCurrentPhase(
+    taskId: string,
+    contract: WorkerContract,
+    correctionIndex: 0 | 1,
+  ): LogicalWorker | undefined {
+    const worker = this.workers.get(taskId);
+    if (!worker) return undefined;
+    const currentPhase = {
+      ...clonePhase(contract.currentPhase),
+      correctionIndex,
+    };
+    worker.currentPhase = currentPhase;
+    worker.state = { kind: "ready" };
     return worker;
   }
 
@@ -117,3 +207,23 @@ export class WorkerRegistry {
     this.workers.clear();
   }
 }
+
+function cloneTask(contract: WorkerContract): WorkerTaskContract {
+  return {
+    stage: contract.stage,
+    role: contract.role,
+    taskId: contract.taskId,
+    objective: contract.objective,
+    roots: [...contract.roots],
+    agents: contract.agents,
+    contractText: contract.contractText,
+    read: [...contract.read],
+    conflicts: [...contract.conflicts],
+    resources: [...contract.resources],
+    output: contract.output,
+  };
+}
+
+function clonePhase(phase: WorkerPhaseContract): WorkerPhaseContract {
+  return structuredClone(phase);
+}