agentic-qe 3.15.8 → 3.15.10

package/dist/coordination/queen-work-stealing.d.ts

@@ -14,8 +14,13 @@ export interface QueenWorkStealingContext {
     getIdleDomains(): DomainName[];
     getBusyDomains(): DomainName[];
     getDomainLoad(domain: DomainName): number;
+    /** #1140: free Queen slots; a steal starts a task, so it needs one */
+    availableSlots(): number;
+    /** #1124: the domain is configured for the task and its plugin can execute it */
+    canExecuteInDomain(domain: DomainName, task: QueenTask): boolean;
     removeFromQueues(task: QueenTask): void;
-    assignTaskToDomain(task: QueenTask, domain: DomainName): Promise<void>;
+    /** Dispatch a stolen task; resolves whether it now runs in `domain`. */
+    assignTaskToDomain(task: QueenTask, domain: DomainName): Promise<boolean>;
     publishEvent(type: string, payload: Record<string, unknown>): Promise<void>;
 }
 /**

package/dist/coordination/queen-work-stealing.js

@@ -4,7 +4,6 @@
  * exponential backoff and automatic disable on repeated failures.
  */
 import { toErrorMessage } from '../shared/error-utils.js';
-import { canDomainHandleTask } from './queen-task-management.js';
 // ============================================================================
 // Work stealing algorithm
 // ============================================================================
