agentix-cli 0.18.0 → 0.19.0

package/dist/chunk-4MREHZP5.js

@@ -0,0 +1,111 @@
+import N from"better-sqlite3";import{existsSync as X,mkdirSync as m}from"fs";import{dirname as R,resolve as y}from"path";import{randomBytes as g}from"crypto";var _="0123456789ABCDEFGHJKMNPQRSTVWXYZ",T=10,a=16;function v(t){let e="";for(let n=T-1;n>=0;n--)e=_[t&31]+e,t=Math.floor(t/32);return e}function I(){let t=g(a),e="";for(let n=0;n<a;n++)e+=_[t[n]&31];return e}function u(t=Date.now()){return v(t)+I()}var d=class{db;path;constructor(e={}){this.path=y(process.cwd(),e.path??".agentx/intent/ledger.sqlite"),m(R(this.path),{recursive:!0}),this.db=new N(this.path),this.db.pragma("journal_mode = WAL"),this.db.pragma("synchronous = NORMAL"),this.db.pragma("foreign_keys = ON"),O(this.db)}close(){this.db.close()}schemaVersion(){return this.db.prepare("SELECT MAX(v) AS v FROM schema_version").get().v??0}recordEvent(e){if(e.sourceEventId!==null){let i=this.findEventBySourceId(e.source,e.sourceEventId);if(i)return i}let n={id:e.id??u(e.ts),ts:e.ts,source:e.source,sourceEventId:e.sourceEventId,project:e.project,subject:e.subject,intent:e.intent,rawJson:e.rawJson};return this.db.prepare(`INSERT INTO intent_events (id, ts, source, source_event_id, project, subject, intent, raw_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(n.id,n.ts,n.source,n.sourceEventId,n.project,n.subject,n.intent,n.rawJson),n}findEventBySourceId(e,n){let i=this.db.prepare(`SELECT id, ts, source, source_event_id, project, subject, intent, raw_json
+         FROM intent_events WHERE source = ? AND source_event_id = ?`).get(e,n);return i?E(i):null}getEventById(e){let n=this.db.prepare(`SELECT id, ts, source, source_event_id, project, subject, intent, raw_json
+         FROM intent_events WHERE id = ?`).get(e);return n?E(n):null}recordDecision(e){this.db.prepare(`INSERT INTO intent_decisions (event_id, decided_at, decided_by, agent_id, outcome, reason)
+         VALUES (?, ?, ?, ?, ?, ?)`).run(e.eventId,e.decidedAt,e.decidedBy,e.agentId,e.outcome,e.reason)}getDecisionsForEvent(e){return this.db.prepare(`SELECT event_id, decided_at, decided_by, agent_id, outcome, reason
+         FROM intent_decisions WHERE event_id = ? ORDER BY decided_at ASC`).all(e).map(l)}getActiveDecisionForSubject(e,n){if(e===null||n===null)return null;let i=this.db.prepare(`SELECT d.event_id, d.decided_at, d.decided_by, d.agent_id, d.outcome, d.reason
+         FROM intent_decisions d
+         JOIN intent_events e ON e.id = d.event_id
+         LEFT JOIN intent_resolutions r
+           ON r.decision_event_id = d.event_id AND r.decision_decided_by = d.decided_by
+         WHERE e.project = ? AND e.subject = ?
+           AND d.outcome = 'dispatched'
+           AND r.decision_event_id IS NULL
+         ORDER BY d.decided_at DESC
+         LIMIT 1`).get(e,n);return i?l(i):null}recordResolution(e){this.db.prepare(`INSERT INTO intent_resolutions (decision_event_id, decision_decided_by, resolved_at, status, duration_ms, result_summary)
+         VALUES (?, ?, ?, ?, ?, ?)`).run(e.decisionEventId,e.decisionDecidedBy,e.resolvedAt,e.status,e.durationMs,e.resultSummary)}cleanupOrphanedDispatches(e="daemon-restart",n=Date.now){let i=this.db.prepare(`
+        SELECT d.event_id, d.decided_by FROM intent_decisions d
+        LEFT JOIN intent_resolutions r
+          ON r.decision_event_id = d.event_id AND r.decision_decided_by = d.decided_by
+        WHERE d.outcome = 'dispatched' AND r.decision_event_id IS NULL
+      `).all(),o=n(),s=0;for(let c of i)try{this.recordResolution({decisionEventId:c.event_id,decisionDecidedBy:c.decided_by,resolvedAt:o,status:"canceled",durationMs:null,resultSummary:e}),s++}catch{}return s}getResolution(e,n){let i=this.db.prepare(`SELECT decision_event_id, decision_decided_by, resolved_at, status, duration_ms, result_summary
+         FROM intent_resolutions WHERE decision_event_id = ? AND decision_decided_by = ?`).get(e,n);return i?b(i):null}recordDivergence(e){this.db.prepare(`INSERT INTO intent_divergences (
+           id, ts, source, event_id, decided_by,
+           ledger_agent_id, ledger_outcome, ledger_reason,
+           legacy_agent_id, legacy_outcome, legacy_reason
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(e.id,e.ts,e.source,e.eventId,e.decidedBy,e.ledgerAgentId,e.ledgerOutcome,e.ledgerReason,e.legacyAgentId,e.legacyOutcome,e.legacyReason)}getDivergences(e={}){let n=[],i=[];e.source!==void 0&&(n.push("source = ?"),i.push(e.source)),e.since!==void 0&&(n.push("ts >= ?"),i.push(e.since));let o=n.length?`WHERE ${n.join(" AND ")}`:"",s=e.limit!==void 0?"LIMIT ?":"";return e.limit!==void 0&&i.push(e.limit),this.db.prepare(`SELECT id, ts, source, event_id, decided_by,
+                ledger_agent_id, ledger_outcome, ledger_reason,
+                legacy_agent_id, legacy_outcome, legacy_reason
+         FROM intent_divergences
+         ${o}
+         ORDER BY ts DESC
+         ${s}`).all(...i).map(L)}};function E(t){return{id:t.id,ts:t.ts,source:t.source,sourceEventId:t.source_event_id,project:t.project,subject:t.subject,intent:t.intent,rawJson:t.raw_json}}function l(t){return{eventId:t.event_id,decidedAt:t.decided_at,decidedBy:t.decided_by,agentId:t.agent_id,outcome:t.outcome,reason:t.reason}}function b(t){return{decisionEventId:t.decision_event_id,decisionDecidedBy:t.decision_decided_by,resolvedAt:t.resolved_at,status:t.status,durationMs:t.duration_ms,resultSummary:t.result_summary}}function L(t){return{id:t.id,ts:t.ts,source:t.source,eventId:t.event_id,decidedBy:t.decided_by,ledgerAgentId:t.ledger_agent_id,ledgerOutcome:t.ledger_outcome,ledgerReason:t.ledger_reason,legacyAgentId:t.legacy_agent_id,legacyOutcome:t.legacy_outcome,legacyReason:t.legacy_reason}}function O(t){t.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (
+      v INTEGER PRIMARY KEY
+    );
+  `);let e=t.prepare("SELECT MAX(v) AS v FROM schema_version").get().v??0;e<1&&p(t),e<2&&S(t)}function p(t){t.exec(`
+    CREATE TABLE IF NOT EXISTS intent_events (
+      -- TEXT PRIMARY KEY isn't auto-NOT-NULL in SQLite; spell it out so the
+      -- ULID invariant is enforced at the schema level rather than relying on
+      -- the application layer.
+      id              TEXT NOT NULL PRIMARY KEY,
+      ts              INTEGER NOT NULL,
+      source          TEXT NOT NULL,
+      source_event_id TEXT,
+      project         TEXT,
+      subject         TEXT,
+      intent          TEXT,
+      raw_json        TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_intent_events_subject
+      ON intent_events (project, subject);
+    CREATE INDEX IF NOT EXISTS idx_intent_events_source_event_id
+      ON intent_events (source, source_event_id);
+    CREATE INDEX IF NOT EXISTS idx_intent_events_ts
+      ON intent_events (ts);
+
+    CREATE TABLE IF NOT EXISTS intent_decisions (
+      event_id    TEXT NOT NULL REFERENCES intent_events(id),
+      decided_at  INTEGER NOT NULL,
+      decided_by  TEXT NOT NULL,
+      agent_id    TEXT,
+      outcome     TEXT NOT NULL,
+      reason      TEXT,
+      PRIMARY KEY (event_id, decided_by)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_intent_decisions_agent
+      ON intent_decisions (agent_id, decided_at);
+    CREATE INDEX IF NOT EXISTS idx_intent_decisions_outcome
+      ON intent_decisions (outcome, decided_at);
+
+    CREATE TABLE IF NOT EXISTS intent_resolutions (
+      decision_event_id    TEXT NOT NULL,
+      decision_decided_by  TEXT NOT NULL,
+      resolved_at          INTEGER NOT NULL,
+      status               TEXT NOT NULL,
+      duration_ms          INTEGER,
+      result_summary       TEXT,
+      PRIMARY KEY (decision_event_id, decision_decided_by),
+      FOREIGN KEY (decision_event_id, decision_decided_by)
+        REFERENCES intent_decisions(event_id, decided_by)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_intent_resolutions_status
+      ON intent_resolutions (status, resolved_at);
+  `),t.prepare("INSERT INTO schema_version (v) VALUES (1)").run()}function S(t){t.exec(`
+    CREATE TABLE IF NOT EXISTS intent_divergences (
+      id                TEXT NOT NULL PRIMARY KEY,
+      ts                INTEGER NOT NULL,
+      source            TEXT NOT NULL,
+      event_id          TEXT NOT NULL,
+      decided_by        TEXT NOT NULL,
+      ledger_agent_id   TEXT,
+      ledger_outcome    TEXT NOT NULL,
+      ledger_reason     TEXT,
+      legacy_agent_id   TEXT,
+      legacy_outcome    TEXT NOT NULL,
+      legacy_reason     TEXT,
+      FOREIGN KEY (event_id, decided_by)
+        REFERENCES intent_decisions(event_id, decided_by)
+    );
+
+    -- "show me recent divergences from gitlab" \u2014 the soak's primary query
+    CREATE INDEX IF NOT EXISTS idx_intent_divergences_source_ts
+      ON intent_divergences (source, ts);
+    -- "are any deciders consistently wrong" \u2014 per-decider analysis
+    CREATE INDEX IF NOT EXISTS idx_intent_divergences_decided_by
+      ON intent_divergences (decided_by, ts);
+  `),t.prepare("INSERT INTO schema_version (v) VALUES (2)").run()}var r;function M(t={}){return r||(r=new d({path:t.path}),r)}export{u as a,d as b,M as c};
+//# sourceMappingURL=chunk-4MREHZP5.js.map

package/dist/chunk-4MREHZP5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/intent/ledger.ts","../src/intent/ulid.ts","../src/intent/instance.ts"],"sourcesContent":["import Database from \"better-sqlite3\"\nimport { existsSync, mkdirSync } from \"fs\"\nimport { dirname, resolve } from \"path\"\nimport { newEventId } from \"./ulid\"\nimport type {\n  IntentDecision,\n  IntentDivergence,\n  IntentEvent,\n  IntentEventInput,\n  IntentResolution,\n  IntentSource,\n} from \"./types\"\n\n// Intent ledger — Phase 1 of the architectural rescue.\n//\n// Append-only SQLite store that becomes the single source of truth for\n// dispatch decisions across all sources (channel router, workflow\n// dispatcher, gitlab handler, cron, mesh). This commit only opens the db\n// and runs the schema migrations. The read/write API arrives in commit 2;\n// the `decideAndCommit` skeleton in commit 3.\n//\n// Lives in its own database file (`.agentx/intent/ledger.sqlite`) rather\n// than sharing the existing observability db at `.agentx/db.sqlite`:\n//   - Different lifecycle: dispatch is hotter than observability, no point\n//     making fsync compete.\n//   - Different durability story: the ledger is canonical state; the\n//     observability tables are derived. Different backup/retention policies.\n//   - Cleaner schema separation — ledger migrations don't entangle with the\n//     observability ones.\n//\n// WAL mode + synchronous=NORMAL — same balance the observability db uses.\n\nexport interface OpenLedgerOptions {\n  /** Resolved relative to cwd. Default: .agentx/intent/ledger.sqlite */\n  path?: string\n}\n\n/**\n * IntentLedger handle. One instance per database file. Tests open per-test\n * tmp instances; the daemon opens one process-global instance (added in a\n * later commit when daemon wiring lands).\n */\nexport class IntentLedger {\n  readonly db: Database.Database\n  readonly path: string\n\n  constructor(opts: OpenLedgerOptions = {}) {\n    this.path = resolve(process.cwd(), opts.path ?? \".agentx/intent/ledger.sqlite\")\n    mkdirSync(dirname(this.path), { recursive: true })\n    this.db = new Database(this.path)\n    this.db.pragma(\"journal_mode = WAL\")\n    this.db.pragma(\"synchronous = NORMAL\")\n    this.db.pragma(\"foreign_keys = ON\")\n    runMigrations(this.db)\n  }\n\n  /** Test-only — production never closes. */\n  close(): void {\n    this.db.close()\n  }\n\n  /** Current schema version. New migrations append to the runMigrations\n   *  list and bump the version. Useful for tests + diagnostics. */\n  schemaVersion(): number {\n    const row = this.db.prepare(\"SELECT MAX(v) AS v FROM schema_version\").get() as { v: number | null }\n    return row.v ?? 0\n  }\n\n  // -------------------------------------------------------------------------\n  // Events\n  // -------------------------------------------------------------------------\n\n  /**\n   * Append an event. Idempotent on `(source, sourceEventId)` — a re-delivery\n   * with the same external id returns the previously-stored row without\n   * inserting a duplicate. Events with `sourceEventId === null` (cron tics,\n   * ad-hoc internal events) are NOT deduplicated; each call writes a new row.\n   *\n   * Returns the canonical (existing or new) event row including its id.\n   */\n  recordEvent(input: IntentEventInput): IntentEvent {\n    if (input.sourceEventId !== null) {\n      const existing = this.findEventBySourceId(input.source, input.sourceEventId)\n      if (existing) return existing\n    }\n    const event: IntentEvent = {\n      id: input.id ?? newEventId(input.ts),\n      ts: input.ts,\n      source: input.source,\n      sourceEventId: input.sourceEventId,\n      project: input.project,\n      subject: input.subject,\n      intent: input.intent,\n      rawJson: input.rawJson,\n    }\n    this.db\n      .prepare(\n        `INSERT INTO intent_events (id, ts, source, source_event_id, project, subject, intent, raw_json)\n         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,\n      )\n      .run(\n        event.id,\n        event.ts,\n        event.source,\n        event.sourceEventId,\n        event.project,\n        event.subject,\n        event.intent,\n        event.rawJson,\n      )\n    return event\n  }\n\n  /** Idempotency probe — used by `recordEvent` and by external callers that\n   *  want to check existence before constructing a full event payload. */\n  findEventBySourceId(source: IntentSource, sourceEventId: string): IntentEvent | null {\n    const row = this.db\n      .prepare(\n        `SELECT id, ts, source, source_event_id, project, subject, intent, raw_json\n         FROM intent_events WHERE source = ? AND source_event_id = ?`,\n      )\n      .get(source, sourceEventId) as EventRow | undefined\n    return row ? rowToEvent(row) : null\n  }\n\n  /** Lookup by primary key. Returns null when not found. */\n  getEventById(id: string): IntentEvent | null {\n    const row = this.db\n      .prepare(\n        `SELECT id, ts, source, source_event_id, project, subject, intent, raw_json\n         FROM intent_events WHERE id = ?`,\n      )\n      .get(id) as EventRow | undefined\n    return row ? rowToEvent(row) : null\n  }\n\n  // -------------------------------------------------------------------------\n  // Decisions\n  // -------------------------------------------------------------------------\n\n  /**\n   * Append a decision. Throws on `(eventId, decidedBy)` conflict — decisions\n   * are once-and-only-once per decider. Idempotency for the *event* is the\n   * caller's responsibility (use `recordEvent` for that); decisions\n   * intentionally do not retry-coalesce so a buggy caller surfaces loudly\n   * instead of silently overwriting prior judgement.\n   */\n  recordDecision(decision: IntentDecision): void {\n    this.db\n      .prepare(\n        `INSERT INTO intent_decisions (event_id, decided_at, decided_by, agent_id, outcome, reason)\n         VALUES (?, ?, ?, ?, ?, ?)`,\n      )\n      .run(\n        decision.eventId,\n        decision.decidedAt,\n        decision.decidedBy,\n        decision.agentId,\n        decision.outcome,\n        decision.reason,\n      )\n  }\n\n  /** All decisions for one event, oldest first. The chain (channel-router →\n   *  pm-gate → workflow) reads naturally in insertion order. */\n  getDecisionsForEvent(eventId: string): IntentDecision[] {\n    const rows = this.db\n      .prepare(\n        `SELECT event_id, decided_at, decided_by, agent_id, outcome, reason\n         FROM intent_decisions WHERE event_id = ? ORDER BY decided_at ASC`,\n      )\n      .all(eventId) as DecisionRow[]\n    return rows.map(rowToDecision)\n  }\n\n  /**\n   * The active-task-safety check. Returns the most recent `dispatched`\n   * decision for `(project, subject)` that has not yet been resolved\n   * (no row in `intent_resolutions`). `decideAndCommit` (commit 3) consults\n   * this to enforce the at-most-one-in-flight invariant.\n   *\n   * Returns null when project or subject is null — the active-task concept\n   * is meaningless without both axes pinned.\n   */\n  getActiveDecisionForSubject(project: string | null, subject: string | null): IntentDecision | null {\n    if (project === null || subject === null) return null\n    const row = this.db\n      .prepare(\n        `SELECT d.event_id, d.decided_at, d.decided_by, d.agent_id, d.outcome, d.reason\n         FROM intent_decisions d\n         JOIN intent_events e ON e.id = d.event_id\n         LEFT JOIN intent_resolutions r\n           ON r.decision_event_id = d.event_id AND r.decision_decided_by = d.decided_by\n         WHERE e.project = ? AND e.subject = ?\n           AND d.outcome = 'dispatched'\n           AND r.decision_event_id IS NULL\n         ORDER BY d.decided_at DESC\n         LIMIT 1`,\n      )\n      .get(project, subject) as DecisionRow | undefined\n    return row ? rowToDecision(row) : null\n  }\n\n  // -------------------------------------------------------------------------\n  // Resolutions\n  // -------------------------------------------------------------------------\n\n  /**\n   * Append a resolution. Throws if a resolution already exists for the\n   * decision — the ledger is append-only, so revising an outcome is a new\n   * event, not an overwrite. The FK to `intent_decisions` ensures the\n   * decision exists.\n   */\n  recordResolution(resolution: IntentResolution): void {\n    this.db\n      .prepare(\n        `INSERT INTO intent_resolutions (decision_event_id, decision_decided_by, resolved_at, status, duration_ms, result_summary)\n         VALUES (?, ?, ?, ?, ?, ?)`,\n      )\n      .run(\n        resolution.decisionEventId,\n        resolution.decisionDecidedBy,\n        resolution.resolvedAt,\n        resolution.status,\n        resolution.durationMs,\n        resolution.resultSummary,\n      )\n  }\n\n  /**\n   * Close every dispatched-and-unresolved decision by writing a\n   * resolution with status \"canceled\" and the given reason. Used at\n   * daemon startup to clean up dispatches whose agent execution died\n   * with the previous process — without this, those decisions sit\n   * in-flight forever and Inv-ActiveTaskSafety blocks legitimate\n   * re-dispatches on the same slot.\n   *\n   * Returns the count of resolutions written. Idempotent — repeated\n   * calls write 0 the second time because nothing remains in-flight.\n   */\n  cleanupOrphanedDispatches(reason: string = \"daemon-restart\", now: () => number = Date.now): number {\n    const rows = this.db\n      .prepare(`\n        SELECT d.event_id, d.decided_by FROM intent_decisions d\n        LEFT JOIN intent_resolutions r\n          ON r.decision_event_id = d.event_id AND r.decision_decided_by = d.decided_by\n        WHERE d.outcome = 'dispatched' AND r.decision_event_id IS NULL\n      `)\n      .all() as Array<{ event_id: string; decided_by: string }>\n    const ts = now()\n    let count = 0\n    for (const row of rows) {\n      try {\n        this.recordResolution({\n          decisionEventId: row.event_id,\n          decisionDecidedBy: row.decided_by,\n          resolvedAt: ts,\n          status: \"canceled\",\n          durationMs: null,\n          resultSummary: reason,\n        })\n        count++\n      } catch {\n        // Skip — resolution already exists (race with normal completion).\n      }\n    }\n    return count\n  }\n\n  /** Returns the resolution for a decision, or null if still in-flight. */\n  getResolution(eventId: string, decidedBy: string): IntentResolution | null {\n    const row = this.db\n      .prepare(\n        `SELECT decision_event_id, decision_decided_by, resolved_at, status, duration_ms, result_summary\n         FROM intent_resolutions WHERE decision_event_id = ? AND decision_decided_by = ?`,\n      )\n      .get(eventId, decidedBy) as ResolutionRow | undefined\n    return row ? rowToResolution(row) : null\n  }\n\n  // -------------------------------------------------------------------------\n  // Divergences (shadow-mode soak surface)\n  // -------------------------------------------------------------------------\n\n  /**\n   * Append a divergence record. Throws on duplicate `id`. The composite FK\n   * to `intent_decisions` (`event_id`, `decided_by`) enforces that a\n   * divergence cannot exist without its ledger-side decision — so callers\n   * must record the decision before reporting the divergence.\n   */\n  recordDivergence(divergence: IntentDivergence): void {\n    this.db\n      .prepare(\n        `INSERT INTO intent_divergences (\n           id, ts, source, event_id, decided_by,\n           ledger_agent_id, ledger_outcome, ledger_reason,\n           legacy_agent_id, legacy_outcome, legacy_reason\n         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,\n      )\n      .run(\n        divergence.id,\n        divergence.ts,\n        divergence.source,\n        divergence.eventId,\n        divergence.decidedBy,\n        divergence.ledgerAgentId,\n        divergence.ledgerOutcome,\n        divergence.ledgerReason,\n        divergence.legacyAgentId,\n        divergence.legacyOutcome,\n        divergence.legacyReason,\n      )\n  }\n\n  /**\n   * Recent divergences, newest first. Filters compose: `source` narrows to\n   * one dispatch source, `since` to a recency window, `limit` to top-N.\n   * The intended consumer is the soak dashboard (commit 8) and `agentx\n   * audit --divergence` queries; per-record introspection is rare so we\n   * don't expose a single-id getter.\n   */\n  getDivergences(opts: {\n    source?: IntentSource\n    since?: number\n    limit?: number\n  } = {}): IntentDivergence[] {\n    const wheres: string[] = []\n    const params: Array<string | number> = []\n    if (opts.source !== undefined) {\n      wheres.push(\"source = ?\")\n      params.push(opts.source)\n    }\n    if (opts.since !== undefined) {\n      wheres.push(\"ts >= ?\")\n      params.push(opts.since)\n    }\n    const whereSql = wheres.length ? `WHERE ${wheres.join(\" AND \")}` : \"\"\n    const limitSql = opts.limit !== undefined ? \"LIMIT ?\" : \"\"\n    if (opts.limit !== undefined) params.push(opts.limit)\n\n    const rows = this.db\n      .prepare(\n        `SELECT id, ts, source, event_id, decided_by,\n                ledger_agent_id, ledger_outcome, ledger_reason,\n                legacy_agent_id, legacy_outcome, legacy_reason\n         FROM intent_divergences\n         ${whereSql}\n         ORDER BY ts DESC\n         ${limitSql}`,\n      )\n      .all(...params) as DivergenceRow[]\n    return rows.map(rowToDivergence)\n  }\n}\n\n// --- Row → typed-object adapters --------------------------------------------\n//\n// SQLite returns snake_case rows; the typed surface uses camelCase. Mapping\n// once here keeps every consumer in TS-ergonomic shape and makes column\n// renames a single-file refactor.\n\ninterface EventRow {\n  id: string\n  ts: number\n  source: string\n  source_event_id: string | null\n  project: string | null\n  subject: string | null\n  intent: string | null\n  raw_json: string\n}\n\ninterface DecisionRow {\n  event_id: string\n  decided_at: number\n  decided_by: string\n  agent_id: string | null\n  outcome: string\n  reason: string | null\n}\n\ninterface ResolutionRow {\n  decision_event_id: string\n  decision_decided_by: string\n  resolved_at: number\n  status: string\n  duration_ms: number | null\n  result_summary: string | null\n}\n\ninterface DivergenceRow {\n  id: string\n  ts: number\n  source: string\n  event_id: string\n  decided_by: string\n  ledger_agent_id: string | null\n  ledger_outcome: string\n  ledger_reason: string | null\n  legacy_agent_id: string | null\n  legacy_outcome: string\n  legacy_reason: string | null\n}\n\nfunction rowToEvent(row: EventRow): IntentEvent {\n  return {\n    id: row.id,\n    ts: row.ts,\n    source: row.source as IntentSource,\n    sourceEventId: row.source_event_id,\n    project: row.project,\n    subject: row.subject,\n    intent: row.intent,\n    rawJson: row.raw_json,\n  }\n}\n\nfunction rowToDecision(row: DecisionRow): IntentDecision {\n  return {\n    eventId: row.event_id,\n    decidedAt: row.decided_at,\n    decidedBy: row.decided_by,\n    agentId: row.agent_id,\n    outcome: row.outcome as IntentDecision[\"outcome\"],\n    reason: row.reason,\n  }\n}\n\nfunction rowToResolution(row: ResolutionRow): IntentResolution {\n  return {\n    decisionEventId: row.decision_event_id,\n    decisionDecidedBy: row.decision_decided_by,\n    resolvedAt: row.resolved_at,\n    status: row.status as IntentResolution[\"status\"],\n    durationMs: row.duration_ms,\n    resultSummary: row.result_summary,\n  }\n}\n\nfunction rowToDivergence(row: DivergenceRow): IntentDivergence {\n  return {\n    id: row.id,\n    ts: row.ts,\n    source: row.source as IntentSource,\n    eventId: row.event_id,\n    decidedBy: row.decided_by,\n    ledgerAgentId: row.ledger_agent_id,\n    ledgerOutcome: row.ledger_outcome as IntentDivergence[\"ledgerOutcome\"],\n    ledgerReason: row.ledger_reason,\n    legacyAgentId: row.legacy_agent_id,\n    legacyOutcome: row.legacy_outcome as IntentDivergence[\"legacyOutcome\"],\n    legacyReason: row.legacy_reason,\n  }\n}\n\n/**\n * Per-version schema steps. New tables / columns go in a new migration\n * function — never mutate an old one. Each step is idempotent so re-running\n * on an already-current db is safe.\n */\nfunction runMigrations(db: Database.Database): void {\n  db.exec(`\n    CREATE TABLE IF NOT EXISTS schema_version (\n      v INTEGER PRIMARY KEY\n    );\n  `)\n  const current = (db\n    .prepare(\"SELECT MAX(v) AS v FROM schema_version\")\n    .get() as { v: number | null }).v ?? 0\n\n  if (current < 1) migrationV1(db)\n  if (current < 2) migrationV2(db)\n}\n\nfunction migrationV1(db: Database.Database): void {\n  db.exec(`\n    CREATE TABLE IF NOT EXISTS intent_events (\n      -- TEXT PRIMARY KEY isn't auto-NOT-NULL in SQLite; spell it out so the\n      -- ULID invariant is enforced at the schema level rather than relying on\n      -- the application layer.\n      id              TEXT NOT NULL PRIMARY KEY,\n      ts              INTEGER NOT NULL,\n      source          TEXT NOT NULL,\n      source_event_id TEXT,\n      project         TEXT,\n      subject         TEXT,\n      intent          TEXT,\n      raw_json        TEXT NOT NULL\n    );\n\n    CREATE INDEX IF NOT EXISTS idx_intent_events_subject\n      ON intent_events (project, subject);\n    CREATE INDEX IF NOT EXISTS idx_intent_events_source_event_id\n      ON intent_events (source, source_event_id);\n    CREATE INDEX IF NOT EXISTS idx_intent_events_ts\n      ON intent_events (ts);\n\n    CREATE TABLE IF NOT EXISTS intent_decisions (\n      event_id    TEXT NOT NULL REFERENCES intent_events(id),\n      decided_at  INTEGER NOT NULL,\n      decided_by  TEXT NOT NULL,\n      agent_id    TEXT,\n      outcome     TEXT NOT NULL,\n      reason      TEXT,\n      PRIMARY KEY (event_id, decided_by)\n    );\n\n    CREATE INDEX IF NOT EXISTS idx_intent_decisions_agent\n      ON intent_decisions (agent_id, decided_at);\n    CREATE INDEX IF NOT EXISTS idx_intent_decisions_outcome\n      ON intent_decisions (outcome, decided_at);\n\n    CREATE TABLE IF NOT EXISTS intent_resolutions (\n      decision_event_id    TEXT NOT NULL,\n      decision_decided_by  TEXT NOT NULL,\n      resolved_at          INTEGER NOT NULL,\n      status               TEXT NOT NULL,\n      duration_ms          INTEGER,\n      result_summary       TEXT,\n      PRIMARY KEY (decision_event_id, decision_decided_by),\n      FOREIGN KEY (decision_event_id, decision_decided_by)\n        REFERENCES intent_decisions(event_id, decided_by)\n    );\n\n    CREATE INDEX IF NOT EXISTS idx_intent_resolutions_status\n      ON intent_resolutions (status, resolved_at);\n  `)\n  db.prepare(\"INSERT INTO schema_version (v) VALUES (1)\").run()\n}\n\nfunction migrationV2(db: Database.Database): void {\n  // Phase 1 commit 5 — divergence reporter surface. Each row records one\n  // observed mismatch between the ledger's decision and the legacy path's\n  // outcome during shadow-mode operation. The composite FK to\n  // intent_decisions ensures a divergence cannot exist without its\n  // ledger-side decision row.\n  db.exec(`\n    CREATE TABLE IF NOT EXISTS intent_divergences (\n      id                TEXT NOT NULL PRIMARY KEY,\n      ts                INTEGER NOT NULL,\n      source            TEXT NOT NULL,\n      event_id          TEXT NOT NULL,\n      decided_by        TEXT NOT NULL,\n      ledger_agent_id   TEXT,\n      ledger_outcome    TEXT NOT NULL,\n      ledger_reason     TEXT,\n      legacy_agent_id   TEXT,\n      legacy_outcome    TEXT NOT NULL,\n      legacy_reason     TEXT,\n      FOREIGN KEY (event_id, decided_by)\n        REFERENCES intent_decisions(event_id, decided_by)\n    );\n\n    -- \"show me recent divergences from gitlab\" — the soak's primary query\n    CREATE INDEX IF NOT EXISTS idx_intent_divergences_source_ts\n      ON intent_divergences (source, ts);\n    -- \"are any deciders consistently wrong\" — per-decider analysis\n    CREATE INDEX IF NOT EXISTS idx_intent_divergences_decided_by\n      ON intent_divergences (decided_by, ts);\n  `)\n  db.prepare(\"INSERT INTO schema_version (v) VALUES (2)\").run()\n}\n\n// existsSync is imported for symmetry with src/storage/sqlite.ts; the\n// ledger constructor doesn't currently branch on file presence (the\n// migration is idempotent regardless), but keeping the import documents\n// the intent should later code need to distinguish first-open from re-open.\nvoid existsSync\n","import { randomBytes } from \"crypto\"\n\n// In-tree ULID generator — Phase 1 of the architectural rescue.\n//\n// The ledger demands monotonically-sortable ids so chronological queries\n// can use ID ranges and the audit trail reads coherently. ULIDs give us\n// that (10-char Crockford-base32 timestamp + 16-char randomness, total\n// 26 chars). The full `ulid` npm package is overkill for the few hundred\n// lines of generation logic we need, and adding a dep means another\n// `pnpm install --prod` step on clawd-server. So we inline.\n//\n// This is not a cryptographic primitive — its job is to be a unique,\n// time-sortable identifier. Random bytes come from `crypto.randomBytes`\n// purely because it's the right tool for \"give me bytes\" and there's no\n// reason to use weaker randomness.\n\nconst ENCODING = \"0123456789ABCDEFGHJKMNPQRSTVWXYZ\" // Crockford base32\n\nconst TIME_LEN = 10\nconst RAND_LEN = 16\n\nfunction encodeTime(ms: number): string {\n  let out = \"\"\n  for (let i = TIME_LEN - 1; i >= 0; i--) {\n    out = ENCODING[ms & 31] + out\n    ms = Math.floor(ms / 32)\n  }\n  return out\n}\n\nfunction encodeRandom(): string {\n  const bytes = randomBytes(RAND_LEN)\n  let out = \"\"\n  for (let i = 0; i < RAND_LEN; i++) {\n    out += ENCODING[bytes[i] & 31]\n  }\n  return out\n}\n\n/** Generate a new ULID. Pass `now` for deterministic tests. */\nexport function newEventId(now: number = Date.now()): string {\n  return encodeTime(now) + encodeRandom()\n}\n\n/** Extract the timestamp portion from a ULID. Inverse of `newEventId`'s\n *  time prefix. Useful for sanity checks; not load-bearing. */\nexport function decodeTime(id: string): number {\n  let ms = 0\n  for (let i = 0; i < TIME_LEN; i++) {\n    const v = ENCODING.indexOf(id[i])\n    if (v < 0) throw new Error(`invalid ULID character at position ${i}: ${id[i]}`)\n    ms = ms * 32 + v\n  }\n  return ms\n}\n","import { IntentLedger } from \"./ledger\"\n\n// Daemon-process singleton accessor for the IntentLedger.\n//\n// Phase 1 commit 6.0 — scaffolding for the call-site wiring that lands in\n// 6.a (gitlab), 6.b (router), 6.c (workflow), 6.d (cron + mesh). Each\n// source's wrapper will read this singleton when the mode is non-\"off\".\n//\n// The singleton is lazy because the ledger isn't needed in production\n// until the operator flips INTENT_LEDGER_MODE off the default. Avoiding\n// eager construction means an unflipped agentx process never opens the\n// ledger db, never holds the file, never writes WAL pages — exactly what\n// \"deploy-time default is off\" means in practice.\n//\n// Tests use `setLedgerForTesting` to inject an in-memory or tmp-dir\n// ledger and `resetLedgerForTesting` to release it between cases. Outside\n// of tests, callers go through `getDefaultLedger()`.\n\nlet _ledger: IntentLedger | undefined\n\nexport interface DefaultLedgerOptions {\n  /** Path override. Default: `.agentx/intent/ledger.sqlite` (resolved\n   *  against cwd by the IntentLedger constructor). */\n  path?: string\n}\n\n/**\n * Lazy singleton getter. Idempotent — repeated calls return the same\n * handle. Constructs the ledger on first call.\n *\n * Throws on construction failure (file unwritable, native binding broken,\n * etc.). Call sites should gate the call behind `getLedgerMode(...) !== \"off\"`\n * so a bad ledger never reaches construction in normal \"off\" production.\n *\n * The decision to throw rather than fail-soft (return null like\n * src/storage/sqlite.ts does) is deliberate: the ledger is canonical\n * state once `mode !== \"off\"`, so a silent failure would leave the\n * dispatcher in an undefined \"I tried to record but didn't\" state. Loud\n * failure surfaces misconfig at startup rather than days into a soak.\n */\nexport function getDefaultLedger(opts: DefaultLedgerOptions = {}): IntentLedger {\n  if (_ledger) return _ledger\n  _ledger = new IntentLedger({ path: opts.path })\n  return _ledger\n}\n\n/** Test-only: inject a pre-built ledger so per-test tmp dirs work without\n *  fighting the singleton. Production code MUST NOT call this. */\nexport function setLedgerForTesting(ledger: IntentLedger): void {\n  _ledger = ledger\n}\n\n/** Test-only: drop the singleton reference. Use in `afterEach` so the\n *  next test's `setLedgerForTesting` or `getDefaultLedger` starts fresh.\n *  Does NOT close the underlying db — the caller (test) owns close(). */\nexport function resetLedgerForTesting(): void {\n  _ledger = undefined\n}\n"],"mappings":"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","names":["Database","existsSync","mkdirSync","dirname","resolve","randomBytes","ENCODING","TIME_LEN","RAND_LEN","encodeTime","ms","out","i","encodeRandom","bytes","newEventId","now","IntentLedger","opts","resolve","mkdirSync","dirname","Database","runMigrations","input","existing","event","newEventId","source","sourceEventId","row","rowToEvent","id","decision","eventId","rowToDecision","project","subject","resolution","reason","now","rows","ts","count","decidedBy","rowToResolution","divergence","wheres","params","whereSql","limitSql","rowToDivergence","db","current","migrationV1","migrationV2","_ledger","getDefaultLedger","opts","IntentLedger"]}

package/dist/chunk-4YCH6IZV.js

@@ -0,0 +1,2 @@
+var d=Object.defineProperty;var e=(a,b,c)=>b in a?d(a,b,{enumerable:!0,configurable:!0,writable:!0,value:c}):a[b]=c;var f=(a=>typeof require<"u"?require:typeof Proxy<"u"?new Proxy(a,{get:(b,c)=>(typeof require<"u"?require:b)[c]}):a)(function(a){if(typeof require<"u")return require.apply(this,arguments);throw new Error('Dynamic require of "'+a+'" is not supported')});var g=(a,b,c)=>(e(a,typeof b!="symbol"?b+"":b,c),c);export{f as a,g as b};
+//# sourceMappingURL=chunk-4YCH6IZV.js.map