@abelxiaoxing/cadence 1.3.0 → 1.4.1

package/src/isolation-backend.ts

@@ -15,6 +15,7 @@ export interface IsolationRunInput {
   mounts?: IsolationMount[];
   environment?: Record<string, string>;
   signal?: AbortSignal;
+  outputWitness?: string;
 }
 
 export type IsolationRunResult =
@@ -24,6 +25,11 @@ export type IsolationRunResult =
       exitCode: number;
       stdout: string;
       stderr: string;
+      outputWitnessMatched?: boolean;
+      logs: {
+        stdout: { bytes: number; truncated: boolean };
+        stderr: { bytes: number; truncated: boolean };
+      };
     }
   | {
       ok: false;
@@ -31,14 +37,13 @@ export type IsolationRunResult =
       code:
         | "isolation-backend-unavailable"
         | "isolation-backend-launch-failed"
-        | "isolation-execution-timeout"
-        | "isolation-output-limit-exceeded";
+        | "isolation-execution-timeout";
     }
   | { ok: false; state: "cancelled"; code: "cancelled" };
 
 export const ISOLATION_RUN_LIMITS = Object.freeze({
   timeoutMs: 10 * 60_000,
-  maxOutputBytes: 1024 * 1024,
+  maxOutputBytes: 256 * 1024,
   terminateGraceMs: 1_000,
 });
 
@@ -64,6 +69,59 @@ function validEnvironmentName(name: string): boolean {
   return /^[A-Za-z_][A-Za-z0-9_]*$/u.test(name);
 }
 
