@openrig/cli 0.1.11 → 0.2.0

package/daemon/dist/domain/workflow-instance-store.d.ts

@@ -0,0 +1,46 @@
+import type Database from "better-sqlite3";
+import type { WorkflowInstance, WorkflowInstanceStatus } from "./workflow-types.js";
+export interface CreateWorkflowInstanceInput {
+    workflowName: string;
+    workflowVersion: string;
+    createdBySession: string;
+    initialFrontier?: string[];
+    /** R2: durable current-step binding set at instantiate time. */
+    currentStepId?: string;
+}
+export declare class WorkflowInstanceError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, details?: Record<string, unknown> | undefined);
+}
+export declare class WorkflowInstanceStore {
+    private readonly db;
+    private readonly now;
+    constructor(db: Database.Database, now?: () => Date);
+    create(input: CreateWorkflowInstanceInput): WorkflowInstance;
+    getById(instanceId: string): WorkflowInstance | null;
+    getByIdOrThrow(instanceId: string): WorkflowInstance;
+    listByStatus(status: WorkflowInstanceStatus): WorkflowInstance[];
+    listAll(): WorkflowInstance[];
+    /**
+     * Update frontier + status atomically. Caller is responsible for
+     * wrapping in a transaction when this needs to compose with other
+     * mutations (e.g., workflow-projector folds this into the
+     * close + create + frontier-update transaction).
+     */
+    updateFrontier(instanceId: string, nextFrontier: string[], nextStatus: WorkflowInstanceStatus, opts?: {
+        bumpHopCount?: boolean;
+        lastContinuationDecision?: Record<string, unknown> | null;
+        fallbackSynthesis?: string | null;
+        completedAt?: string | null;
+        /**
+         * R2: explicit next current_step_id. When provided, OVERWRITES
+         * the column (including to NULL by passing the empty string for
+         * "clear"). When omitted, current_step_id is preserved (the
+         * frontier packet is reused, e.g., on waiting). To clear pass
+         * the symbol "clear-current-step" (typed as the literal below).
+         */
+        currentStepId?: string | "preserve" | "clear";
+    }): void;
+}
+//# sourceMappingURL=workflow-instance-store.d.ts.map

package/daemon/dist/domain/workflow-instance-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-instance-store.d.ts","sourceRoot":"","sources":["../../src/domain/workflow-instance-store.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAE3C,OAAO,KAAK,EACV,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,qBAAqB,CAAC;AAiB7B,MAAM,WAAW,2BAA2B;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,gEAAgE;IAChE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,qBAAa,qBAAsB,SAAQ,KAAK;aAE5B,IAAI,EAAE,MAAM;aAEZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;gBAFjC,IAAI,EAAE,MAAM,EAC5B,OAAO,EAAE,MAAM,EACC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAA;CAKpD;AAED,qBAAa,qBAAqB;IAE9B,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,GAAG;gBADH,EAAE,EAAE,QAAQ,CAAC,QAAQ,EACrB,GAAG,GAAE,MAAM,IAAuB;IAGrD,MAAM,CAAC,KAAK,EAAE,2BAA2B,GAAG,gBAAgB;IAuB5D,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI;IAOpD,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB;IAYpD,YAAY,CAAC,MAAM,EAAE,sBAAsB,GAAG,gBAAgB,EAAE;IAShE,OAAO,IAAI,gBAAgB,EAAE;IAO7B;;;;;OAKG;IACH,cAAc,CACZ,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EAAE,EACtB,UAAU,EAAE,sBAAsB,EAClC,IAAI,GAAE;QACJ,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,wBAAwB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;QAC1D,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAClC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC5B;;;;;;WAMG;QACH,aAAa,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC;KAC1C,GACL,IAAI;CAyCR"}

package/daemon/dist/domain/workflow-instance-store.js

