@abelxiaoxing/cadence 1.1.1 → 1.2.0

package/src/index.ts

@@ -210,6 +210,42 @@ const DESIGN_CONTROL_REQUEST_SCHEMA = {
   description:
     "One closed durable Design control operation. The operation body is strict and idempotent by operationId.",
   oneOf: [
+    ...(["requirement", "change"] as const).map((field) => ({
+      type: "object" as const,
+      properties: {
+        operation: { type: "string" as const, enum: ["start"] },
+        operationId: { type: "string" as const },
+        [field]: {
+          type: "string" as const,
+          description:
+            field === "requirement"
+              ? "Raw Design requirement; code derives and stores only its stable hash."
+              : "Existing canonical change name to resume or revise.",
+        },
+      },
+      required: ["operation", "operationId", field],
+      additionalProperties: false,
+    })),
+    {
+      type: "object",
+      properties: {
+        operation: { type: "string", enum: ["status"] },
+        runId: { type: "string" },
+      },
+      required: ["operation", "runId"],
+      additionalProperties: false,
+    },
+    {
+      type: "object",
+      properties: {
+        operation: { type: "string", enum: ["bind-change"] },
+        runId: { type: "string" },
+        operationId: { type: "string" },
+        change: { type: "string" },
+      },
+      required: ["operation", "runId", "operationId", "change"],
+      additionalProperties: false,
+    },
     {
       type: "object",
       properties: {
@@ -218,7 +254,11 @@ const DESIGN_CONTROL_REQUEST_SCHEMA = {
         operationId: { type: "string" },
         decisionId: { type: "string" },
         category: { type: "string", enum: ["behavior", "technical"] },
-        contractHash: { type: "string" },
+        contract: {
+          type: "string",
+          description:
+            "Normalized decision contract; code hashes it and never persists the text.",
+        },
         refs: { type: "array", items: { type: "string" } },
       },
       required: [
@@ -227,7 +267,7 @@ const DESIGN_CONTROL_REQUEST_SCHEMA = {
         "operationId",
         "decisionId",
         "category",
-        "contractHash",
+        "contract",
         "refs",
       ],
       additionalProperties: false,
@@ -238,10 +278,25 @@ const DESIGN_CONTROL_REQUEST_SCHEMA = {
         operation: { type: "string", enum: ["approve-gate"] },
         runId: { type: "string" },
         operationId: { type: "string" },
-        gate: { type: "string", enum: ["gate-a", "gate-b"] },
-        contractHash: { type: "string" },
+        gate: { type: "string", enum: ["gate-a"] },
+        contract: {
+          type: "string",
+          description:
+            "Complete approved WHAT contract; code hashes it and never persists the text.",
+        },
+      },
+      required: ["operation", "runId", "operationId", "gate", "contract"],
+      additionalProperties: false,
+    },
+    {
+      type: "object",
+      properties: {
+        operation: { type: "string", enum: ["approve-gate"] },
+        runId: { type: "string" },
+        operationId: { type: "string" },
+        gate: { type: "string", enum: ["gate-b"] },
       },
-      required: ["operation", "runId", "operationId", "gate", "contractHash"],
+      required: ["operation", "runId", "operationId", "gate"],
       additionalProperties: false,
     },
     {
@@ -417,7 +472,7 @@ export interface PackageDeliverySourceOptions {
 
 export interface PackageWorkflowDeliverySource extends WorkflowDeliverySource {
   discoverLatest(input: {
-    stage: "abel-design" | "abel-implement";
+    stage: "abel-implement";
     change: string;
   }): Promise<WorkflowAvailableDelivery | undefined>;
 }
@@ -1418,6 +1473,7 @@ export function openPackageWorkflowControlEngine(
   const routeResolution = loadRoutePolicy({
     cwd: consumerRoot,
     home: homedir(),
+    ...(initialContext.model ? { parentModel: initialContext.model } : {}),
   });
   const stateRoot = resolveStateRoot({
     consumerRoot,
@@ -1614,6 +1670,7 @@ export function openPackageWorkflowControlEngine(
       const operationRouteResolution = loadRoutePolicy({
         cwd: consumerRoot,
         home: homedir(),
+        ...(context.model ? { parentModel: context.model } : {}),
       });
       engine.updateRoutePolicy(
         operationRouteResolution.ok
@@ -1636,12 +1693,7 @@ export function openPackageWorkflowControlEngine(
           operationRouteResolution,
           engine.routePolicyStatus(),
         );
-        const designStatus =
-          validation.value.stage === "abel-design" &&
-          typeof outcome.runId === "string"
-            ? { design: design.status(outcome.runId) }
-            : {};
-        return { ...outcome, ...designStatus, routePolicy };
+        return { ...outcome, routePolicy };
       });
     },
     executeDesign(request: unknown) {
@@ -1781,10 +1833,9 @@ export function registerWorkflowControl(
       },
       stage: {
         type: "string",
-        enum: ["abel-design", "abel-implement"],
+        enum: ["abel-implement"],
       },
       change: { type: "string" },
-      provisionalKey: { type: "string" },
       operationId: { type: "string" },
       deliveryRevision: { type: "integer", minimum: 1 },
       receiptHash: { type: "string" },
@@ -1818,7 +1869,7 @@ export function registerWorkflowControl(
       label: "Abel Control",
       description:
         kind === "command"
-          ? "Private stage-bound Abel workflow control. Accepts durable Design and Implement change commands."
+          ? "Private stage-bound Abel workflow control. Accepts durable Implement change commands."
           : "Private stage-bound Abel packet control. Accepts bounded Design and Diagnose packet operations.",
       executionMode: "parallel",
       parameters:
@@ -2007,10 +2058,6 @@ export function registerWorkflowControl(
           ["completed", "discarded", "rejected"].includes(String(payload.state))
         ) {
           await deactivateStage();
-        } else if (validation.value.stage === "abel-design") {
-          // Design starts/statuses through the command surface, then switches to
-          // its bounded evidence and artifact packet surface for the next turn.
-          registerDispatchTool("packet");
         }
         let display: ReturnType<typeof activity.finalizeWorkflow>;
         if (tuiControl) {
@@ -2068,7 +2115,7 @@ export function registerWorkflowControl(
       if (activePrompt === "abel-design" && prompt !== "abel-design") {
         restoreDesignTools();
       }
-      registerDispatchTool(prompt === "abel-diagnose" ? "packet" : "command");
+      registerDispatchTool(prompt === "abel-implement" ? "command" : "packet");
       activePrompt = prompt;
       const sessionId = ctx.sessionManager?.getSessionId?.();
       if (typeof sessionId === "string") {

package/src/packet-runtime.ts

@@ -20,7 +20,6 @@ import { runtimeForWorkerRoute } from "./parent-provider.ts";
 import {
   loadRoutePolicy,
   type RoutePolicy,
-  unavailableRoutePolicy,
   type WorkerRole,
 } from "./route-policy.ts";
 import { type BrokerActivityUpdate, RunWorkerBroker } from "./worker-broker.ts";
@@ -319,7 +318,7 @@ export class PacketRuntime {
     if (!agent) {
       throw new Error("packet agent definition is unavailable");
     }
-    const broker = this.#brokerFor(context.cwd);
+    const broker = this.#brokerFor(context);
     const routed = await broker.run({
       runId: `${packet.stage}:${packet.id}`,
       operationId: packet.id,
@@ -405,8 +404,8 @@ export class PacketRuntime {
     return routed.value.child;
   }
 
-  #brokerFor(cwd: string): RunWorkerBroker {
-    const root = path.resolve(cwd);
+  #brokerFor(context: PacketContext): RunWorkerBroker {
+    const root = path.resolve(context.cwd);
     const existing = this.#brokers.get(root);
     let policy = this.#routePolicy;
     if (policy && existing) return existing;
@@ -414,12 +413,13 @@ export class PacketRuntime {
       const resolution = loadRoutePolicy({
         cwd: root,
         ...(this.#routePolicyHome ? { home: this.#routePolicyHome } : {}),
+        ...(context.model ? { parentModel: context.model } : {}),
       });
-      if (!resolution.ok && resolution.source.kind !== "none") {
+      if (!resolution.ok) {
         const code = resolution.diagnostics[0]?.code ?? "policy-invalid";
         throw new Error(`route-policy-unavailable:${code}`);
       }
-      policy = resolution.ok ? resolution.policy : unavailableRoutePolicy();
+      policy = resolution.policy;
     }
     const serializedPolicy = JSON.stringify(policy);
     if (existing && this.#brokerPolicies.get(root) === serializedPolicy) {

package/src/route-policy.ts

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { lstatSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 import { ROLES } from "./contracts.ts";
@@ -21,6 +21,11 @@ export interface RouteCapabilities {
   maxTokens: number;
 }
 
+export interface ParentModelCapabilities {
+  contextWindow: number;
+  maxTokens: number;
+}
+
 interface RouteBase {
   id: string;
   kind: "inherited" | "custom";
@@ -50,10 +55,9 @@ export interface RoutePolicy {
 
 export type RoutePolicySource =
   | { kind: "project" | "user"; path: string }
-  | { kind: "none" };
+  | { kind: "default" };
 
 export type RoutePolicyDiagnosticCode =
-  | "policy-missing"
   | "policy-unreadable"
   | "policy-invalid-json"
   | "policy-invalid"
@@ -77,7 +81,7 @@ export type ParsedRoutePolicy =
 export type RoutePolicyResolution =
   | {
       ok: true;
-      source: Extract<RoutePolicySource, { kind: "project" | "user" }>;
+      source: RoutePolicySource;
       policy: RoutePolicy;
     }
   | {
@@ -87,8 +91,8 @@ export type RoutePolicyResolution =
     };
 
 /**
- * Internal fail-closed policy used while the selected external policy is
- * missing or invalid. It deliberately contains no inherited-parent route:
+ * Internal fail-closed policy used while a selected explicit policy is
+ * invalid. It deliberately contains no inherited-parent route:
  * the broker therefore reports endpoint-unavailable without making a Worker
  * request, while the local durable control plane remains available.
  *
@@ -351,8 +355,16 @@ export function parseRoutePolicy(value: unknown): ParsedRoutePolicy {
   };
 }
 
-/** Parent-model route used by read-only Design and Diagnose packets. */
-export function parentRoutePolicy(): RoutePolicy {
+/** Default parent-model route used when no explicit policy file exists. */
+export function parentRoutePolicy(
+  parentModel?: ParentModelCapabilities,
+): RoutePolicy {
+  const contextWindow = positiveInteger(parentModel?.contextWindow)
+    ? parentModel.contextWindow
+    : 1;
+  const maxTokens = positiveInteger(parentModel?.maxTokens)
+    ? Math.min(parentModel.maxTokens, contextWindow)
+    : 1;
   const parsed = parseRoutePolicy({
     version: ROUTE_POLICY_VERSION,
     routes: {
@@ -361,8 +373,8 @@ export function parentRoutePolicy(): RoutePolicy {
         capabilities: {
           roles: [...ROLES],
           dialects: [...ROUTE_DIALECTS],
-          contextWindow: 1_000_000,
-          maxTokens: 500_000,
+          contextWindow,
+          maxTokens,
         },
       },
     },
@@ -372,25 +384,41 @@ export function parentRoutePolicy(): RoutePolicy {
   return parsed.policy;
 }
 
-function selectedSource(cwd: string, home: string): RoutePolicySource {
+function selectedSource(
+  cwd: string,
+  home: string,
+): { kind: "project" | "user"; path: string } | { kind: "none" } {
+  const mayExist = (candidate: string): boolean => {
+    try {
+      return lstatSync(candidate, { throwIfNoEntry: false }) !== undefined;
+    } catch {
+      // Permission and path-observation failures are explicit unreadable
+      // policy candidates, not proof that the policy is absent.
+      return true;
+    }
+  };
   const projectPath = path.join(cwd, ".pi", "cadence", "routes.json");
-  if (existsSync(projectPath)) return { kind: "project", path: projectPath };
+  if (mayExist(projectPath)) return { kind: "project", path: projectPath };
   const userPath = path.join(home, ".pi", "agent", "cadence", "routes.json");
-  if (existsSync(userPath)) return { kind: "user", path: userPath };
+  if (mayExist(userPath)) return { kind: "user", path: userPath };
   return { kind: "none" };
 }
 
 export function loadRoutePolicy(
-  options: { cwd?: string; home?: string } = {},
+  options: {
+    cwd?: string;
+    home?: string;
+    parentModel?: ParentModelCapabilities;
+  } = {},
 ): RoutePolicyResolution {
   const cwd = path.resolve(options.cwd ?? process.cwd());
   const home = path.resolve(options.home ?? homedir());
   const source = selectedSource(cwd, home);
   if (source.kind === "none") {
     return {
-      ok: false,
-      source,
-      diagnostics: [{ code: "policy-missing" }],
+      ok: true,
+      source: { kind: "default" },
+      policy: parentRoutePolicy(options.parentModel),
     };
   }
   let bytes: string;

package/src/run-state.ts

@@ -1,5 +1,7 @@
 import { createHash } from "node:crypto";
-import type { ControlStage } from "./control-contracts.ts";
+
+export const RUN_STAGES = ["abel-design", "abel-implement"] as const;
+export type RunStage = (typeof RUN_STAGES)[number];
 
 export const RUN_STATES = [
   "created",
@@ -57,7 +59,7 @@ export interface DeliveryBindingProjection {
 export interface RunProjection {
   runId: string;
   rootHash: string;
-  stage: ControlStage;
+  stage: RunStage;
   change?: string;
   provisionalKey?: string;
   state: RunState;

package/src/run-store.ts

@@ -1,12 +1,12 @@
 import { randomUUID } from "node:crypto";
 import { chmodSync, closeSync, lstatSync, openSync } from "node:fs";
 import { DatabaseSync } from "node:sqlite";
-import type { ControlStage } from "./control-contracts.ts";
 import {
   createRunEvent,
   type DeliveryGate,
   type RunEvent,
   type RunProjection,
+  type RunStage,
   type RunState,
   reduceRunEvents,
   ZERO_EVENT_HASH,
@@ -37,6 +37,7 @@ interface EventRow {
 }
 
 interface OperationRow {
+  kind: string;
   state: string;
   outcome_json: string | null;
   lease_token: string | null;
@@ -49,7 +50,7 @@ export interface RunStoreOptions {
 }
 
 export interface StartRunInput {
-  stage: ControlStage;
+  stage: RunStage;
   change?: string;
   provisionalKey?: string;
   operationId: string;
@@ -338,7 +339,7 @@ export class RunStore {
   #operation(runId: string, operationId: string): OperationRow | undefined {
     return this.#database
       .prepare(
-        `SELECT state, outcome_json, lease_token, lease_expires_at
+        `SELECT kind, state, outcome_json, lease_token, lease_expires_at
          FROM operations WHERE run_id = ? AND operation_id = ?`,
       )
       .get(runId, operationId) as OperationRow | undefined;
@@ -347,8 +348,10 @@ export class RunStore {
   #operationOutcome(
     runId: string,
     operationId: string,
+    kind: string,
   ): RunProjection | undefined {
     const row = this.#operation(runId, operationId);
+    if (row && row.kind !== kind) throw new Error("operation-id-conflict");
     if (row?.state !== "committed" || row.outcome_json === null)
       return undefined;
     return parseProjection(row.outcome_json);
@@ -465,6 +468,7 @@ export class RunStore {
         const replay = this.#operationOutcome(
           existing.run_id,
           input.operationId,
+          "start",
         );
         if (replay) return replay;
         const projection = parseProjection(existing.projection_json);
@@ -539,7 +543,11 @@ export class RunStore {
     requireIdentifier(input.operationId, "operation-id");
     if (!CHANGE_NAME.test(input.change)) throw new Error("invalid-change");
     return this.#transaction(() => {
-      const replay = this.#operationOutcome(input.runId, input.operationId);
+      const replay = this.#operationOutcome(
+        input.runId,
+        input.operationId,
+        "change-bound",
+      );
       if (replay) return replay;
       const current = this.status(input.runId);
       if (current.stage !== "abel-design" || !current.provisionalKey) {
@@ -597,7 +605,11 @@ export class RunStore {
       if (input.lease.runId !== input.runId) throw new Error("lease-fenced");
       this.#assertLease(input.lease);
     }
-    const replay = this.#operationOutcome(input.runId, input.operationId);
+    const replay = this.#operationOutcome(
+      input.runId,
+      input.operationId,
+      "delivery-bound",
+    );
     if (replay) return replay;
     const existing = this.#database
       .prepare(
@@ -911,7 +923,11 @@ export class RunStore {
         if (input.lease.runId !== input.runId) throw new Error("lease-fenced");
         this.#assertLease(input.lease);
       }
-      const replay = this.#operationOutcome(input.runId, input.operationId);
+      const replay = this.#operationOutcome(
+        input.runId,
+        input.operationId,
+        "state-transitioned",
+      );
       if (replay) return replay;
       const current = this.status(input.runId);
       const projection = this.#appendEvent(input.runId, "state-transitioned", {