@abelxiaoxing/cadence 1.0.1 → 1.0.3

package/src/file-snapshot.ts

@@ -1,10 +1,17 @@
 // File-level snapshots: content hashes for observed files, deterministic
-// directory-entry manifests for observed directories, and explicit absent
+// recursive content manifests for observed directories, and explicit absent
 // markers for proposed new paths. Currency is decided per bound path; no
 // global workspace revision participates.
 import { createHash } from "node:crypto";
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { resolve } from "node:path";
+import {
+  existsSync,
+  lstatSync,
+  readdirSync,
+  readFileSync,
+  readlinkSync,
+  statSync,
+} from "node:fs";
+import { join, resolve } from "node:path";
 
 export interface FileBound {
   kind: "file";
@@ -37,7 +44,57 @@ export function snapshotFile(root: string, relPath: string): FileBound | null {
   return { sha256: sha256(bytes), bytes: bytes.length, kind: "file" };
 }
 
-/** Deterministic directory-entry manifest: hash of sorted name/type entries. */
+function updateManifest(
+  hash: ReturnType<typeof createHash>,
+  ...fields: Array<string | Buffer>
+): void {
+  for (const field of fields) {
+    const bytes = typeof field === "string" ? Buffer.from(field) : field;
+    hash.update(`${bytes.length}:`);
+    hash.update(bytes);
+  }
+}
+
+function recursiveDirectoryManifest(abs: string): string {
+  const hash = createHash("sha256");
+  updateManifest(hash, "cadence-directory-manifest-v2");
+  const visit = (directory: string, prefix: string): void => {
+    const names = readdirSync(directory).sort();
+    for (const name of names) {
+      const relative = prefix ? `${prefix}/${name}` : name;
+      const current = join(directory, name);
+      const stat = lstatSync(current);
+      if (stat.isDirectory()) {
+        updateManifest(hash, "dir", relative, String(stat.mode & 0o777));
+        visit(current, relative);
+      } else if (stat.isFile()) {
+        const bytes = readFileSync(current);
+        updateManifest(
+          hash,
+          "file",
+          relative,
+          String(stat.mode & 0o777),
+          String(bytes.length),
+          sha256(bytes),
+        );
+      } else if (stat.isSymbolicLink()) {
+        updateManifest(hash, "symlink", relative, readlinkSync(current));
+      } else {
+        updateManifest(
+          hash,
+          "special",
+          relative,
+          String(stat.mode),
+          String(stat.size),
+        );
+      }
+    }
+  };
+  visit(abs, "");
+  return hash.digest("hex");
+}
+
+/** Deterministic recursive directory manifest bound to installed content. */
 export function snapshotDirManifest(
   root: string,
   relDir: string,
@@ -45,10 +102,7 @@ export function snapshotDirManifest(
   const abs = resolve(root, relDir);
   const st = statSync(abs, { throwIfNoEntry: false });
   if (!st?.isDirectory()) return null;
-  const entries = readdirSync(abs, { withFileTypes: true })
-    .map((e) => `${e.name}:${e.isDirectory() ? "dir" : "file"}`)
-    .sort();
-  return { manifest: sha256(Buffer.from(entries.join("\n"))), kind: "dir" };
+  return { manifest: recursiveDirectoryManifest(abs), kind: "dir" };
 }
 
 /** Build a bound map for the given file paths, observed directories, and absent markers. */

package/src/index.ts

@@ -15,6 +15,7 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import { type Activation, activateTool, deactivateTool } from "./activation.ts";
 import { ACTIONS } from "./contracts.ts";
+import { ParentPayloadBridge } from "./parent-payload-bridge.ts";
 import { Runtime } from "./runtime.ts";
 import {
   ACTIVITY_DETAILS_KEY,
@@ -68,20 +69,27 @@ function hasExpandedPromptMarker(
   );
 }
 
+function isVerifiedStageInvocation(
+  pi: ExtensionAPI,
+  activation: Activation,
+  name: EligiblePrompt,
+  prompt: string,
+): boolean {
+  return (
+    hasPackageProvenance(pi, name) &&
+    hasExpandedPromptMarker(prompt, name) &&
+    (activation.isActive() || activation.state === "inactive")
+  );
+}
+
 function activateDispatcher(
   pi: ExtensionAPI,
   activation: Activation,
   name: EligiblePrompt,
   prompt: string,
 ): void {
-  if (
-    !hasPackageProvenance(pi, name) ||
-    !hasExpandedPromptMarker(prompt, name)
-  ) {
-    return;
-  }
+  if (!isVerifiedStageInvocation(pi, activation, name, prompt)) return;
   if (!activation.isActive()) {
-    if (activation.state !== "inactive") return;
     activation.request();
     activation.activate();
   }
@@ -91,15 +99,24 @@ function activateDispatcher(
   }
 }
 
+function splitUsage(result: unknown): { payload: unknown; usage?: unknown } {
+  if (typeof result !== "object" || result === null || !("usage" in result)) {
+    return { payload: result };
+  }
+  const { usage, ...payload } = result as Record<string, unknown>;
+  return { payload, usage };
+}
+
 export default function register(pi: ExtensionAPI): void {
-  const runtime = new Runtime();
+  const parentPayloadBridge = new ParentPayloadBridge();
+  const runtime = new Runtime({ parentPayloadBridge });
   const activity = new ActivityController();
 
   pi.registerTool({
     name: DISPATCH_TOOL,
     label: "Abel Dispatch",
     description:
-      "Private Abel workflow delegation: run bounded read-only evidence or Worker phase requests, apply or discard retained results, cancel work, or finish the stage. Inactive unless an eligible Abel stage verified its invocation.",
+      "Private Abel workflow delegation: run bounded read-only evidence or Worker phase requests, apply or discard retained results, apply a parent-only stable AGENTS checkpoint, cancel work, or finish the stage. Inactive unless an eligible Abel stage verified its invocation.",
     parameters: {
       type: "object",
       properties: {
@@ -112,12 +129,32 @@ export default function register(pi: ExtensionAPI): void {
           type: "string",
           description: "Retained result id for apply/discard",
         },
+        requestId: {
+          type: "string",
+          description: "Current Implement apply/discard operation identity",
+        },
+        rejection: {
+          type: "object",
+          description: "Typed parent rejection for Implement discard",
+        },
+        agentsCheckpoint: {
+          type: "object",
+          description:
+            "Parent-owned approved managed-block checkpoint for action=apply (mutually exclusive with resultId)",
+        },
       },
       required: ["action"],
     },
     async execute(
       toolCallId: string,
-      params: { action?: string; request?: unknown; resultId?: string },
+      params: {
+        action?: string;
+        request?: unknown;
+        resultId?: string;
+        requestId?: string;
+        rejection?: unknown;
+        agentsCheckpoint?: unknown;
+      },
       signal: AbortSignal | undefined,
       onUpdate: AgentToolUpdateCallback<unknown> | undefined,
       ctx: ExtensionContext,
@@ -126,10 +163,11 @@ export default function register(pi: ExtensionAPI): void {
       const validRun =
         action === "run" && runtime.validateRequest(params.request).ok;
       const tuiRun = ctx.mode === "tui" && validRun;
+      const { action: _action, ...operation } = params;
       const result = tuiRun
         ? await runtime.execute(
             action,
-            params,
+            operation,
             ctx,
             signal,
             activity.observe(
@@ -137,24 +175,21 @@ export default function register(pi: ExtensionAPI): void {
               onUpdate as ((result: unknown) => void) | undefined,
             ),
           )
-        : await runtime.execute(action, params, ctx, signal);
+        : await runtime.execute(action, operation, ctx, signal);
       const display = tuiRun
         ? activity.finalize(toolCallId, result)
         : undefined;
+      const { payload, usage } = splitUsage(result);
       const details = display
-        ? { ...result, [ACTIVITY_DETAILS_KEY]: display }
-        : result;
-      if (result.ok) {
-        return {
-          content: [{ type: "text", text: JSON.stringify(result) }],
-          details,
-          usage: result.usage,
-        };
-      }
+        ? {
+            ...(payload as Record<string, unknown>),
+            [ACTIVITY_DETAILS_KEY]: display,
+          }
+        : payload;
       return {
-        content: [{ type: "text", text: result.error }],
+        content: [{ type: "text", text: JSON.stringify(payload) }],
         details,
-        isError: true,
+        ...(usage === undefined ? {} : { usage }),
       };
     },
     renderCall(args: unknown, theme: Theme, _context: unknown) {
@@ -177,23 +212,59 @@ export default function register(pi: ExtensionAPI): void {
     return { action: "continue" };
   });
 
-  pi.on("before_agent_start", (event) => {
+  pi.on("before_agent_start", (event, ctx) => {
     const prompt = pendingPrompt;
     pendingPrompt = undefined;
+    if (
+      prompt &&
+      isVerifiedStageInvocation(pi, runtime.activation, prompt, event.prompt)
+    ) {
+      const sessionId = ctx.sessionManager?.getSessionId?.();
+      if (typeof sessionId === "string") {
+        parentPayloadBridge.beginSession(sessionId);
+      } else {
+        parentPayloadBridge.clear();
+      }
+    }
+    if (ctx.model) {
+      parentPayloadBridge.install(ctx.model, ctx.modelRegistry);
+    }
     if (prompt)
       activateDispatcher(pi, runtime.activation, prompt, event.prompt);
   });
 
-  pi.on("session_start", (_event, ctx) => {
+  pi.on("session_start", async (_event, ctx) => {
     pendingPrompt = undefined;
     activity.detach();
-    if (ctx.mode === "tui") activity.attach(ctx.ui);
-    // Restore the default: dispatch is inactive unless a verified stage
-    // reactivates it through the activation helpers.
     const active = pi.getActiveTools();
     if (active.includes(DISPATCH_TOOL)) {
       pi.setActiveTools(deactivateTool(active, DISPATCH_TOOL));
     }
+    await runtime.drain();
+    activity.clear();
+    const sessionId = ctx.sessionManager?.getSessionId?.();
+    if (typeof sessionId === "string") {
+      parentPayloadBridge.beginSession(sessionId);
+      if (ctx.model) {
+        parentPayloadBridge.install(ctx.model, ctx.modelRegistry);
+      }
+    } else {
+      parentPayloadBridge.clear();
+    }
+    if (ctx.mode === "tui") activity.attach(ctx.ui);
+  });
+
+  pi.on("model_select", (event, ctx) => {
+    const sessionId = ctx.sessionManager?.getSessionId?.();
+    if (typeof sessionId !== "string") {
+      parentPayloadBridge.clear();
+      return;
+    }
+    parentPayloadBridge.beginSession(sessionId);
+    const model = event.model ?? ctx.model;
+    if (model) {
+      parentPayloadBridge.install(model, ctx.modelRegistry);
+    }
   });
 
   pi.on("session_shutdown", async () => {