@abelxiaoxing/cadence 1.6.0 → 1.7.0

package/src/index.ts

@@ -48,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";
 
@@ -707,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;
@@ -797,6 +804,7 @@ export function registerWorkflowControl(
   };
   const deactivateStage = async () => {
     activePrompt = undefined;
+    implementContinuation.deactivate();
     await packetRuntime.drain();
     deactivate();
   };
@@ -1349,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 ||
@@ -1385,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);
@@ -1395,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 &&
@@ -1408,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);
@@ -1422,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
@@ -1445,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();
@@ -1457,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-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 }
+      : {}),
   };
 }

package/src/package-workflow.ts

@@ -171,6 +171,9 @@ function openPreparedPackageWorkflowService(
                   (phase) => phase.verification,
                 ),
                 task.affectedVerification,
+                ...(task.baselineVerification
+                  ? [task.baselineVerification]
+                  : []),
                 task.repairVerification,
               ]),
               plan.verification.baseline.fullSuite,

package/src/phase-execution.ts

@@ -43,6 +43,7 @@ import {
   LOCKFILES,
   SHA256,
   semanticRouteFailure,
+  taskExecutionContract,
   type WorkflowAttemptOutcome,
   type WorkflowRouteFacts,
   type WorkflowWorker,
@@ -60,6 +61,7 @@ export interface PhaseExecutionServices {
     resources: PhaseResources;
     ledger: TaskLedger;
     signal: AbortSignal;
+    taskId?: string;
   }): Promise<DurableBaselineResult>;
   verifyTaskAffected(input: {
     resources: PhaseResources;
@@ -197,7 +199,10 @@ export class PhaseExecution {
       runId: input.runId,
       deliveryRevision: input.deliveryRevision,
       taskId: input.taskId,
-      boundaryHash: hash("durable-task-boundary", JSON.stringify(input.task)),
+      boundaryHash: hash(
+        "durable-task-boundary",
+        JSON.stringify(taskExecutionContract(input.task)),
+      ),
       objective: input.task.objective,
       contextRefs,
       initialPhase:
@@ -1562,6 +1567,7 @@ export class PhaseExecution {
         resources,
         ledger,
         signal: input.signal,
+        taskId: input.taskId,
       });
       if (!captured.ok) {
         const outcome = captured.outcome;