@abelxiaoxing/cadence 1.3.0 → 1.4.1

package/src/subagent-activity.ts

@@ -12,8 +12,11 @@ import {
 import type {
   PacketActivityEvent,
   PacketActivityObserver,
-  PacketActivityState,
-} from "./packet-runtime.ts";
+} from "./activity-contracts.ts";
+import {
+  projectDesignDiagnostic,
+  type SafeDesignDiagnostic,
+} from "./design-diagnostics.ts";
 
 export const ACTIVITY_DETAILS_KEY = "activityDisplay" as const;
 export const ACTIVITY_WIDGET_KEY = "abel-subagents" as const;
@@ -22,51 +25,20 @@ export const ACTIVITY_REFRESH_MS = 100;
 export const ACTIVITY_WIDGET_MAX_LINES = 12;
 export const ACTIVITY_WIDGET_MIN_WIDTH = 3;
 
-export const WORKFLOW_ACTIVITY_STATES = [
-  "queued",
-  "connecting",
-  "waiting-first-response",
-  "running",
-  "validating",
-  "retrying",
-  "verifying",
-  "paused",
-  "approval-needed",
-  "applying",
-  "recovering",
-  "operation-cancelled",
-  "discarded",
-  "rejected",
-  "completed",
-] as const;
-
-export type WorkflowActivityState = (typeof WORKFLOW_ACTIVITY_STATES)[number];
-export type ActivityState = PacketActivityState | WorkflowActivityState;
-export type TerminalActivityState =
-  | Exclude<
-      PacketActivityState,
-      | "queued"
-      | "connecting"
-      | "waiting-first-response"
-      | "running"
-      | "retrying"
-    >
-  | WorkflowActivityState;
-
-export interface WorkflowActivityUpdate {
-  state: WorkflowActivityState;
-  stage?: "abel-design" | "abel-implement";
-  runId?: string;
-  change?: string;
-  taskId?: string;
-  phase?: string;
-  objective?: string;
-  code?: string;
-  attempt?: number;
-  maxAttempts?: number;
-  wait?: string;
-  legalCommands?: string[];
-}
+export type {
+  ActivityState,
+  TerminalActivityState,
+  WorkflowActivityState,
+  WorkflowActivityUpdate,
+} from "./activity-contracts.ts";
+export { WORKFLOW_ACTIVITY_STATES } from "./activity-contracts.ts";
+
+import type {
+  ActivityState,
+  TerminalActivityState,
+  WorkflowActivityState,
+  WorkflowActivityUpdate,
+} from "./activity-contracts.ts";
 
 export interface EvidenceActivitySummary {
   kind: "evidence";
@@ -224,7 +196,7 @@ export function sanitizeFailureReason(value: unknown, maxLength = 240): string {
 function safeDesignFailure(value: unknown): {
   operation: string;
   code: string;
-  diagnostics: Array<Record<string, string>>;
+  diagnostics: SafeDesignDiagnostic[];
 } | null {
   const failure = asRecord(value);
   if (
@@ -237,23 +209,9 @@ function safeDesignFailure(value: unknown): {
   ) {
     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>,
-    ];
+  const diagnostics = failure.diagnostics.slice(0, 64).flatMap((candidate) => {
+    const diagnostic = projectDesignDiagnostic(candidate);
+    return diagnostic ? [diagnostic] : [];
   });
   return {
     operation: failure.operation,
@@ -286,7 +244,10 @@ function renderDesignFailure(
   const lines = failure.diagnostics.map((diagnostic) => {
     const details = Object.entries(diagnostic)
       .filter(([key]) => key !== "code")
-      .map(([key, value]) => `${key}=${value}`)
+      .map(
+        ([key, value]) =>
+          `${key}=${Array.isArray(value) ? JSON.stringify(value) : value}`,
+      )
       .join(" · ");
     return `  - ${diagnostic.code}${details ? ` · ${details}` : ""}`;
   });
@@ -315,6 +276,7 @@ function stateGlyph(state: ActivityState, spinnerFrame = 0): string {
   switch (state) {
     case "queued":
       return "…";
+    case "preparing":
     case "connecting":
     case "waiting-first-response":
     case "running":
@@ -532,6 +494,17 @@ function asRecord(value: unknown): Record<string, unknown> | undefined {
     : undefined;
 }
 
+function hasAutomaticContinuation(result: Record<string, unknown>): boolean {
+  const continuation = asRecord(result.continuation);
+  return (
+    ["paused", "approval-needed"].includes(String(result.state)) &&
+    asRecord(result.pause)?.code !== "operation-cancelled" &&
+    continuation?.owner === "parent" &&
+    continuation.automatic === true &&
+    (continuation.action === "amend" || continuation.command === "resume")
+  );
+}
+
 function workflowStateOf(
   result: Record<string, unknown>,
 ): WorkflowActivityState {
@@ -544,6 +517,7 @@ function workflowStateOf(
   ) {
     return "operation-cancelled";
   }
+  if (hasAutomaticContinuation(result)) return "recovering";
   const state = result.state;
   switch (state) {
     case "not-started":
@@ -551,6 +525,8 @@ function workflowStateOf(
     case "ready":
     case "queued":
       return "queued";
+    case "preparing":
+      return "preparing";
     case "connecting":
       return "connecting";
     case "waiting-first-response":
@@ -669,6 +645,7 @@ function workflowWait(
   ) {
     return approval.gate;
   }
+  if (state === "preparing") return "worker-setup";
   if (state === "connecting") return "connection";
   if (state === "waiting-first-response") return "first-response";
   if (state === "retrying") return "bounded-policy";
@@ -755,7 +732,8 @@ export function projectWorkflowActivity(
     ...(workflowWait(state, payload)
       ? { wait: workflowWait(state, payload) }
       : {}),
-    ...(nextWorkflowAction(state, legalCommands)
+    ...(!hasAutomaticContinuation(payload) &&
+    nextWorkflowAction(state, legalCommands)
       ? { nextAction: nextWorkflowAction(state, legalCommands) }
       : {}),
   };
@@ -854,6 +832,7 @@ function terminalState(
 } {
   return ![
     "queued",
+    "preparing",
     "connecting",
     "waiting-first-response",
     "running",

package/src/submit-tool.ts

@@ -17,65 +17,16 @@ import {
   validateDiffResult,
   validateEvidenceResult,
 } from "./contracts.ts";
+import {
+  completeEvidenceDraft,
+  evidenceDraftSchema,
+} from "./evidence-draft.ts";
 import {
   type BeginCandidateInput,
   TASK_LEDGER_LIMITS,
   type TaskLedger,
 } from "./task-ledger.ts";
 
-const compactEvidenceSchema = Type.Object({
-  id: Type.String(),
-  role: Type.String(),
-  kind: Type.Literal("evidence"),
-  conclusions: Type.Array(Type.String()),
-  citations: Type.Array(
-    Type.Object({ path: Type.String(), lines: Type.String() }),
-  ),
-  constraints: Type.Array(Type.String()),
-  dependencies: Type.Array(Type.String()),
-  risks: Type.Array(Type.String()),
-  blockingQuestions: Type.Array(Type.String()),
-  hints: Type.Object({
-    writeSet: Type.Array(Type.String()),
-    verification: Type.String(),
-    agentsImpact: Type.String(),
-  }),
-});
-
-const designEvidenceSchema = Type.Object(
-  {
-    id: Type.String(),
-    role: Type.Literal("design-explorer"),
-    kind: Type.Literal("evidence"),
-    packet_id: Type.String(),
-    module_name: Type.String(),
-    scope: Type.Array(Type.String()),
-    files_read: Type.Array(Type.String()),
-    evidence: Type.Array(
-      Type.Object(
-        {
-          claim: Type.String(),
-          path: Type.String(),
-          line_start: Type.Integer({ minimum: 1 }),
-          line_end: Type.Integer({ minimum: 1 }),
-        },
-        { additionalProperties: false },
-      ),
-    ),
-    existing_structures: Type.Array(Type.String()),
-    existing_conventions: Type.Array(Type.String()),
-    constraints_discovered: Type.Array(Type.String()),
-    open_questions: Type.Array(Type.String()),
-    dependencies: Type.Array(Type.String()),
-    write_set_hints: Type.Array(Type.String()),
-    validation_hints: Type.Array(Type.String()),
-    agents_impact_hints: Type.Array(Type.String()),
-    risks: Type.Array(Type.String()),
-    success_criteria_hints: Type.Array(Type.String()),
-  },
-  { additionalProperties: false },
-);
-
 const diffSchema = Type.Object({
   id: Type.String(),
   role: Type.String(),
@@ -225,6 +176,7 @@ export interface CandidateContextBoundary {
   writePaths: readonly string[];
   deletePaths?: readonly string[];
   taskPaths: readonly string[];
+  contextReadRoots?: readonly string[];
   redWritePaths: readonly string[];
   agents: {
     impact: "none" | "update-existing" | "create-index" | "remove-index";
@@ -354,6 +306,19 @@ function pathWithinAny(relative: string, approved: readonly string[]): boolean {
   return approved.some((path) => contextRefWithinBoundary(relative, path));
 }
 
+export function permitsContextRead(
+  relative: string,
+  roots: readonly string[],
+): boolean {
+  // Dynamic discovery never grants hidden credentials or a directory tree.
+  return (
+    isValidRelativePath(relative) &&
+    relative.split("/").every((part) => !part.startsWith(".")) &&
+    !/\.(?:pem|key|p12|pfx)$/iu.test(relative) &&
+    pathWithinAny(relative, roots)
+  );
+}
+
 export function classifyCandidateContextRequest(
   request: {
     kind: "context-request";
@@ -377,11 +342,15 @@ export function classifyCandidateContextRequest(
   const ordinaryRequested = requested.filter((ref) => !isAgentsPath(ref.path));
   const outsideOrdinary = ordinaryRequested.filter(
     (ref) =>
+      !(
+        ref.access === "read" &&
+        permitsContextRead(ref.path, boundary.contextReadRoots ?? [])
+      ) &&
       !pathWithinAny(
         ref.path,
         ref.access === "write"
           ? [...boundary.writePaths, ...(boundary.deletePaths ?? [])]
-          : phasePaths,
+          : [...phasePaths, ...boundary.taskPaths],
       ),
   );
   const agentsRequested = requested.filter((ref) => isAgentsPath(ref.path));
@@ -428,7 +397,7 @@ export function classifyCandidateContextRequest(
     classification = { kind: "paused", code: "agents-context-needed" };
   } else {
     classification = {
-      kind: request.code === "approved-context-needed" ? "retryable" : "paused",
+      kind: "retryable",
       code:
         request.code === "task-split-needed"
           ? "task-split-needed"
@@ -863,13 +832,11 @@ export function createSubmitTool(input: {
     name: "abel_submit_result",
     label: "Submit Abel Result",
     description:
-      "Submit the one final structured Abel evidence or complete unified-diff result.",
+      "Submit one accepted final result. Evidence identity and omitted advisory fields are completed by this tool; keep citations, constraints, risks, and open questions explicit. After a rejection, correct once in this same session. Brief accompanying text is harmless.",
     executionMode: "sequential",
     parameters:
       input.output === "evidence"
-        ? input.role === "design-explorer"
-          ? designEvidenceSchema
-          : compactEvidenceSchema
+        ? evidenceDraftSchema(input.requestId, input.role)
         : diffSchema,
     async execute(_toolCallId, params) {
       attempts++;
@@ -898,7 +865,11 @@ export function createSubmitTool(input: {
         phase: true,
       };
       failure = undefined;
-      const value = params as unknown as Record<string, unknown>;
+      const value = (
+        input.output === "evidence"
+          ? completeEvidenceDraft(params, input.requestId, input.role)
+          : params
+      ) as Record<string, unknown>;
       if (value === null || typeof value !== "object") {
         identity.request = false;
         identity.role = false;
@@ -945,7 +916,15 @@ export function createSubmitTool(input: {
               stage: "structural-submit",
             });
         throw new Error(
-          validation.reason ?? "submitted result identity does not match",
+          JSON.stringify({
+            code: "code" in failure ? failure.code : failure.kind,
+            reason:
+              validation.reason ?? "submitted result identity does not match",
+            identityMismatch: Object.entries(identity)
+              .filter(([, matches]) => !matches)
+              .map(([field]) => field),
+            remainingCorrections: Math.max(0, 2 - attempts),
+          }),
         );
       }
       submitted = structuredClone(value) as unknown as

package/src/task-ledger.ts

@@ -2,14 +2,16 @@ import { createHash } from "node:crypto";
 import { chmodSync, lstatSync, mkdirSync } from "node:fs";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
-
 import type { ArtifactStore } from "./artifact-store.ts";
+import { compareCanonicalStrings } from "./canonical.ts";
 import {
   diffWritePaths,
   IMPLEMENTATION_PHASES,
   type ImplementationPhase,
   isValidRelativePath,
 } from "./contracts.ts";
+import { configureSqlite, ensureSqliteSchema } from "./sqlite-schema.ts";
+import { TASK_SCHEMA } from "./storage-schema.ts";
 
 export const TASK_LEDGER_LIMITS = {
   maxSegmentBytes: 128 * 1024,
@@ -413,7 +415,9 @@ function normalizeContextRefs(value: unknown): TaskContextReference[] {
   if (new Set(identities).size !== identities.length) {
     throw new Error("ledger-context-refs-invalid");
   }
-  return refs.sort((left, right) => left.path.localeCompare(right.path));
+  return refs.sort((left, right) =>
+    compareCanonicalStrings(left.path, right.path),
+  );
 }
 
 function safeText(value: unknown, code: string, maximum = 256): string {
@@ -694,57 +698,8 @@ export class TaskLedger {
       throw new Error("task-ledger-database-invalid");
     }
     this.#database = new DatabaseSync(databasePath);
-    this.#database.exec(
-      "PRAGMA journal_mode = WAL; PRAGMA synchronous = FULL; PRAGMA foreign_keys = ON;",
-    );
-    this.#database.exec(`
-      CREATE TABLE IF NOT EXISTS candidates (
-        candidate_id TEXT PRIMARY KEY,
-        identity_json TEXT NOT NULL,
-        state TEXT NOT NULL,
-        next_sequence INTEGER NOT NULL,
-        total_bytes INTEGER NOT NULL,
-        artifact_hash TEXT,
-        candidate_hash TEXT,
-        segment_count INTEGER,
-        paths_json TEXT,
-        pause_code TEXT
-      ) STRICT;
-      CREATE TABLE IF NOT EXISTS candidate_segments (
-        candidate_id TEXT NOT NULL REFERENCES candidates(candidate_id) ON DELETE CASCADE,
-        sequence INTEGER NOT NULL,
-        artifact_hash TEXT NOT NULL,
-        size_bytes INTEGER NOT NULL,
-        segment_hash TEXT NOT NULL,
-        PRIMARY KEY (candidate_id, sequence)
-      ) STRICT;
-      CREATE TABLE IF NOT EXISTS task_ledger (
-        run_id TEXT NOT NULL,
-        task_id TEXT NOT NULL,
-        delivery_revision INTEGER NOT NULL,
-        boundary_hash TEXT NOT NULL,
-        objective TEXT NOT NULL,
-        context_refs_json TEXT NOT NULL,
-        initial_phase TEXT NOT NULL,
-        PRIMARY KEY (run_id, task_id)
-      ) STRICT;
-      CREATE TABLE IF NOT EXISTS task_events (
-        run_id TEXT NOT NULL,
-        task_id TEXT NOT NULL,
-        ordinal INTEGER NOT NULL,
-        event_id TEXT NOT NULL,
-        event_json TEXT NOT NULL,
-        prior_hash TEXT NOT NULL,
-        event_hash TEXT NOT NULL,
-        PRIMARY KEY (run_id, task_id, ordinal),
-        UNIQUE (run_id, task_id, event_id),
-        FOREIGN KEY (run_id, task_id) REFERENCES task_ledger(run_id, task_id) ON DELETE CASCADE
-      ) STRICT;
-      CREATE TABLE IF NOT EXISTS durable_facts (
-        fact_key TEXT PRIMARY KEY,
-        fact_json TEXT NOT NULL
-      ) STRICT;
-    `);
+    configureSqlite(this.#database);
+    ensureSqliteSchema(this.#database, TASK_SCHEMA);
     chmodSync(databasePath, 0o600);
   }
 
@@ -1173,7 +1128,7 @@ export class TaskLedger {
   commitVerifiedEvent(input: VerifiedTaskEvent) {
     this.#assertOpen();
     const normalized = normalizeVerifiedEvent(input);
-    this.#task(normalized.runId, normalized.taskId);
+    const task = this.#task(normalized.runId, normalized.taskId);
     const rows = this.#events(normalized.runId, normalized.taskId);
     const existing = rows.find((row) => row.event_id === normalized.eventId);
     const json = JSON.stringify(normalized);
@@ -1186,6 +1141,8 @@ export class TaskLedger {
       throw new Error("ledger-event-capacity-exceeded");
     }
     if (normalized.kind === "phase-verified") {
+      if (task.initial_phase === "green" && normalized.phase === "red")
+        throw new Error("ledger-phase-order-invalid");
       const completed = rows
         .map((row) => JSON.parse(row.event_json) as VerifiedTaskEvent)
         .filter(
@@ -1195,7 +1152,9 @@ export class TaskLedger {
         .map((event) => event.phase);
       const required =
         normalized.phase === "green"
-          ? "red"
+          ? task.initial_phase === "green"
+            ? undefined
+            : "red"
           : normalized.phase === "refactor"
             ? "green"
             : undefined;

package/src/transport-budget.ts

@@ -0,0 +1,32 @@
+/** Request budgets describe observable model progress, never TCP/TLS events. */
+export const REQUEST_BOUNDS = Object.freeze({
+  firstProgressMs: 90_000,
+  streamIdleMs: 180_000,
+  cancellationDrainMs: 250,
+});
+export type TransportTimeoutCode =
+  | "first-progress-timeout"
+  | "stream-idle-timeout"
+  | "attempt-timeout";
+export class TransportTimeout extends Error {
+  readonly scope: "request" | "attempt";
+  constructor(readonly code: TransportTimeoutCode) {
+    super(code);
+    this.name = "TransportTimeout";
+    this.scope = code === "attempt-timeout" ? "attempt" : "request";
+  }
+}
+export function isTransportTimeoutCode(
+  code: string,
+): code is TransportTimeoutCode {
+  return [
+    "first-progress-timeout",
+    "stream-idle-timeout",
+    "attempt-timeout",
+  ].includes(code);
+}
+export function transportFailureError(code: string): Error {
+  return isTransportTimeoutCode(code)
+    ? new TransportTimeout(code)
+    : new Error("transport-failure");
+}