@@ -0,0 +1,116 @@
+// PL-004 Phase D: workflow instance store.
+//
+// Owns CRUD on workflow_instances. Frontier tracking uses
+// current_frontier_json (serialized JSON array of qitem_ids). Survives
+// daemon restart without filesystem reconciliation: list/getById query
+// SQLite directly.
+import { ulid } from "ulid";
+export class WorkflowInstanceError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "WorkflowInstanceError";
+    }
+}
+export class WorkflowInstanceStore {
+    db;
+    now;
+    constructor(db, now = () => new Date()) {
+        this.db = db;
+        this.now = now;
+    }
+    create(input) {
+        const instanceId = ulid();
+        const createdAt = this.now().toISOString();
+        const frontier = input.initialFrontier ?? [];
+        this.db
+            .prepare(`INSERT INTO workflow_instances (
+           instance_id, workflow_name, workflow_version, created_by_session,
+           created_at, status, current_frontier_json, current_step_id, hop_count
+         ) VALUES (?, ?, ?, ?, ?, 'active', ?, ?, 0)`)
+            .run(instanceId, input.workflowName, input.workflowVersion, input.createdBySession, createdAt, JSON.stringify(frontier), input.currentStepId ?? null);
+        return this.getByIdOrThrow(instanceId);
+    }
+    getById(instanceId) {
+        const row = this.db
+            .prepare(`SELECT * FROM workflow_instances WHERE instance_id = ?`)
+            .get(instanceId);
+        return row ? rowToInstance(row) : null;
+    }
+    getByIdOrThrow(instanceId) {
+        const inst = this.getById(instanceId);
+        if (!inst) {
+            throw new WorkflowInstanceError("instance_not_found", `workflow instance ${instanceId} not found`, { instanceId });
+        }
+        return inst;
+    }
+    listByStatus(status) {
+        const rows = this.db
+            .prepare(`SELECT * FROM workflow_instances WHERE status = ? ORDER BY created_at ASC`)
+            .all(status);
+        return rows.map(rowToInstance);
+    }
+    listAll() {
+        const rows = this.db
+            .prepare(`SELECT * FROM workflow_instances ORDER BY created_at ASC`)
+            .all();
+        return rows.map(rowToInstance);
+    }
+    /**
+     * Update frontier + status atomically. Caller is responsible for
+     * wrapping in a transaction when this needs to compose with other
+     * mutations (e.g., workflow-projector folds this into the
+     * close + create + frontier-update transaction).
+     */
+    updateFrontier(instanceId, nextFrontier, nextStatus, opts = {}) {
+        const setHop = opts.bumpHopCount ? "hop_count = hop_count + 1, " : "";
+        let currentStepClause = "";
+        let currentStepValue;
+        if (opts.currentStepId === "preserve" || opts.currentStepId === undefined) {
+            currentStepClause = "";
+            currentStepValue = undefined;
+        }
+        else if (opts.currentStepId === "clear") {
+            currentStepClause = "current_step_id = NULL, ";
+        }
+        else {
+            currentStepClause = "current_step_id = ?, ";
+            currentStepValue = opts.currentStepId;
+        }
+        const sql = `UPDATE workflow_instances SET
+           ${setHop}${currentStepClause}status = ?, current_frontier_json = ?,
+           last_continuation_decision_json = COALESCE(?, last_continuation_decision_json),
+           fallback_synthesis = COALESCE(?, fallback_synthesis),
+           completed_at = COALESCE(?, completed_at)
+         WHERE instance_id = ?`;
+        const stmt = this.db.prepare(sql);
+        if (currentStepValue !== undefined) {
+            stmt.run(currentStepValue, nextStatus, JSON.stringify(nextFrontier), opts.lastContinuationDecision ? JSON.stringify(opts.lastContinuationDecision) : null, opts.fallbackSynthesis ?? null, opts.completedAt ?? null, instanceId);
+        }
+        else {
+            stmt.run(nextStatus, JSON.stringify(nextFrontier), opts.lastContinuationDecision ? JSON.stringify(opts.lastContinuationDecision) : null, opts.fallbackSynthesis ?? null, opts.completedAt ?? null, instanceId);
+        }
+    }
+}
+function rowToInstance(row) {
+    return {
+        instanceId: row.instance_id,
+        workflowName: row.workflow_name,
+        workflowVersion: row.workflow_version,
+        createdBySession: row.created_by_session,
+        createdAt: row.created_at,
+        status: row.status,
+        currentFrontier: JSON.parse(row.current_frontier_json),
+        currentStepId: row.current_step_id,
+        hopCount: row.hop_count,
+        fallbackSynthesis: row.fallback_synthesis,
+        lastContinuationDecision: row.last_continuation_decision_json
+            ? JSON.parse(row.last_continuation_decision_json)
+            : null,
+        completedAt: row.completed_at,
+    };
+}
+//# sourceMappingURL=workflow-instance-store.js.map

