@abelxiaoxing/cadence 1.8.2 → 1.8.4

package/src/durable-workflow.ts

@@ -22,24 +22,18 @@ interface DurableRunResources extends DurableExecutionResources {
 
 import { lstatSync, mkdirSync, readFileSync } from "node:fs";
 import path from "node:path";
-import { DatabaseSync } from "node:sqlite";
 import { ApplyTransaction } from "./apply-transaction.ts";
 import { ArtifactStore } from "./artifact-store.ts";
 import { compareCanonicalStrings } from "./canonical.ts";
 import type { ImplementPlan, PlanTaskDraft } from "./delivery-compiler.ts";
-import type { RoutePolicy } from "./route-policy.ts";
 import { observeSafePath } from "./safe-path.ts";
-import { configureSqlite, ensureSqliteSchema } from "./sqlite-schema.ts";
-import { ROUTE_HEALTH_SCHEMA } from "./storage-schema.ts";
 import { TaskLedger } from "./task-ledger.ts";
-import { type RouteHealthStore, RunWorkerBroker } from "./worker-broker.ts";
 import {
   deliveryBoundPaths,
   deliveryTrackingPath,
   hash,
   hasVerificationLifecycle,
   IDENTIFIER,
-  implementationRouteRequirements,
   isRecord,
   SHA256,
   type WorkflowApplication,
@@ -52,125 +46,6 @@ import {
 import { WorkflowEngine } from "./workflow-state-machine.ts";
 import { type WorkspaceRevision, WorkspaceStore } from "./workspace-store.ts";
 
-type DurableRouteHealth = Parameters<RouteHealthStore["set"]>[1];
-
-class DurableRouteHealthStore implements RouteHealthStore {
-  readonly #databasePath: string;
-  #database?: DatabaseSync;
-  #closed = false;
-
-  constructor(databasePath: string) {
-    this.#databasePath = databasePath;
-  }
-
-  #open(): DatabaseSync {
-    if (this.#closed) throw new Error("route-health-store-closed");
-    if (this.#database) return this.#database;
-    const database = new DatabaseSync(this.#databasePath);
-    try {
-      configureSqlite(database);
-      ensureSqliteSchema(database, ROUTE_HEALTH_SCHEMA);
-    } catch (error) {
-      database.close();
-      throw error;
-    }
-
-    this.#database = database;
-    return database;
-  }
-
-  get(fingerprint: string): DurableRouteHealth | undefined {
-    if (!SHA256.test(fingerprint)) return undefined;
-    const row = this.#open()
-      .prepare(
-        `SELECT state, next_half_open_at, projection_json
-         FROM route_health WHERE route_fingerprint = ?`,
-      )
-      .get(fingerprint) as
-      | {
-          state: string;
-          next_half_open_at: number | null;
-          projection_json: string;
-        }
-      | undefined;
-    if (!row || !["healthy", "open", "half-open"].includes(row.state)) {
-      return undefined;
-    }
-    let projection: unknown;
-    try {
-      projection = JSON.parse(row.projection_json);
-    } catch {
-      return undefined;
-    }
-    if (!isRecord(projection) || projection.state !== row.state) {
-      return undefined;
-    }
-    const retryAt = row.next_half_open_at ?? undefined;
-    const lastCode =
-      typeof projection.lastCode === "string" &&
-      projection.lastCode.length > 0 &&
-      projection.lastCode.length <= 128
-        ? projection.lastCode
-        : undefined;
-    const probeExpiresAt =
-      Number.isSafeInteger(projection.probeExpiresAt) &&
-      (projection.probeExpiresAt as number) >= 0
-        ? (projection.probeExpiresAt as number)
-        : undefined;
-    return {
-      state: row.state as DurableRouteHealth["state"],
-      ...(retryAt === undefined ? {} : { retryAt }),
-      ...(projection.probeInFlight === true ? { probeInFlight: true } : {}),
-      ...(probeExpiresAt === undefined ? {} : { probeExpiresAt }),
-      ...(lastCode === undefined ? {} : { lastCode }),
-    };
-  }
-
-  set(fingerprint: string, health: DurableRouteHealth): void {
-    if (
-      !SHA256.test(fingerprint) ||
-      !["healthy", "open", "half-open"].includes(health.state) ||
-      (health.retryAt !== undefined &&
-        (!Number.isSafeInteger(health.retryAt) || health.retryAt < 0)) ||
-      (health.probeExpiresAt !== undefined &&
-        (!Number.isSafeInteger(health.probeExpiresAt) ||
-          health.probeExpiresAt < 0))
-    ) {
-      throw new Error("route-health-fact-invalid");
-    }
-    const projection = {
-      state: health.state,
-      ...(health.probeInFlight ? { probeInFlight: true } : {}),
-      ...(health.probeExpiresAt === undefined
-        ? {}
-        : { probeExpiresAt: health.probeExpiresAt }),
-      ...(health.lastCode ? { lastCode: health.lastCode.slice(0, 128) } : {}),
-    };
-    this.#open()
-      .prepare(
-        `INSERT INTO route_health(
-           route_fingerprint, state, next_half_open_at, projection_json
-         ) VALUES (?, ?, ?, ?)
-         ON CONFLICT(route_fingerprint) DO UPDATE SET
-           state = excluded.state,
-           next_half_open_at = excluded.next_half_open_at,
-           projection_json = excluded.projection_json`,
-      )
-      .run(
-        fingerprint,
-        health.state,
-        health.retryAt ?? null,
-        JSON.stringify(projection),
-      );
-  }
-
-  close(): void {
-    if (this.#closed) return;
-    this.#database?.close();
-    this.#closed = true;
-  }
-}
-
 function ensurePrivateRunDirectory(directory: string): void {
   const existing = lstatSync(directory, { throwIfNoEntry: false });
   if (existing) {
@@ -196,19 +71,10 @@ class DurableWorkflowComposition
   readonly #phase: PhaseExecution;
   readonly #verification: ChangeVerification;
   readonly #options: DurableWorkflowEngineOptions;
-  readonly #routeHealth: DurableRouteHealthStore;
-  #broker: RunWorkerBroker;
   readonly #runs = new Map<string, DurableRunResources>();
 
   constructor(options: DurableWorkflowEngineOptions) {
     this.#options = options;
-    this.#routeHealth = new DurableRouteHealthStore(
-      options.stateRoot.databasePath,
-    );
-    this.#broker = new RunWorkerBroker(options.routePolicy, {
-      ...(options.now ? { now: options.now } : {}),
-      healthStore: this.#routeHealth,
-    });
     this.#verification = new ChangeVerification(options, {
       prepareResources: (input, signal) =>
         this.#prepareResources(input, signal),
@@ -217,7 +83,7 @@ class DurableWorkflowComposition
       revalidatePhasePolicy: (...args) =>
         this.#phase.revalidatePhasePolicy(...args),
     });
-    this.#phase = new PhaseExecution(options, this.#broker, {
+    this.#phase = new PhaseExecution(options, {
       prepareResources: (input, signal) =>
         this.#prepareResources(input, signal),
       ledger: (resources, revision) => this.#ledger(resources, revision),
@@ -229,14 +95,6 @@ class DurableWorkflowComposition
     });
   }
 
-  updateRoutePolicy(policy: RoutePolicy): void {
-    this.#broker.updatePolicy(policy);
-  }
-
-  routePolicyStatus(): Record<string, unknown> {
-    return this.#broker.status();
-  }
-
   #runRoot(runId: string): string {
     if (!IDENTIFIER.test(runId)) throw new Error("workflow-run-id-invalid");
     const dataRoot = path.join(this.#options.stateRoot.rootDir, "run-data");
@@ -770,21 +628,8 @@ class DurableWorkflowComposition
     return revision.entries[input.path]?.kind === "file";
   }
 
-  rebind(input: Parameters<WorkflowWorker["rebind"]>[0]) {
-    const rebound = this.#broker.rebind({
-      runId: input.runId,
-      taskId: input.taskId,
-      role: input.role,
-      routeId: input.routeId,
-      requirements: implementationRouteRequirements({ task: input.task }),
-    });
-    return rebound.ok
-      ? {
-          ok: true as const,
-          routeId: rebound.route.id,
-          routeFingerprint: rebound.route.fingerprint,
-        }
-      : { ok: false as const, code: rebound.code };
+  rebind(_input: Parameters<WorkflowWorker["rebind"]>[0]) {
+    return { ok: false as const, code: "route-configuration-removed" };
   }
 
   async prepare(
@@ -912,7 +757,6 @@ class DurableWorkflowComposition
       this.#closeResources(resources);
     }
     this.#runs.clear();
