@abelxiaoxing/cadence 1.2.2 → 1.2.4

package/src/run-store.ts

@@ -17,7 +17,32 @@ 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;
+  }
+}
+
+export class RunStoreMigrationError extends Error {
+  readonly code = "run-store-migration-failed" as const;
+  readonly schemaVersion: number;
+
+  constructor(schemaVersion: number, cause: unknown) {
+    super("run-store-migration-failed", { cause });
+    this.name = "RunStoreMigrationError";
+    this.schemaVersion = schemaVersion;
+  }
+}
 
 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;
@@ -53,6 +78,7 @@ export interface StartRunInput {
   stage: RunStage;
   change?: string;
   provisionalKey?: string;
+  provisionalAliases?: readonly string[];
   operationId: string;
 }
 
@@ -84,10 +110,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 +213,180 @@ 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;
+const LEGACY_SCHEMA_VERSION = 4;
+
+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 hasRequiredCoreSchema(
+  database: DatabaseSync,
+  tables: readonly string[],
+): boolean {
+  const deliveryBindingColumns = tableColumns(database, "delivery_bindings");
+  return (
+    REQUIRED_TABLES.every((table) => tables.includes(table)) &&
+    REQUIRED_DELIVERY_BINDING_COLUMNS.every((column) =>
+      deliveryBindingColumns.includes(column),
+    )
+  );
+}
+
+function hasCurrentSchema(
+  database: DatabaseSync,
+  tables: readonly string[],
+): boolean {
+  return (
+    !tables.includes("schema_meta") && hasRequiredCoreSchema(database, tables)
+  );
+}
+
+function isSupportedLegacySchema(
+  database: DatabaseSync,
+  tables: readonly string[],
+): boolean {
+  if (
+    !tables.includes("schema_meta") ||
+    !hasRequiredCoreSchema(database, tables) ||
+    tableColumns(database, "schema_meta").join("\0") !== "version"
+  ) {
+    return false;
+  }
+  const rows = database
+    .prepare("SELECT version FROM schema_meta")
+    .all() as unknown as Array<{
+    version: number;
+  }>;
+  return (
+    rows.length === 1 && Number(rows[0]?.version) === LEGACY_SCHEMA_VERSION
+  );
+}
+
+function isSqliteLocked(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "errcode" in error &&
+    ((error as { errcode?: unknown }).errcode === 5 ||
+      (error as { errcode?: unknown }).errcode === 6)
+  );
+}
+
+function isStoreUnavailable(error: unknown): boolean {
+  if (typeof error !== "object" || error === null) return false;
+  const errcode = (error as { errcode?: unknown }).errcode;
+  if ([8, 10, 13, 14, 23, 24].includes(Number(errcode))) return true;
+  const code = (error as { code?: unknown }).code;
+  return (
+    typeof code === "string" &&
+    [
+      "EACCES",
+      "EBUSY",
+      "EMFILE",
+      "ENFILE",
+      "ENOSPC",
+      "EPERM",
+      "EROFS",
+    ].includes(code)
+  );
+}
+
+function ensureCurrentSchema(
+  database: DatabaseSync,
+  databasePath: string,
+): void {
+  const initialTables = applicationTables(database);
+  if (hasCurrentSchema(database, initialTables)) return;
+  let transactionStarted = false;
+  let migrating = false;
+  try {
+    database.exec("BEGIN IMMEDIATE");
+    transactionStarted = true;
+    const tables = applicationTables(database);
+    if (tables.length === 0) {
+      database.exec(SCHEMA);
+    } else if (hasCurrentSchema(database, tables)) {
+      // Another opener may already have completed the same migration.
+    } else if (isSupportedLegacySchema(database, tables)) {
+      migrating = true;
+      database.exec("DROP TABLE schema_meta");
+    } else {
+      throw new RunStoreFormatError(databasePath);
+    }
+    database.exec("COMMIT");
+  } catch (error) {
+    if (transactionStarted) {
+      try {
+        database.exec("ROLLBACK");
+      } catch {
+        // The original schema or commit failure remains authoritative.
+      }
+    }
+    if (
+      error instanceof RunStoreFormatError ||
+      error instanceof RunStoreMigrationError ||
+      isSqliteLocked(error)
+    ) {
+      throw error;
+    }
+    if (migrating) {
+      throw new RunStoreMigrationError(LEGACY_SCHEMA_VERSION, error);
+    }
+    throw error;
+  }
+}
+
 function parseProjection(value: string): RunProjection {
   const parsed = JSON.parse(value) as RunProjection;
   if (
@@ -203,22 +399,35 @@ function parseProjection(value: string): RunProjection {
   return parsed;
 }
 
-function lookupKey(input: StartRunInput): string {
+function lookupKeys(input: StartRunInput): string[] {
   const hasChange = typeof input.change === "string";
   const hasProvisional = typeof input.provisionalKey === "string";
   if (hasChange === hasProvisional) throw new Error("invalid-run-lookup-key");
   if (hasChange) {
+    if (input.provisionalAliases !== undefined) {
+      throw new Error("invalid-run-lookup-key");
+    }
     if (!CHANGE_NAME.test(input.change as string))
       throw new Error("invalid-change");
-    return `change:${input.change}`;
+    return [`change:${input.change}`];
   }
   if (!SHA256.test(input.provisionalKey as string)) {
     throw new Error("invalid-provisional-key");
   }
+  if (
+    input.provisionalAliases !== undefined &&
+    (!Array.isArray(input.provisionalAliases) ||
+      input.provisionalAliases.length > 4 ||
+      input.provisionalAliases.some((alias) => !SHA256.test(alias)))
+  ) {
+    throw new Error("invalid-provisional-key");
+  }
   if (input.stage !== "abel-design") {
     throw new Error("provisional-run-requires-design");
   }
-  return `provisional:${input.provisionalKey}`;
+  return [
+    ...new Set([input.provisionalKey, ...(input.provisionalAliases ?? [])]),
+  ].map((hash) => `provisional:${hash}`);
 }
 
 export class RunStore {
@@ -262,29 +471,41 @@ 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);
+      ensureCurrentSchema(database, stateRoot.databasePath);
+    } catch (error) {
+      try {
+        database?.close();
+      } catch {
+        // The run-store initialization failure remains authoritative.
+      }
+      if (
+        error instanceof RunStoreFormatError ||
+        error instanceof RunStoreMigrationError ||
+        isSqliteLocked(error) ||
+        isStoreUnavailable(error)
+      ) {
+        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();
-    return store;
+    try {
+      store.#secureDatabaseFiles();
+      store.recoverExpiredLeases();
+      return store;
+    } catch (error) {
+      try {
+        database.close();
+      } catch {
+        // The permission or lease-recovery failure remains authoritative.
+      }
+      throw error;
+    }
   }
 
   #assertOpen(): void {
@@ -299,7 +520,11 @@ export class RunStore {
       value = work();
       this.#database.exec("COMMIT");
     } catch (error) {
-      this.#database.exec("ROLLBACK");
+      try {
+        this.#database.exec("ROLLBACK");
+      } catch {
+        // The original operation or commit failure remains authoritative.
+      }
       throw error;
     }
     this.#secureDatabaseFiles();
@@ -442,16 +667,62 @@ export class RunStore {
     if (input.stage !== "abel-design" && input.stage !== "abel-implement") {
       throw new Error("invalid-run-stage");
     }
-    const key = lookupKey(input);
+    const keys = lookupKeys(input);
+    const key = keys[0];
+    if (!key) throw new Error("invalid-run-lookup-key");
     return this.#transaction(() => {
-      let existing = this.#database
+      const operationRows = this.#database
         .prepare(
-          `SELECT run_id, projection_json FROM runs
-           WHERE root_hash = ? AND stage = ? AND lookup_key = ?`,
+          `SELECT operations.run_id, operations.kind, operations.state,
+                  operations.outcome_json, runs.lookup_key
+           FROM operations
+           JOIN runs ON runs.run_id = operations.run_id
+           WHERE runs.root_hash = ? AND runs.stage = ?
+             AND operations.operation_id = ?`,
         )
-        .get(this.stateRoot.consumerRootHash, input.stage, key) as
-        | RunRow
-        | undefined;
+        .all(
+          this.stateRoot.consumerRootHash,
+          input.stage,
+          input.operationId,
+        ) as unknown as Array<{
+        run_id: string;
+        kind: string;
+        state: string;
+        outcome_json: string | null;
+        lookup_key: string;
+      }>;
+      if (operationRows.length > 0) {
+        const replay = operationRows.find(
+          (row) =>
+            row.kind === "start" &&
+            row.state === "committed" &&
+            row.outcome_json !== null &&
+            keys.includes(row.lookup_key),
+        );
+        if (operationRows.length !== 1 || !replay) {
+          throw new Error("operation-id-conflict");
+        }
+        const outcome = parseProjection(replay.outcome_json as string);
+        if (outcome.runId !== replay.run_id) {
+          throw new Error("operation-outcome-invalid");
+        }
+        return outcome;
+      }
+      let existing: RunRow | undefined;
+      for (const compatibleKey of keys) {
+        const candidate = this.#database
+          .prepare(
+            `SELECT run_id, projection_json FROM runs
+             WHERE root_hash = ? AND stage = ? AND lookup_key = ?`,
+          )
+          .get(this.stateRoot.consumerRootHash, input.stage, compatibleKey) as
+          | RunRow
+          | undefined;
+        if (candidate && existing && candidate.run_id !== existing.run_id) {
+          throw new Error("run-lookup-conflict");
+        }
+        existing ??= candidate;
+      }
       if (existing) {
         const projection = parseProjection(existing.projection_json);
         if (

package/src/subagent-activity.ts

@@ -87,7 +87,6 @@ export type ActivitySummary = EvidenceActivitySummary | DiffActivitySummary;
 export type ActivityTone = "accent" | "success" | "warning" | "muted" | "error";
 
 export interface ActivityDisplay {
-  version: 1;
   kind: "activityDisplay";
   requestId: string;
   role: string;
@@ -188,6 +187,7 @@ export function sanitizeDisplayText(value: unknown, maxLength = 240): string {
 }
 
 const SAFE_WORKFLOW_CODE = /^[a-z0-9](?:[a-z0-9._:-]{0,126}[a-z0-9])?$/iu;
+const SAFE_DESIGN_DETAIL_VALUE = /^[a-z0-9](?:[a-z0-9._:-]{0,126}[a-z0-9])?$/iu;
 const SAFE_CONTROL_ACTIONS = new Set([
   "start",
   "status",
@@ -221,6 +221,82 @@ export function sanitizeFailureReason(value: unknown, maxLength = 240): string {
   return safe.slice(0, Math.max(0, maxLength));
 }
 
+function safeDesignFailure(value: unknown): {
+  operation: string;
+  code: string;
+  diagnostics: Array<Record<string, string>>;
+} | null {
+  const failure = asRecord(value);
+  if (
+    failure?.kind !== "design-control-failure" ||
+    typeof failure.operation !== "string" ||
+    !SAFE_DESIGN_DETAIL_VALUE.test(failure.operation) ||
+    typeof failure.code !== "string" ||
+    !SAFE_DESIGN_DETAIL_VALUE.test(failure.code) ||
+    !Array.isArray(failure.diagnostics)
+  ) {
+    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>,
+    ];
+  });
+  return {
+    operation: failure.operation,
+    code: failure.code,
+    diagnostics,
+  };
+}
+
+function renderDesignFailure(
+  failure: ReturnType<typeof safeDesignFailure> & object,
+  expanded: boolean,
+  theme?: ActivityTheme,
+): Component {
+  const title = styled(
+    theme,
+    "error",
+    `${dispatchLabel("design")} ${failure.operation} failed: ${failure.code}`,
+  );
+  if (!expanded || failure.diagnostics.length === 0) {
+    const suffix =
+      failure.diagnostics.length > 0
+        ? styled(
+            theme,
+            "muted",
+            ` (${failure.diagnostics.length} diagnostic${failure.diagnostics.length === 1 ? "" : "s"})`,
+          )
+        : "";
+    return new Text(`${title}${suffix}`, 0, 0);
+  }
+  const lines = failure.diagnostics.map((diagnostic) => {
+    const details = Object.entries(diagnostic)
+      .filter(([key]) => key !== "code")
+      .map(([key, value]) => `${key}=${value}`)
+      .join(" · ");
+    return `  - ${diagnostic.code}${details ? ` · ${details}` : ""}`;
+  });
+  return new Text(
+    [title, ...lines.map((entry) => styled(theme, "muted", entry))].join("\n"),
+    0,
+    0,
+  );
+}
+
 export function formatElapsed(milliseconds: number): string {
   const value = Math.max(
     0,
@@ -470,6 +546,7 @@ function workflowStateOf(
   }
   const state = result.state;
   switch (state) {
+    case "not-started":
     case "created":
     case "ready":
     case "queued":
@@ -659,7 +736,6 @@ export function projectWorkflowActivity(
       ? "completion-state-inconsistent"
       : workflowCode(payload);
   return {
-    version: 1,
     kind: "activityDisplay",
     requestId: sanitizeDisplayText(
       runId ?? taskId ?? change ?? command.operationId ?? "pending",
@@ -792,7 +868,6 @@ function displayFromEvent(
 ): ActivityDisplay {
   const reason = event.failureReason;
   return {
-    version: 1,
     kind: "activityDisplay",
     requestId: entry.requestId,
     role: entry.role,
@@ -989,7 +1064,6 @@ export class ActivityController {
     const entry = this.entries.get(toolCallId);
     if (!entry) return;
     const display: ActivityDisplay = {
-      version: 1,
       kind: "activityDisplay",
       requestId: entry.requestId,
       role: entry.role,
@@ -1230,7 +1304,6 @@ export function renderActivityResult(
   if (failedRun) {
     const snapshot = identityFromDispatchArgs(asRecord(context?.args)?.request);
     const display: ActivityDisplay = {
-      version: 1,
       kind: "activityDisplay",
       requestId: isActivityDisplay(activity)
         ? activity.requestId
@@ -1250,6 +1323,10 @@ export function renderActivityResult(
     return new ActivityInlineComponent(display, theme);
   }
   if (failed) {
+    const designFailure = safeDesignFailure(details?.designFailure);
+    if (args?.action === "design" && designFailure) {
+      return renderDesignFailure(designFailure, options.expanded, theme);
+    }
     return new Text(
       `${dispatchLabel(args?.action ?? args?.command)} failed`,
       0,
@@ -1275,7 +1352,6 @@ function isActivityDisplay(value: unknown): value is ActivityDisplay {
   const record = asRecord(value);
   return (
     record?.kind === "activityDisplay" &&
-    record.version === 1 &&
     typeof record.requestId === "string" &&
     typeof record.role === "string" &&
     typeof record.phase === "string" &&