package/daemon/dist/domain/workflow-instance-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-instance-store.js","sourceRoot":"","sources":["../../src/domain/workflow-instance-store.ts"],"names":[],"mappings":"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"}

package/daemon/dist/domain/workflow-projector.d.ts

@@ -0,0 +1,64 @@
+import type Database from "better-sqlite3";
+import type { EventBus } from "./event-bus.js";
+import type { QueueRepository } from "./queue-repository.js";
+import type { WorkflowInstanceStore } from "./workflow-instance-store.js";
+import type { WorkflowSpecCache } from "./workflow-spec-cache.js";
+import type { WorkflowStepTrailLog } from "./workflow-step-trail-log.js";
+import type { WorkflowExitKind, WorkflowInstance } from "./workflow-types.js";
+export declare class WorkflowProjectorError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, details?: Record<string, unknown> | undefined);
+}
+export interface ProjectStepInput {
+    instanceId: string;
+    /** The qitem being closed (must be in instance.currentFrontier). */
+    currentPacketId: string;
+    /** What kind of exit closes this packet. */
+    exit: WorkflowExitKind;
+    /** Free-form closure result text (POC: --result). */
+    resultNote?: string;
+    /** For waiting exits: the blocker reference (qitem id, gate name). */
+    blockedOn?: string;
+    /** Operator-supplied evidence for the closure record (audit). */
+    closureEvidence?: Record<string, unknown>;
+    /** Session that closed the packet (owner-as-author). */
+    actorSession: string;
+    /**
+     * Optional explicit override for the next-step destination session.
+     * When omitted, the projector resolves from the next step's
+     * actor_role + role.preferred_targets[]. Required when no
+     * preferred_targets are declared OR none are operator-resolvable.
+     */
+    nextOwnerSession?: string;
+}
+export interface ProjectStepResult {
+    instance: WorkflowInstance;
+    closurePriorPacketId: string;
+    closureReason: WorkflowExitKind;
+    /** null on terminal closures (waiting / done / failed / no-successor). */
+    nextQitemId: string | null;
+    /** null on terminal closures. */
+    nextOwnerSession: string | null;
+    /** null on terminal closures. */
+    nextStepId: string | null;
+    /** Composite fired events (step_closed + optional next_qitem_projected + optional completed). */
+    emittedEventTypes: string[];
+}
+export declare class WorkflowProjector {
+    private readonly db;
+    private readonly eventBus;
+    private readonly queueRepo;
+    private readonly instanceStore;
+    private readonly trailLog;
+    private readonly specCache;
+    private readonly now;
+    constructor(db: Database.Database, eventBus: EventBus, queueRepo: QueueRepository, instanceStore: WorkflowInstanceStore, trailLog: WorkflowStepTrailLog, specCache: WorkflowSpecCache, now?: () => Date);
+    /**
+     * Close the current packet AND create/project the next-step packet
+     * IN THE SAME TRANSACTION. The load-bearing transactional-scribe
+     * call site.
+     */
+    project(input: ProjectStepInput): Promise<ProjectStepResult>;
+}
+//# sourceMappingURL=workflow-projector.d.ts.map