@@ -26,14 +25,18 @@ export async function triggerWorkStealing(ctx) {
             break;
         const queue = ctx.domainQueues.get(busyDomain) || [];
         const stealCount = Math.min(queue.length, ctx.config.workStealing.stealBatchSize);
-        for (let i = 0; i < stealCount && idleDomains.length > 0; i++) {
-            const task = queue.find(t => canDomainHandleTask(idleDomains[0], t));
+        // #1140: each steal takes a slot, so stop when none is free.
+        for (let i = 0; i < stealCount && idleDomains.length > 0 && ctx.availableSlots() > 0; i++) {
+            const task = queue.find(t => ctx.canExecuteInDomain(idleDomains[0], t));
             if (task) {
                 const stealerDomain = idleDomains.shift();
                 ctx.removeFromQueues(task);
+                // #1124: a task that is not running afterwards (already terminal, or
+                // failed at assignment) was not stolen.
+                if (!await ctx.assignTaskToDomain(task, stealerDomain))
+                    continue;
                 // SEC-003 Simplified: Log work stealing for observability
                 ctx.auditLogger.logSteal(task.id, busyDomain, stealerDomain);
-                await ctx.assignTaskToDomain(task, stealerDomain);
                 stolenCount++;
                 ctx.tasksStolen++;
                 await ctx.publishEvent('TaskStolen', {

package/dist/coordination/result-saver-adapters.d.ts

@@ -0,0 +1,15 @@
+/**
+ * #1125 review: task_orchestrate and `aqe fleet run` now submit the domains'
+ * concrete handler types (sast-scan, analyze-quality) for the abstract types
+ * scan-security and assess-quality. These adapters map those handler results
+ * onto the report shapes ResultSaver already writes, so they are saved by the
+ * security and quality savers rather than as generic JSON. Nothing missing
+ * from a result is filled in: absent values stay absent.
+ */
+import type { TaskType } from './queen-types.js';
+/** The saver type and report for a task result; other types pass through. */
+export declare function resultForSaver(taskType: string, result: unknown): {
+    saveType: TaskType;
+    report: unknown;
+};
+//# sourceMappingURL=result-saver-adapters.d.ts.map

package/dist/coordination/result-saver-adapters.js

@@ -0,0 +1,57 @@
+const asRecord = (value) => value !== null && typeof value === 'object' ? value : {};
+/** sast-scan's SASTResult -> the scan-security report shape. */
+function securityReport(result) {
+    const data = asRecord(result);
+    const summary = asRecord(data.summary);
+    const findings = Array.isArray(data.vulnerabilities) ? data.vulnerabilities : [];
+    const count = (severity) => typeof summary[severity] === 'number' ? summary[severity] : 0;
+    return {
+        vulnerabilities: findings.length,
+        critical: count('critical'),
+        high: count('high'),
+        medium: count('medium'),
+        low: count('low'),
+        topVulnerabilities: findings.slice(0, 10).map(f => ({
+            type: f.title ?? f.category ?? 'finding',
+            severity: f.severity ?? 'unknown',
+            file: f.location?.file ?? '',
+            line: f.location?.line ?? 0,
+        })),
+        findings: findings.map(f => ({
+            title: f.title, type: f.category, severity: f.severity ?? 'unknown', location: f.location?.file
+                ? { file: f.location.file, line: f.location.line } : undefined, description: f.description,
+        })),
+        recommendations: [],
+        evidence: data.evidence,
+        coverage: data.coverage,
+        analysisDepth: 'sast-patterns',
+    };
+}
+/** analyze-quality's analysis -> the assess-quality report shape. No gate runs. */
+function qualityReport(result) {
+    const data = asRecord(result);
+    const score = asRecord(data.score);
+    const metrics = Array.isArray(data.metrics) ? data.metrics : [];
+    const unmeasured = Array.isArray(data.unmeasured)
+        ? data.unmeasured.map(u => u.metric).filter((m) => !!m)
+        : [];
+    return {
+        ...(typeof score.overall === 'number' ? { qualityScore: score.overall } : {}),
+        passed: false,
+        gateEvaluated: false,
+        metrics: Object.fromEntries(metrics.filter(m => m.name && typeof m.value === 'number').map(m => [m.name, m.value])),
+        recommendations: Array.isArray(data.recommendations) ? data.recommendations : [],
+        unmeasured,
+        evidenceStatus: unmeasured.length > 0 ? 'insufficient-evidence' : 'measured',
+        scoreBasis: metrics.map(m => m.name).filter((m) => !!m),
+    };
+}
+/** The saver type and report for a task result; other types pass through. */
+export function resultForSaver(taskType, result) {
+    switch (taskType) {
+        case 'sast-scan': return { saveType: 'scan-security', report: securityReport(result) };
+        case 'analyze-quality': return { saveType: 'assess-quality', report: qualityReport(result) };
+        default: return { saveType: taskType, report: result };
+    }
+}
+//# sourceMappingURL=result-saver-adapters.js.map

package/dist/coordination/result-saver.d.ts

@@ -58,7 +58,7 @@ export declare class ResultSaver {
     /**
      * Save task result in appropriate format(s)
      */
-    save(taskId: string, taskType: TaskType, result: unknown, options?: SaveOptions): Promise<SavedResult>;
+    save(taskId: string, taskType: TaskType, taskResult: unknown, options?: SaveOptions): Promise<SavedResult>;
     private saveTestGeneration;
     private saveCoverage;
     private saveSecurityScan;

package/dist/coordination/result-saver.js

@@ -7,6 +7,7 @@ import * as path from 'path';
 import { createHash, randomBytes } from 'crypto';
 import { safeJsonParse } from '../shared/safe-json.js';
 import { getProjectStorePath } from '../kernel/project-root.js';
+import { resultForSaver } from './result-saver-adapters.js';
 /** Cap on the sanitized stem of a generated test file name (see generatedTestFilename). */
 const MAX_GENERATED_STEM_LENGTH = 100;
 function securityReportExecution(data) {
@@ -92,12 +93,14 @@ export class ResultSaver {
     /**
      * Save task result in appropriate format(s)
      */
-    async save(taskId, taskType, result, options = {}) {
+    async save(taskId, taskType, taskResult, options = {}) {
+        // #1125: concrete handler types are saved by their abstract type's saver.
+        const { saveType, report: result } = resultForSaver(taskType, taskResult);
         const timestamp = new Date();
         const files = [];
         // Database-free mode (#534): do not write .agentic-qe/results/* to disk.
         if (process.env.AQE_MEMORY_BACKEND === 'memory') {
-            return { taskId, taskType, timestamp, files, summary: this.extractSummary(taskType, result) };
+            return { taskId, taskType, timestamp, files, summary: this.extractSummary(saveType, result) };
         }
         // Ensure directories exist
         await this.ensureDirectories(taskType);
@@ -110,7 +113,7 @@ export class ResultSaver {
         const tsStr = this.formatTimestamp(timestamp);
         const prefix = options.filenamePrefix || `${tsStr}_${this.uniqueSuffix(taskId)}`;
         // Save based on task type
-        switch (taskType) {
+        switch (saveType) {
             case 'generate-tests':
                 files.push(...await this.saveTestGeneration(result, prefix, options));
                 break;
@@ -140,10 +143,10 @@ export class ResultSaver {
                 break;
             default:
                 // Generic JSON save for unknown types
-                files.push(...await this.saveGeneric(taskType, result, prefix));
+                files.push(...await this.saveGeneric(saveType, result, prefix));
         }
         // Update index
-        const summary = this.extractSummary(taskType, result);
+        const summary = this.extractSummary(saveType, result);
         await this.updateIndex(taskId, taskType, timestamp, files, summary);
         return {
             taskId,

package/dist/coordination/task-dag/dag-algorithms.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Agentic QE v3 - Task DAG Graph Algorithms
+ * ADR-064 Phase 1E: topological sort (Kahn), cycle detection (DFS
+ * coloring) and critical path (longest-path DP) over a TaskDAG's edges.
+ *
+ * Edges that point at IDs not present in `nodes` (missing or removed
+ * prerequisites) are ignored for ordering purposes.
+ */
+import type { DAGTask } from './types.js';
+/** Read-only view of the graph used by the algorithms */
+export interface DAGGraphView {
+    readonly nodes: ReadonlyMap<string, DAGTask>;
+    /** taskId -> prerequisite IDs */
+    readonly forwardEdges: ReadonlyMap<string, ReadonlySet<string>>;
+    /** prerequisiteId -> dependent IDs */
+    readonly reverseEdges: ReadonlyMap<string, ReadonlySet<string>>;
+}
+/**
+ * Topological sort using Kahn's algorithm.
+ * @throws Error if cycles exist
+ */
+export declare function topologicalSort(graph: DAGGraphView): DAGTask[];
+/**
+ * Detect cycles using DFS with white/gray/black coloring.
+ * @returns Array of cycles (empty if acyclic)
+ */
+export declare function findCycles(graph: DAGGraphView): string[][];
+/**
+ * Find the critical path (longest path through the DAG).
+ * @returns Tasks on the critical path in execution order
+ */
+export declare function criticalPath(graph: DAGGraphView): DAGTask[];
+//# sourceMappingURL=dag-algorithms.d.ts.map

package/dist/coordination/task-dag/dag-algorithms.js

@@ -0,0 +1,162 @@
+/**
+ * Agentic QE v3 - Task DAG Graph Algorithms
+ * ADR-064 Phase 1E: topological sort (Kahn), cycle detection (DFS
+ * coloring) and critical path (longest-path DP) over a TaskDAG's edges.
+ *
+ * Edges that point at IDs not present in `nodes` (missing or removed
+ * prerequisites) are ignored for ordering purposes.
+ */
+/** DFS node coloring for cycle detection */
+var NodeColor;
+(function (NodeColor) {
+    NodeColor[NodeColor["White"] = 0] = "White";
+    NodeColor[NodeColor["Gray"] = 1] = "Gray";
+    NodeColor[NodeColor["Black"] = 2] = "Black";
+})(NodeColor || (NodeColor = {}));
+/**
+ * Topological sort using Kahn's algorithm.
+ * @throws Error if cycles exist
+ */
+export function topologicalSort(graph) {
+    const { nodes, forwardEdges, reverseEdges } = graph;
+    const inDegree = new Map();
+    for (const nodeId of nodes.keys()) {
+        let count = 0;
+        const fwd = forwardEdges.get(nodeId);
+        if (fwd) {
+            for (const dep of fwd) {
+                if (nodes.has(dep))
+                    count++;
+            }
+        }
+        inDegree.set(nodeId, count);
+    }
+    const queue = [];
+    for (const [id, deg] of inDegree) {
+        if (deg === 0)
+            queue.push(id);
+    }
+    const sorted = [];
+    while (queue.length > 0) {
+        const nodeId = queue.shift();
+        const task = nodes.get(nodeId);
+        if (task)
+            sorted.push(task);
+        const dependents = reverseEdges.get(nodeId);
+        if (dependents) {
+            for (const depId of dependents) {
+                if (!nodes.has(depId))
+                    continue;
+                const newDeg = (inDegree.get(depId) ?? 0) - 1;
+                inDegree.set(depId, newDeg);
+                if (newDeg === 0)
+                    queue.push(depId);
+            }
+        }
+    }
+    if (sorted.length !== nodes.size) {
+        throw new Error(`Cycle detected: sorted ${sorted.length} of ${nodes.size} tasks`);
+    }
+    return sorted;
+}
+/**
+ * Detect cycles using DFS with white/gray/black coloring.
+ * @returns Array of cycles (empty if acyclic)
+ */
+export function findCycles(graph) {
+    const color = new Map();
+    const parent = new Map();
+    const cycles = [];
+    for (const id of graph.nodes.keys())
+        color.set(id, NodeColor.White);
+    for (const id of graph.nodes.keys()) {
+        if (color.get(id) === NodeColor.White) {
+            dfsCycles(graph, id, color, parent, cycles);
+        }
+    }
+    return cycles;
+}
+/**
+ * Find the critical path (longest path through the DAG).
+ * @returns Tasks on the critical path in execution order
+ */
+export function criticalPath(graph) {
+    const { nodes, reverseEdges } = graph;
+    if (nodes.size === 0)
+        return [];
+    let sorted;
+    try {
+        sorted = topologicalSort(graph);
+    }
+    catch {
+        return [];
+    }
+    const dist = new Map();
+    const pred = new Map();
+    for (const t of sorted) {
+        dist.set(t.id, 1);
+        pred.set(t.id, null);
+    }
+    for (const task of sorted) {
+        const d = dist.get(task.id);
+        const deps = reverseEdges.get(task.id);
+        if (deps) {
+            for (const depId of deps) {
+                if (!nodes.has(depId))
+                    continue;
+                if (d + 1 > (dist.get(depId) ?? 1)) {
+                    dist.set(depId, d + 1);
+                    pred.set(depId, task.id);
+                }
+            }
+        }
+    }
+    let maxDist = 0;
+    let endNode = null;
+    for (const [id, d] of dist) {
+        if (d > maxDist) {
+            maxDist = d;
+            endNode = id;
+        }
+    }
+    if (!endNode)
+        return [];
+    const path = [];
+    let cur = endNode;
+    while (cur !== null) {
+        const t = nodes.get(cur);
+        if (t)
+            path.unshift(t);
+        cur = pred.get(cur) ?? null;
+    }
+    return path;
+}
+function dfsCycles(graph, nodeId, color, parent, cycles) {
+    color.set(nodeId, NodeColor.Gray);
+    const dependencies = graph.forwardEdges.get(nodeId);
+    if (dependencies) {
+        for (const depId of dependencies) {
+            if (!graph.nodes.has(depId))
+                continue;
+            const c = color.get(depId);
+            if (c === NodeColor.White) {
+                parent.set(depId, nodeId);
+                dfsCycles(graph, depId, color, parent, cycles);
+            }
+            else if (c === NodeColor.Gray) {
+                const cycle = [depId, nodeId];
+                let cur = nodeId;
+                while (cur !== depId) {
+                    const p = parent.get(cur);
+                    if (p === null || p === undefined || p === depId)
+                        break;
+                    cycle.push(p);
+                    cur = p;
+                }
+                cycles.push(cycle);
+            }
+        }
+    }
+    color.set(nodeId, NodeColor.Black);
+}
+//# sourceMappingURL=dag-algorithms.js.map

package/dist/coordination/task-dag/dag-obligations.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Agentic QE v3 - Task DAG Obligation Helpers
+ * Issue #1069: pure helpers for initial edge dispositions, waiver
+ * authorization and status counting, kept out of dag.ts for size.
+ */
+import type { DAGStats, DAGTask, PrerequisiteDisposition, WaivePrerequisiteInput, WaiverPolicy } from './types.js';
+import { type PrerequisiteLedger } from './prerequisite-ledger.js';
+/** Disposition of a new edge given the prerequisite's current state. */
+export declare function initialDisposition(blocker: DAGTask | undefined, tombstoned: boolean): PrerequisiteDisposition;
+/**
+ * Check that a validated waiver may be applied: the revision guard holds,
+ * the dependent exists and is not terminal, the edge exists and is
+ * unresolved, and the optional policy approves.
+ * @throws PrerequisiteWaiverError or GraphRevisionConflictError
+ */
+export declare function authorizeWaiver(ledger: PrerequisiteLedger, policy: WaiverPolicy | undefined, req: WaivePrerequisiteInput, task: DAGTask | undefined, prerequisites: ReadonlySet<string> | undefined): asserts task is DAGTask;
+type StatusCounts = Pick<DAGStats, 'pending' | 'ready' | 'inProgress' | 'completed' | 'failed' | 'blocked' | 'cancelled'>;
+/** Count tasks by execution status. */
+export declare function countStatuses(tasks: Iterable<DAGTask>): StatusCounts;
+export {};
+//# sourceMappingURL=dag-obligations.d.ts.map

package/dist/coordination/task-dag/dag-obligations.js

@@ -0,0 +1,83 @@
+/**
+ * Agentic QE v3 - Task DAG Obligation Helpers
+ * Issue #1069: pure helpers for initial edge dispositions, waiver
+ * authorization and status counting, kept out of dag.ts for size.
+ */
+import { PrerequisiteWaiverError, TERMINAL_STATUSES, } from './prerequisite-ledger.js';
+/** Disposition of a new edge given the prerequisite's current state. */
+export function initialDisposition(blocker, tombstoned) {
+    if (!blocker)
+        return tombstoned ? 'REMOVED' : 'MISSING';
+    switch (blocker.status) {
+        case 'completed': return 'SATISFIED';
+        case 'failed': return 'FAILED';
+        case 'cancelled': return 'CANCELLED';
+        default: return 'UNRESOLVED';
+    }
+}
+/**
+ * Check that a validated waiver may be applied: the revision guard holds,
+ * the dependent exists and is not terminal, the edge exists and is
+ * unresolved, and the optional policy approves.
+ * @throws PrerequisiteWaiverError or GraphRevisionConflictError
+ */
+export function authorizeWaiver(ledger, policy, req, task, prerequisites) {
+    ledger.checkRevision(req.expectedRevision);
+    if (!task)
+        throw new PrerequisiteWaiverError(`Task '${req.taskId}' not found in the DAG`);
+    if (!prerequisites?.has(req.prerequisiteId)) {
+        throw new PrerequisiteWaiverError(`Task '${req.taskId}' has no prerequisite '${req.prerequisiteId}'`);
+    }
+    if (TERMINAL_STATUSES.has(task.status)) {
+        throw new PrerequisiteWaiverError(`Cannot waive for '${req.taskId}': status '${task.status}' is terminal`);
+    }
+    const current = ledger.disposition(req.taskId, req.prerequisiteId) ?? 'UNRESOLVED';
+    if (current === 'SATISFIED' || current === 'WAIVED') {
+        throw new PrerequisiteWaiverError(`Prerequisite '${req.prerequisiteId}' of '${req.taskId}' is already ${current}`);
+    }
+    // Only a literal `true` approves; a truthy non-boolean (e.g. a Promise) fails closed
+    if (policy && policy({
+        graphId: ledger.graphId,
+        graphRevision: ledger.graphRevision,
+        taskId: req.taskId,
+        prerequisiteId: req.prerequisiteId,
+        actor: req.actor,
+        reason: req.reason,
+        authorityRef: req.authorityRef,
+        currentDisposition: current,
+    }) !== true) {
+        throw new PrerequisiteWaiverError(`Waiver of '${req.prerequisiteId}' for '${req.taskId}' by '${req.actor}' rejected by policy`);
+    }
+}
+/** Count tasks by execution status. */
+export function countStatuses(tasks) {
+    let pending = 0, ready = 0, inProgress = 0, completed = 0;
+    let failed = 0, blocked = 0, cancelled = 0;
+    for (const task of tasks) {
+        switch (task.status) {
+            case 'pending':
+                pending++;
+                break;
+            case 'ready':
+                ready++;
+                break;
+            case 'in_progress':
+                inProgress++;
+                break;
+            case 'completed':
+                completed++;
+                break;
+            case 'failed':
+                failed++;
+                break;
+            case 'blocked':
+                blocked++;
+                break;
+            case 'cancelled':
+                cancelled++;
+                break;
+        }
+    }
+    return { pending, ready, inProgress, completed, failed, blocked, cancelled };
+}
+//# sourceMappingURL=dag-obligations.js.map

package/dist/coordination/task-dag/dag.d.ts

@@ -5,8 +5,13 @@
  * Directed acyclic graph where nodes are tasks and edges represent
  * "blocked-by" dependencies. Topological sort via Kahn's algorithm,
  * cycle detection via DFS coloring, critical path via longest-path DP.
+ *
+ * Issue #1069: every prerequisite edge carries a typed disposition backed
+ * by an immutable PrerequisiteReceiptV1. A dependent becomes ready only
+ * when every edge is SATISFIED or WAIVED. Removing an unfinished
+ * prerequisite leaves a REMOVED tombstone and keeps dependents blocked.
  */
-import type { DAGTask, AddTaskInput, DAGStats, DAGEventHandler } from './types.js';
+import type { DAGTask, AddTaskInput, DAGStats, DAGSnapshot, DAGEventHandler, CompleteTaskOptions, ObligationSummary, PrerequisiteEdgeState, PrerequisiteReceiptV1, RemovedTaskRecord, RemoveTaskOptions, TaskDAGOptions, WaivePrerequisiteInput } from './types.js';
 /**
  * Directed acyclic graph for task dependency management.
  *
@@ -18,17 +23,30 @@ export declare class TaskDAG {
     private readonly forwardEdges;
     private readonly reverseEdges;
     private readonly eventHandlers;
+    private readonly ledger;
+    private readonly waiverPolicy?;
+    constructor(options?: TaskDAGOptions);
+    /** Stable identity of this graph, stamped on every receipt. */
+    get graphId(): string;
+    /** Monotonically increasing revision; advances on every mutation. */
+    get graphRevision(): number;
     /**
-     * Add a task to the DAG. Status is 'ready' if no incomplete blockers,
-     * otherwise 'blocked'. Reverse edges are computed automatically.
+     * Add a task to the DAG. Status is 'ready' if every prerequisite is
+     * SATISFIED, otherwise 'blocked'. Prerequisites not yet in the graph are
+     * recorded as MISSING until they are added.
      * @throws Error if a task with the same ID already exists
      */
     addTask(input: AddTaskInput): DAGTask;
     /**
-     * Remove a task, clean up edges, and unblock dependents if appropriate.
+     * Remove a task. A lifecycle operation, not an obligation resolution:
+     * dependents keep the edge. An unfinished task's unresolved dependent
+     * edges become REMOVED and dependents stay blocked until it is re-added
+     * and completed, or the edge is waived. SATISFIED edges survive removal,
+     * and the task stays in the obligation denominator as a tombstone.
      * @returns true if removed, false if not found
+     * @throws GraphRevisionConflictError if options.expectedRevision is stale
      */
-    removeTask(taskId: string): boolean;
+    removeTask(taskId: string, options?: RemoveTaskOptions): boolean;
     /** Get a task by ID. */
     getTask(taskId: string): DAGTask | undefined;
     /** Get all tasks with 'ready' status. */
@@ -39,16 +57,48 @@ export declare class TaskDAG {
      */
     start(taskId: string, agentId: string): void;
     /**
-     * Mark a task completed and unblock downstream tasks.
+     * Mark a task completed, record SATISFIED on its dependent edges, and
+     * unblock dependents whose edges are all SATISFIED or WAIVED.
      * @returns Array of newly unblocked task IDs
      * @throws Error if task not found or not 'in_progress'
+     * @throws GraphRevisionConflictError if options.expectedRevision is stale
      */
-    complete(taskId: string, result?: unknown): string[];
+    complete(taskId: string, result?: unknown, options?: CompleteTaskOptions): string[];
     /**
-     * Mark a task failed and cascade cancellation to dependents.
+     * Mark a task failed, record FAILED on its unresolved dependent edges,
+     * and cascade cancellation to dependents.
      * @throws Error if task not found or not in 'in_progress'/'ready'
      */
     fail(taskId: string, error: string): void;
+    /**
+     * Cancel a non-terminal task, record CANCELLED on its unresolved
+     * dependent edges, and cascade cancellation to dependents.
+     * @throws Error if task not found or already terminal
+     */
+    cancel(taskId: string, reason: string): void;
+    /**
+     * Explicitly waive one prerequisite edge. This is the only way a
+     * dependent becomes ready without a SATISFIED receipt. The original edge
+     * is kept and a WAIVED receipt carries actor, reason, authority and time.
+     * @returns The WAIVED receipt
+     * @throws PrerequisiteWaiverError on invalid input, unknown edge,
+     *   already-resolved edge, terminal dependent, or policy rejection
+     * @throws GraphRevisionConflictError if expectedRevision is stale
+     */
+    waivePrerequisite(input: WaivePrerequisiteInput): PrerequisiteReceiptV1;
+    /** Current disposition of every prerequisite edge of a task. */
+    getPrerequisiteDispositions(taskId: string): PrerequisiteEdgeState[];
+    /** Prerequisite edges that currently prevent a task from being ready. */
+    getBlockers(taskId: string): PrerequisiteEdgeState[];
+    /** Append-only receipt log, optionally filtered by dependent or prerequisite. */
+    getReceipts(filter?: {
+        taskId?: string;
+        prerequisiteId?: string;
+    }): PrerequisiteReceiptV1[];
+    /** Tombstones for tasks removed from the graph. */
+    getRemovedTasks(): RemovedTaskRecord[];
+    /** Obligation accounting against the original task denominator. */
+    getObligationSummary(): ObligationSummary;
     /**
      * Topological sort using Kahn's algorithm.
      * @throws Error if cycles exist
@@ -66,28 +116,28 @@ export declare class TaskDAG {
     getCriticalPath(): DAGTask[];
     /** Get aggregate statistics about the DAG. */
     getStats(): DAGStats;
-    /** Remove all tasks from the DAG. */
+    /**
+     * Remove all tasks, receipts and tombstones from the DAG. The graph
+     * revision keeps increasing so stale expectedRevision guards still fail.
+     */
     clear(): void;
-    /** Serialize the DAG for debugging. */
-    toJSON(): {
-        tasks: DAGTask[];
-        edges: Array<{
-            from: string;
-            to: string;
-        }>;
-        stats: DAGStats;
-    };
+    /** Serialize the DAG, its receipt log and tombstones. */
+    toJSON(): DAGSnapshot;
     /**
      * Register a handler to receive DAG events.
      * @returns Unsubscribe function
      */
     onEvent(handler: DAGEventHandler): () => void;
+    private graphView;
     private requireTask;
     private computeStatus;
     private setStatus;
+    /** Commit a failed/cancelled outcome and propagate it to dependent edges. */
+    private terminate;
+    /** Record a disposition on every live dependent edge currently in `from`. */
+    private recordOnDependents;
     private unblockDependents;
     private cascadeCancellation;
-    private dfsCycles;
     private emit;
 }
 //# sourceMappingURL=dag.d.ts.map