+/** Retains independent head/tail copies; discarded chunks never stay referenced. */
+class BoundedLog {
+  bytes = 0;
+  #head = Buffer.alloc(0);
+  #tail = Buffer.alloc(0);
+  readonly limit: number;
+  readonly #witness?: Buffer;
+  #witnessTail = Buffer.alloc(0);
+  witnessMatched = false;
+  constructor(limit: number, witness?: string) {
+    this.limit = limit;
+    if (witness) this.#witness = Buffer.from(witness);
+  }
+  append(chunk: Buffer | string): void {
+    const input = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    this.bytes += input.byteLength;
+    if (this.#witness && !this.witnessMatched) {
+      const searchable = Buffer.concat([this.#witnessTail, input]);
+      this.witnessMatched = searchable.includes(this.#witness);
+      this.#witnessTail = this.witnessMatched
+        ? Buffer.alloc(0)
+        : Buffer.from(
+            searchable.subarray(
+              Math.max(0, searchable.length - this.#witness.length + 1),
+            ),
+          );
+    }
+    const headLimit = Math.ceil(this.limit / 2);
+    const take = Math.min(input.length, headLimit - this.#head.length);
+    if (take > 0)
+      this.#head = Buffer.concat([this.#head, input.subarray(0, take)]);
+    const rest = input.subarray(take);
+    const tailLimit = this.limit - headLimit;
+    if (rest.length && tailLimit) {
+      this.#tail =
+        rest.length >= tailLimit
+          ? Buffer.from(rest.subarray(-tailLimit))
+          : Buffer.concat([
+              this.#tail.subarray(
+                Math.max(0, this.#tail.length + rest.length - tailLimit),
+              ),
+              rest,
+            ]);
+    }
+  }
+  text(): string {
+    return Buffer.concat([this.#head, this.#tail]).toString("utf8");
+  }
+  metadata() {
+    return { bytes: this.bytes, truncated: this.bytes > this.limit };
+  }
+}
+
 /** Linux isolation capability. Lack of Bubblewrap is a pause, never a fallback. */
 export class BubblewrapIsolationBackend {
   readonly #bwrapPath: string;
@@ -103,6 +161,13 @@ export class BubblewrapIsolationBackend {
   }
 
   async run(input: IsolationRunInput): Promise<IsolationRunResult> {
+    if (
+      input.outputWitness !== undefined &&
+      (typeof input.outputWitness !== "string" ||
+        input.outputWitness.length < 1 ||
+        input.outputWitness.length > 512)
+    )
+      throw new Error("isolation-output-witness-invalid");
     if (!(await this.available())) {
       return {
         ok: false,
@@ -165,9 +230,8 @@ export class BubblewrapIsolationBackend {
 
     return new Promise((resolve) => {
       let settled = false;
-      const stdout: Buffer[] = [];
-      const stderr: Buffer[] = [];
-      let capturedBytes = 0;
+      const stdout = new BoundedLog(this.#maxOutputBytes, input.outputWitness);
+      const stderr = new BoundedLog(this.#maxOutputBytes, input.outputWitness);
       let child: ReturnType<typeof spawn>;
       let executionTimer: ReturnType<typeof setTimeout> | undefined;
       let killTimer: ReturnType<typeof setTimeout> | undefined;
@@ -207,21 +271,11 @@ export class BubblewrapIsolationBackend {
         });
         return;
       }
-      const capture = (destination: Buffer[], chunk: Buffer | string): void => {
-        if (settled || terminationResult) return;
-        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        const remaining = this.#maxOutputBytes - capturedBytes;
-        if (remaining > 0) destination.push(bytes.subarray(0, remaining));
-        if (bytes.byteLength > remaining) {
-          capturedBytes = this.#maxOutputBytes;
-          terminate({
-            ok: false,
-            state: "paused",
-            code: "isolation-output-limit-exceeded",
-          });
-          return;
-        }
-        capturedBytes += bytes.byteLength;
+      const capture = (
+        destination: BoundedLog,
+        chunk: Buffer | string,
+      ): void => {
+        if (!settled && !terminationResult) destination.append(chunk);
       };
       child.stdout?.on("data", (chunk: Buffer | string) => {
         capture(stdout, chunk);
@@ -244,8 +298,15 @@ export class BubblewrapIsolationBackend {
             ok: true,
             state: "completed",
             exitCode: code ?? 1,
-            stdout: Buffer.concat(stdout).toString("utf8"),
-            stderr: Buffer.concat(stderr).toString("utf8"),
+            stdout: stdout.text(),
+            stderr: stderr.text(),
+            logs: { stdout: stdout.metadata(), stderr: stderr.metadata() },
+            ...(input.outputWitness
+              ? {
+                  outputWitnessMatched:
+                    stdout.witnessMatched || stderr.witnessMatched,
+                }
+              : {}),
           },
         );
       });

package/src/model-source.ts

@@ -0,0 +1,22 @@
+import type { Model, Provider } from "@earendil-works/pi-ai";
+
+/** Code-owned capability boundary. No session events, tools, UI or host context. */
+export interface ParentModelSource {
+  readonly model?: Model<string>;
+  readonly modelRegistry: {
+    getProvider(id: string): Provider | undefined;
+    getApiKeyAndHeaders(model: Model<string>): Promise<
+      | {
+          ok: true;
+          apiKey?: string;
+          headers?: Record<string, string | null>;
+          baseUrl?: string;
+          env?: Record<string, string>;
+        }
+      | { ok: false }
+    >;
+  };
+}
+export interface PackageContext extends ParentModelSource {
+  readonly cwd: string;
+}

package/src/package-candidate.ts

@@ -0,0 +1,224 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { runChildSession } from "./child-session.ts";
+import { LIMITS } from "./contracts.ts";
+import type { DurableWorkflowEngineOptions } from "./durable-contracts.ts";
+import type { ParentModelSource } from "./model-source.ts";
+import { runtimeForWorkerRoute } from "./parent-provider.ts";
+import type { WorkerRoutePolicy } from "./route-policy.ts";
+import { isSafeRegularFile } from "./safe-path.ts";
+import {
+  classifyCandidateContextRequest,
+  permitsContextRead,
+} from "./submit-tool.ts";
+import { transportFailureError } from "./transport-budget.ts";
+import type { DurableCandidateProposal } from "./workflow-policy.ts";
+
+function childRequestId(
+  operationId: string,
+  taskId: string,
+  phase: string,
+): string {
+  return `child-${createHash("sha256").update(`${operationId}\0${taskId}\0${phase}`).digest("hex").slice(0, 40)}`;
+}
+export async function proposePackageCandidate(
+  input: Parameters<DurableWorkflowEngineOptions["proposeCandidate"]>[0],
+  context: ParentModelSource | undefined,
+  implementationAgent: { content: string },
+): Promise<DurableCandidateProposal> {
+  if (!context) {
+    return { kind: "paused", code: "parent-context-unavailable" };
+  }
+  const phaseRuntime = await runtimeForWorkerRoute(
+    input.route as WorkerRoutePolicy,
+    context,
+    input.signal,
+    process.env,
+  );
+  if (!phaseRuntime.ok) {
+    if (phaseRuntime.failure.kind === "cancelled") {
+      return { kind: "operation-cancelled", code: "cancelled" };
+    }
+    throw new Error(phaseRuntime.failure.code);
+  }
+  const phase = input.task.phases[input.phase];
+  if (!phase) {
+    return { kind: "paused", code: "task-phase-unavailable" };
+  }
+  const taskPhases = Object.values(input.task.phases);
+  const executionBoundary = input.artifactCorrection
+    ? {
+        read: [
+          ...new Set(
+            taskPhases.flatMap((boundary) => [
+              ...boundary.read,
+              ...boundary.write,
+              ...boundary.delete,
+            ]),
+          ),
+        ].sort(),
+        write: [
+          ...new Set(taskPhases.flatMap((boundary) => boundary.write)),
+        ].sort(),
+        delete: [
+          ...new Set(taskPhases.flatMap((boundary) => boundary.delete)),
+        ].sort(),
+      }
+    : {
+        read: [
+          ...new Set(
+            taskPhases.flatMap((boundary) => [
+              ...boundary.read,
+              ...boundary.write,
+              ...boundary.delete,
+            ]),
+          ),
+        ].sort(),
+        write: [...phase.write],
+        delete: [...phase.delete],
+      };
+  executionBoundary.read = [
+    ...new Set([
+      ...executionBoundary.read,
+      ...(input.contextReadPaths ?? []).filter(
+        (relative) =>
+          permitsContextRead(relative, input.task.roots) &&
+          isSafeRegularFile(input.workspaceRoot, relative),
+      ),
+    ]),
+  ].sort();
+  const phaseContract = {
+    candidateId: input.candidateArtifact.identity.candidateId,
+    taskId: input.taskId,
+    phase: input.phase,
+    readSet: executionBoundary.read,
+    writeSet: executionBoundary.write,
+    deleteSet: executionBoundary.delete,
+    verification: structuredClone(phase.verification),
+    agentsImpact: input.task.agents.impact,
+    agentsTarget: input.task.agents.target ?? null,
+    agentsManagedOnly: true,
+    agentsWriteAllowed: false,
+    impactClosure: structuredClone(input.task.impactClosure),
+    ...(input.artifactCorrection
+      ? { artifactCorrection: structuredClone(input.artifactCorrection) }
+      : {}),
+    ...(input.contextRequest
+      ? { requestedContext: structuredClone(input.contextRequest) }
+      : {}),
+    ...(input.recoveryFeedback
+      ? { recoveryFeedback: structuredClone(input.recoveryFeedback) }
+      : {}),
+    ...(input.repair
+      ? {
+          repair: {
+            attempt: input.repair.attempt,
+            attribution: input.repair.attribution,
+            failureIdentities: [...input.repair.failureIdentities],
+            verification: structuredClone(input.task.repairVerification),
+            inBoundaryOnly: true,
+          },
+        }
+      : {}),
+  };
+  const child = await runChildSession({
+    cwd: input.workspaceRoot,
+    modelRuntime: phaseRuntime.modelRuntime,
+    model: phaseRuntime.model,
+    systemPrompt: [
+      implementationAgent.content,
+      input.task.objective,
+      input.task.context.agents,
+      input.task.context.contract,
+      "Use recoveryFeedback to change the failing approach. For compact-patch, prefer exact replace operations and omit unchanged bodies; submit one complete atomic patch. Never repeat an unchanged failing submission or weaken verification to obtain a pass.",
+      `<phase-contract>${JSON.stringify(phaseContract)}</phase-contract>`,
+    ].join("\n\n"),
+    requestId: childRequestId(input.operationId, input.taskId, input.phase),
+    taskId: input.taskId,
+    role: "implementation-worker",
+    phase: input.phase,
+    output: "diff",
+    roots: input.task.roots.map((root) =>
+      path.resolve(input.workspaceRoot, root),
+    ),
+    allowedPaths: [
+      ...new Set([
+        ...executionBoundary.read,
+        ...executionBoundary.write,
+        ...executionBoundary.delete,
+      ]),
+    ],
+    timeoutMs: LIMITS.phaseTimeoutMs,
+    signal: input.signal,
+    ledgerProjection: input.ledgerProjection,
+    candidateArtifact: input.candidateArtifact,
+    onStreamStart: input.onRequestStart,
+    onStreamHeaders: input.onHeaders,
+    onStreamProgress: input.onProgress,
+  });
+  if (!child.ok) {
+    if (child.failure.kind === "transport") {
+      throw transportFailureError(child.failure.code);
+    }
+    if (child.failure.kind === "cancelled") {
+      return { kind: "operation-cancelled", code: "cancelled" };
+    }
+    if (child.failure.kind === "approval-boundary") {
+      return { kind: "approval-needed", code: child.failure.code };
+    }
+    if (child.failure.kind === "execution-limit") {
+      return { kind: "paused", code: "needs-task-split" };
+    }
+    if (child.failure.kind === "result-limit") {
+      return { kind: "retryable", code: "needs-task-split" };
+    }
+    const attemptDiagnostic = {
+      finalCategory: child.classification.finalCategory,
+      submitAttempts: child.classification.attempts,
+      schema: child.classification.schema,
+      identityMismatch: Object.entries(child.classification.identity)
+        .filter(([, matches]) => !matches)
+        .map(([dimension]) => dimension),
+    };
+    return child.failure.kind === "environment" ||
+      child.failure.kind === "verification-adapter"
+      ? { kind: "paused", code: child.failure.code, attemptDiagnostic }
+      : { kind: "retryable", code: child.failure.code, attemptDiagnostic };
+  }
+  const result = child.result;
+  if (result.kind === "context-request") {
+    return classifyCandidateContextRequest(result, {
+      phase: input.phase,
+      contextReadRoots: input.task.roots,
+      readPaths: phase.read,
+      writePaths: phase.write,
+      deletePaths: phase.delete,
+      taskPaths: [
+        ...new Set(
+          Object.values(input.task.phases).flatMap((boundary) => [
+            ...boundary.read,
+            ...boundary.write,
+            ...boundary.delete,
+          ]),
+        ),
+      ],
+      redWritePaths: input.task.phases.red.write,
+      agents: {
+        impact: input.task.agents.impact,
+        ...(input.task.agents.target
+          ? { target: input.task.agents.target }
+          : {}),
+      },
+    });
+  }
+  if (result.kind !== "sealed-candidate") {
+    return { kind: "retryable", code: "candidate-diff-invalid" };
+  }
+  return {
+    kind: "sealed-candidate",
+    candidateId: result.candidateId,
+    artifactHash: result.artifactHash,
+    bytes: result.bytes,
+    paths: [...result.paths],
+  };
+}