package/daemon/dist/domain/workflow-projector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-projector.d.ts","sourceRoot":"","sources":["../../src/domain/workflow-projector.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAC1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAGjB,MAAM,qBAAqB,CAAC;AAE7B,qBAAa,sBAAuB,SAAQ,KAAK;aAE7B,IAAI,EAAE,MAAM;aAEZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;gBAFjC,IAAI,EAAE,MAAM,EAC5B,OAAO,EAAE,MAAM,EACC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAA;CAKpD;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,oEAAoE;IACpE,eAAe,EAAE,MAAM,CAAC;IACxB,4CAA4C;IAC5C,IAAI,EAAE,gBAAgB,CAAC;IACvB,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,wDAAwD;IACxD,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,EAAE,gBAAgB,CAAC;IAChC,0EAA0E;IAC1E,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,iCAAiC;IACjC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,iCAAiC;IACjC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,iGAAiG;IACjG,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,GAAG;gBANH,EAAE,EAAE,QAAQ,CAAC,QAAQ,EACrB,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,eAAe,EAC1B,aAAa,EAAE,qBAAqB,EACpC,QAAQ,EAAE,oBAAoB,EAC9B,SAAS,EAAE,iBAAiB,EAC5B,GAAG,GAAE,MAAM,IAAuB;IAGrD;;;;OAIG;IACG,OAAO,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAuSnE"}

package/daemon/dist/domain/workflow-projector.js

