@abelxiaoxing/cadence 1.2.1 → 1.2.3

package/src/packet-runtime.ts

@@ -97,6 +97,16 @@ export type PacketChildRunner = (input: {
   signal: AbortSignal;
 }) => Promise<ChildSessionResult>;
 
+type PacketRouteResult =
+  | {
+      kind: "phase-failure";
+      phase: Extract<
+        Awaited<ReturnType<typeof runtimeForWorkerRoute>>,
+        { ok: false }
+      >;
+    }
+  | { kind: "child"; child: ChildSessionResult };
+
 interface WaitingPacket {
   controller: AbortController;
   resolve(acquired: boolean): void;
@@ -251,7 +261,7 @@ export class PacketRuntime {
         this.#notify(packet, observer, sequence, "running");
       }
       const usage = new UsageAggregator();
-      const child = await this.#dispatchChild(
+      let child = await this.#dispatchChild(
         packet,
         context,
         controller.signal,
@@ -259,6 +269,28 @@ export class PacketRuntime {
           this.#notifyBrokerActivity(packet, observer, sequence, activity),
       );
       usage.add("launch:0", child.usage);
+      if (
+        this.#childRunner &&
+        !child.ok &&
+        child.failure.kind === "artifact" &&
+        !controller.signal.aborted
+      ) {
+        this.#notifyBrokerActivity(packet, observer, sequence, {
+          state: "retrying",
+          attempt: 1,
+          maxAttempts: 2,
+          code: child.failure.code,
+          wait: "bounded-policy",
+        });
+        child = await this.#dispatchChild(
+          packet,
+          context,
+          controller.signal,
+          (activity) =>
+            this.#notifyBrokerActivity(packet, observer, sequence, activity),
+        );
+        usage.add("launch:1", child.usage);
+      }
       if (!child.ok) {
         const state = failureState(child.failureKind);
         this.#notify(packet, observer, sequence, state);
@@ -319,12 +351,26 @@ export class PacketRuntime {
       throw new Error("packet agent definition is unavailable");
     }
     const broker = this.#brokerFor(context);
-    const routed = await broker.run({
+    const brokerUsage = new UsageAggregator();
+    let childAttempt = 0;
+    const withBrokerUsage = (
+      child: ChildSessionResult,
+    ): ChildSessionResult => ({
+      ...child,
+      usage: brokerUsage.total(),
+    });
+    const routed = await broker.run<PacketRouteResult>({
       runId: `${packet.stage}:${packet.id}`,
       operationId: packet.id,
       role: packet.role as WorkerRole,
       signal,
       ...(onActivity ? { onActivity } : {}),
+      classifyResult: (value) =>
+        value.kind === "child" &&
+        !value.child.ok &&
+        value.child.failure.kind === "artifact"
+          ? value.child.failure.code
+          : undefined,
       execute: async (attempt) => {
         const phase = await runtimeForWorkerRoute(
           attempt.route,
@@ -332,6 +378,7 @@ export class PacketRuntime {
           this.#parentPayloadBridge,
           attempt.signal,
           this.#environment,
+          { onResponse: attempt.onHeaders },
         );
         if (!phase.ok) {
           if (phase.failure.kind === "cancelled") {
@@ -360,6 +407,15 @@ export class PacketRuntime {
           role: packet.role,
           phase: packet.phase,
           output: packet.output as "evidence" | "diff",
+          ...(packet.role === "diagnosis-worker" && packet.output === "diff"
+            ? {
+                structuredPatch: {
+                  workspaceRoot: context.cwd,
+                  writePaths: packet.declared.write,
+                  deletePaths: packet.declared.write,
+                },
+              }
+            : {}),
           roots: packet.roots.map((root) => path.resolve(context.cwd, root)),
           allowedPaths: [
             ...new Set([...packet.declared.read, ...packet.declared.write]),
@@ -367,9 +423,9 @@ export class PacketRuntime {
           timeoutMs: LIMITS.phaseTimeoutMs,
           signal: attempt.signal,
           failureOverride: phase.failureOverride,
-          onStreamStart: attempt.onHeaders,
           onStreamProgress: attempt.onProgress,
         });
+        brokerUsage.add(`attempt:${childAttempt++}`, child.usage);
         if (!child.ok && child.failure.kind === "transport") {
           throw new Error(child.failure.code);
         }
@@ -379,29 +435,31 @@ export class PacketRuntime {
     if (!routed.ok) {
       const cancelled = routed.state === "cancelled" || signal.aborted;
       const timedOut = !cancelled && routed.code === "phase-timeout";
-      return syntheticChildFailure(
-        cancelled ? "packet cancelled" : routed.code,
-        cancelled
-          ? { kind: "cancelled", code: "cancelled" }
-          : timedOut
-            ? {
-                kind: "transport",
-                code: "timeout",
-                stage: "child-timeout",
-              }
-            : {
-                kind: "transport",
-                code: "transport-failure",
-                stage: "child-provider-stream",
-              },
-        cancelled ? "cancelled" : timedOut ? "timed-out" : "failed",
+      return withBrokerUsage(
+        syntheticChildFailure(
+          cancelled ? "packet cancelled" : routed.code,
+          cancelled
+            ? { kind: "cancelled", code: "cancelled" }
+            : timedOut
+              ? {
+                  kind: "transport",
+                  code: "timeout",
+                  stage: "child-timeout",
+                }
+              : {
+                  kind: "transport",
+                  code: "transport-failure",
+                  stage: "child-provider-stream",
+                },
+          cancelled ? "cancelled" : timedOut ? "timed-out" : "failed",
+        ),
       );
     }
     if (routed.value.kind === "phase-failure") {
       const phase = routed.value.phase;
-      return syntheticChildFailure(phase.error, phase.failure);
+      return withBrokerUsage(syntheticChildFailure(phase.error, phase.failure));
     }
-    return routed.value.child;
+    return withBrokerUsage(routed.value.child);
   }
 
   #brokerFor(context: PacketContext): RunWorkerBroker {

package/src/parent-provider.ts

@@ -29,6 +29,10 @@ import {
 
 const SUBAGENT_PROVIDER_ID = "abel-subagent";
 
+export interface PhaseTransportObserver {
+  onResponse?(): void;
+}
+
 function customStreamOptions<T extends StreamOptions>(
   model: Model<string>,
   options?: T,
@@ -49,32 +53,55 @@ function customStreamOptions<T extends StreamOptions>(
   } as T;
 }
 
+function observedStreamOptions<T extends StreamOptions>(
+  options?: T,
+  observer?: PhaseTransportObserver,
+): T | undefined {
+  if (!observer?.onResponse) return options;
+  const childOnResponse = options?.onResponse;
+  return {
+    ...options,
+    onResponse: async (response, requestModel) => {
+      observer.onResponse?.();
+      await childOnResponse?.(response, requestModel);
+    },
+  } as T;
+}
+
 // The compat dispatchers resolve the concrete API implementation from
 // model.api at call time, so one pair serves all supported dialects.
-const SUBAGENT_STREAMS = {
-  stream(
-    model: Parameters<typeof subagentStream>[0],
-    context: Parameters<typeof subagentStream>[1],
-    options?: Parameters<typeof subagentStream>[2],
-  ) {
-    return subagentStream(
-      model,
-      context,
-      customStreamOptions(model as Model<string>, options),
-    );
-  },
-  streamSimple(
-    model: Parameters<typeof subagentStreamSimple>[0],
-    context: Parameters<typeof subagentStreamSimple>[1],
-    options?: Parameters<typeof subagentStreamSimple>[2],
-  ) {
-    return subagentStreamSimple(
-      model,
-      context,
-      customStreamOptions(model as Model<string>, options),
-    );
-  },
-};
+function subagentStreams(observer?: PhaseTransportObserver) {
+  return {
+    stream(
+      model: Parameters<typeof subagentStream>[0],
+      context: Parameters<typeof subagentStream>[1],
+      options?: Parameters<typeof subagentStream>[2],
+    ) {
+      return subagentStream(
+        model,
+        context,
+        observedStreamOptions(
+          customStreamOptions(model as Model<string>, options),
+          observer,
+        ),
+      );
+    },
+    streamSimple(
+      model: Parameters<typeof subagentStreamSimple>[0],
+      context: Parameters<typeof subagentStreamSimple>[1],
+      options?: Parameters<typeof subagentStreamSimple>[2],
+    ) {
+      return subagentStreamSimple(
+        model,
+        context,
+        observedStreamOptions(
+          customStreamOptions(model as Model<string>, options),
+          observer,
+        ),
+      );
+    },
+  };
+}
 
 function customSubagentModel(endpoint: ResolvedCustomRoute): Model<string> {
   return {
@@ -97,6 +124,7 @@ function customSubagentModel(endpoint: ResolvedCustomRoute): Model<string> {
 function customSubagentProvider(
   endpoint: ResolvedCustomRoute,
   model: Model<string>,
+  observer?: PhaseTransportObserver,
 ): Provider {
   return createProvider({
     id: SUBAGENT_PROVIDER_ID,
@@ -118,7 +146,7 @@ function customSubagentProvider(
       },
     },
     models: [model],
-    api: SUBAGENT_STREAMS,
+    api: subagentStreams(observer),
   }) as Provider;
 }
 
@@ -126,11 +154,12 @@ export async function customPhaseRuntime(
   route: CustomRoutePolicy,
   signal?: AbortSignal,
   environment: Readonly<Record<string, string | undefined>> = process.env,
+  observer?: PhaseTransportObserver,
 ): Promise<PhaseRuntimeResult> {
   if (signal?.aborted) return cancelledPhaseRuntime();
   const endpoint = resolveCustomRoute(route, environment);
   const model = customSubagentModel(endpoint);
-  const provider = customSubagentProvider(endpoint, model);
+  const provider = customSubagentProvider(endpoint, model, observer);
   let modelRuntime: ModelRuntime;
   try {
     modelRuntime = await runtimeForProvider(provider, signal);
@@ -236,6 +265,7 @@ export function phaseProvider(
   },
   payloadBridge: PhasePayloadBridge,
   diagnostic?: { failure?: PhaseRuntimeFailure },
+  observer?: PhaseTransportObserver,
 ): Provider {
   return {
     ...parent,
@@ -262,7 +292,7 @@ export function phaseProvider(
         diagnostic,
       );
       return parent.stream(model, context, {
-        ...options,
+        ...observedStreamOptions(options, observer),
         apiKey: auth.apiKey,
         headers: { ...options?.headers, ...auth.headers },
         env: { ...options?.env, ...auth.env },
@@ -278,7 +308,7 @@ export function phaseProvider(
         diagnostic,
       );
       return parent.streamSimple(model, context, {
-        ...options,
+        ...observedStreamOptions(options, observer),
         apiKey: auth.apiKey,
         headers: { ...options?.headers, ...auth.headers },
         env: { ...options?.env, ...auth.env },
@@ -314,6 +344,7 @@ export async function runtimeFromContext(
   ctx: Pick<ExtensionContext, "model" | "modelRegistry">,
   payloadBridge: ParentPayloadBridge,
   signal?: AbortSignal,
+  observer?: PhaseTransportObserver,
 ): Promise<PhaseRuntimeResult> {
   if (signal?.aborted) return cancelledPhaseRuntime();
   if (!ctx.model) {
@@ -398,6 +429,7 @@ export async function runtimeFromContext(
       capture,
     },
     diagnostic,
+    observer,
   );
   let modelRuntime: ModelRuntime;
   try {
@@ -432,10 +464,11 @@ export async function runtimeForWorkerRoute(
   payloadBridge: ParentPayloadBridge,
   signal?: AbortSignal,
   environment: Readonly<Record<string, string | undefined>> = process.env,
+  observer?: PhaseTransportObserver,
 ): Promise<PhaseRuntimeResult> {
   return route.kind === "custom"
-    ? customPhaseRuntime(route, signal, environment)
-    : runtimeFromContext(ctx, payloadBridge, signal);
+    ? customPhaseRuntime(route, signal, environment, observer)
+    : runtimeFromContext(ctx, payloadBridge, signal, observer);
 }
 
 function abortable<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T> {

package/src/route-policy.ts

@@ -4,7 +4,6 @@ import { homedir } from "node:os";
 import path from "node:path";
 import { ROLES } from "./contracts.ts";
 
-export const ROUTE_POLICY_VERSION = 2 as const;
 export const ROUTE_DIALECTS = [
   "openai-completions",
   "openai-responses",
@@ -48,7 +47,6 @@ export interface CustomRoutePolicy extends RouteBase {
 export type WorkerRoutePolicy = InheritedRoutePolicy | CustomRoutePolicy;
 
 export interface RoutePolicy {
-  version: typeof ROUTE_POLICY_VERSION;
   routes: Readonly<Record<string, WorkerRoutePolicy>>;
   roles: Readonly<Record<WorkerRole, readonly string[]>>;
 }
@@ -61,11 +59,11 @@ export type RoutePolicyDiagnosticCode =
   | "policy-unreadable"
   | "policy-invalid-json"
   | "policy-invalid"
+  | "policy-version-unsupported"
   | "route-invalid"
   | "route-duplicate"
   | "role-invalid"
-  | "route-reference-invalid"
-  | "unsupported-policy-version";
+  | "route-reference-invalid";
 
 export interface RoutePolicyDiagnostic {
   code: RoutePolicyDiagnosticCode;
@@ -102,7 +100,6 @@ export type RoutePolicyResolution =
  */
 export function unavailableRoutePolicy(): RoutePolicy {
   return {
-    version: ROUTE_POLICY_VERSION,
     routes: Object.freeze({}),
     roles: Object.freeze(
       Object.fromEntries(
@@ -273,18 +270,21 @@ function parseRoute(
 }
 
 export function parseRoutePolicy(value: unknown): ParsedRoutePolicy {
-  if (
-    !isRecord(value) ||
-    !hasExactKeys(value, ["version", "routes", "roles"])
-  ) {
+  if (!isRecord(value)) {
     return { ok: false, diagnostics: [{ code: "policy-invalid" }] };
   }
-  if (value.version !== ROUTE_POLICY_VERSION) {
+  const legacyVersion = Object.hasOwn(value, "version")
+    ? value.version
+    : undefined;
+  if (legacyVersion !== undefined && legacyVersion !== 2) {
     return {
       ok: false,
-      diagnostics: [{ code: "unsupported-policy-version", field: "version" }],
+      diagnostics: [{ code: "policy-version-unsupported", field: "version" }],
     };
   }
+  if (!hasExactKeys(value, ["routes", "roles"], ["version"])) {
+    return { ok: false, diagnostics: [{ code: "policy-invalid" }] };
+  }
   if (!isRecord(value.routes) || !isRecord(value.roles)) {
     return { ok: false, diagnostics: [{ code: "policy-invalid" }] };
   }
@@ -341,7 +341,6 @@ export function parseRoutePolicy(value: unknown): ParsedRoutePolicy {
   return {
     ok: true,
     policy: {
-      version: ROUTE_POLICY_VERSION,
       routes: Object.freeze(structuredClone(routes)),
       roles: Object.freeze(
         Object.fromEntries(
@@ -355,6 +354,48 @@ export function parseRoutePolicy(value: unknown): ParsedRoutePolicy {
   };
 }
 
+function constrainInheritedRoutes(
+  policy: RoutePolicy,
+  parentModel?: ParentModelCapabilities,
+): RoutePolicy {
+  if (!parentModel) return policy;
+  const routes = Object.fromEntries(
+    Object.entries(policy.routes).map(([routeId, route]) => {
+      if (route.kind !== "inherited") return [routeId, structuredClone(route)];
+      const capabilities = {
+        ...structuredClone(route.capabilities),
+        contextWindow: Math.min(
+          route.capabilities.contextWindow,
+          parentModel.contextWindow,
+        ),
+        maxTokens: Math.min(
+          route.capabilities.maxTokens,
+          parentModel.maxTokens,
+          route.capabilities.contextWindow,
+          parentModel.contextWindow,
+        ),
+      };
+      const raw = { kind: "inherited" as const, capabilities };
+      return [
+        routeId,
+        {
+          id: route.id,
+          ...raw,
+          fingerprint: routeFingerprint(raw),
+        },
+      ];
+    }),
+  );
+  return {
+    routes: Object.freeze(routes),
+    roles: Object.freeze(
+      Object.fromEntries(
+        ROLES.map((role) => [role, Object.freeze([...policy.roles[role]])]),
+      ),
+    ) as unknown as RoutePolicy["roles"],
+  };
+}
+
 /** Default parent-model route used when no explicit policy file exists. */
 export function parentRoutePolicy(
   parentModel?: ParentModelCapabilities,
@@ -366,7 +407,6 @@ export function parentRoutePolicy(
     ? Math.min(parentModel.maxTokens, contextWindow)
     : 1;
   const parsed = parseRoutePolicy({
-    version: ROUTE_POLICY_VERSION,
     routes: {
       parent: {
         kind: "inherited",
@@ -451,7 +491,11 @@ export function loadRoutePolicy(
   }
   const parsed = parseRoutePolicy(value);
   return parsed.ok
-    ? { ok: true, source, policy: parsed.policy }
+    ? {
+        ok: true,
+        source,
+        policy: constrainInheritedRoutes(parsed.policy, options.parentModel),
+      }
     : { ok: false, source, diagnostics: parsed.diagnostics };
 }
 

package/src/run-store.ts

@@ -17,7 +17,21 @@ import {
   StateRootError,
 } from "./state-root.ts";
 
-export const RUN_STORE_SCHEMA_VERSION = 4 as const;
+export class RunStoreFormatError extends Error {
+  readonly code = "run-store-reset-required" as const;
+  readonly databasePath: string;
+  readonly recovery = Object.freeze({
+    action: "reset-private-run-store" as const,
+    requiresBackup: true as const,
+    retryCommand: "status-or-start" as const,
+  });
+
+  constructor(databasePath: string) {
+    super("run-store-reset-required");
+    this.name = "RunStoreFormatError";
+    this.databasePath = databasePath;
+  }
+}
 
 const CHANGE_NAME = /^[a-z0-9](?:[a-z0-9-]{0,126}[a-z0-9])?$/u;
 const IDENTIFIER = /^[a-z0-9](?:[a-z0-9._:-]{0,126}[a-z0-9])?$/iu;
@@ -84,10 +98,6 @@ export interface OperationLeaseStatus {
 }
 
 const SCHEMA = `
-  CREATE TABLE IF NOT EXISTS schema_meta (
-    version INTEGER PRIMARY KEY CHECK (version = 4)
-  ) STRICT;
-
   CREATE TABLE IF NOT EXISTS runs (
     run_id TEXT PRIMARY KEY,
     root_hash TEXT NOT NULL,
@@ -191,6 +201,74 @@ function requireIdentifier(value: string, label: string): void {
   if (!IDENTIFIER.test(value)) throw new Error(`invalid-${label}`);
 }
 
+function configureDatabase(
+  database: DatabaseSync,
+  busyTimeoutMs: number | undefined,
+): void {
+  database.exec("PRAGMA foreign_keys = ON");
+  database.exec("PRAGMA journal_mode = WAL");
+  database.exec("PRAGMA synchronous = FULL");
+  database.exec(
+    `PRAGMA busy_timeout = ${Math.max(1, Math.min(30_000, busyTimeoutMs ?? 5_000))}`,
+  );
+}
+
+const REQUIRED_TABLES = [
+  "runs",
+  "delivery_bindings",
+  "events",
+  "tasks",
+  "operations",
+  "route_health",
+  "artifacts",
+  "workspace_revisions",
+  "apply_transactions",
+  "bootstrap_handoffs",
+] as const;
+
+const REQUIRED_DELIVERY_BINDING_COLUMNS = [
+  "run_id",
+  "gate",
+  "revision",
+  "receipt_hash",
+  "approval_revision",
+  "contract_hash",
+  "record_hash",
+  "operation_id",
+] as const;
+
+function applicationTables(database: DatabaseSync): string[] {
+  return (
+    database
+      .prepare(
+        `SELECT name FROM sqlite_master
+         WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+         ORDER BY name`,
+      )
+      .all() as unknown as Array<{ name: string }>
+  ).map(({ name }) => name);
+}
+
+function tableColumns(database: DatabaseSync, table: string): string[] {
+  return (
+    database.prepare(`PRAGMA table_info(${table})`).all() as unknown as Array<{
+      name: string;
+    }>
+  ).map(({ name }) => name);
+}
+
+function hasCurrentSchema(database: DatabaseSync): boolean {
+  const tables = applicationTables(database);
+  const deliveryBindingColumns = tableColumns(database, "delivery_bindings");
+  return (
+    !tables.includes("schema_meta") &&
+    REQUIRED_TABLES.every((table) => tables.includes(table)) &&
+    REQUIRED_DELIVERY_BINDING_COLUMNS.every((column) =>
+      deliveryBindingColumns.includes(column),
+    )
+  );
+}
+
 function parseProjection(value: string): RunProjection {
   const parsed = JSON.parse(value) as RunProjection;
   if (
@@ -262,25 +340,22 @@ export class RunStore {
     }
     chmodSync(stateRoot.databasePath, 0o600);
 
-    const database = new DatabaseSync(stateRoot.databasePath);
-    database.exec("PRAGMA foreign_keys = ON");
-    database.exec("PRAGMA journal_mode = WAL");
-    database.exec("PRAGMA synchronous = FULL");
-    database.exec(
-      `PRAGMA busy_timeout = ${Math.max(1, Math.min(30_000, options.busyTimeoutMs ?? 5_000))}`,
-    );
-    database.exec(SCHEMA);
-    const schemaRow = database
-      .prepare("SELECT version FROM schema_meta LIMIT 1")
-      .get() as { version: number } | undefined;
-    if (!schemaRow) {
-      database
-        .prepare("INSERT INTO schema_meta(version) VALUES (?)")
-        .run(RUN_STORE_SCHEMA_VERSION);
-    } else if (schemaRow.version !== RUN_STORE_SCHEMA_VERSION) {
-      database.close();
-      throw new Error("run-store-schema-version-rejected");
+    let database: DatabaseSync | undefined;
+    try {
+      database = new DatabaseSync(stateRoot.databasePath);
+      configureDatabase(database, options.busyTimeoutMs);
+      const tables = applicationTables(database);
+      if (tables.length === 0) {
+        database.exec(SCHEMA);
+      } else if (!hasCurrentSchema(database)) {
+        throw new RunStoreFormatError(stateRoot.databasePath);
+      }
+    } catch (error) {
+      database?.close();
+      if (error instanceof RunStoreFormatError) throw error;
+      throw new RunStoreFormatError(stateRoot.databasePath);
     }
+    if (!database) throw new RunStoreFormatError(stateRoot.databasePath);
     const store = new RunStore(stateRoot, database, options);
     store.#secureDatabaseFiles();
     store.recoverExpiredLeases();
@@ -917,7 +992,23 @@ export class RunStore {
     code?: string;
     lease?: OperationLease;
   }): RunProjection {
+    return this.transitionAtomically(input, () => {});
+  }
+
+  transitionAtomically(
+    input: {
+      runId: string;
+      to: RunState;
+      operationId: string;
+      code?: string;
+      lease?: OperationLease;
+    },
+    write: (database: DatabaseSync) => void,
+  ): RunProjection {
     requireIdentifier(input.operationId, "operation-id");
+    if (typeof write !== "function") {
+      throw new Error("state-transition-write-invalid");
+    }
     return this.#transaction(() => {
       if (input.lease) {
         if (input.lease.runId !== input.runId) throw new Error("lease-fenced");
@@ -935,6 +1026,7 @@ export class RunStore {
         to: input.to,
         ...(input.code ? { code: input.code } : {}),
       });
+      write(this.#database);
       this.#recordOperation(
         input.runId,
         input.operationId,