@goah/cli 0.11.5 → 0.13.1

package/node_modules/goah-ledger-sqlite/dist/index.js

@@ -1,884 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-import { assertActionRequest, assertActionTransition, assertGoalSnapshot, assertGoalTransition, controlStream, goalStream, wakeStream, workRecordStream, } from "goah-ledger-contract";
-export const SQLITE_SCHEMA_VERSION = 9;
-const createGoals = `CREATE TABLE IF NOT EXISTS goals (
-  id TEXT PRIMARY KEY,
-  parent_id TEXT REFERENCES goals(id),
-  objective TEXT NOT NULL,
-  observation_method TEXT CHECK(observation_method IS NULL OR length(trim(observation_method)) > 0),
-  verification_method TEXT CHECK(verification_method IS NULL OR length(trim(verification_method)) > 0),
-  owner TEXT NOT NULL,
-  phase TEXT NOT NULL CHECK(phase IN ('active','paused','blocked','complete')),
-  revision INTEGER NOT NULL CHECK(revision >= 0)
-) STRICT;`;
-const createWorkRecords = `CREATE TABLE IF NOT EXISTS work_records (
-  goal_id TEXT PRIMARY KEY REFERENCES goals(id),
-  record_revision INTEGER NOT NULL CHECK(record_revision >= 0),
-  goal_revision INTEGER NOT NULL CHECK(goal_revision >= 0),
-  content TEXT NOT NULL CHECK(length(trim(content)) > 0),
-  updated_by TEXT NOT NULL,
-  updated_in_turn TEXT NOT NULL,
-  updated_in_wake TEXT,
-  updated_at TEXT NOT NULL,
-  reason TEXT NOT NULL CHECK(length(trim(reason)) > 0),
-  evidence TEXT NOT NULL CHECK(json_valid(evidence)),
-  last_event_seq INTEGER NOT NULL REFERENCES events(seq)
-) STRICT;`;
-const createWakes = `CREATE TABLE IF NOT EXISTS wakes (
-  id TEXT PRIMARY KEY,
-  agent TEXT NOT NULL,
-  trigger_ref TEXT NOT NULL,
-  status TEXT NOT NULL CHECK(status IN ('queued','leased','running','done','abnormal','merge_blocked')),
-  lease_until TEXT,
-  attempt INTEGER NOT NULL CHECK(attempt >= 0),
-  started_at TEXT,
-  ended_at TEXT,
-  enqueued_seq INTEGER NOT NULL CHECK(enqueued_seq > 0),
-  lease_token TEXT,
-  runner_pid INTEGER,
-  UNIQUE(agent, trigger_ref),
-  CHECK((status IN ('leased','running') AND lease_until IS NOT NULL AND lease_token IS NOT NULL) OR status NOT IN ('leased','running')),
-  CHECK((status IN ('done','abnormal','merge_blocked') AND ended_at IS NOT NULL) OR status NOT IN ('done','abnormal','merge_blocked'))
-) STRICT;`;
-const createActions = `CREATE TABLE IF NOT EXISTS actions (
-  id TEXT PRIMARY KEY,
-  agent TEXT NOT NULL,
-  kind TEXT NOT NULL,
-  connector TEXT NOT NULL,
-  payload TEXT NOT NULL CHECK(json_valid(payload)),
-  reason TEXT NOT NULL CHECK(length(trim(reason)) > 0),
-  evidence TEXT NOT NULL CHECK(json_valid(evidence) AND json_array_length(evidence) > 0),
-  gated INTEGER NOT NULL CHECK(gated IN (0,1)),
-  status TEXT NOT NULL CHECK(status IN ('requested','approved','dispatching','confirmed','failed','unknown')),
-  reconciled_at TEXT,
-  external_ref TEXT,
-  audit_advice TEXT CHECK(audit_advice IS NULL OR json_valid(audit_advice)),
-  advice_acked INTEGER NOT NULL CHECK(advice_acked IN (0,1)),
-  CHECK(reconciled_at IS NULL OR status IN ('confirmed','failed'))
-) STRICT;`;
-const indexesAndTriggers = `
-CREATE UNIQUE INDEX IF NOT EXISTS wakes_one_active_agent ON wakes(agent) WHERE status IN ('leased','running');
-CREATE INDEX IF NOT EXISTS wakes_queue_order ON wakes(status, enqueued_seq);
-CREATE INDEX IF NOT EXISTS schedule_due ON schedule(next_wake_at);
-CREATE INDEX IF NOT EXISTS events_actor_type_seq ON events(actor, type, seq DESC);
-CREATE INDEX IF NOT EXISTS events_stream_seq ON events(stream_id, stream_seq);
-CREATE INDEX IF NOT EXISTS events_coalesced_trigger ON events(json_extract(data,'$.triggerRef'), stream_id) WHERE type='wake.trigger_coalesced';
-CREATE INDEX IF NOT EXISTS actions_agent_status ON actions(agent, status);
-CREATE VIRTUAL TABLE IF NOT EXISTS events_fts USING fts5(actor, type, data, content='events', content_rowid='seq');
-
-CREATE TRIGGER IF NOT EXISTS events_no_update BEFORE UPDATE ON events
-BEGIN SELECT RAISE(ABORT, 'events are append-only'); END;
-CREATE TRIGGER IF NOT EXISTS events_no_delete BEFORE DELETE ON events
-BEGIN SELECT RAISE(ABORT, 'events are append-only'); END;
-CREATE TRIGGER IF NOT EXISTS events_fts_insert AFTER INSERT ON events
-BEGIN INSERT INTO events_fts(rowid,actor,type,data) VALUES (new.seq,new.actor,new.type,new.data); END;
-
-CREATE TRIGGER IF NOT EXISTS wakes_valid_transition BEFORE UPDATE OF status ON wakes
-WHEN OLD.status <> NEW.status AND NOT (
-  (OLD.status = 'queued' AND NEW.status IN ('leased','abnormal')) OR
-  (OLD.status = 'leased' AND NEW.status IN ('queued','running','abnormal')) OR
-  (OLD.status = 'running' AND NEW.status IN ('done','abnormal','merge_blocked'))
-)
-BEGIN SELECT RAISE(ABORT, 'invalid wake transition'); END;
-
-CREATE TRIGGER IF NOT EXISTS actions_valid_transition BEFORE UPDATE OF status ON actions
-WHEN OLD.status <> NEW.status AND NOT (
-  (OLD.status = 'requested' AND NEW.status IN ('approved','failed')) OR
-  (OLD.status = 'approved' AND NEW.status IN ('dispatching','failed')) OR
-  (OLD.status = 'dispatching' AND NEW.status IN ('confirmed','failed','unknown')) OR
-  (OLD.status = 'unknown' AND NEW.status IN ('dispatching','confirmed','failed'))
-)
-BEGIN SELECT RAISE(ABORT, 'invalid action transition'); END;
-
-CREATE TRIGGER IF NOT EXISTS goals_valid_transition BEFORE UPDATE OF phase ON goals
-WHEN OLD.phase <> NEW.phase AND NOT (
-  (OLD.phase = 'active' AND NEW.phase IN ('paused','blocked','complete')) OR
-  (OLD.phase = 'paused' AND NEW.phase IN ('active','complete')) OR
-  (OLD.phase = 'blocked' AND NEW.phase IN ('active','complete'))
-)
-BEGIN SELECT RAISE(ABORT, 'invalid goal transition'); END;
-`;
-const schema = `
-CREATE TABLE IF NOT EXISTS events (
-  seq INTEGER PRIMARY KEY AUTOINCREMENT,
-  stream_id TEXT NOT NULL,
-  stream_seq INTEGER NOT NULL CHECK(stream_seq > 0),
-  ts TEXT NOT NULL,
-  actor TEXT NOT NULL,
-  type TEXT NOT NULL,
-  data TEXT NOT NULL CHECK(json_valid(data)),
-  ignorable INTEGER CHECK(ignorable IS NULL OR ignorable = 1),
-  UNIQUE(stream_id, stream_seq)
-) STRICT;
-${createGoals}
-${createWorkRecords}
-CREATE TABLE IF NOT EXISTS schedule (
-  id TEXT PRIMARY KEY,
-  agent TEXT NOT NULL,
-  next_wake_at TEXT NOT NULL,
-  reason TEXT NOT NULL,
-  set_by TEXT NOT NULL
-) STRICT;
-${createWakes}
-CREATE TABLE IF NOT EXISTS mailbox (
-  id TEXT PRIMARY KEY,
-  to_agent TEXT NOT NULL,
-  from_agent TEXT NOT NULL,
-  level TEXT NOT NULL CHECK(level IN ('fyi','decision','emergency')),
-  body TEXT NOT NULL CHECK(json_valid(body)),
-  read_at TEXT
-) STRICT;
-${createActions}
-${indexesAndTriggers}`;
-class SystemClock {
-    now() { return new Date(); }
-}
-export class SqliteLedger {
-    db;
-    #faultInjector;
-    #clock;
-    constructor(path = ":memory:", options = {}) {
-        this.db = new DatabaseSync(path);
-        this.db.exec(`PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = ${options.busyTimeoutMs ?? 5_000};`);
-        this.#faultInjector = options.faultInjector;
-        this.#clock = options.clock ?? new SystemClock();
-        const version = Number(this.db.prepare("PRAGMA user_version").get().user_version);
-        if (version > SQLITE_SCHEMA_VERSION) {
-            this.db.close();
-            throw new Error(`ledger schema ${version} is newer than supported schema ${SQLITE_SCHEMA_VERSION}`);
-        }
-        if (version === 0) {
-            this.db.exec(schema);
-            this.db.exec(`PRAGMA user_version = ${SQLITE_SCHEMA_VERSION}`);
-        }
-        else if (version < SQLITE_SCHEMA_VERSION) {
-            this.#migrateLegacy();
-        }
-        else {
-            this.db.exec(schema);
-        }
-    }
-    close() { this.db.close(); }
-    appendEvent(input) { return this.#transaction(() => this.#insertEvent(input)); }
-    appendEvents(inputs) { return this.#transaction(() => inputs.map((input) => this.#insertEvent(input))); }
-    readStream(streamId, fromStreamSeq = 1) {
-        return this.db.prepare("SELECT * FROM events WHERE stream_id=? AND stream_seq>=? ORDER BY stream_seq").all(streamId, fromStreamSeq).map(mapEvent);
-    }
-    putGoal(goal, actor, wakeId) {
-        const normalized = normalizeGoal(goal);
-        assertGoalSnapshot(normalized);
-        const current = this.#getGoal(normalized.id);
-        if (current) {
-            if (normalized.revision !== current.revision + 1)
-                throw new Error("goal revision CAS failed");
-            if (current.phase === "complete")
-                throw new Error("completed goal cannot be modified");
-            if (normalized.parentId !== current.parentId)
-                throw new Error("goal reparenting is not supported");
-            if (normalized.phase === "complete")
-                throw new Error("goal completion requires reason and evidence");
-            if (normalized.objective !== current.objective && ((current.observationMethod !== null && normalized.observationMethod === current.observationMethod) || (current.verificationMethod !== null && normalized.verificationMethod === current.verificationMethod)))
-                throw new Error("objective revision must replace or invalidate observation and verification methods");
-            assertGoalTransition(current.phase, normalized.phase);
-            this.#assertGoalAuthority(current.parentId, actor);
-        }
-        else {
-            if (normalized.revision !== 0)
-                throw new Error("new goal revision must be 0");
-            this.#assertGoalAuthority(normalized.parentId, actor);
-        }
-        return this.#transaction(() => {
-            const event = this.#recordProjection("goals", normalized, actor, "goal.put", wakeId, undefined, undefined, goalStream(normalized.id));
-            if (!current)
-                this.#createWorkRecord(normalized, actor, wakeId ?? `goal:create:${normalized.id}`, wakeId);
-            return event;
-        });
-    }
-    updateWorkRecord(request, actor) {
-        if (!request.turnId.trim() || !request.reason.trim() || !request.content.trim())
-            throw new Error("work record turn, reason and content are required");
-        this.#assertEvidenceExists(request.evidence);
-        const goal = this.#getGoal(request.goalId);
-        if (!goal)
-            throw new Error("work record goal does not exist");
-        if (goal.revision !== request.goalRevision)
-            throw new Error("work record goal revision is stale");
-        this.#assertWorkRecordAuthority(goal, actor);
-        const current = this.workRecord(goal.id);
-        if (!current)
-            throw new Error("work record does not exist");
-        if (current.recordRevision !== request.expectedRevision)
-            throw new Error("work record revision CAS failed");
-        if (current.content === request.content)
-            throw new Error("work record content is unchanged");
-        return this.#transaction(() => this.#recordWorkRecord({
-            ...current,
-            recordRevision: current.recordRevision + 1,
-            goalRevision: goal.revision,
-            content: request.content,
-            updatedBy: actor,
-            updatedInTurn: request.turnId,
-            updatedInWake: request.wakeId ?? null,
-            updatedAt: this.#now(),
-            reason: request.reason,
-            evidence: request.evidence,
-        }, "work_record.updated"));
-    }
-    commitDelegation(request, actor, wakeId) {
-        const existing = this.#delegationResult(request.id);
-        if (existing) {
-            if (existing.goal.id !== request.childGoal.id || existing.goal.parentId !== request.parentGoalId || existing.goal.objective !== request.childGoal.objective || existing.goal.observationMethod !== request.childGoal.observationMethod || existing.goal.verificationMethod !== request.childGoal.verificationMethod || existing.goal.owner !== request.childGoal.owner)
-                throw new Error("delegation id was reused with a different child goal");
-            return existing;
-        }
-        if (!request.id.trim() || !request.reason.trim())
-            throw new Error("delegation id and reason are required");
-        if (request.childGoal.owner === actor)
-            throw new Error("delegate to a distinct worker agent; use goal.put for self-owned subgoals");
-        if (!request.childGoal.id.trim() || !request.childGoal.objective.trim() || !request.childGoal.observationMethod.trim() || !request.childGoal.verificationMethod.trim() || !request.childGoal.owner.trim())
-            throw new Error("delegation child goal is incomplete");
-        this.#assertEvidenceExists(request.evidence);
-        const parent = this.#getGoal(request.parentGoalId);
-        if (!parent)
-            throw new Error("delegation parent goal does not exist");
-        if (parent.owner !== actor)
-            throw new Error("only the parent goal owner may delegate");
-        if (parent.phase !== "active")
-            throw new Error("delegation parent goal must be active");
-        if (this.#getGoal(request.childGoal.id))
-            throw new Error("delegation child goal already exists");
-        return this.#transaction(() => {
-            const goal = normalizeGoal({ ...request.childGoal, parentId: request.parentGoalId, phase: "active", revision: 0 });
-            const mail = {
-                id: `delegation-mail:${request.id}`,
-                to: goal.owner,
-                from: actor,
-                level: "decision",
-                body: { type: "delegation", delegationId: request.id, goalId: goal.id, parentGoalId: request.parentGoalId, objective: goal.objective, observationMethod: goal.observationMethod, verificationMethod: goal.verificationMethod ?? null, brief: request.brief, reason: request.reason, evidence: request.evidence },
-                readAt: null,
-            };
-            const wakeBase = {
-                id: `delegation-wake:${request.id}`,
-                agent: goal.owner,
-                triggerRef: `delegation:${request.id}`,
-                status: "queued",
-                leaseUntil: null,
-                attempt: 0,
-                startedAt: null,
-                endedAt: null,
-                enqueuedSeq: 0,
-                leaseToken: null,
-                runnerPid: null,
-            };
-            this.#insertEvent({
-                streamId: wakeId ? wakeStream(wakeId) : controlStream("delegations"),
-                ts: this.#now(),
-                actor,
-                type: "delegation.created",
-                data: { delegationId: request.id, parentGoalId: request.parentGoalId, goalId: goal.id, mailId: mail.id, wakeId: wakeBase.id, reason: request.reason, evidence: request.evidence },
-            });
-            this.#faultInjector?.("after_delegation_event");
-            this.#recordProjection("goals", goal, actor, "goal.put", wakeId, undefined, undefined, goalStream(goal.id));
-            this.#createWorkRecord(goal, actor, wakeId ?? `delegation:${request.id}`, wakeId);
-            this.#recordProjection("mailbox", mail, actor, "mail.put", wakeId);
-            const wake = { ...wakeBase, enqueuedSeq: this.#nextEventSeq() };
-            this.#recordProjection("wakes", wake, "supervisor", "wake.enqueued", wake.id, undefined, wake.enqueuedSeq);
-            return { delegationId: request.id, goal, mail, wake };
-        });
-    }
-    commitReassignment(request, actor, wakeId) {
-        const existing = this.#reassignmentResult(request.id);
-        if (existing) {
-            if (existing.goal.id !== request.goalId || existing.goal.owner !== request.newOwner)
-                throw new Error("reassignment id was reused with a different target");
-            return existing;
-        }
-        if (!request.id.trim() || !request.newOwner.trim() || !request.reason.trim())
-            throw new Error("reassignment id, owner and reason are required");
-        this.#assertEvidenceExists(request.evidence);
-        const current = this.#getGoal(request.goalId);
-        if (!current)
-            throw new Error("reassignment goal does not exist");
-        if (!current.parentId)
-            throw new Error("root goals cannot be reassigned by CEO");
-        this.#assertGoalAuthority(current.parentId, actor);
-        if (current.phase === "complete")
-            throw new Error("completed goals cannot be reassigned");
-        if (current.owner === request.newOwner)
-            throw new Error("reassignment owner is unchanged");
-        return this.#transaction(() => {
-            const goal = { ...current, owner: request.newOwner, revision: current.revision + 1 };
-            const mail = [
-                { id: `reassignment-old-mail:${request.id}`, to: current.owner, from: actor, level: "fyi", body: { type: "reassignment", reassignmentId: request.id, goalId: goal.id, role: "previous_owner", reason: request.reason, evidence: request.evidence }, readAt: null },
-                { id: `reassignment-new-mail:${request.id}`, to: goal.owner, from: actor, level: "decision", body: { type: "reassignment", reassignmentId: request.id, goalId: goal.id, role: "new_owner", brief: request.brief, reason: request.reason, evidence: request.evidence }, readAt: null },
-            ];
-            const wakeBase = { id: `reassignment-wake:${request.id}`, agent: goal.owner, triggerRef: `reassignment:${request.id}`, status: "queued", leaseUntil: null, attempt: 0, startedAt: null, endedAt: null, enqueuedSeq: 0, leaseToken: null, runnerPid: null };
-            this.#insertEvent({ streamId: wakeId ? wakeStream(wakeId) : controlStream("reassignments"), ts: this.#now(), actor, type: "goal.reassigned", data: { reassignmentId: request.id, goalId: goal.id, oldOwner: current.owner, newOwner: goal.owner, mailIds: mail.map((item) => item.id), wakeId: wakeBase.id, reason: request.reason, evidence: request.evidence } });
-            this.#faultInjector?.("after_reassignment_event");
-            this.#recordProjection("goals", goal, actor, "goal.put", wakeId, undefined, undefined, goalStream(goal.id));
-            const oldWake = this.queuedWakeForAgent(current.owner);
-            if (oldWake)
-                this.#recordProjection("wakes", { ...oldWake, status: "abnormal", endedAt: this.#now() }, "supervisor", "wake.suppressed", oldWake.id);
-            for (const item of mail)
-                this.#recordProjection("mailbox", item, actor, "mail.put", wakeId);
-            const wake = { ...wakeBase, enqueuedSeq: this.#nextEventSeq() };
-            this.#recordProjection("wakes", wake, "supervisor", "wake.enqueued", wake.id, undefined, wake.enqueuedSeq);
-            return { reassignmentId: request.id, goal, mail, wake };
-        });
-    }
-    completeGoal(request, actor, wakeId) {
-        if (!request.reason.trim())
-            throw new Error("goal completion reason is required");
-        this.#assertEvidenceExists(request.evidence);
-        const current = this.#getGoal(request.goalId);
-        if (!current)
-            throw new Error("goal does not exist");
-        if (request.revision !== current.revision)
-            throw new Error("goal completion revision is stale");
-        if (current.phase === "complete")
-            return current;
-        if (current.observationMethod === null)
-            throw new Error("goal completion requires an observation method");
-        if (current.verificationMethod === null || current.verificationMethod === undefined)
-            throw new Error("goal completion requires a verification method");
-        this.#assertGoalAuthority(current.parentId, actor);
-        if (current.parentId === null && this.#hasNonCompleteDescendant(current.id))
-            throw new Error("root goal cannot complete while descendants remain non-complete");
-        const source = this.db.prepare("SELECT seq FROM events WHERE stream_id=? AND type='goal.put' AND json_extract(data,'$.snapshot.revision')=? ORDER BY seq DESC LIMIT 1").get(goalStream(current.id), current.revision);
-        if (!source)
-            throw new Error("goal revision has no source event");
-        if (request.evidence.some((seq) => seq <= source.seq))
-            throw new Error("goal completion evidence predates the current revision");
-        return this.#transaction(() => {
-            this.#insertEvent({ streamId: goalStream(current.id), ts: this.#now(), actor, type: "goal.completion_decided", data: { goalId: current.id, revision: current.revision, observationMethod: current.observationMethod, verificationMethod: current.verificationMethod ?? null, reason: request.reason, evidence: request.evidence } });
-            const next = { ...current, phase: "complete", revision: current.revision + 1 };
-            this.#recordProjection("goals", next, actor, "goal.put", wakeId, undefined, undefined, goalStream(current.id));
-            return next;
-        });
-    }
-    putSchedule(value, actor, wakeId) {
-        if (actor !== "supervisor" && actor !== value.agent)
-            throw new Error("schedule may only be set by its agent or supervisor");
-        return this.#project("schedule", value, actor, "schedule.put", wakeId);
-    }
-    enqueueWake(input, actor) {
-        if (actor !== "supervisor")
-            throw new Error("only supervisor may enqueue wakes");
-        if (input.status !== "queued" || input.attempt !== 0 || input.leaseUntil || input.startedAt || input.endedAt || input.leaseToken || input.runnerPid) {
-            throw new Error("new wake must be pristine and queued");
-        }
-        const duplicate = this.wakeByTrigger(input.agent, input.triggerRef);
-        if (duplicate) {
-            const row = this.db.prepare("SELECT * FROM events WHERE type='wake.enqueued' AND json_extract(data, '$.snapshot.id')=? ORDER BY seq DESC LIMIT 1").get(duplicate.id);
-            if (!row)
-                throw new Error("wake projection has no source event");
-            return { event: mapEvent(row), created: false };
-        }
-        return this.#transaction(() => {
-            const enqueuedSeq = this.#nextEventSeq();
-            const wake = { ...input, enqueuedSeq };
-            const event = this.#recordProjection("wakes", wake, actor, "wake.enqueued", wake.id, undefined, enqueuedSeq);
-            return { event, created: true };
-        });
-    }
-    claimNextWake(now, leaseUntil, leaseToken) {
-        return this.#transaction(() => {
-            const row = this.db.prepare(`SELECT * FROM wakes w WHERE status='queued' AND NOT EXISTS (
-        SELECT 1 FROM wakes active WHERE active.agent=w.agent AND active.status IN ('leased','running')
-      ) ORDER BY CASE WHEN trigger_ref LIKE 'interaction:%' THEN 0 ELSE 1 END,enqueued_seq LIMIT 1`).get();
-            if (!row)
-                return null;
-            const current = mapWake(row);
-            const next = { ...current, status: "leased", leaseUntil, leaseToken, runnerPid: null, attempt: current.attempt + 1 };
-            this.#recordProjection("wakes", next, "supervisor", "wake.leased", next.id, now);
-            return next;
-        });
-    }
-    markWakeRunning(id, now, leaseToken) {
-        const current = this.#requiredWake(id);
-        this.#assertLease(current, leaseToken);
-        const next = { ...current, status: "running", startedAt: now };
-        this.#project("wakes", next, "supervisor", "wake.running", id, now);
-        return next;
-    }
-    attachWakeProcess(id, leaseToken, pid, now) {
-        const current = this.#requiredWake(id);
-        this.#assertLease(current, leaseToken);
-        if (current.status !== "running")
-            throw new Error("runner pid may only be attached to a running wake");
-        const next = { ...current, runnerPid: pid };
-        this.#project("wakes", next, "supervisor", "wake.runner_attached", id, now);
-        return next;
-    }
-    renewWakeLease(id, leaseToken, leaseUntil, now) {
-        const current = this.#requiredWake(id);
-        this.#assertLease(current, leaseToken);
-        if (current.status !== "leased" && current.status !== "running")
-            throw new Error("only an active wake lease may be renewed");
-        if (leaseUntil <= now)
-            throw new Error("renewed lease must expire in the future");
-        const next = { ...current, leaseUntil };
-        this.#project("wakes", next, "supervisor", "wake.lease_renewed", id, now);
-        return next;
-    }
-    finishWake(id, status, now) {
-        const current = this.#requiredWake(id);
-        const next = { ...current, status, leaseUntil: null, leaseToken: null, runnerPid: null, endedAt: now };
-        this.#project("wakes", next, "supervisor", `wake.${status}`, id, now);
-        return next;
-    }
-    expiredWakes(now) {
-        return this.db.prepare("SELECT * FROM wakes WHERE status IN ('leased','running') AND lease_until <= ? ORDER BY enqueued_seq").all(now).map(mapWake);
-    }
-    recoverExpiredWake(id, now) {
-        const current = this.#requiredWake(id);
-        if (current.status !== "leased" && current.status !== "running")
-            throw new Error("wake is not recoverable");
-        if (!current.leaseUntil || current.leaseUntil > now)
-            throw new Error("wake lease has not expired");
-        const running = current.status === "running";
-        const next = { ...current, status: running ? "abnormal" : "queued", leaseUntil: null, leaseToken: null, runnerPid: null, endedAt: running ? now : null };
-        this.#project("wakes", next, "supervisor", running ? "wake.expired_abnormal" : "wake.lease_expired", id, now);
-        return next;
-    }
-    appendRunnerEvent(input, leaseToken) {
-        return this.#transaction(() => {
-            if (!input.streamId.startsWith("wake:"))
-                throw new Error("runner event requires a wake stream");
-            const wake = this.#requiredWake(input.streamId.slice("wake:".length));
-            this.#assertLease(wake, leaseToken);
-            if (wake.status !== "running" || !wake.leaseUntil || input.ts > wake.leaseUntil)
-                throw new Error("stale runner event rejected");
-            return this.#insertEvent(input);
-        });
-    }
-    requestAction(action, actor, wakeId) {
-        assertActionRequest(action);
-        if (actor !== action.agent)
-            throw new Error("action actor does not match action agent");
-        this.#assertEvidenceExists(action.evidence);
-        return this.#project("actions", action, actor, "action.requested", wakeId);
-    }
-    approveAction(id, approver, reason, evidence) {
-        return this.#decideAction(id, "approved", approver, reason, evidence);
-    }
-    rejectAction(id, approver, reason, evidence) {
-        return this.#decideAction(id, "failed", approver, reason, evidence);
-    }
-    transitionAction(id, status, patch = {}) {
-        const current = this.#requiredAction(id);
-        assertActionTransition(current.status, status);
-        if (current.status === "unknown" && (status === "confirmed" || status === "failed") && !patch.reconciledAt)
-            throw new Error("unknown action requires a reconciliation timestamp");
-        if (patch.reconciledAt && current.status !== "unknown")
-            throw new Error("reconciledAt is only written after unknown is queried");
-        if (patch.reconciledAt && status !== "confirmed" && status !== "failed")
-            throw new Error("reconciliation must resolve to a final state");
-        const next = { ...current, ...patch, status };
-        this.#project("actions", next, "supervisor", `action.${status}`);
-        return next;
-    }
-    recoverDispatchingActions() {
-        const rows = this.db.prepare("SELECT id FROM actions WHERE status='dispatching' ORDER BY id").all();
-        return rows.map(({ id }) => this.transitionAction(id, "unknown"));
-    }
-    putAuditAdvice(id, input, wakeId) {
-        const advice = { ...input, at: this.#now() };
-        this.#assertEvidenceExists(advice.evidence);
-        const current = this.#requiredAction(id);
-        const next = { ...current, auditAdvice: advice, adviceAcked: false };
-        this.#project("actions", next, advice.by, "action.audit_advice", wakeId, advice.at);
-        return next;
-    }
-    ackAuditAdvice(id, agent) {
-        const current = this.#requiredAction(id);
-        if (current.agent !== agent)
-            throw new Error("only the action owner may acknowledge audit advice");
-        if (!current.auditAdvice)
-            throw new Error("action has no audit advice");
-        const next = { ...current, adviceAcked: true };
-        this.#project("actions", next, agent, "action.audit_advice_acked");
-        return next;
-    }
-    putMail(mail, actor, wakeId) {
-        if (mail.from !== actor && actor !== "supervisor")
-            throw new Error("mail sender does not match actor");
-        return this.#project("mailbox", mail, actor, "mail.put", wakeId);
-    }
-    commitHandoff(commit) {
-        return this.#transaction(() => {
-            const wake = this.#requiredWake(commit.wakeId);
-            if (wake.status !== "running" || wake.agent !== commit.agent)
-                throw new Error("handoff does not match a running wake");
-            const event = this.#insertEvent({ streamId: wakeStream(commit.wakeId), ts: commit.ts, actor: commit.agent, type: "handoff.recorded", data: commit.output.handoff });
-            for (const mail of this.unreadMail(commit.agent)) {
-                this.#recordProjection("mailbox", { ...mail, readAt: commit.ts }, "supervisor", "mail.read", commit.wakeId, commit.ts);
-            }
-            for (const mail of commit.outgoingMail) {
-                if (mail.from !== commit.agent)
-                    throw new Error("handoff mail sender does not match agent");
-                this.#recordProjection("mailbox", mail, commit.agent, "mail.put", commit.wakeId, commit.ts);
-            }
-            if (commit.schedule) {
-                if (commit.schedule.agent !== commit.agent || commit.schedule.setBy !== commit.agent)
-                    throw new Error("handoff schedule does not match agent");
-                this.#recordProjection("schedule", commit.schedule, commit.agent, "schedule.put", commit.wakeId, commit.ts);
-            }
-            return event;
-        });
-    }
-    commitInteraction(commit) {
-        return this.#transaction(() => {
-            const wake = this.#requiredWake(commit.wakeId);
-            if (wake.status !== "running" || wake.agent !== commit.agent)
-                throw new Error("interaction does not match a running wake");
-            const mailRow = this.db.prepare("SELECT * FROM mailbox WHERE id=?").get(commit.mailId);
-            if (!mailRow)
-                throw new Error("interaction mail does not exist");
-            const mail = mapMail(mailRow);
-            if (mail.to !== commit.agent || mail.readAt !== null)
-                throw new Error("interaction mail is not unread for the agent");
-            const event = this.#insertEvent({ streamId: wakeStream(commit.wakeId), ts: commit.ts, actor: commit.agent, type: "interaction.completed", data: { mailId: mail.id, response: commit.response } });
-            this.#recordProjection("mailbox", { ...mail, readAt: commit.ts }, "supervisor", "mail.read", commit.wakeId, commit.ts);
-            return event;
-        });
-    }
-    dueSchedules(now) { return this.db.prepare("SELECT * FROM schedule WHERE next_wake_at <= ? ORDER BY next_wake_at,id").all(now).map(mapSchedule); }
-    unreadMail(agent) { return this.db.prepare("SELECT * FROM mailbox WHERE to_agent=? AND read_at IS NULL ORDER BY rowid").all(agent).map(mapMail); }
-    unackedAuditAdvice(agent) { return this.db.prepare("SELECT * FROM actions WHERE agent=? AND audit_advice IS NOT NULL AND advice_acked=0 ORDER BY rowid").all(agent).map(mapAction); }
-    lastEvent(actor, type) { const row = this.db.prepare("SELECT * FROM events WHERE actor=? AND type=? ORDER BY seq DESC LIMIT 1").get(actor, type); return row ? mapEvent(row) : null; }
-    latestEvent() { const row = this.db.prepare("SELECT * FROM events ORDER BY seq DESC LIMIT 1").get(); return row ? mapEvent(row) : null; }
-    eventsForWake(wakeId) { return this.readStream(wakeStream(wakeId)); }
-    wake(id) { const row = this.db.prepare("SELECT * FROM wakes WHERE id=?").get(id); return row ? mapWake(row) : null; }
-    wakeByTrigger(agent, triggerRef) {
-        const direct = this.db.prepare("SELECT * FROM wakes WHERE agent=? AND trigger_ref=?").get(agent, triggerRef);
-        if (direct)
-            return mapWake(direct);
-        const coalesced = this.db.prepare(`SELECT w.* FROM events e JOIN wakes w ON e.stream_id='wake:'||w.id
-      WHERE e.type='wake.trigger_coalesced' AND json_extract(e.data,'$.triggerRef')=? AND w.agent=? LIMIT 1`).get(triggerRef, agent);
-        return coalesced ? mapWake(coalesced) : null;
-    }
-    queuedWakeForAgent(agent) { const row = this.db.prepare("SELECT * FROM wakes WHERE agent=? AND status='queued' ORDER BY enqueued_seq LIMIT 1").get(agent); return row ? mapWake(row) : null; }
-    action(id) { const row = this.db.prepare("SELECT * FROM actions WHERE id=?").get(id); return row ? mapAction(row) : null; }
-    goalsForOwner(owner) { return this.db.prepare("SELECT * FROM goals WHERE owner=? ORDER BY id").all(owner).map(mapGoal); }
-    goal(id) { return this.#getGoal(id); }
-    workRecord(goalId) { const row = this.db.prepare("SELECT * FROM work_records WHERE goal_id=?").get(goalId); return row ? mapWorkRecord(row) : null; }
-    workRecordHistory(goalId) {
-        return this.readStream(workRecordStream(goalId)).filter((event) => event.type === "work_record.created" || event.type === "work_record.updated").map((event) => mapWorkRecordEvent(event));
-    }
-    workRecordDiff(goalId, fromRevision, toRevision) {
-        const history = this.workRecordHistory(goalId);
-        const from = history.find((record) => record.recordRevision === fromRevision);
-        const to = history.find((record) => record.recordRevision === toRevision);
-        if (!from || !to)
-            throw new Error("work record diff revision does not exist");
-        return { goalId, fromRevision, toRevision, text: lineDiff(from.content, to.content) };
-    }
-    searchWorkRecords(query, limit = 50) {
-        return this.db.prepare(`SELECT e.* FROM events_fts f JOIN events e ON e.seq=f.rowid
-      WHERE events_fts MATCH ? AND e.type IN ('work_record.created','work_record.updated') ORDER BY rank LIMIT ?`).all(query, limit).map((row) => mapWorkRecordEvent(mapEvent(row)));
-    }
-    triggeringMail() { return this.db.prepare("SELECT * FROM mailbox WHERE read_at IS NULL AND level IN ('decision','emergency') ORDER BY rowid").all().map(mapMail); }
-    eventsSince(seq, types) {
-        const events = this.db.prepare("SELECT * FROM events WHERE seq>? ORDER BY seq").all(seq).map(mapEvent);
-        return types?.length ? events.filter((event) => types.includes(event.type)) : events;
-    }
-    searchEvents(query, limit = 50) {
-        return this.db.prepare("SELECT e.* FROM events_fts f JOIN events e ON e.seq=f.rowid WHERE events_fts MATCH ? ORDER BY rank LIMIT ?").all(query, limit).map(mapEvent);
-    }
-    metricSamples(goalId) {
-        return this.db.prepare("SELECT data FROM events WHERE type='metric.sampled' AND json_extract(data,'$.goalId')=? ORDER BY seq").all(goalId).map((row) => JSON.parse(row.data));
-    }
-    events() { return this.db.prepare("SELECT * FROM events ORDER BY seq").all().map(mapEvent); }
-    goals() { return this.db.prepare("SELECT * FROM goals ORDER BY id").all().map(mapGoal); }
-    workRecords() { return this.db.prepare("SELECT * FROM work_records ORDER BY goal_id").all().map(mapWorkRecord); }
-    schedules() { return this.db.prepare("SELECT * FROM schedule ORDER BY id").all().map(mapSchedule); }
-    wakes() { return this.db.prepare("SELECT * FROM wakes ORDER BY enqueued_seq").all().map(mapWake); }
-    actions() { return this.db.prepare("SELECT * FROM actions ORDER BY id").all().map(mapAction); }
-    mailbox() { return this.db.prepare("SELECT * FROM mailbox ORDER BY rowid").all().map(mapMail); }
-    rebuildProjections() {
-        const source = this.events();
-        this.#transaction(() => {
-            this.db.exec("DELETE FROM work_records; DELETE FROM actions; DELETE FROM mailbox; DELETE FROM wakes; DELETE FROM schedule; DELETE FROM goals;");
-            for (const event of source) {
-                const data = event.data;
-                if (data.projection && data.snapshot)
-                    this.#applyProjection(data.projection, data.snapshot, event.seq);
-            }
-        });
-    }
-    #delegationResult(id) {
-        const row = this.db.prepare("SELECT data FROM events WHERE type='delegation.created' AND json_extract(data,'$.delegationId')=? ORDER BY seq LIMIT 1").get(id);
-        if (!row)
-            return null;
-        const data = JSON.parse(row.data);
-        const goal = this.#getGoal(data.goalId);
-        const mailRow = this.db.prepare("SELECT * FROM mailbox WHERE id=?").get(data.mailId);
-        const wake = this.wake(data.wakeId);
-        if (!goal || !mailRow || !wake)
-            throw new Error("committed delegation projections are incomplete");
-        return { delegationId: id, goal, mail: mapMail(mailRow), wake };
-    }
-    #reassignmentResult(id) {
-        const row = this.db.prepare("SELECT data FROM events WHERE type='goal.reassigned' AND json_extract(data,'$.reassignmentId')=? ORDER BY seq LIMIT 1").get(id);
-        if (!row)
-            return null;
-        const data = JSON.parse(row.data);
-        const goal = this.#getGoal(data.goalId);
-        const mail = data.mailIds.map((mailId) => {
-            const mailRow = this.db.prepare("SELECT * FROM mailbox WHERE id=?").get(mailId);
-            if (!mailRow)
-                throw new Error("committed reassignment mail is missing");
-            return mapMail(mailRow);
-        });
-        const wake = this.wake(data.wakeId);
-        if (!goal || !wake)
-            throw new Error("committed reassignment projections are incomplete");
-        return { reassignmentId: id, goal, mail, wake };
-    }
-    #decideAction(id, status, approver, reason, evidence) {
-        if (!reason.trim())
-            throw new Error("approval reason is required");
-        this.#assertEvidenceExists(evidence);
-        return this.#transaction(() => {
-            const current = this.#requiredAction(id);
-            assertActionTransition(current.status, status);
-            this.#insertEvent({ streamId: controlStream("actions"), ts: this.#now(), actor: approver, type: `action.${status}_decision`, data: { actionId: id, reason, evidence } });
-            const next = { ...current, status };
-            this.#recordProjection("actions", next, approver, `action.${status}`);
-            return next;
-        });
-    }
-    #createWorkRecord(goal, actor, turnId, wakeId, seed) {
-        return this.#recordWorkRecord({
-            goalId: goal.id,
-            recordRevision: 0,
-            goalRevision: goal.revision,
-            content: seed?.content ?? initialWorkRecord(),
-            updatedBy: actor,
-            updatedInTurn: turnId,
-            updatedInWake: wakeId ?? null,
-            updatedAt: this.#now(),
-            reason: "Goal created",
-            evidence: seed?.evidence ?? [],
-            lastEventSeq: 0,
-        }, "work_record.created");
-    }
-    #recordWorkRecord(snapshot, type) {
-        const seq = this.#nextEventSeq();
-        const committed = { ...snapshot, lastEventSeq: seq };
-        this.#recordProjection("work_records", committed, committed.updatedBy, type, committed.updatedInWake ?? undefined, committed.updatedAt, seq, workRecordStream(committed.goalId));
-        return committed;
-    }
-    #assertWorkRecordAuthority(goal, actor) {
-        if (goal.owner === actor || (goal.parentId === null && actor === "human"))
-            return;
-        const parent = goal.parentId ? this.#getGoal(goal.parentId) : null;
-        if (parent?.owner !== actor)
-            throw new Error("only the goal owner or parent owner may update its work record");
-    }
-    #assertGoalAuthority(parentId, actor) {
-        if (parentId === null) {
-            if (actor !== "human")
-                throw new Error("only human may modify a root goal");
-            return;
-        }
-        const parent = this.#getGoal(parentId);
-        if (!parent)
-            throw new Error("parent goal does not exist");
-        if (parent.owner !== actor)
-            throw new Error("only the parent goal owner may modify a child goal");
-    }
-    #hasNonCompleteDescendant(goalId) {
-        return Boolean(this.db.prepare(`WITH RECURSIVE descendants(id) AS (
-      SELECT id FROM goals WHERE parent_id=?
-      UNION ALL SELECT g.id FROM goals g JOIN descendants d ON g.parent_id=d.id
-    ) SELECT 1 FROM goals WHERE id IN (SELECT id FROM descendants) AND phase<>'complete' LIMIT 1`).get(goalId));
-    }
-    #assertEvidenceExists(evidence) {
-        const exists = this.db.prepare("SELECT 1 FROM events WHERE seq=?");
-        for (const seq of evidence)
-            if (!Number.isInteger(seq) || seq <= 0 || !exists.get(seq))
-                throw new Error(`evidence event does not exist: ${seq}`);
-    }
-    #assertLease(wake, leaseToken) {
-        if (wake.leaseToken !== leaseToken)
-            throw new Error("stale wake lease token");
-    }
-    #getGoal(id) { const row = this.db.prepare("SELECT * FROM goals WHERE id=?").get(id); return row ? mapGoal(row) : null; }
-    #requiredWake(id) { const value = this.wake(id); if (!value)
-        throw new Error(`wake not found: ${id}`); return value; }
-    #requiredAction(id) { const value = this.action(id); if (!value)
-        throw new Error(`action not found: ${id}`); return value; }
-    #project(projection, snapshot, actor, type, wakeId, ts, streamId) {
-        return this.#transaction(() => this.#recordProjection(projection, snapshot, actor, type, wakeId, ts, undefined, streamId));
-    }
-    #recordProjection(projection, snapshot, actor, type, wakeId, ts, expectedSeq, streamId) {
-        const event = this.#insertEvent({ streamId: streamId ?? (wakeId ? wakeStream(wakeId) : controlStream(projection)), ts: ts ?? this.#now(), actor, type, data: { projection, snapshot } }, expectedSeq);
-        this.#faultInjector?.("after_event_before_projection");
-        this.#applyProjection(projection, snapshot, event.seq);
-        return event;
-    }
-    #insertEvent(input, expectedSeq) {
-        if (!input.streamId.trim() || !input.actor.trim() || !input.type.trim())
-            throw new Error("event streamId, actor and type are required");
-        const streamSeq = Number(this.db.prepare("SELECT COALESCE(MAX(stream_seq),0)+1 AS next FROM events WHERE stream_id=?").get(input.streamId).next);
-        const result = expectedSeq === undefined
-            ? this.db.prepare("INSERT INTO events(stream_id,stream_seq,ts,actor,type,data,ignorable) VALUES (?,?,?,?,?,json(?),?)").run(input.streamId, streamSeq, input.ts, input.actor, input.type, JSON.stringify(input.data), input.ignorable === true ? 1 : null)
-            : this.db.prepare("INSERT INTO events(seq,stream_id,stream_seq,ts,actor,type,data,ignorable) VALUES (?,?,?,?,?,?,json(?),?)").run(expectedSeq, input.streamId, streamSeq, input.ts, input.actor, input.type, JSON.stringify(input.data), input.ignorable === true ? 1 : null);
-        return { ...input, seq: Number(result.lastInsertRowid), streamSeq };
-    }
-    #nextEventSeq() {
-        const row = this.db.prepare("SELECT seq FROM sqlite_sequence WHERE name='events'").get();
-        return Number(row?.seq ?? 0) + 1;
-    }
-    #applyProjection(projection, raw, sourceSeq) {
-        if (projection === "goals") {
-            const v = normalizeGoal(raw);
-            this.db.prepare(`INSERT INTO goals VALUES (?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET parent_id=excluded.parent_id,objective=excluded.objective,observation_method=excluded.observation_method,verification_method=excluded.verification_method,owner=excluded.owner,phase=excluded.phase,revision=excluded.revision`).run(v.id, v.parentId, v.objective, v.observationMethod, v.verificationMethod ?? null, v.owner, v.phase, v.revision);
-        }
-        else if (projection === "work_records") {
-            const v = raw;
-            this.db.prepare(`INSERT INTO work_records VALUES (?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(goal_id) DO UPDATE SET record_revision=excluded.record_revision,goal_revision=excluded.goal_revision,content=excluded.content,updated_by=excluded.updated_by,updated_in_turn=excluded.updated_in_turn,updated_in_wake=excluded.updated_in_wake,updated_at=excluded.updated_at,reason=excluded.reason,evidence=excluded.evidence,last_event_seq=excluded.last_event_seq`).run(v.goalId, v.recordRevision, v.goalRevision, v.content, v.updatedBy, v.updatedInTurn, v.updatedInWake, v.updatedAt, v.reason, JSON.stringify(v.evidence), v.lastEventSeq || sourceSeq);
-        }
-        else if (projection === "schedule") {
-            const v = raw;
-            this.db.prepare(`INSERT INTO schedule VALUES (?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET agent=excluded.agent,next_wake_at=excluded.next_wake_at,reason=excluded.reason,set_by=excluded.set_by`).run(v.id, v.agent, v.nextWakeAt, v.reason, v.setBy);
-        }
-        else if (projection === "wakes") {
-            const old = raw;
-            const existing = this.wake(old.id);
-            const active = old.status === "leased" || old.status === "running";
-            const v = {
-                ...old,
-                enqueuedSeq: old.enqueuedSeq ?? existing?.enqueuedSeq ?? sourceSeq,
-                leaseToken: old.leaseToken !== undefined ? old.leaseToken : active ? existing?.leaseToken ?? `legacy:${old.id}:${old.attempt}` : null,
-                runnerPid: old.runnerPid !== undefined ? old.runnerPid : existing?.runnerPid ?? null,
-            };
-            this.db.prepare(`INSERT INTO wakes VALUES (?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET agent=excluded.agent,trigger_ref=excluded.trigger_ref,status=excluded.status,lease_until=excluded.lease_until,attempt=excluded.attempt,started_at=excluded.started_at,ended_at=excluded.ended_at,enqueued_seq=excluded.enqueued_seq,lease_token=excluded.lease_token,runner_pid=excluded.runner_pid`).run(v.id, v.agent, v.triggerRef, v.status, v.leaseUntil, v.attempt, v.startedAt, v.endedAt, v.enqueuedSeq, v.leaseToken, v.runnerPid);
-        }
-        else if (projection === "mailbox") {
-            const v = raw;
-            this.db.prepare(`INSERT INTO mailbox VALUES (?,?,?,?,json(?),?) ON CONFLICT(id) DO UPDATE SET to_agent=excluded.to_agent,from_agent=excluded.from_agent,level=excluded.level,body=excluded.body,read_at=excluded.read_at`).run(v.id, v.to, v.from, v.level, JSON.stringify(v.body), v.readAt);
-        }
-        else {
-            const old = raw;
-            const v = { ...old, connector: old.connector ?? "legacy" };
-            this.db.prepare(`INSERT INTO actions VALUES (?,?,?,?,json(?),?,json(?),?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET agent=excluded.agent,kind=excluded.kind,connector=excluded.connector,payload=excluded.payload,reason=excluded.reason,evidence=excluded.evidence,gated=excluded.gated,status=excluded.status,reconciled_at=excluded.reconciled_at,external_ref=excluded.external_ref,audit_advice=excluded.audit_advice,advice_acked=excluded.advice_acked`).run(v.id, v.agent, v.kind, v.connector, JSON.stringify(v.payload), v.reason, JSON.stringify(v.evidence), v.gated ? 1 : 0, v.status, v.reconciledAt, v.externalRef, v.auditAdvice === null ? null : JSON.stringify(v.auditAdvice), v.adviceAcked ? 1 : 0);
-        }
-    }
-    #legacyWorkRecord(goal) {
-        const handoff = this.lastEvent(goal.owner, "handoff.recorded");
-        const legacy = handoff?.data && typeof handoff.data === "object" && !Array.isArray(handoff.data) && !("goalId" in handoff.data) ? handoff.data : null;
-        const notes = this.readStream(`memory:${goal.owner}`).filter((event) => event.type === "memory.appended");
-        const list = (items) => items?.length ? items.map((item) => `- ${item}`).join("\n") : "None recorded.";
-        const decisions = notes.length ? notes.map((event) => `- ${String(event.data.note ?? "")} [event:${event.seq}]`).join("\n") : "None recorded.";
-        return {
-            content: `# Current State\n\nMigrated from the previous Goal continuity model.\n\n# Observations\n\n${list(legacy?.observations)}\n\n# Work Completed\n\n${list(legacy?.results)}\n\n# Decisions\n\n${decisions}\n\n# Blockers\n\n${legacy?.blocker ?? "None recorded."}\n\n# Next Steps\n\n${list(legacy?.nextSteps)}\n`,
-            evidence: [...(handoff ? [handoff.seq] : []), ...notes.map((event) => event.seq)],
-        };
-    }
-    #migrateLegacy() {
-        this.#transaction(() => {
-            const goalColumns = new Set(this.db.prepare("PRAGMA table_info(goals)").all().map((row) => row.name));
-            const observationSource = goalColumns.has("observation_method") ? "observation_method" : "NULL";
-            const verificationSource = goalColumns.has("verification_method") ? "verification_method" : observationSource;
-            this.db.exec(`PRAGMA defer_foreign_keys=ON;
-        DROP TABLE IF EXISTS work_records;
-        DROP TRIGGER IF EXISTS events_no_update; DROP TRIGGER IF EXISTS events_no_delete; DROP TRIGGER IF EXISTS events_fts_insert;
-        DROP TRIGGER IF EXISTS wakes_valid_transition; DROP TRIGGER IF EXISTS actions_valid_transition; DROP TRIGGER IF EXISTS goals_valid_transition;
-        DROP INDEX IF EXISTS events_agent_kind_seq; DROP INDEX IF EXISTS events_wake_seq; DROP INDEX IF EXISTS events_coalesced_trigger;
-        DROP INDEX IF EXISTS events_actor_type_seq; DROP INDEX IF EXISTS events_stream_seq;
-        DROP INDEX IF EXISTS wakes_one_active_agent; DROP INDEX IF EXISTS wakes_queue_order; DROP INDEX IF EXISTS schedule_due; DROP INDEX IF EXISTS actions_agent_status;
-        DROP TABLE IF EXISTS events_fts;
-
-        ALTER TABLE goals RENAME TO goals_legacy; ${createGoals}
-        INSERT INTO goals(id,parent_id,objective,observation_method,verification_method,owner,phase,revision) SELECT id,parent_id,objective,${observationSource},${verificationSource},owner,phase,revision FROM goals_legacy;
-        DROP TABLE goals_legacy;`);
-            const wakeColumns = new Set(this.db.prepare("PRAGMA table_info(wakes)").all().map((row) => row.name));
-            if (!wakeColumns.has("enqueued_seq")) {
-                this.db.exec(`ALTER TABLE wakes RENAME TO wakes_legacy; ${createWakes}
-          INSERT INTO wakes SELECT id,agent,trigger_ref,status,lease_until,attempt,started_at,ended_at,rowid,
-            CASE WHEN status IN ('leased','running') THEN 'legacy:'||id||':'||attempt ELSE NULL END,NULL FROM wakes_legacy;
-          DROP TABLE wakes_legacy;`);
-            }
-            const actionColumns = new Set(this.db.prepare("PRAGMA table_info(actions)").all().map((row) => row.name));
-            if (!actionColumns.has("connector")) {
-                this.db.exec(`ALTER TABLE actions RENAME TO actions_legacy; ${createActions}
-          INSERT INTO actions SELECT id,agent,kind,'legacy',payload,reason,evidence,gated,status,reconciled_at,external_ref,audit_advice,advice_acked FROM actions_legacy;
-          DROP TABLE actions_legacy;`);
-            }
-            const eventColumns = new Set(this.db.prepare("PRAGMA table_info(events)").all().map((row) => row.name));
-            if (!eventColumns.has("stream_id")) {
-                this.db.exec(`ALTER TABLE events RENAME TO events_legacy;
-          CREATE TABLE events (
-            seq INTEGER PRIMARY KEY AUTOINCREMENT,
-            stream_id TEXT NOT NULL,
-            stream_seq INTEGER NOT NULL CHECK(stream_seq > 0),
-            ts TEXT NOT NULL,
-            actor TEXT NOT NULL,
-            type TEXT NOT NULL,
-            data TEXT NOT NULL CHECK(json_valid(data)),
-            ignorable INTEGER CHECK(ignorable IS NULL OR ignorable = 1),
-            UNIQUE(stream_id, stream_seq)
-          ) STRICT;
-          INSERT INTO events(seq,stream_id,stream_seq,ts,actor,type,data,ignorable)
-          SELECT seq,stream_id,ROW_NUMBER() OVER (PARTITION BY stream_id ORDER BY seq),ts,agent,kind,data,NULL FROM (
-            SELECT seq,ts,agent,kind,data,CASE WHEN wake_id IS NULL THEN 'control:'||agent ELSE 'wake:'||wake_id END AS stream_id FROM events_legacy
-          );
-          DROP TABLE events_legacy;`);
-            }
-            else if (!eventColumns.has("ignorable")) {
-                this.db.exec("ALTER TABLE events ADD COLUMN ignorable INTEGER CHECK(ignorable IS NULL OR ignorable = 1)");
-            }
-            this.db.exec(createWorkRecords);
-            for (const goal of this.goals()) {
-                if (!this.workRecord(goal.id))
-                    this.#createWorkRecord(goal, "supervisor", `migration:work-record:${goal.id}`, undefined, this.#legacyWorkRecord(goal));
-            }
-            this.db.exec(`${indexesAndTriggers} INSERT INTO events_fts(events_fts) VALUES('rebuild'); PRAGMA user_version=${SQLITE_SCHEMA_VERSION};`);
-        });
-    }
-    #transaction(fn) {
-        this.db.exec("BEGIN IMMEDIATE");
-        try {
-            const result = fn();
-            this.db.exec("COMMIT");
-            return result;
-        }
-        catch (error) {
-            this.db.exec("ROLLBACK");
-            throw error;
-        }
-    }
-    #now() { return this.#clock.now().toISOString(); }
-}
-function mapEvent(r) { return { seq: Number(r.seq), streamId: String(r.stream_id), streamSeq: Number(r.stream_seq), ts: String(r.ts), actor: String(r.actor), type: String(r.type), data: JSON.parse(String(r.data)), ...(Number(r.ignorable) === 1 ? { ignorable: true } : {}) }; }
-function normalizeGoal(goal) { return { ...goal, observationMethod: goal.observationMethod ?? null, verificationMethod: goal.verificationMethod === undefined ? goal.observationMethod ?? null : goal.verificationMethod }; }
-function mapGoal(r) { return { id: String(r.id), parentId: r.parent_id === null ? null : String(r.parent_id), objective: String(r.objective), observationMethod: r.observation_method === null || r.observation_method === undefined ? null : String(r.observation_method), verificationMethod: r.verification_method === null || r.verification_method === undefined ? null : String(r.verification_method), owner: String(r.owner), phase: String(r.phase), revision: Number(r.revision) }; }
-function mapWorkRecord(r) { return { goalId: String(r.goal_id), recordRevision: Number(r.record_revision), goalRevision: Number(r.goal_revision), content: String(r.content), updatedBy: String(r.updated_by), updatedInTurn: String(r.updated_in_turn), updatedInWake: r.updated_in_wake === null ? null : String(r.updated_in_wake), updatedAt: String(r.updated_at), reason: String(r.reason), evidence: JSON.parse(String(r.evidence)), lastEventSeq: Number(r.last_event_seq) }; }
-function mapWorkRecordEvent(event) { const data = event.data; if (!data.snapshot)
-    throw new Error(`work record event ${event.seq} has no snapshot`); return { ...data.snapshot, lastEventSeq: event.seq }; }
-function initialWorkRecord() { return "# Current State\n\nGoal created. Work has not started.\n\n# Observations\n\n# Work Completed\n\n# Decisions\n\n# Blockers\n\n# Next Steps\n"; }
-function lineDiff(from, to) {
-    const before = from.split("\n");
-    const after = to.split("\n");
-    const lines = [];
-    for (let index = 0; index < Math.max(before.length, after.length); index += 1) {
-        if (before[index] === after[index]) {
-            if (before[index] !== undefined)
-                lines.push(` ${before[index]}`);
-            continue;
-        }
-        if (before[index] !== undefined)
-            lines.push(`-${before[index]}`);
-        if (after[index] !== undefined)
-            lines.push(`+${after[index]}`);
-    }
-    return lines.join("\n");
-}
-function mapSchedule(r) { return { id: String(r.id), agent: String(r.agent), nextWakeAt: String(r.next_wake_at), reason: String(r.reason), setBy: String(r.set_by) }; }
-function mapWake(r) { return { id: String(r.id), agent: String(r.agent), triggerRef: String(r.trigger_ref), status: String(r.status), leaseUntil: r.lease_until === null ? null : String(r.lease_until), attempt: Number(r.attempt), startedAt: r.started_at === null ? null : String(r.started_at), endedAt: r.ended_at === null ? null : String(r.ended_at), enqueuedSeq: Number(r.enqueued_seq), leaseToken: r.lease_token === null ? null : String(r.lease_token), runnerPid: r.runner_pid === null ? null : Number(r.runner_pid) }; }
-function mapMail(r) { return { id: String(r.id), to: String(r.to_agent), from: String(r.from_agent), level: String(r.level), body: JSON.parse(String(r.body)), readAt: r.read_at === null ? null : String(r.read_at) }; }
-function mapAction(r) { return { id: String(r.id), agent: String(r.agent), kind: String(r.kind), connector: String(r.connector), payload: JSON.parse(String(r.payload)), reason: String(r.reason), evidence: JSON.parse(String(r.evidence)), gated: Boolean(r.gated), status: String(r.status), reconciledAt: r.reconciled_at === null ? null : String(r.reconciled_at), externalRef: r.external_ref === null ? null : String(r.external_ref), auditAdvice: r.audit_advice === null ? null : JSON.parse(String(r.audit_advice)), adviceAcked: Boolean(r.advice_acked) }; }
-//# sourceMappingURL=index.js.map