-    this.#routeHealth.close();
   }
   runAttempt(input: Parameters<WorkflowWorker["runAttempt"]>[0]) {
     return this.#phase.runAttempt(input);

package/src/evidence-draft.ts

@@ -21,7 +21,7 @@ export function evidenceDraftSchema(requestId: string, role: string) {
     id: Type.Optional(
       Type.Literal(requestId, {
         description:
-          "Omit: bound by the submit tool. If supplied, must match this request.",
+          "Omit: bound by the parent result adapter. If supplied, must match this request.",
       }),
     ),
     role: Type.Optional(Type.Literal(role)),

package/src/index.ts

@@ -59,7 +59,7 @@ import { canonicalJson } from "./implement-graph.ts";
 import { PACKET_ACTIONS, PacketRuntime } from "./packet-runtime.ts";
 
 import { RunStoreFormatError, RunStoreMigrationError } from "./run-store.ts";
-import { STARTUP_CARD_KEY, startupCardLines } from "./startup-card.ts";
+import { startupCardLines } from "./startup-card.ts";
 import { StateRootError } from "./state-root.ts";
 import {
   ACTIVITY_DETAILS_KEY,
@@ -1792,23 +1792,19 @@ export function registerWorkflowControl(
 }
 
 export default function register(pi: ExtensionAPI): void {
+  // Process children are deliberately started without extensions as a second
+  // defense. Keep this guard for hosts that inject the extension explicitly.
+  if (process.env.CADENCE_SUBAGENT_CHILD === "1") return;
   registerWorkflowControl(pi);
-  // Presentation only: never persist a dismissal or inject a model message.
+  // Presentation only: use the host's subdued one-shot notification rather
+  // than a persistent widget; never persist a dismissal or inject a model message.
   pi.on("session_start", (_event, ctx) => {
     if (!ctx.hasUI) return;
-    ctx.ui.setWidget(
-      STARTUP_CARD_KEY,
-      startupCardLines({
-        cwd: ctx.cwd,
-        home: homedir(),
-        projectTrusted: ctx.isProjectTrusted(),
-      }),
-    );
-  });
-  pi.on("agent_start", (_event, ctx) => {
-    if (ctx.hasUI) ctx.ui.setWidget(STARTUP_CARD_KEY, undefined);
-  });
-  pi.on("session_shutdown", (_event, ctx) => {
-    if (ctx.hasUI) ctx.ui.setWidget(STARTUP_CARD_KEY, undefined);
+    const lines = startupCardLines({
+      cwd: ctx.cwd,
+      home: homedir(),
+      projectTrusted: ctx.isProjectTrusted(),
+    });
+    ctx.ui.notify(lines.at(-1) ?? "Cadence研究配置已加载。", "info");
   });
 }

package/src/package-candidate-process.ts

@@ -0,0 +1,206 @@
+import { execFileSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { VerificationFailureSummary } from "./contracts.ts";
+import { isValidRelativePath } from "./contracts.ts";
+import type { DurableWorkflowEngineOptions } from "./durable-contracts.ts";
+import type { ParentModelSource } from "./model-source.ts";
+import { isSafeRegularFile } from "./safe-path.ts";
+import {
+  buildSubagentPrompt,
+  runSubagentProcess,
+  SUBAGENT_LIMITS,
+} from "./subagent-process.ts";
+import type { DurableCandidateProposal } from "./workflow-policy.ts";
+
+function permitsContextRead(
+  relative: string,
+  roots: readonly string[],
+): boolean {
+  return (
+    isValidRelativePath(relative) &&
+    relative.split("/").every((part) => !part.startsWith(".")) &&
+    !/\.(?:pem|key|p12|pfx)$/iu.test(relative) &&
+    roots.some((root) => relative === root || relative.startsWith(`${root}/`))
+  );
+}
+
+function restoreWorkspace(root: string, baseline: string): void {
+  rmSync(root, { recursive: true, force: true });
+  mkdirSync(root, { recursive: true });
+  cpSync(baseline, root, { recursive: true, force: true, dereference: false });
+}
+
+/** Produce a Git patch from two disposable trees without invoking a shell. */
+function workspaceDiff(baseline: string, proposal: string): Uint8Array {
+  const parent = path.dirname(baseline);
+  const proposalSnapshot = mkdtempSync(
+    path.join(parent, "cadence-subagent-proposal-"),
+  );
+  cpSync(proposal, proposalSnapshot, {
+    recursive: true,
+    force: true,
+    dereference: false,
+  });
+  try {
+    const baseName = path.basename(baseline);
+    const proposalName = path.basename(proposalSnapshot);
+    try {
+      execFileSync(
+        "git",
+        [
+          "-c",
+          "core.autocrlf=false",
+          "-c",
+          "core.eol=lf",
+          "diff",
+          "--no-index",
+          "--binary",
+          "--no-color",
+          "--",
+          baseName,
+          proposalName,
+        ],
+        {
+          cwd: parent,
+          encoding: "buffer",
+          maxBuffer: 8 * 1024 * 1024,
+          stdio: ["ignore", "pipe", "ignore"],
+        },
+      );
+      return Buffer.alloc(0);
+    } catch (error) {
+      if (!error || typeof error !== "object") return Buffer.alloc(0);
+      const output = (error as { stdout?: Buffer }).stdout;
+      if (!output) return Buffer.alloc(0);
+      const pathPrefixes = [
+        `a/${baseName}/`,
+        `a/${proposalName}/`,
+        `b/${baseName}/`,
+        `b/${proposalName}/`,
+      ];
+      const normalizeHeader = (line: string): string => {
+        let normalized = line;
+        for (const prefix of pathPrefixes) {
+          const replacement = prefix.startsWith("a/") ? "a/" : "b/";
+          normalized = normalized.replaceAll(prefix, replacement);
+        }
+        return normalized;
+      };
+      const normalized = output
+        .toString("utf8")
+        .split("\n")
+        .map((line) =>
+          line.startsWith("diff --git ") ||
+          line.startsWith("--- ") ||
+          line.startsWith("+++ ")
+            ? normalizeHeader(line)
+            : line,
+        )
+        .join("\n");
+      return Buffer.from(normalized, "utf8");
+    }
+  } finally {
+    rmSync(proposalSnapshot, { recursive: true, force: true });
+  }
+}
+
+export async function proposeProcessPackageCandidate(
+  input: Parameters<DurableWorkflowEngineOptions["proposeCandidate"]>[0],
+  context: ParentModelSource | undefined,
+  implementationAgent: { content: string },
+  verificationDiagnostics: VerificationFailureSummary[] = [],
+): Promise<DurableCandidateProposal> {
+  if (!context) return { kind: "paused", code: "parent-context-unavailable" };
+  if (input.signal.aborted)
+    return { kind: "operation-cancelled", code: "cancelled" };
+  const phase = input.task.phases[input.phase];
+  if (!phase) return { kind: "paused", code: "task-phase-unavailable" };
+  const taskPhases = Object.values(input.task.phases);
+  const read = [
+    ...new Set(
+      taskPhases.flatMap((boundary) => [
+        ...boundary.read,
+        ...boundary.write,
+        ...boundary.delete,
+      ]),
+    ),
+  ].sort();
+  const write = input.artifactCorrection
+    ? [...new Set(taskPhases.flatMap((boundary) => boundary.write))].sort()
+    : [...phase.write];
+  const deletePaths = input.artifactCorrection
+    ? [...new Set(taskPhases.flatMap((boundary) => boundary.delete))].sort()
+    : [...phase.delete];
+  const allowedContext = (input.contextReadPaths ?? []).filter(
+    (relative) =>
+      permitsContextRead(relative, input.task.roots) &&
+      isSafeRegularFile(input.workspaceRoot, relative),
+  );
+  const allowedPaths = [...new Set([...read, ...allowedContext])].sort();
+  const baseline = mkdtempSync(
+    path.join(os.tmpdir(), "cadence-subagent-baseline-"),
+  );
+  try {
+    cpSync(input.workspaceRoot, baseline, {
+      recursive: true,
+      force: true,
+      dereference: false,
+    });
+    const prompt = buildSubagentPrompt({
+      role: "implementation-worker",
+      agentContent: implementationAgent.content,
+      objective: input.task.objective,
+      context: [
+        input.task.context.agents,
+        input.task.context.contract,
+        JSON.stringify({
+          taskId: input.taskId,
+          phase: input.phase,
+          readSet: allowedPaths,
+          writeSet: write,
+          deleteSet: deletePaths,
+          verificationDiagnostics,
+          recoveryFeedback: input.recoveryFeedback,
+        }),
+      ].join("\n\n"),
+      finalConvention:
+        "Edit the disposable workspace directly. Finish with a plain-text summary; the parent will derive and validate the candidate diff.",
+    });
+    const child = await runSubagentProcess({
+      role: "implementation-worker",
+      cwd: input.workspaceRoot,
+      prompt,
+      model: context.model
+        ? { provider: context.model.provider, id: context.model.id }
+        : undefined,
+      signal: input.signal,
+      timeoutMs: SUBAGENT_LIMITS.timeoutMs,
+      onEvent: (event) => {
+        if (event.type === "agent_start") input.onRequestStart?.();
+        if (event.type === "tool_execution_start") input.onProgress?.();
+      },
+    });
+    if (child.status === "cancelled")
+      return { kind: "operation-cancelled", code: "cancelled" };
+    if (child.status === "timed-out")
+      return { kind: "paused", code: "child-timeout" };
+    if (child.status === "output-limit")
+      return { kind: "retryable", code: "needs-task-split" };
+    if (child.status !== "completed")
+      return { kind: "retryable", code: "transport-failure" };
+    const bytes = workspaceDiff(baseline, input.workspaceRoot);
+    // Existing parent code applies the candidate patch to this root. Restore the
+    // baseline first so child edits cannot be applied twice.
+    restoreWorkspace(input.workspaceRoot, baseline);
+    if (bytes.length === 0)
+      return { kind: "retryable", code: "candidate-diff-invalid" };
+    return { kind: "candidate", bytes };
+  } finally {
+    // A child is never allowed to leave edits in the proposal root: the
+    // parent-side apply/verification path consumes the generated bytes.
+    if (existsSync(baseline)) restoreWorkspace(input.workspaceRoot, baseline);
+    rmSync(baseline, { recursive: true, force: true });
+  }
+}