@abelxiaoxing/cadence 1.5.3 → 1.7.0

package/src/index.ts

@@ -4,6 +4,7 @@ import {
   projectDesignDiagnostic,
   type SafeDesignDiagnostic,
 } from "./design-diagnostics.ts";
+import { PackageStateError } from "./package-state.ts";
 import { openPackageWorkflowService } from "./package-workflow.ts";
 import { packageContext } from "./pi-adapter.ts";
 
@@ -47,6 +48,11 @@ import {
   DesignFinalizationError,
   validateDesignControlRequest,
 } from "./design-control.ts";
+import {
+  ImplementContinuationDriver,
+  implementChangeFromInvocation,
+  implementPromptBindsChange,
+} from "./implement-continuation.ts";
 import { canonicalJson } from "./implement-graph.ts";
 import { PACKET_ACTIONS, PacketRuntime } from "./packet-runtime.ts";
 
@@ -457,6 +463,14 @@ function classifyDesignFailure(
   field?: string;
 } {
   const message = error instanceof Error ? error.message : "";
+  if (error instanceof PackageStateError) {
+    return {
+      code: error.code,
+      category: "storage",
+      retryable: false,
+      field: "packageVersion",
+    };
+  }
   if (error instanceof DesignControlValidationError) {
     return {
       code: "invalid-design-control-request",
@@ -698,7 +712,9 @@ export function registerWorkflowControl(
   const engines = new Map<string, Promise<WorkflowControlEngine>>();
   const designOperations = new Set<Promise<void>>();
   const designFailures = new Map<string, SafeDesignFailure>();
+  const implementContinuation = new ImplementContinuationDriver();
   let pendingPrompt: EligiblePrompt | undefined;
+  let pendingImplementChange: string | undefined;
   let pendingInit = false;
   let exitingStage = false;
   let activePrompt: EligiblePrompt | undefined;
@@ -788,6 +804,7 @@ export function registerWorkflowControl(
   };
   const deactivateStage = async () => {
     activePrompt = undefined;
+    implementContinuation.deactivate();
     await packetRuntime.drain();
     deactivate();
   };
@@ -1229,6 +1246,25 @@ export function registerWorkflowControl(
           if (exitingStage || !activation.isActive())
             throw new Error("stage-control-mismatch");
         } catch (error) {
+          if (error instanceof PackageStateError) {
+            const payload = {
+              stage: "abel-implement",
+              change: validation.value.change,
+              state: "paused",
+              durable: false,
+              completed: false,
+              pause: { code: error.code },
+              legalCommands: ["status", "start"],
+              tasks: [],
+              queue: [],
+            };
+            return {
+              content: [
+                { type: "text" as const, text: JSON.stringify(payload) },
+              ],
+              details: payload,
+            };
+          }
           if (!(error instanceof RunStoreFormatError)) throw error;
           const payload = runStoreUnavailableStatus(error, validation.value);
           return {
@@ -1321,6 +1357,13 @@ export function registerWorkflowControl(
   registerDispatchTool("packet");
 
   pi.on("tool_result", (event) => {
+    implementContinuation.noteToolResult({
+      toolName: event.toolName,
+      input: event.input,
+      content: event.content,
+      details: event.details,
+      isError: event.isError,
+    });
     if (
       event.toolName !== DISPATCH_TOOL ||
       !event.isError ||
@@ -1357,7 +1400,9 @@ export function registerWorkflowControl(
     };
   });
   pi.on("input", (event) => {
+    implementContinuation.noteInput();
     pendingPrompt = undefined;
+    pendingImplementChange = undefined;
     pendingInit = false;
     const prompt = invokedPrompt(event.text);
     const init = /^\/abel-init(?:\s|$)/u.test(event.text);
@@ -1367,6 +1412,10 @@ export function registerWorkflowControl(
       return { action: prompt || init ? "handled" : "continue" };
     }
     pendingPrompt = prompt;
+    pendingImplementChange =
+      prompt === "abel-implement"
+        ? implementChangeFromInvocation(event.text)
+        : undefined;
     pendingInit = init && hasPackageProvenance(pi, "abel-init");
     if (
       activePrompt &&
@@ -1380,11 +1429,13 @@ export function registerWorkflowControl(
     }
     return { action: "continue" };
   });
-  pi.on("before_agent_start", (event) => {
+  pi.on("before_agent_start", (event, ctx) => {
     const prompt = pendingPrompt;
+    const implementChange = pendingImplementChange;
     const init =
       pendingInit && hasExpandedPromptMarker(event.prompt, "abel-init");
     pendingPrompt = undefined;
+    pendingImplementChange = undefined;
     pendingInit = false;
     const verified =
       prompt && isVerifiedStageInvocation(pi, activation, prompt, event.prompt);
@@ -1394,10 +1445,30 @@ export function registerWorkflowControl(
       }
       registerDispatchTool(prompt === "abel-implement" ? "command" : "packet");
       activePrompt = prompt;
+      if (prompt === "abel-implement") {
+        if (
+          implementChange &&
+          implementPromptBindsChange(event.prompt, implementChange) &&
+          typeof ctx.cwd === "string"
+        )
+          implementContinuation.activate({
+            cwd: ctx.cwd,
+            change: implementChange,
+          });
+        else implementContinuation.deactivate();
+      } else {
+        implementContinuation.deactivate();
+      }
     }
     if (prompt) activateDispatcher(pi, activation, prompt, event.prompt);
     if (activation.isActive() && activePrompt === "abel-design")
       enforceDesignTools();
+    if (
+      activation.isActive() &&
+      activePrompt === "abel-implement" &&
+      typeof ctx.cwd === "string"
+    )
+      implementContinuation.beginParentTurn(ctx.cwd);
     const boundary = activePrompt
       ? `Abel stage ${activePrompt} is active only for the invoked task and its direct follow-ups. If the user ends it or requests an unrelated task, first call abel_dispatch with {"action":"finish"}, then handle that task normally with the restored tools. A successful finish ends stage authority immediately, including within this turn. Do not extend Gates or workflow rules to that task. A direct Gate answer or same-task continuation stays in this stage. Never invoke another Abel stage automatically.`
       : init
@@ -1417,10 +1488,113 @@ export function registerWorkflowControl(
     }
     return { ...event.payload, parallel_tool_calls: true };
   });
+  pi.on("agent_end", async (event, ctx) => {
+    // The host may replace its current signal after abort/settlement. Retain
+    // this run's signal so a late status result cannot revive an aborted turn.
+    const runSignal = ctx.signal;
+    const aborted = () => runSignal?.aborted || ctx.signal?.aborted;
+    if (
+      aborted() ||
+      exitingStage ||
+      !activation.isActive() ||
+      activePrompt !== "abel-implement"
+    ) {
+      return;
+    }
+    if (
+      typeof ctx.hasPendingMessages === "function" &&
+      ctx.hasPendingMessages()
+    ) {
+      return;
+    }
+    const probe = implementContinuation.prepareSettlement({
+      cwd: ctx.cwd,
+      messages: event.messages,
+    });
+    if (!probe) return;
+
+    let status: Record<string, unknown>;
+    try {
+      const engine = await engineFor(ctx);
+      if (
+        aborted() ||
+        exitingStage ||
+        !activation.isActive() ||
+        activePrompt !== "abel-implement"
+      ) {
+        return;
+      }
+      status = await engine.execute(
+        {
+          command: "status",
+          stage: "abel-implement",
+          change: probe.change,
+        },
+        ctx,
+        runSignal,
+      );
+      if (
+        aborted() ||
+        (typeof ctx.hasPendingMessages === "function" &&
+          ctx.hasPendingMessages())
+      ) {
+        return;
+      }
+    } catch {
+      // A host reminder cannot replace a trustworthy local status read.
+      return;
+    }
+
+    const decision = implementContinuation.finishSettlement(probe, status);
+    if (decision?.kind === "terminal") {
+      await deactivateStage();
+      return;
+    }
+    if (!decision) return;
+    if (
+      aborted() ||
+      (typeof ctx.hasPendingMessages === "function" && ctx.hasPendingMessages())
+    ) {
+      return;
+    }
+
+    if (decision.kind === "stalled") {
+      pi.sendMessage(
+        {
+          customType: "abel-implement-continuation-stalled",
+          content: [{ type: "text", text: decision.message }],
+          display: true,
+          details: {
+            code: decision.code,
+            change: decision.change,
+            state: decision.state,
+            statusFingerprint: decision.statusFingerprint,
+          },
+        },
+        { triggerTurn: false },
+      );
+      return;
+    }
+
+    pi.sendMessage(
+      {
+        customType: "abel-implement-continuation",
+        content: [{ type: "text", text: decision.message }],
+        display: false,
+        details: {
+          change: decision.change,
+          statusFingerprint: decision.statusFingerprint,
+        },
+      },
+      { triggerTurn: true, deliverAs: "followUp" },
+    );
+  });
   pi.on("session_start", async (_event, ctx) => {
     pendingPrompt = undefined;
+    pendingImplementChange = undefined;
     pendingInit = false;
     activePrompt = undefined;
+    implementContinuation.deactivate();
     designFailures.clear();
     activity.detach();
     await packetRuntime.drain();
@@ -1429,7 +1603,11 @@ export function registerWorkflowControl(
     if (ctx.mode === "tui") activity.attach(ctx.ui);
   });
   pi.on("session_shutdown", async () => {
+    pendingPrompt = undefined;
+    pendingImplementChange = undefined;
+    pendingInit = false;
     activePrompt = undefined;
+    implementContinuation.deactivate();
     designFailures.clear();
     activity.detach();
     await packetRuntime.drain();

package/src/operator-cli.mjs

@@ -652,9 +652,6 @@ function observeSafePath(root, relative) {
   }
   return { kind: "unsafe", reason: "invalid-path" };
 }
-function isSafeRegularFile(root, relative) {
-  return observeSafePath(root, relative).kind === "file";
-}
 
 // src/file-snapshot.ts
 function sha256(bytes) {
@@ -697,10 +694,16 @@ function capabilitySuccess(verificationId, runnerBindings = []) {
     }))
   };
 }
-function adapterFailure(verificationId, code, message) {
+function adapterFailure(verificationId, code, message, inputObservation) {
   return {
     ok: false,
-    diagnostic: { kind: "verification-adapter", code, verificationId, message }
+    diagnostic: {
+      kind: "verification-adapter",
+      code,
+      verificationId,
+      message,
+      ...inputObservation ? { inputObservation } : {}
+    }
   };
 }
 function fileStatus(root, relative) {
@@ -1223,8 +1226,10 @@ function validateCapability(root, value, options, requireInputAvailability) {
 function validateAcceptedVerificationCapability(root, verification, dependencyOwner, runnerEnvironment, requireInputAvailability, executionWritePaths) {
   if (requireInputAvailability) {
     for (const input of verificationInputPaths(verification)) {
-      if (!isSafeRegularFile(root, input)) {
-        return adapterFailure(verification.id, "input-missing", `verification input ${input} is missing or unsafe`);
+      const status = fileStatus(root, input);
+      if (status !== "regular") {
+        const inputObservation = { path: input, kind: status };
+        return adapterFailure(verification.id, status === "absent" ? "input-missing" : "input-unsafe", `verification input ${input} is ${status}`, inputObservation);
       }
     }
   }

package/src/package-state.ts

@@ -0,0 +1,309 @@
+import { randomUUID } from "node:crypto";
+import {
+  closeSync,
+  existsSync,
+  fsyncSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { syncDirectory } from "./directory-sync.ts";
+import { RunStore } from "./run-store.ts";
+import { prepareStateRoot, type ResolvedStateRoot } from "./state-root.ts";
+
+export class PackageStateError extends Error {
+  readonly code: string;
+  constructor(code: string) {
+    super(code);
+    this.code = code;
+  }
+}
+export interface PackageStateNotice {
+  reason:
+    | "package-upgrade"
+    | "unversioned-store"
+    | "unreadable-store"
+    | "missing-store";
+  previousVersion: string | null;
+  currentVersion: string;
+  backupPath: string;
+  oldRunsAbandoned: true;
+  workspaceRestored: false;
+  warning: string;
+}
+interface ResetIntent
+  extends Omit<
+    PackageStateNotice,
+    "oldRunsAbandoned" | "workspaceRestored" | "warning"
+  > {
+  backupName: string;
+}
+const fail = (code: string): never => {
+  throw new PackageStateError(code);
+};
+const versionParts = (version: string): number[] => {
+  if (!/^\d+\.\d+\.\d+$/u.test(version)) fail("package-state-version-invalid");
+  const parts = version.split(".").map(Number);
+  if (parts.some((part) => !Number.isSafeInteger(part)))
+    fail("package-state-version-invalid");
+  return parts;
+};
+function compareVersions(left: string, right: string): number {
+  const a = versionParts(left),
+    b = versionParts(right);
+  for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;
+  return 0;
+}
+function regular(file: string): boolean {
+  const stat = lstatSync(file, { throwIfNoEntry: false });
+  if (!stat) return false;
+  if (!stat.isFile() || stat.isSymbolicLink())
+    fail("package-state-path-unsafe");
+  return true;
+}
+function table(db: DatabaseSync, name: string): boolean {
+  return !!db
+    .prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?")
+    .get(name);
+}
+function storedVersion(db: DatabaseSync): string | null {
+  if (!table(db, "cadence_package_version")) return null;
+  const rows = db.prepare("SELECT version FROM cadence_package_version").all();
+  if (rows.length !== 1 || typeof rows[0].version !== "string")
+    fail("package-state-version-invalid");
+  const version = String(rows[0].version);
+  versionParts(version);
+  return version;
+}
+// Only inspect the version. Old task/lease/apply records are deliberately not
+// interpreted: this policy abandons them, including malformed or unreadable facts.
+function inspectVersion(file: string): {
+  version: string | null;
+  unreadable: boolean;
+} {
+  let db: DatabaseSync | undefined;
+  try {
+    db = new DatabaseSync(file, { readOnly: true });
+    return { version: storedVersion(db), unreadable: false };
+  } catch (error) {
+    const failure = error as { errcode?: number; code?: string };
+    // An actual SQLite lock is not a stale durable lease record. Do not move
+    // storage while an uncoordinated old opener is observably using it.
+    if (failure.errcode !== undefined && [5, 6].includes(failure.errcode & 255))
+      fail("package-state-in-use");
+    if (
+      (error instanceof PackageStateError &&
+        error.code === "package-state-version-invalid") ||
+      (failure.errcode !== undefined &&
+        [1, 11, 26].includes(failure.errcode & 255))
+    )
+      return { version: null, unreadable: true };
+    // Schema errors / SQLITE_CORRUPT / SQLITE_NOTADB mean opaque old bytes.
+    // Permissions, disk I/O, resource exhaustion and unknown errors do not.
+    return fail("package-state-reset-unavailable");
+  } finally {
+    db?.close();
+  }
+}
+
+function hasOldResources(state: ResolvedStateRoot): boolean {
+  // Cover the production run-data layout and unknown historical resources.
+  // Never descend through resource links; the whole root is renamed as-is.
+  const emptyScaffolds = new Set(["artifacts", "workspaces", "transactions"]);
+  return readdirSync(state.rootDir).some((name) => {
+    const file = path.join(state.rootDir, name);
+    const stat = lstatSync(file);
+    return (
+      !emptyScaffolds.has(name) ||
+      !stat.isDirectory() ||
+      stat.isSymbolicLink() ||
+      readdirSync(file).length > 0
+    );
+  });
+}
+
+const RESET_WARNING =
+  "Old runs and approval evidence are abandoned, not resumed. Stop all old hosts and execution processes before resetting; the lock cannot fence older versions or detached descendants. The main workspace is not restored: interrupted apply may have left partial changes. Inspect Git diff before starting new work.";
+
+function persistIntent(file: string, intent: ResetIntent): void {
+  const temp = `${file}.tmp`;
+  regular(temp);
+  const fd = openSync(temp, "w", 0o600);
+  try {
+    writeFileSync(fd, JSON.stringify(intent));
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  renameSync(temp, file);
+  syncDirectory(path.dirname(file));
+}
+
+/** Package boundary only: low-level storage and read-only operator inspection never reset state.
+ * The external SQLite write lock is held until every service connection has closed.
+ * SQLite releases it on process death; no PID guessing or stale-lock deletion is used.
+ */
+export function acquirePackageState(
+  unresolved: ResolvedStateRoot,
+  version = String(
+    JSON.parse(
+      readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+    ).version,
+  ),
+): { notice?: PackageStateNotice; close(): void } {
+  versionParts(version);
+  const state = prepareStateRoot(unresolved);
+  for (const suffix of ["-wal", "-shm", "-journal"])
+    regular(state.databasePath + suffix);
+  const coordinator = path.join(
+    state.rootsDir,
+    `${state.consumerRootHash}.package-state`,
+  );
+  const stat = lstatSync(coordinator, { throwIfNoEntry: false });
+  if (stat && (!stat.isDirectory() || stat.isSymbolicLink()))
+    fail("package-state-path-unsafe");
+  mkdirSync(coordinator, { recursive: true, mode: 0o700 });
+  const lockFile = path.join(coordinator, "lock.sqlite3");
+  for (const suffix of ["", "-journal", "-wal", "-shm"])
+    regular(lockFile + suffix);
+  if (!existsSync(lockFile)) {
+    try {
+      closeSync(openSync(lockFile, "wx", 0o600));
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+    }
+  }
+  const lock = new DatabaseSync(lockFile);
+  let closed = false;
+  const close = () => {
+    if (!closed) {
+      closed = true;
+      lock.close();
+    }
+  };
+  try {
+    lock.exec("PRAGMA busy_timeout = 1; BEGIN IMMEDIATE");
+  } catch {
+    close();
+    fail("package-state-in-use");
+  }
+  try {
+    const intentFile = path.join(coordinator, "reset.json");
+    let intent: ResetIntent | undefined;
+    if (regular(intentFile)) {
+      intent = JSON.parse(readFileSync(intentFile, "utf8")) as ResetIntent;
+      if (
+        !intent ||
+        !/^backup-[a-f0-9-]{36}$/u.test(intent.backupName) ||
+        intent.backupPath !== path.join(coordinator, intent.backupName) ||
+        ![
+          "package-upgrade",
+          "unversioned-store",
+          "unreadable-store",
+          "missing-store",
+        ].includes(intent.reason) ||
+        (intent.previousVersion !== null &&
+          typeof intent.previousVersion !== "string")
+      )
+        fail("package-state-reset-intent-invalid");
+      if (intent.currentVersion !== version)
+        fail("package-state-reset-version-mismatch");
+    }
+    let fresh = !regular(state.databasePath);
+    if (!intent) {
+      const observed = fresh
+        ? { version: null, unreadable: false }
+        : inspectVersion(state.databasePath);
+      if (observed.version === version) return { close };
+      if (
+        observed.version !== null &&
+        compareVersions(observed.version, version) > 0
+      )
+        fail("package-state-downgrade-blocked");
+      if (!fresh || hasOldResources(state)) {
+        const backupName = `backup-${randomUUID()}`;
+        intent = {
+          backupName,
+          backupPath: path.join(coordinator, backupName),
+          previousVersion: observed.version,
+          currentVersion: version,
+          reason: fresh
+            ? "missing-store"
+            : observed.unreadable
+              ? "unreadable-store"
+              : observed.version === null
+                ? "unversioned-store"
+                : "package-upgrade",
+        };
+        persistIntent(intentFile, intent);
+      }
+    }
+    if (intent) {
+      const backup = lstatSync(intent.backupPath, { throwIfNoEntry: false });
+      if (backup && (!backup.isDirectory() || backup.isSymbolicLink()))
+        fail("package-state-path-unsafe");
+      if (!backup) {
+        // Abandon the old namespace as opaque bytes, including run-data and
+        // SQLite sidecars. No transaction replay or main-workspace rollback.
+        renameSync(state.rootDir, intent.backupPath);
+        syncDirectory(coordinator);
+        syncDirectory(state.rootsDir);
+      }
+      prepareStateRoot(state);
+      fresh = true;
+    }
+    if (fresh) {
+      RunStore.open(state).close();
+      const db = new DatabaseSync(state.databasePath);
+      try {
+        db.exec(
+          "PRAGMA synchronous = FULL; BEGIN IMMEDIATE; CREATE TABLE IF NOT EXISTS cadence_package_version (version TEXT NOT NULL) STRICT",
+        );
+        const existing = db
+          .prepare("SELECT version FROM cadence_package_version")
+          .all();
+        if (existing.length === 0)
+          db.prepare("INSERT INTO cadence_package_version VALUES (?)").run(
+            version,
+          );
+        else if (existing.length !== 1 || existing[0].version !== version)
+          fail("package-state-reset-version-mismatch");
+        db.exec("COMMIT");
+      } finally {
+        db.close();
+      }
+      syncDirectory(state.rootDir);
+    }
+    if (intent) {
+      unlinkSync(intentFile);
+      syncDirectory(coordinator);
+    }
+    return {
+      close,
+      ...(intent
+        ? {
+            notice: {
+              reason: intent.reason,
+              previousVersion: intent.previousVersion,
+              currentVersion: version,
+              backupPath: intent.backupPath,
+              oldRunsAbandoned: true,
+              workspaceRestored: false,
+              warning: RESET_WARNING,
+            },
+          }
+        : {}),
+    };
+  } catch (error) {
+    close();
+    if (error instanceof PackageStateError) throw error;
+    throw new PackageStateError("package-state-reset-unavailable");
+  }
+}

package/src/package-verification.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 import {
   type AtomicVerificationContract,
   type StructuredVerificationContract,
+  type VerificationInputObservation,
   type VerificationObservation,
   verificationSteps,
 } from "./contracts.ts";
@@ -321,11 +322,13 @@ export async function executePackageVerification(input: {
   const unavailable = (
     code: string,
     category: "environment" | "adapter" | "resource" = "adapter",
+    inputObservation?: VerificationInputObservation,
   ): VerificationObservation => ({
     kind: "unavailable",
     category,
     code,
     verificationId: input.verification.id,
+    ...(inputObservation ? { inputObservation } : {}),
     ...(executionDiagnostic
       ? {
           diagnostic: {
@@ -349,7 +352,14 @@ export async function executePackageVerification(input: {
       executionWritePaths: input.executionWritePaths,
     },
   );
-  if (!capability.ok) return unavailable(capability.diagnostic.code);
+  if (!capability.ok)
+    return unavailable(
+      capability.diagnostic.code,
+      "adapter",
+      capability.diagnostic.kind === "verification-adapter"
+        ? capability.diagnostic.inputObservation
+        : undefined,
+    );
   let environment: Awaited<ReturnType<typeof prepareVerificationEnvironment>>;
   try {
     environment = await prepareVerificationEnvironment(
@@ -552,6 +562,9 @@ export function phaseVerificationResult(result: VerificationObservation) {
     kind: "paused" as const,
     code: result.code,
     category: result.category,
+    ...(result.inputObservation
+      ? { inputObservation: result.inputObservation }
+      : {}),
   };
 }
 
@@ -583,5 +596,8 @@ export function changeVerificationResult(result: VerificationObservation) {
         ? ("verification-adapter" as const)
         : ("environment" as const),
     code: result.code,
+    ...(result.inputObservation
+      ? { inputObservation: result.inputObservation }
+      : {}),
   };
 }