@@ -0,0 +1,424 @@
+// PL-004 Phase D: workflow projector — transactional-scribe contract.
+//
+// LOAD-BEARING. The single most important Phase D contract.
+//
+// Per PRD § L4 + audit row 16: every code path that closes a
+// `workflow_instances.current_frontier` qitem AND every code path that
+// creates the next-step qitem MUST happen inside the SAME daemon-managed
+// transaction. If two separate transactions can be observed, that is a
+// contract violation. Lost handoffs are impossible by design.
+//
+// Composition (one db.transaction):
+//   1. Verify spec + instance + current packet are consistent.
+//   2. Resolve next step from spec (one-hop default per PRD).
+//   3. Update queue_items: close current packet (handoff/waiting/done).
+//   4. Create next-step queue item via QueueRepository.createWithinTransaction.
+//   5. Append workflow_step_trails entry with prior + next ids.
+//   6. Update workflow_instances frontier + status.
+//   7. Persist workflow.* events (step_closed, next_qitem_projected, completed).
+//
+// All in one db.transaction. If any step throws, all rollback. After
+// commit, fan out events to subscribers + nudge next owner.
+export class WorkflowProjectorError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "WorkflowProjectorError";
+    }
+}
+export class WorkflowProjector {
+    db;
+    eventBus;
+    queueRepo;
+    instanceStore;
+    trailLog;
+    specCache;
+    now;
+    constructor(db, eventBus, queueRepo, instanceStore, trailLog, specCache, now = () => new Date()) {
+        this.db = db;
+        this.eventBus = eventBus;
+        this.queueRepo = queueRepo;
+        this.instanceStore = instanceStore;
+        this.trailLog = trailLog;
+        this.specCache = specCache;
+        this.now = now;
+    }
+    /**
+     * Close the current packet AND create/project the next-step packet
+     * IN THE SAME TRANSACTION. The load-bearing transactional-scribe
+     * call site.
+     */
+    async project(input) {
+        const instance = this.instanceStore.getByIdOrThrow(input.instanceId);
+        if (instance.status !== "active" && instance.status !== "waiting") {
+            throw new WorkflowProjectorError("instance_not_active", `workflow instance ${instance.instanceId} has status ${instance.status}; only active|waiting instances accept project`, { instanceId: instance.instanceId, status: instance.status });
+        }
+        if (!instance.currentFrontier.includes(input.currentPacketId)) {
+            throw new WorkflowProjectorError("packet_not_on_frontier", `qitem ${input.currentPacketId} is not in workflow instance ${instance.instanceId} frontier ${JSON.stringify(instance.currentFrontier)}; either the packet is already closed or belongs to a different instance`, { instanceId: instance.instanceId, currentPacketId: input.currentPacketId, frontier: instance.currentFrontier });
+        }
+        const specRow = this.specCache.getByNameVersion(instance.workflowName, instance.workflowVersion);
+        if (!specRow) {
+            throw new WorkflowProjectorError("spec_not_cached", `workflow spec ${instance.workflowName}@${instance.workflowVersion} is not in the spec cache. Re-run validate to refresh the cache.`, { workflowName: instance.workflowName, workflowVersion: instance.workflowVersion });
+        }
+        const spec = specRow.spec;
+        // Look up the qitem being closed to identify the current step.
+        const currentPacket = this.queueRepo.getById(input.currentPacketId);
+        if (!currentPacket) {
+            throw new WorkflowProjectorError("packet_not_found", `qitem ${input.currentPacketId} not found in queue_items`, { currentPacketId: input.currentPacketId });
+        }
+        // R2 fix (guard blocker 1): read durable current_step_id from instance
+        // rather than inferring "last_trail_step + 1". Reused-frontier packets
+        // (waiting then resume) now correctly resume the SAME step.
+        const currentStep = resolveCurrentStep(spec, instance);
+        if (!currentStep) {
+            throw new WorkflowProjectorError("current_step_unknown", `workflow instance ${instance.instanceId} has no resolvable current step (current_step_id=${JSON.stringify(instance.currentStepId)}). The instance may be in a terminal state, or the spec ${spec.id}@${spec.version} may have changed shape mid-instance.`, { instanceId: instance.instanceId, currentStepId: instance.currentStepId, frontier: instance.currentFrontier });
+        }
+        // R2 fix (guard blocker 2): enforce currentStep.allowed_exits at
+        // projection time. POC contract: an exit not in the step's
+        // allowed_exits is rejected with a structured error and NO state
+        // mutation. Validation happens BEFORE any side effect (queue close,
+        // trail append, frontier update, event persist). When allowed_exits
+        // is omitted on the step, no enforcement (operator opted out at
+        // spec authoring time).
+        if (currentStep.allowed_exits &&
+            currentStep.allowed_exits.length > 0 &&
+            !currentStep.allowed_exits.includes(input.exit)) {
+            throw new WorkflowProjectorError("exit_not_allowed", `step "${currentStep.id}" allows exits ${JSON.stringify(currentStep.allowed_exits)}; got "${input.exit}". Either close with a permitted exit, or amend the spec.`, {
+                instanceId: instance.instanceId,
+                stepId: currentStep.id,
+                attemptedExit: input.exit,
+                allowedExits: currentStep.allowed_exits,
+            });
+        }
+        // Determine next step (one-hop default; multi-hop is graduation).
+        const nextStep = resolveNextStep(spec, currentStep);
+        const evaluatedAt = this.now().toISOString();
+        let nextQitemId = null;
+        let nextOwnerSession = null;
+        let nextStepId = null;
+        let nextQitemCreatePostCommit = null;
+        const persistedEvents = [];
+        const txn = this.db.transaction(() => {
+            // 1. Resolve next owner BEFORE closing prior so closure_target is set.
+            let resolvedNextOwner = null;
+            if (input.exit === "handoff") {
+                if (!nextStep) {
+                    throw new WorkflowProjectorError("no_next_step", `workflow instance ${instance.instanceId} reached terminal step "${currentStep.id}" but exit was handoff; use exit=done for terminal steps or extend the spec with a next step`, { instanceId: instance.instanceId, currentStepId: currentStep.id });
+                }
+                const owner = input.nextOwnerSession ?? resolveDefaultOwner(spec, nextStep);
+                if (!owner) {
+                    throw new WorkflowProjectorError("next_owner_unresolved", `cannot resolve next owner for step "${nextStep.id}" (role "${nextStep.actor_role}"); supply nextOwnerSession explicitly or add preferred_targets to the role in the spec`, { instanceId: instance.instanceId, nextStepId: nextStep.id, nextRole: nextStep.actor_role });
+                }
+                resolvedNextOwner = owner;
+            }
+            // 2. R1 fix (guard blocker 1): close the current packet via Phase A's
+            // QueueRepository.updateWithinTransaction. This validates closure
+            // (Phase A hot-potato strict-rejection invariants), persists closure
+            // metadata (closure_reason, closure_target, handed_off_to / blocked_on),
+            // appends queue_transitions, and emits queue.updated — all inside this
+            // outer transaction. The Phase A closure authority is preserved.
+            const closure = workflowExitToQueueClosure(input, resolvedNextOwner);
+            const queueUpdate = this.queueRepo.updateWithinTransaction({
+                qitemId: input.currentPacketId,
+                actorSession: input.actorSession,
+                state: closure.state,
+                closureReason: closure.closureReason,
+                closureTarget: closure.closureTarget ?? undefined,
+                handedOffTo: closure.handedOffTo,
+                blockedOn: closure.blockedOn,
+                transitionNote: closure.transitionNote,
+            });
+            persistedEvents.push(queueUpdate.persistedEvent);
+            // 3. If exit is handoff: create next-step qitem in same txn.
+            let createdNext = null;
+            if (input.exit === "handoff" && nextStep && resolvedNextOwner) {
+                nextOwnerSession = resolvedNextOwner;
+                nextStepId = nextStep.id;
+                createdNext = this.queueRepo.createWithinTransaction({
+                    sourceSession: input.actorSession,
+                    destinationSession: resolvedNextOwner,
+                    body: workflowHandoffBody({
+                        spec,
+                        instance,
+                        currentStep,
+                        nextStep,
+                        actorSession: input.actorSession,
+                        resultNote: input.resultNote,
+                    }),
+                    priority: "routine",
+                    tier: "mode2",
+                    tags: ["workflow", "handoff", `workflow:${spec.id}`, `instance:${instance.instanceId}`],
+                    chainOfRecord: [input.currentPacketId],
+                });
+                nextQitemId = createdNext.qitemId;
+                nextQitemCreatePostCommit = {
+                    destinationSession: createdNext.destinationSession,
+                    nudge: createdNext.nudge,
+                };
+            }
+            // 4. Append step trail entry (prior + next ids).
+            this.trailLog.record({
+                instanceId: instance.instanceId,
+                stepId: currentStep.id,
+                stepRole: currentStep.actor_role,
+                closedAt: evaluatedAt,
+                closureReason: input.exit,
+                closureEvidence: input.closureEvidence ?? null,
+                actorSession: input.actorSession,
+                nextQitemId,
+                priorQitemId: input.currentPacketId,
+            });
+            // 5. Update instance frontier + status.
+            // R1 fix (guard blocker 2b): on exit=waiting, PRESERVE the closed
+            // packet on the frontier. workflow-keepalive treats waiting as
+            // eligible and resolves owners from current_frontier_json; removing
+            // the packet would leave a single-packet waiting workflow with no
+            // owner to wake.
+            const remainingFrontier = instance.currentFrontier.filter((id) => id !== input.currentPacketId);
+            let nextFrontier;
+            if (input.exit === "waiting") {
+                // Keep the closed packet on frontier; the watchdog uses it to wake the owner.
+                nextFrontier = [...remainingFrontier, input.currentPacketId];
+            }
+            else if (nextQitemId) {
+                nextFrontier = [...remainingFrontier, nextQitemId];
+            }
+            else {
+                nextFrontier = remainingFrontier;
+            }
+            // R1 fix (guard blocker 2a): exit=failed sets status=failed, NOT
+            // completed. Emits workflow.failed instead of workflow.completed.
+            let nextStatus;
+            let completedAt = null;
+            if (input.exit === "waiting") {
+                nextStatus = "waiting";
+            }
+            else if (input.exit === "failed") {
+                nextStatus = "failed";
+                completedAt = evaluatedAt;
+            }
+            else if (nextFrontier.length === 0) {
+                nextStatus = "completed";
+                completedAt = evaluatedAt;
+            }
+            else {
+                nextStatus = "active";
+            }
+            // R2 fix: set durable current_step_id transition.
+            //   handoff       → next step
+            //   waiting       → preserve (resume on same packet still on same step)
+            //   done / failed → clear (terminal)
+            let currentStepIdUpdate;
+            if (input.exit === "handoff" && nextStep) {
+                currentStepIdUpdate = nextStep.id;
+            }
+            else if (input.exit === "waiting") {
+                currentStepIdUpdate = "preserve";
+            }
+            else {
+                // done or failed
+                currentStepIdUpdate = "clear";
+            }
+            this.instanceStore.updateFrontier(instance.instanceId, nextFrontier, nextStatus, {
+                bumpHopCount: input.exit === "handoff",
+                lastContinuationDecision: {
+                    exit: input.exit,
+                    actorSession: input.actorSession,
+                    closedPacket: input.currentPacketId,
+                    nextPacket: nextQitemId,
+                    resultNote: input.resultNote ?? null,
+                    blockedOn: input.blockedOn ?? null,
+                    currentStep: currentStep.id,
+                },
+                completedAt,
+                currentStepId: currentStepIdUpdate,
+            });
+            // 6. Persist workflow events within the same txn.
+            persistedEvents.push(this.eventBus.persistWithinTransaction({
+                type: "workflow.step_closed",
+                instanceId: instance.instanceId,
+                stepId: currentStep.id,
+                closureReason: input.exit,
+                actorSession: input.actorSession,
+                priorQitemId: input.currentPacketId,
+            }));
+            if (createdNext && nextStep && resolvedNextOwner) {
+                persistedEvents.push(createdNext.persistedEvent);
+                persistedEvents.push(this.eventBus.persistWithinTransaction({
+                    type: "workflow.next_qitem_projected",
+                    instanceId: instance.instanceId,
+                    nextQitemId: createdNext.qitemId,
+                    nextOwner: createdNext.destinationSession,
+                    nextStepId: nextStep.id,
+                }));
+            }
+            if (nextStatus === "completed") {
+                persistedEvents.push(this.eventBus.persistWithinTransaction({
+                    type: "workflow.completed",
+                    instanceId: instance.instanceId,
+                    workflowName: instance.workflowName,
+                }));
+            }
+            else if (nextStatus === "failed") {
+                persistedEvents.push(this.eventBus.persistWithinTransaction({
+                    type: "workflow.failed",
+                    instanceId: instance.instanceId,
+                    workflowName: instance.workflowName,
+                    reason: input.resultNote ?? "workflow_step_failed",
+                }));
+            }
+        });
+        txn();
+        // Post-commit fan-out: notify subscribers + nudge next owner.
+        for (const e of persistedEvents) {
+            this.eventBus.notifySubscribers(e);
+        }
+        const postCommit = nextQitemCreatePostCommit;
+        if (nextQitemId && postCommit) {
+            await this.queueRepo.maybeNudge(nextQitemId, postCommit.destinationSession, postCommit.nudge);
+        }
+        const updatedInstance = this.instanceStore.getByIdOrThrow(instance.instanceId);
+        return {
+            instance: updatedInstance,
+            closurePriorPacketId: input.currentPacketId,
+            closureReason: input.exit,
+            nextQitemId,
+            nextOwnerSession,
+            nextStepId,
+            emittedEventTypes: persistedEvents.map((e) => e.type),
+        };
+    }
+}
+/**
+ * R2 fix (guard blocker 1): resolve the current step from durable
+ * instance.currentStepId, NOT from trail order. The previous trail-based
+ * inference produced wrong results for reused-frontier packets:
+ * waiting → resume on same packet would skip a step, because the
+ * waiting close wrote a trail row that the next inference treated as
+ * "last step + 1".
+ *
+ * Falls back to the entry step ONLY when current_step_id is null
+ * (instantiate didn't set it; defense-in-depth, not the production
+ * path).
+ *
+ * Multi-active-frontier instances (parallel steps) remain a graduation;
+ * v1 supports a single active frontier packet, so a single
+ * current_step_id column suffices.
+ */
+function resolveCurrentStep(spec, instance) {
+    if (instance.currentStepId) {
+        return spec.steps.find((s) => s.id === instance.currentStepId) ?? null;
+    }
+    // Defense-in-depth: instance lacks current_step_id. Fall back to
+    // entry step (matches behavior of pre-R2 instances if any survive).
+    const entryRole = spec.entry?.role;
+    return (spec.steps[0] ??
+        (entryRole ? spec.steps.find((s) => s.actor_role === entryRole) ?? null : null) ??
+        null);
+}
+/**
+ * Resolve the next step. v1 = one-hop continuity (the next step in
+ * declaration order). Multi-hop chaining via `next_hop.suggested_roles`
+ * is a graduation feature per PRD § Risks "Workflow runtime over-engineered".
+ */
+function resolveNextStep(spec, currentStep) {
+    const idx = spec.steps.findIndex((s) => s.id === currentStep.id);
+    if (idx === -1)
+        return null;
+    return spec.steps[idx + 1] ?? null;
+}
+/**
+ * Resolve a default owner for a step. v1 picks the first declared
+ * preferred_target. Returns null if none declared (caller must supply
+ * nextOwnerSession explicitly).
+ */
+function resolveDefaultOwner(spec, step) {
+    const role = spec.roles?.[step.actor_role];
+    const targets = role?.preferred_targets ?? [];
+    return targets[0] ?? null;
+}
+/**
+ * R1 fix (guard blocker 1): translate a workflow exit into the Phase A
+ * queue closure shape (state + closure_reason + closure_target +
+ * handed_off_to / blocked_on metadata). Phase A's hot-potato closure
+ * validation enforces the rules:
+ *   - state=done requires closure_reason from CLOSURE_REASONS
+ *   - handed_off_to / blocked_on / escalation also require closure_target
+ *
+ * Mappings:
+ *   handoff → state=handed-off, closure_reason=handed_off_to,
+ *             closure_target+handed_off_to=<next-owner>
+ *   waiting → state=blocked, closure_reason=blocked_on,
+ *             closure_target+blocked_on=<blocker>
+ *   done    → state=done, closure_reason=no-follow-on
+ *   failed  → state=done, closure_reason=denied (workflow status=failed
+ *             is set separately on the instance row)
+ */
+function workflowExitToQueueClosure(input, resolvedNextOwner) {
+    switch (input.exit) {
+        case "handoff": {
+            if (!resolvedNextOwner) {
+                // Defense-in-depth — projector validates this earlier and throws
+                // next_owner_unresolved, so this branch is unreachable in practice.
+                throw new WorkflowProjectorError("next_owner_unresolved", "handoff exit requires a resolved next owner before queue closure");
+            }
+            return {
+                state: "handed-off",
+                closureReason: "handed_off_to",
+                closureTarget: resolvedNextOwner,
+                handedOffTo: resolvedNextOwner,
+                transitionNote: `workflow handoff to ${resolvedNextOwner}`,
+            };
+        }
+        case "waiting": {
+            const blocker = input.blockedOn ?? "external-gate";
+            return {
+                state: "blocked",
+                closureReason: "blocked_on",
+                closureTarget: blocker,
+                blockedOn: blocker,
+                transitionNote: `workflow waiting on ${blocker}`,
+            };
+        }
+        case "done": {
+            return {
+                state: "done",
+                closureReason: "no-follow-on",
+                closureTarget: null,
+                transitionNote: input.resultNote
+                    ? `workflow done: ${input.resultNote}`
+                    : "workflow done",
+            };
+        }
+        case "failed": {
+            return {
+                state: "done",
+                closureReason: "denied",
+                closureTarget: input.resultNote ?? "workflow_step_failed",
+                transitionNote: input.resultNote
+                    ? `workflow failed: ${input.resultNote}`
+                    : "workflow failed",
+            };
+        }
+    }
+}
+function workflowHandoffBody(input) {
+    const lines = [
+        `### Workflow handoff: ${input.spec.id}@${input.spec.version} step ${input.nextStep.id}`,
+        "",
+        `Workflow instance: ${input.instance.instanceId}`,
+        `Prior step: ${input.currentStep.id} (${input.currentStep.actor_role}) closed by ${input.actorSession}`,
+        `This step: ${input.nextStep.id} (${input.nextStep.actor_role})`,
+    ];
+    if (input.nextStep.objective) {
+        lines.push(`Objective: ${input.nextStep.objective}`);
+    }
+    if (input.resultNote) {
+        lines.push("", `Prior step note: ${input.resultNote}`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=workflow-projector.js.map