@abelxiaoxing/cadence 1.4.0 → 1.5.0

package/src/single-task-draft.ts

@@ -0,0 +1,142 @@
+import { DesignPlanValidationError } from "./design-diagnostics.ts";
+import type {
+  DraftVerification,
+  PlanDraft,
+  PlanTaskInput,
+} from "./plan-draft.ts";
+
+/** Small author input. Evidence, scope and the complete suite remain explicit. */
+export interface SingleTaskDraft {
+  changeId: string;
+  changeContract?: PlanDraft["changeContract"];
+  singleTask: {
+    taskId: string;
+    objective: string;
+    context: PlanTaskInput["context"];
+    roots: string[];
+    read: string[];
+    greenWrite: string[];
+    redWrite?: string[];
+    expectedFailure?: string;
+    verificationMode?: "behavior" | "mechanical" | "refactor";
+    verification: DraftVerification;
+    fullSuite: DraftVerification;
+    impactClosure: PlanTaskInput["impactClosure"];
+    agents: PlanTaskInput["agents"];
+    recovery?: { artifactAttempts: number; repairAttempts: number };
+  };
+}
+
+function invalid(code: string, field = "singleTask"): never {
+  throw new DesignPlanValidationError(code, [{ code, field }]);
+}
+
+function record(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/** Mechanical expansion only; the ordinary compiler validates all resulting fields. */
+export function expandSingleTaskDraft(value: unknown): unknown {
+  if (!record(value) || !Object.hasOwn(value, "singleTask")) return value;
+  if (
+    Object.keys(value).some(
+      (key) => !["changeId", "changeContract", "singleTask"].includes(key),
+    ) ||
+    !record(value.singleTask)
+  )
+    invalid("single-task-draft-invalid");
+  const input = value.singleTask;
+  const required = [
+    "taskId",
+    "objective",
+    "context",
+    "roots",
+    "read",
+    "greenWrite",
+    "verification",
+    "fullSuite",
+    "impactClosure",
+    "agents",
+  ];
+  const optional = [
+    "redWrite",
+    "expectedFailure",
+    "verificationMode",
+    "recovery",
+  ];
+  if (
+    required.some((key) => !Object.hasOwn(input, key)) ||
+    Object.keys(input).some((key) => ![...required, ...optional].includes(key))
+  )
+    invalid("single-task-draft-invalid");
+  const task = structuredClone(
+    input,
+  ) as unknown as SingleTaskDraft["singleTask"];
+  const mode = task.verificationMode ?? "behavior";
+  if (mode === "behavior" && (!task.redWrite?.length || !task.expectedFailure))
+    invalid("single-task-red-required");
+  if (
+    mode !== "behavior" &&
+    (task.redWrite !== undefined || task.expectedFailure !== undefined)
+  )
+    invalid("single-task-red-unexpected");
+  if (
+    Object.hasOwn(input, "recovery") &&
+    (!record(task.recovery) ||
+      !Object.hasOwn(task.recovery, "artifactAttempts") ||
+      !Object.hasOwn(task.recovery, "repairAttempts") ||
+      Object.keys(task.recovery).some(
+        (key) => !["artifactAttempts", "repairAttempts"].includes(key),
+      ))
+  )
+    invalid("single-task-recovery-invalid");
+  return {
+    changeId: value.changeId,
+    ...(value.changeContract === undefined
+      ? {}
+      : { changeContract: value.changeContract }),
+    tasks: [
+      {
+        taskId: task.taskId,
+        objective: task.objective,
+        context: task.context,
+        roots: task.roots,
+        read: task.read,
+        dependsOn: [],
+        verificationMode: mode,
+        phases: {
+          ...(mode === "behavior"
+            ? {
+                red: {
+                  write: task.redWrite,
+                  delete: [],
+                  verification: {
+                    ...task.verification,
+                    expectedFailure: task.expectedFailure,
+                  },
+                },
+              }
+            : {}),
+          green: {
+            write: task.greenWrite,
+            delete: [],
+            verification: task.verification,
+          },
+        },
+        affectedVerification: task.fullSuite,
+        repairVerification: task.fullSuite,
+        scheduling: { conflicts: [], resources: [] },
+        agents: task.agents,
+        approvedDependencies: [],
+        impactClosure: task.impactClosure,
+      },
+    ],
+    outputs: [],
+    verification: {
+      baseline: { fullSuite: task.fullSuite },
+      change: { fullSuite: task.fullSuite, postApply: task.fullSuite },
+      artifactCorrection: { maxAttempts: task.recovery?.artifactAttempts ?? 2 },
+      repair: { maxAttempts: task.recovery?.repairAttempts ?? 1 },
+    },
+  };
+}

package/src/subagent-activity.ts

@@ -12,8 +12,11 @@ import {
 import type {
   PacketActivityEvent,
   PacketActivityObserver,
-  PacketActivityState,
-} from "./packet-runtime.ts";
+} from "./activity-contracts.ts";
+import {
+  projectDesignDiagnostic,
+  type SafeDesignDiagnostic,
+} from "./design-diagnostics.ts";
 
 export const ACTIVITY_DETAILS_KEY = "activityDisplay" as const;
 export const ACTIVITY_WIDGET_KEY = "abel-subagents" as const;
@@ -22,51 +25,20 @@ export const ACTIVITY_REFRESH_MS = 100;
 export const ACTIVITY_WIDGET_MAX_LINES = 12;
 export const ACTIVITY_WIDGET_MIN_WIDTH = 3;
 
-export const WORKFLOW_ACTIVITY_STATES = [
-  "queued",
-  "connecting",
-  "waiting-first-response",
-  "running",
-  "validating",
-  "retrying",
-  "verifying",
-  "paused",
-  "approval-needed",
-  "applying",
-  "recovering",
-  "operation-cancelled",
-  "discarded",
-  "rejected",
-  "completed",
-] as const;
-
-export type WorkflowActivityState = (typeof WORKFLOW_ACTIVITY_STATES)[number];
-export type ActivityState = PacketActivityState | WorkflowActivityState;
-export type TerminalActivityState =
-  | Exclude<
-      PacketActivityState,
-      | "queued"
-      | "connecting"
-      | "waiting-first-response"
-      | "running"
-      | "retrying"
-    >
-  | WorkflowActivityState;
-
-export interface WorkflowActivityUpdate {
-  state: WorkflowActivityState;
-  stage?: "abel-design" | "abel-implement";
-  runId?: string;
-  change?: string;
-  taskId?: string;
-  phase?: string;
-  objective?: string;
-  code?: string;
-  attempt?: number;
-  maxAttempts?: number;
-  wait?: string;
-  legalCommands?: string[];
-}
+export type {
+  ActivityState,
+  TerminalActivityState,
+  WorkflowActivityState,
+  WorkflowActivityUpdate,
+} from "./activity-contracts.ts";
+export { WORKFLOW_ACTIVITY_STATES } from "./activity-contracts.ts";
+
+import type {
+  ActivityState,
+  TerminalActivityState,
+  WorkflowActivityState,
+  WorkflowActivityUpdate,
+} from "./activity-contracts.ts";
 
 export interface EvidenceActivitySummary {
   kind: "evidence";
@@ -224,7 +196,7 @@ export function sanitizeFailureReason(value: unknown, maxLength = 240): string {
 function safeDesignFailure(value: unknown): {
   operation: string;
   code: string;
-  diagnostics: Array<Record<string, string>>;
+  diagnostics: SafeDesignDiagnostic[];
 } | null {
   const failure = asRecord(value);
   if (
@@ -237,23 +209,9 @@ function safeDesignFailure(value: unknown): {
   ) {
     return null;
   }
-  const diagnostics = failure.diagnostics.flatMap((candidate) => {
-    const record = asRecord(candidate);
-    if (
-      !record ||
-      typeof record.code !== "string" ||
-      !SAFE_DESIGN_DETAIL_VALUE.test(record.code)
-    ) {
-      return [];
-    }
-    return [
-      Object.fromEntries(
-        Object.entries(record).filter(
-          ([, entry]) =>
-            typeof entry === "string" && SAFE_DESIGN_DETAIL_VALUE.test(entry),
-        ),
-      ) as Record<string, string>,
-    ];
+  const diagnostics = failure.diagnostics.slice(0, 64).flatMap((candidate) => {
+    const diagnostic = projectDesignDiagnostic(candidate);
+    return diagnostic ? [diagnostic] : [];
   });
   return {
     operation: failure.operation,
@@ -286,7 +244,10 @@ function renderDesignFailure(
   const lines = failure.diagnostics.map((diagnostic) => {
     const details = Object.entries(diagnostic)
       .filter(([key]) => key !== "code")
-      .map(([key, value]) => `${key}=${value}`)
+      .map(
+        ([key, value]) =>
+          `${key}=${Array.isArray(value) ? JSON.stringify(value) : value}`,
+      )
       .join(" · ");
     return `  - ${diagnostic.code}${details ? ` · ${details}` : ""}`;
   });
@@ -315,6 +276,7 @@ function stateGlyph(state: ActivityState, spinnerFrame = 0): string {
   switch (state) {
     case "queued":
       return "…";
+    case "preparing":
     case "connecting":
     case "waiting-first-response":
     case "running":
@@ -563,6 +525,8 @@ function workflowStateOf(
     case "ready":
     case "queued":
       return "queued";
+    case "preparing":
+      return "preparing";
     case "connecting":
       return "connecting";
     case "waiting-first-response":
@@ -681,6 +645,7 @@ function workflowWait(
   ) {
     return approval.gate;
   }
+  if (state === "preparing") return "worker-setup";
   if (state === "connecting") return "connection";
   if (state === "waiting-first-response") return "first-response";
   if (state === "retrying") return "bounded-policy";
@@ -867,6 +832,7 @@ function terminalState(
 } {
   return ![
     "queued",
+    "preparing",
     "connecting",
     "waiting-first-response",
     "running",

package/src/submit-tool.ts

@@ -17,65 +17,16 @@ import {
   validateDiffResult,
   validateEvidenceResult,
 } from "./contracts.ts";
+import {
+  completeEvidenceDraft,
+  evidenceDraftSchema,
+} from "./evidence-draft.ts";
 import {
   type BeginCandidateInput,
   TASK_LEDGER_LIMITS,
   type TaskLedger,
 } from "./task-ledger.ts";
 
-const compactEvidenceSchema = Type.Object({
-  id: Type.String(),
-  role: Type.String(),
-  kind: Type.Literal("evidence"),
-  conclusions: Type.Array(Type.String()),
-  citations: Type.Array(
-    Type.Object({ path: Type.String(), lines: Type.String() }),
-  ),
-  constraints: Type.Array(Type.String()),
-  dependencies: Type.Array(Type.String()),
-  risks: Type.Array(Type.String()),
-  blockingQuestions: Type.Array(Type.String()),
-  hints: Type.Object({
-    writeSet: Type.Array(Type.String()),
-    verification: Type.String(),
-    agentsImpact: Type.String(),
-  }),
-});
-
-const designEvidenceSchema = Type.Object(
-  {
-    id: Type.String(),
-    role: Type.Literal("design-explorer"),
-    kind: Type.Literal("evidence"),
-    packet_id: Type.String(),
-    module_name: Type.String(),
-    scope: Type.Array(Type.String()),
-    files_read: Type.Array(Type.String()),
-    evidence: Type.Array(
-      Type.Object(
-        {
-          claim: Type.String(),
-          path: Type.String(),
-          line_start: Type.Integer({ minimum: 1 }),
-          line_end: Type.Integer({ minimum: 1 }),
-        },
-        { additionalProperties: false },
-      ),
-    ),
-    existing_structures: Type.Array(Type.String()),
-    existing_conventions: Type.Array(Type.String()),
-    constraints_discovered: Type.Array(Type.String()),
-    open_questions: Type.Array(Type.String()),
-    dependencies: Type.Array(Type.String()),
-    write_set_hints: Type.Array(Type.String()),
-    validation_hints: Type.Array(Type.String()),
-    agents_impact_hints: Type.Array(Type.String()),
-    risks: Type.Array(Type.String()),
-    success_criteria_hints: Type.Array(Type.String()),
-  },
-  { additionalProperties: false },
-);
-
 const diffSchema = Type.Object({
   id: Type.String(),
   role: Type.String(),
@@ -881,13 +832,11 @@ export function createSubmitTool(input: {
     name: "abel_submit_result",
     label: "Submit Abel Result",
     description:
-      "Submit the one final structured Abel evidence or complete unified-diff result.",
+      "Submit one accepted final result. Evidence identity and omitted advisory fields are completed by this tool; keep citations, constraints, risks, and open questions explicit. After a rejection, correct once in this same session. Brief accompanying text is harmless.",
     executionMode: "sequential",
     parameters:
       input.output === "evidence"
-        ? input.role === "design-explorer"
-          ? designEvidenceSchema
-          : compactEvidenceSchema
+        ? evidenceDraftSchema(input.requestId, input.role)
         : diffSchema,
     async execute(_toolCallId, params) {
       attempts++;
@@ -916,7 +865,11 @@ export function createSubmitTool(input: {
         phase: true,
       };
       failure = undefined;
-      const value = params as unknown as Record<string, unknown>;
+      const value = (
+        input.output === "evidence"
+          ? completeEvidenceDraft(params, input.requestId, input.role)
+          : params
+      ) as Record<string, unknown>;
       if (value === null || typeof value !== "object") {
         identity.request = false;
         identity.role = false;
@@ -963,7 +916,15 @@ export function createSubmitTool(input: {
               stage: "structural-submit",
             });
         throw new Error(
-          validation.reason ?? "submitted result identity does not match",
+          JSON.stringify({
+            code: "code" in failure ? failure.code : failure.kind,
+            reason:
+              validation.reason ?? "submitted result identity does not match",
+            identityMismatch: Object.entries(identity)
+              .filter(([, matches]) => !matches)
+              .map(([field]) => field),
+            remainingCorrections: Math.max(0, 2 - attempts),
+          }),
         );
       }
       submitted = structuredClone(value) as unknown as

package/src/transport-budget.ts

@@ -0,0 +1,52 @@
+/** Request budgets describe observable model progress, never TCP/TLS events. */
+export const REQUEST_BOUNDS = Object.freeze({
+  firstProgressMs: 90_000,
+  streamIdleMs: 180_000,
+  cancellationDrainMs: 250,
+});
+export type TransportTimeoutCode =
+  | "first-progress-timeout"
+  | "stream-idle-timeout"
+  | "attempt-timeout";
+export class TransportTimeout extends Error {
+  readonly scope: "request" | "attempt";
+  constructor(readonly code: TransportTimeoutCode) {
+    super(code);
+    this.name = "TransportTimeout";
+    this.scope = code === "attempt-timeout" ? "attempt" : "request";
+  }
+}
+export function isTransportTimeoutCode(
+  code: string,
+): code is TransportTimeoutCode {
+  return [
+    "first-progress-timeout",
+    "stream-idle-timeout",
+    "attempt-timeout",
+  ].includes(code);
+}
+export function transportFailureError(code: string): Error {
+  return isTransportTimeoutCode(code)
+    ? new TransportTimeout(code)
+    : new Error(
+        code === "child-provider-rate-limited" ? code : "transport-failure",
+      );
+}
+
+/** Snapshot at the start of each request; Workers cannot override these values. */
+export function requestBounds(env: NodeJS.ProcessEnv = process.env) {
+  const read = (name: string, fallback: number) => {
+    const value = Number(env[name] ?? fallback);
+    if (!Number.isSafeInteger(value) || value < 1 || value > 1_200_000)
+      throw new Error("request-budget-invalid");
+    return value;
+  };
+  return {
+    ...REQUEST_BOUNDS,
+    firstProgressMs: read(
+      "ABEL_FIRST_PROGRESS_MS",
+      REQUEST_BOUNDS.firstProgressMs,
+    ),
+    streamIdleMs: read("ABEL_STREAM_IDLE_MS", REQUEST_BOUNDS.streamIdleMs),
+  };
+}

package/src/verification-capability.ts

@@ -16,6 +16,7 @@ import {
   verificationInputPaths,
   verificationSteps,
 } from "./contracts.ts";
+import { executionProfile } from "./execution-profile.ts";
 import {
   type Bound,
   isCurrent,
@@ -828,9 +829,10 @@ function validateAtomicCapability(
       continue;
     if (
       lstatSync(path.join(root, relative)).size > 64 * 1024 ||
-      unsupportedExecutionConfiguration(
-        readFileSync(path.join(root, relative), "utf8"),
-      )
+      (executionProfile().mode !== "local-trusted" &&
+        unsupportedExecutionConfiguration(
+          readFileSync(path.join(root, relative), "utf8"),
+        ))
     ) {
       return adapterFailure(
         step.id,

package/src/verification-diagnostics.ts

@@ -0,0 +1,76 @@
+import type {
+  VerificationFailureSummary,
+  VerificationObservation,
+} from "./contracts.ts";
+
+/** Diagnostic text is evidence for repair, never a failure identity or authority. */
+
+export function diagnosticText(value: string, maximum = 4096): string {
+  const clean = value
+    .replace(
+      new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[A-Za-z]`, "gu"),
+      "",
+    )
+    .replace(/(Bearer\s+)\S+/giu, "$1[redacted]")
+    .replace(
+      /((?:api[_-]?key|token|password|secret)\s*[:=]\s*)[^\s,;]+/giu,
+      "$1[redacted]",
+    )
+    .replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/giu, "$1[redacted]@");
+  return clean.length <= maximum
+    ? clean
+    : `${clean.slice(0, Math.floor(maximum / 2))}\n…[truncated]…\n${clean.slice(-Math.floor(maximum / 2))}`;
+}
+
+/** Bounded operation-local feedback; no raw transcripts or global cross-run cache. */
+export class VerificationFeedback {
+  readonly #entries = new Map<string, VerificationFailureSummary>();
+  observe(result: VerificationObservation): void {
+    if (result.kind === "cancelled") return;
+    const id =
+      result.kind === "unavailable"
+        ? result.verificationId
+        : result.evidence.id;
+    this.#entries.delete(id);
+    if (result.kind === "accepted") return;
+    const summary = result.diagnostic ?? {
+      verificationId: id,
+      code: result.code,
+      failures: [],
+      stdout: "",
+      stderr: "",
+      truncated: false,
+      nextStep:
+        "Repair the verification environment or adapter before changing product code.",
+    };
+    this.#entries.set(id, structuredClone(summary));
+    const oldest = this.#entries.keys().next().value;
+    if (this.#entries.size > 32 && oldest !== undefined)
+      this.#entries.delete(oldest);
+  }
+  current(): VerificationFailureSummary[] {
+    const result: VerificationFailureSummary[] = [];
+    let bytes = 0;
+    for (const entry of [...this.#entries.values()].reverse()) {
+      const summary = {
+        ...entry,
+        failures: entry.failures
+          .slice(0, 4)
+          .map((text) => diagnosticText(text, 256)),
+        stdout: diagnosticText(entry.stdout, 512),
+        stderr: diagnosticText(entry.stderr, 1024),
+        truncated:
+          entry.truncated ||
+          entry.failures.length > 4 ||
+          entry.failures.some((text) => text.length > 256) ||
+          entry.stdout.length > 512 ||
+          entry.stderr.length > 1024,
+      };
+      const size = Buffer.byteLength(JSON.stringify(summary), "utf8");
+      if (bytes + size > 6000) break;
+      result.push(summary);
+      bytes += size;
+    }
+    return structuredClone(result.reverse());
+  }
+}