@openrig/cli 0.4.8 → 0.5.1

package/node_modules/@openrig/daemon/dist/domain/active-lens-store.js

@@ -0,0 +1,87 @@
+// Workflows in Spec Library + Activation Lens v0 — active lens persistence.
+//
+// PRD § Item 4: lens selection persists daemon-side across daemon
+// restarts + browser refresh. The PRD bounce conditions explicitly
+// reject ephemeral state.
+//
+// Implementation: a small JSON file under OPENRIG_HOME/active-workflow
+// -lens.json. Same env-var-aware persistence pattern as UI Enhancement
+// Pack v0's file-edit-audit JSONL — no new SQLite table, no new
+// migration. The file is rewritten atomically on every set so concurrent
+// daemons (rare at single-host MVP) don't tear the read.
+//
+// Single-active-lens invariant: setting a lens replaces any prior
+// lens; clearing removes the file entirely. The store does NOT
+// validate that the named workflow_spec actually exists in the
+// workflow_specs cache — that's an upstream concern at the route
+// layer, since the spec might be uncached temporarily during a
+// workspace-surface reconciliation cycle and re-appear before the
+// next read.
+import * as fs from "node:fs";
+import * as path from "node:path";
+export class ActiveLensStore {
+    filePath;
+    now;
+    constructor(opts) {
+        this.filePath = opts.filePath;
+        this.now = opts.now ?? (() => new Date());
+    }
+    get() {
+        let raw;
+        try {
+            raw = fs.readFileSync(this.filePath, "utf-8");
+        }
+        catch {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.specName !== "string" || typeof parsed.specVersion !== "string")
+                return null;
+            return {
+                specName: parsed.specName,
+                specVersion: parsed.specVersion,
+                activatedAt: typeof parsed.activatedAt === "string" ? parsed.activatedAt : this.now().toISOString(),
+            };
+        }
+        catch {
+            // Malformed file → treat as no lens. Operator can `rm` to recover.
+            return null;
+        }
+    }
+    set(specName, specVersion) {
+        const lens = {
+            specName,
+            specVersion,
+            activatedAt: this.now().toISOString(),
+        };
+        const dir = path.dirname(this.filePath);
+        fs.mkdirSync(dir, { recursive: true });
+        // Atomic-ish: write to temp + rename. v0 doesn't fsync (the lens
+        // is operator UX state, not an audit-record-keeping invariant —
+        // losing it across a hard crash is acceptable; the operator
+        // re-clicks Activate).
+        const tmp = `${this.filePath}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+        try {
+            fs.writeFileSync(tmp, JSON.stringify(lens));
+            fs.renameSync(tmp, this.filePath);
+        }
+        catch (err) {
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch { /* best-effort */ }
+            throw err;
+        }
+        return lens;
+    }
+    clear() {
+        try {
+            fs.unlinkSync(this.filePath);
+        }
+        catch {
+            // Already absent — no-op.
+        }
+    }
+}
+//# sourceMappingURL=active-lens-store.js.map

package/node_modules/@openrig/daemon/dist/domain/active-lens-store.js.map

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

package/node_modules/@openrig/daemon/dist/domain/activity-endpoint.d.ts

@@ -0,0 +1,25 @@
+/** OPR.0.4.3.28 B2 — derive the activity ingest URL the daemon injects into seats
+ *  from its OWN bound host+port, so the seat's relay posts to an address the
+ *  daemon is actually listening on. When OPENRIG_HOST is an explicit host
+ *  (loopback, localhost, a tailnet IP, a hostname) the daemon binds ONLY that
+ *  host, so the URL MUST use it — a hardcoded 127.0.0.1 would be unreachable.
+ *  Wildcard/bind-all hosts (0.0.0.0 / ::) are not connectable addresses and the
+ *  daemon also binds loopback there, so they map to 127.0.0.1. An absent host
+ *  (the default loopback+tailscale multi-bind) also uses loopback. */
+export declare function deriveActivityUrl(host: string | undefined, port: string | undefined): string;
+/** Read the durable activity-hook token from state, or generate + persist one.
+ *  Stable across restarts (so frozen-env seats keep authenticating). */
+export declare function ensureActivityHookToken(stateDir: string): string;
+/** Snapshot the current {baseUrl, token} to activity-endpoint.json (mode 0600)
+ *  for the relay file-discovery fallback (B3). Best-effort. */
+export declare function writeActivityEndpointFile(stateDir: string, endpoint: {
+    baseUrl: string;
+    token: string;
+}): void;
+/** Read {baseUrl, token} from activity-endpoint.json, or null if absent/invalid.
+ *  (The relay .cjs reads the file directly; this is for daemon-side use + tests.) */
+export declare function readActivityEndpointFile(stateDir: string): {
+    baseUrl: string;
+    token: string;
+} | null;
+//# sourceMappingURL=activity-endpoint.d.ts.map

package/node_modules/@openrig/daemon/dist/domain/activity-endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-endpoint.d.ts","sourceRoot":"","sources":["../../src/domain/activity-endpoint.ts"],"names":[],"mappings":"AA0BA;;;;;;;sEAOsE;AACtE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAK5F;AAED;wEACwE;AACxE,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAkBhE;AAED;+DAC+D;AAC/D,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAS9G;AAED;qFACqF;AACrF,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAYpG"}

package/node_modules/@openrig/daemon/dist/domain/activity-endpoint.js

@@ -0,0 +1,91 @@
+// OPR.0.4.3.28 B2/B3 — self-provisioned activity-hook endpoint (url + token).
+//
+// The daemon generates a per-install activity-hook token and derives its own
+// ingest URL so launched seats can reach /api/activity/hooks WITHOUT the
+// operator seeding OPENRIG_URL / OPENRIG_ACTIVITY_HOOK_TOKEN into their shell
+// (the confirmed live break — see the slice-28 IMPL-SPEC §1.1).
+//
+// The token is a LOCALHOST internal-auth HANDLE, not a founder-secret: kept out
+// of logs/prints and stored mode-0600, but no redaction machinery is built
+// around it (orch-advisor ruling 2026-07-02).
+//
+// - activity-hook-token : durable token, STABLE across daemon restarts so
+//   already-launched seats (whose env froze the token at launch) still
+//   authenticate after a restart.
+// - activity-endpoint.json : {baseUrl, token} snapshot, re-written each boot,
+//   read by the relay's file-discovery fallback for reconcile/restored seats
+//   whose frozen process env carries no OpenRig activity vars (B3).
+import fs from "node:fs";
+import nodePath from "node:path";
+import { randomBytes } from "node:crypto";
+const TOKEN_FILE = "activity-hook-token";
+const ENDPOINT_FILE = "activity-endpoint.json";
+const DEFAULT_DAEMON_PORT = "7433";
+/** OPR.0.4.3.28 B2 — derive the activity ingest URL the daemon injects into seats
+ *  from its OWN bound host+port, so the seat's relay posts to an address the
+ *  daemon is actually listening on. When OPENRIG_HOST is an explicit host
+ *  (loopback, localhost, a tailnet IP, a hostname) the daemon binds ONLY that
+ *  host, so the URL MUST use it — a hardcoded 127.0.0.1 would be unreachable.
+ *  Wildcard/bind-all hosts (0.0.0.0 / ::) are not connectable addresses and the
+ *  daemon also binds loopback there, so they map to 127.0.0.1. An absent host
+ *  (the default loopback+tailscale multi-bind) also uses loopback. */
+export function deriveActivityUrl(host, port) {
+    const p = port && port.trim().length > 0 ? port.trim() : DEFAULT_DAEMON_PORT;
+    const h = host?.trim();
+    const wildcard = !h || h === "0.0.0.0" || h === "::" || h === "[::]" || h === "*";
+    return `http://${wildcard ? "127.0.0.1" : h}:${p}`;
+}
+/** Read the durable activity-hook token from state, or generate + persist one.
+ *  Stable across restarts (so frozen-env seats keep authenticating). */
+export function ensureActivityHookToken(stateDir) {
+    const tokenPath = nodePath.join(stateDir, TOKEN_FILE);
+    try {
+        const existing = fs.readFileSync(tokenPath, "utf-8").trim();
+        if (existing.length > 0)
+            return existing;
+    }
+    catch {
+        // not present yet — generate below
+    }
+    const token = randomBytes(32).toString("hex");
+    try {
+        fs.mkdirSync(stateDir, { recursive: true });
+        fs.writeFileSync(tokenPath, token, { mode: 0o600 });
+        fs.chmodSync(tokenPath, 0o600); // enforce mode even if the file pre-existed
+    }
+    catch {
+        // best-effort persist — an in-memory token still works for this daemon run,
+        // it just won't survive a restart (falls back to regenerate).
+    }
+    return token;
+}
+/** Snapshot the current {baseUrl, token} to activity-endpoint.json (mode 0600)
+ *  for the relay file-discovery fallback (B3). Best-effort. */
+export function writeActivityEndpointFile(stateDir, endpoint) {
+    const endpointPath = nodePath.join(stateDir, ENDPOINT_FILE);
+    try {
+        fs.mkdirSync(stateDir, { recursive: true });
+        fs.writeFileSync(endpointPath, JSON.stringify({ baseUrl: endpoint.baseUrl, token: endpoint.token }), { mode: 0o600 });
+        fs.chmodSync(endpointPath, 0o600);
+    }
+    catch {
+        // best-effort — reconcile/restored seats simply won't get file-discovery.
+    }
+}
+/** Read {baseUrl, token} from activity-endpoint.json, or null if absent/invalid.
+ *  (The relay .cjs reads the file directly; this is for daemon-side use + tests.) */
+export function readActivityEndpointFile(stateDir) {
+    const endpointPath = nodePath.join(stateDir, ENDPOINT_FILE);
+    try {
+        const parsed = JSON.parse(fs.readFileSync(endpointPath, "utf-8"));
+        if (typeof parsed.baseUrl === "string" && parsed.baseUrl.length > 0
+            && typeof parsed.token === "string" && parsed.token.length > 0) {
+            return { baseUrl: parsed.baseUrl, token: parsed.token };
+        }
+    }
+    catch {
+        // absent or malformed
+    }
+    return null;
+}
+//# sourceMappingURL=activity-endpoint.js.map

package/node_modules/@openrig/daemon/dist/domain/activity-endpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-endpoint.js","sourceRoot":"","sources":["../../src/domain/activity-endpoint.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,EAAE;AACF,6EAA6E;AAC7E,yEAAyE;AACzE,8EAA8E;AAC9E,gEAAgE;AAChE,EAAE;AACF,gFAAgF;AAChF,2EAA2E;AAC3E,8CAA8C;AAC9C,EAAE;AACF,0EAA0E;AAC1E,uEAAuE;AACvE,kCAAkC;AAClC,8EAA8E;AAC9E,6EAA6E;AAC7E,oEAAoE;AAEpE,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,QAAQ,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,MAAM,UAAU,GAAG,qBAAqB,CAAC;AACzC,MAAM,aAAa,GAAG,wBAAwB,CAAC;AAC/C,MAAM,mBAAmB,GAAG,MAAM,CAAC;AAEnC;;;;;;;sEAOsE;AACtE,MAAM,UAAU,iBAAiB,CAAC,IAAwB,EAAE,IAAwB;IAClF,MAAM,CAAC,GAAG,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC;IAC7E,MAAM,CAAC,GAAG,IAAI,EAAE,IAAI,EAAE,CAAC;IACvB,MAAM,QAAQ,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,MAAM,IAAI,CAAC,KAAK,GAAG,CAAC;IAClF,OAAO,UAAU,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;AACrD,CAAC;AAED;wEACwE;AACxE,MAAM,UAAU,uBAAuB,CAAC,QAAgB;IACtD,MAAM,SAAS,GAAG,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;IACtD,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,EAAE,CAAC,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC;QAC5D,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,QAAQ,CAAC;IAC3C,CAAC;IAAC,MAAM,CAAC;QACP,mCAAmC;IACrC,CAAC;IACD,MAAM,KAAK,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC9C,IAAI,CAAC;QACH,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5C,EAAE,CAAC,aAAa,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACpD,EAAE,CAAC,SAAS,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC,4CAA4C;IAC9E,CAAC;IAAC,MAAM,CAAC;QACP,4EAA4E;QAC5E,8DAA8D;IAChE,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;+DAC+D;AAC/D,MAAM,UAAU,yBAAyB,CAAC,QAAgB,EAAE,QAA4C;IACtG,MAAM,YAAY,GAAG,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;IAC5D,IAAI,CAAC;QACH,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5C,EAAE,CAAC,aAAa,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACtH,EAAE,CAAC,SAAS,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;IACpC,CAAC;IAAC,MAAM,CAAC;QACP,0EAA0E;IAC5E,CAAC;AACH,CAAC;AAED;qFACqF;AACrF,MAAM,UAAU,wBAAwB,CAAC,QAAgB;IACvD,MAAM,YAAY,GAAG,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;IAC5D,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,OAAO,CAAC,CAA2C,CAAC;QAC5G,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC;eAC9D,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACjE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;QAC1D,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,sBAAsB;IACxB,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/node_modules/@openrig/daemon/dist/domain/agent-activity-store.d.ts

@@ -0,0 +1,92 @@
+import type Database from "better-sqlite3";
+import type { EventBus } from "./event-bus.js";
+import type { AgentActivity, PersistedEvent } from "./types.js";
+export declare const AGENT_ACTIVITY_FRESHNESS_MS: number;
+export interface HookActivityInput {
+    runtime: string | null;
+    sessionName?: string | null;
+    nodeId?: string | null;
+    hookEvent: string;
+    subtype?: string | null;
+    occurredAt?: string | null;
+    /** W2a-1 — the EMITTING occupant's generation, CARRIED source-bound on the hook (the producer/relay
+     *  supplies it at fire time; the route ingests it). NOT inferred from record-time state — that
+     *  inference mis-attributes a delayed prior-occupant hook to the live occupant. Absent on a legacy,
+     *  excluded, or no-tenure emitting path ⇒ stamped null ⇒ unresolved at read (never false-fresh). */
+    generation?: string | null;
+}
+export type RecordHookActivityResult = {
+    ok: true;
+    activity: AgentActivity;
+    event: PersistedEvent;
+} | {
+    ok: false;
+    code: "missing_session_identity" | "session_not_found";
+    error: string;
+};
+interface AgentActivityStoreDeps {
+    db: Database.Database;
+    eventBus: EventBus;
+    now?: () => Date;
+    freshnessMs?: number;
+    /** W2a-1 — resolve the LIVE occupant generation for a node (the shipped occupant-tenure
+     *  generation_uuid), or null when UNKNOWN. Injected (not self-constructed) so the store stays
+     *  decoupled from SessionRegistry and unit-testable with a fake. When ABSENT the store applies no
+     *  generation gate — legacy clock-only freshness — so the existing callers are unchanged until the
+     *  producer wiring injects the real resolver. Resolution is SYNCHRONOUS (a better-sqlite3 read),
+     *  which is why the gate lives inline in the sync read path with no signature churn to 9 callers. */
+    resolveOccupantGeneration?: (nodeId: string) => string | null;
+    /** Confirm that a carried generation is registered for this node. A side-effect-free reservation
+     * that never committed must remain unresolvable, not become positive mismatch evidence. */
+    isRegisteredOccupantGeneration?: (nodeId: string, generation: string) => boolean;
+}
+export declare class AgentActivityStore {
+    readonly db: Database.Database;
+    private readonly eventBus;
+    private readonly now;
+    private readonly freshnessMs;
+    private readonly resolveOccupantGeneration?;
+    private readonly isRegisteredOccupantGeneration?;
+    constructor(deps: AgentActivityStoreDeps);
+    recordHookEvent(input: HookActivityInput): RecordHookActivityResult;
+    getLatestForNode(input: {
+        nodeId?: string | null;
+        sessionName?: string | null;
+        now?: Date;
+    }): AgentActivity | null;
+    /** W2a-1 — the dead-tenure verdict: the claim's occupant generation is REGISTERED FOR THIS NODE and
+     *  DIFFERENT from the live generation. The membership gate runs before this helper, so an uncommitted
+     *  reservation can never manufacture a positive dead-tenure finding.
+     *  It must not be honored as the live seat. Returns unknown + `generation_mismatch`,
+     *  stale:true (detection fires), provenance `resolved` (both generations WERE resolved — they simply
+     *  differ). This is the ONLY generation case that abstains; a null on either side is UNRESOLVED
+     *  provenance and is DELIVERED labelled, never routed here. */
+    private generationMismatch;
+    /** W2a-1 — the UNRESOLVABLE-provenance verdict (ABSENCE of evidence, not a dead-tenure finding).
+     *  State UNKNOWN + a distinct reason + stale:true so no consumer reads it as verified-live (fresh is
+     *  a positive liveness claim). The STORE delivers the row carrying generationProvenance:"unresolved"
+     *  at the ACTIVITY layer; turning that label into a still-flowing CONSUMER row is the tap FOLLOW-ON
+     *  (verify-demotion, qitem-20260808183747-f7f04662) — the unchanged tap still discards it in the
+     *  INTERIM (a bounded regression, mint-race-transient exposure; mm2 has no occupant_tenures table
+     *  until 0.5.1). Kept DISTINCT from generationMismatch: ignorance and evidence get different verdicts,
+     *  and the paths must not collapse — at the store now, and at the tap when the follow-on lands. */
+    private generationUnresolved;
+    /** W2a-1 — the resolver-EXCEPTION verdict: the live-generation resolver threw (a transient ledger/db
+     *  fault). DEGRADE to unknown + a DISTINCT reason (`generation_resolver_error`) + stale:true, so the
+     *  read never crashes and the claim is never rendered fresh; provenance `unresolved`. Kept separate
+     *  from a clean null (unresolvable) so a resolver FAULT is distinguishable from an honest ABSENCE. */
+    private generationDegraded;
+    resolveSession(input: {
+        sessionName?: string | null;
+        nodeId?: string | null;
+        runtime?: string | null;
+    }): {
+        sessionId: string;
+        rigId: string;
+        nodeId: string;
+        sessionName: string;
+    } | null;
+    private _resolveSession;
+}
+export {};
+//# sourceMappingURL=agent-activity-store.d.ts.map

package/node_modules/@openrig/daemon/dist/domain/agent-activity-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-activity-store.d.ts","sourceRoot":"","sources":["../../src/domain/agent-activity-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEhE,eAAO,MAAM,2BAA2B,QAAgB,CAAC;AAEzD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;;wGAGoG;IACpG,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,MAAM,wBAAwB,GAChC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,cAAc,CAAA;CAAE,GAC5D;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,0BAA0B,GAAG,mBAAmB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzF,UAAU,sBAAsB;IAC9B,EAAE,EAAE,QAAQ,CAAC,QAAQ,CAAC;IACtB,QAAQ,EAAE,QAAQ,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;yGAKqG;IACrG,yBAAyB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IAC9D;+FAC2F;IAC3F,8BAA8B,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;CAClF;AAaD,qBAAa,kBAAkB;IAC7B,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,CAAC;IAC/B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;IACpC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAa;IACjC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAC,CAAoC;IAC/E,OAAO,CAAC,QAAQ,CAAC,8BAA8B,CAAC,CAAkD;gBAEtF,IAAI,EAAE,sBAAsB;IASxC,eAAe,CAAC,KAAK,EAAE,iBAAiB,GAAG,wBAAwB;IAkDnE,gBAAgB,CAAC,KAAK,EAAE;QACtB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC5B,GAAG,CAAC,EAAE,IAAI,CAAC;KACZ,GAAG,aAAa,GAAG,IAAI;IA8FxB;;;;;;mEAM+D;IAC/D,OAAO,CAAC,kBAAkB;IAa1B;;;;;;;uGAOmG;IACnG,OAAO,CAAC,oBAAoB;IAiB5B;;;0GAGsG;IACtG,OAAO,CAAC,kBAAkB;IAa1B,cAAc,CAAC,KAAK,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAUzL,OAAO,CAAC,eAAe;CAwBxB"}

package/node_modules/@openrig/daemon/dist/domain/agent-activity-store.js

@@ -0,0 +1,321 @@
+export const AGENT_ACTIVITY_FRESHNESS_MS = 5 * 60 * 1000;
+export class AgentActivityStore {
+    db;
+    eventBus;
+    now;
+    freshnessMs;
+    resolveOccupantGeneration;
+    isRegisteredOccupantGeneration;
+    constructor(deps) {
+        this.db = deps.db;
+        this.eventBus = deps.eventBus;
+        this.now = deps.now ?? (() => new Date());
+        this.freshnessMs = deps.freshnessMs ?? AGENT_ACTIVITY_FRESHNESS_MS;
+        this.resolveOccupantGeneration = deps.resolveOccupantGeneration;
+        this.isRegisteredOccupantGeneration = deps.isRegisteredOccupantGeneration;
+    }
+    recordHookEvent(input) {
+        if (!input.sessionName && !input.nodeId) {
+            return {
+                ok: false,
+                code: "missing_session_identity",
+                error: "Hook activity requires a managed sessionName or nodeId",
+            };
+        }
+        const session = this._resolveSession(input);
+        if (!session) {
+            return {
+                ok: false,
+                code: "session_not_found",
+                error: "Hook activity did not match a managed session. List seats with: rig ps --nodes",
+            };
+        }
+        const sampledAt = this.now().toISOString();
+        const eventAt = parseTimestamp(input.occurredAt) ?? sampledAt;
+        // W2a-1 — SOURCE-BOUND stamp: the emitting occupant's generation is CARRIED on the hook (supplied
+        // by the producer/relay at fire time, ingested by the route), NEVER inferred from record-time
+        // state. A delayed prior-occupant hook recorded after a new tenure minted carries its OWN (prior)
+        // generation, so the read detects a mismatch rather than crediting it to the live occupant — and
+        // this is immune to boot_at precision / clock skew because nothing is timed. Absent on a legacy,
+        // excluded, or no-tenure emitting path ⇒ null ⇒ unresolved at read (the P21 claimed-era pattern:
+        // absence recorded as its own state, never false-fresh). No record-time
+        // resolver call — the live-gen resolver is used only at READ, for the comparison.
+        const generation = input.generation ?? null;
+        const activity = normalizeHookActivity({
+            runtime: input.runtime ?? session.runtime,
+            hookEvent: input.hookEvent,
+            subtype: input.subtype ?? null,
+            sampledAt,
+            eventAt,
+            generation,
+        });
+        const event = this.eventBus.emit({
+            type: "agent.activity",
+            rigId: session.rig_id,
+            nodeId: session.node_id,
+            sessionName: session.session_name,
+            runtime: activity.runtime ?? session.runtime,
+            activity,
+        });
+        return { ok: true, activity, event };
+    }
+    getLatestForNode(input) {
+        const nodeId = input.nodeId ?? (input.sessionName ? this._resolveSession({ sessionName: input.sessionName })?.node_id : null);
+        if (!nodeId)
+            return null;
+        const row = this.db.prepare("SELECT payload FROM events WHERE node_id = ? AND type = 'agent.activity' ORDER BY seq DESC LIMIT 1").get(nodeId);
+        if (!row)
+            return null;
+        const payload = parseActivityPayload(row.payload);
+        if (!payload?.activity)
+            return null;
+        const activity = payload.activity;
+        if (input.sessionName && payload.sessionName !== input.sessionName)
+            return null;
+        const referenceTime = input.now ?? this.now();
+        // W2a-1 — compare-at-read against the shipped occupant-tenure generation_uuid (pm ruling
+        // 2026-08-08, the fully-specified Variant C):
+        //  (1) the carried generation is REGISTERED FOR THIS NODE and differs from live ⇒ MISMATCH:
+        //      positive evidence the claim belongs to a prior, dead tenure ⇒ unknown +
+        //      `generation_mismatch`, stale:true, provenance RESOLVED. An unregistered prelaunch
+        //      reservation is absence of evidence and stays UNRESOLVABLE, never mismatch.
+        //  (2) both known and EQUAL (incl. a same-native-session relaunch — the ledger treats it as a
+        //      continuation with no new generation) ⇒ provenance RESOLVED, deliver normally (fresh).
+        //  (3) null on EITHER side ⇒ UNRESOLVABLE: ABSENCE of evidence, not a dead-tenure finding. State
+        //      UNKNOWN + its distinct reason, stale:true — NEVER fresh (fresh is a positive liveness claim
+        //      the seat has not earned; marking null-tenure fresh is bare-attribution one field over). The
+        //      STORE delivers the row carrying generationProvenance='unresolved' at the ACTIVITY layer. The
+        //      tap's discard-condition change that turns this label into a still-flowing consumer row is a
+        //      FOLLOW-ON (qitem-20260808183747-f7f04662, verify-demotion) — NOT this fold; in the INTERIM
+        //      the unchanged tap still discards it (a bounded regression whose exposure is the mint-race
+        //      transient; mm2 is unaffected — its daemon carries no occupant_tenures table until 0.5.1).
+        //      Ignorance and evidence get DIFFERENT verdicts; the two paths must not collapse.
+        // Gate runs only when a resolver is injected (else legacy clock-only, no label).
+        let generationProvenance;
+        if (this.resolveOccupantGeneration) {
+            let liveGeneration;
+            try {
+                liveGeneration = this.resolveOccupantGeneration(nodeId);
+            }
+            catch {
+                // Resolver EXCEPTION (e.g. a transient ledger/db fault) ⇒ DEGRADE to a distinct unknown
+                // branch: never crash the read, never render fresh. Distinct from a clean null (unresolvable).
+                return this.generationDegraded(activity, referenceTime);
+            }
+            const recordedGeneration = activity.generation ?? null;
+            if (liveGeneration !== null && recordedGeneration !== null) {
+                if (this.isRegisteredOccupantGeneration) {
+                    let registered;
+                    try {
+                        registered = this.isRegisteredOccupantGeneration(nodeId, recordedGeneration);
+                    }
+                    catch {
+                        return this.generationDegraded(activity, referenceTime);
+                    }
+                    if (!registered) {
+                        return this.generationUnresolved(activity, referenceTime, "generation_unresolvable");
+                    }
+                }
+                if (recordedGeneration !== liveGeneration) {
+                    return this.generationMismatch(activity, referenceTime);
+                }
+                generationProvenance = "resolved";
+            }
+            else {
+                return this.generationUnresolved(activity, referenceTime, liveGeneration === null ? "generation_unresolvable" : "generation_unverifiable");
+            }
+        }
+        const eventTime = activity.eventAt ? Date.parse(activity.eventAt) : NaN;
+        if (Number.isFinite(eventTime) && referenceTime.getTime() - eventTime > this.freshnessMs) {
+            return {
+                ...activity,
+                state: "unknown",
+                reason: "stale_runtime_hook",
+                evidenceSource: "runtime_hook",
+                sampledAt: referenceTime.toISOString(),
+                fallback: false,
+                stale: true,
+                generationProvenance,
+            };
+        }
+        return {
+            ...activity,
+            sampledAt: referenceTime.toISOString(),
+            fallback: false,
+            stale: false,
+            generationProvenance,
+        };
+    }
+    /** W2a-1 — the dead-tenure verdict: the claim's occupant generation is REGISTERED FOR THIS NODE and
+     *  DIFFERENT from the live generation. The membership gate runs before this helper, so an uncommitted
+     *  reservation can never manufacture a positive dead-tenure finding.
+     *  It must not be honored as the live seat. Returns unknown + `generation_mismatch`,
+     *  stale:true (detection fires), provenance `resolved` (both generations WERE resolved — they simply
+     *  differ). This is the ONLY generation case that abstains; a null on either side is UNRESOLVED
+     *  provenance and is DELIVERED labelled, never routed here. */
+    generationMismatch(activity, referenceTime) {
+        return {
+            ...activity,
+            state: "unknown",
+            reason: "generation_mismatch",
+            generationProvenance: "resolved",
+            evidenceSource: "runtime_hook",
+            sampledAt: referenceTime.toISOString(),
+            fallback: false,
+            stale: true,
+        };
+    }
+    /** W2a-1 — the UNRESOLVABLE-provenance verdict (ABSENCE of evidence, not a dead-tenure finding).
+     *  State UNKNOWN + a distinct reason + stale:true so no consumer reads it as verified-live (fresh is
+     *  a positive liveness claim). The STORE delivers the row carrying generationProvenance:"unresolved"
+     *  at the ACTIVITY layer; turning that label into a still-flowing CONSUMER row is the tap FOLLOW-ON
+     *  (verify-demotion, qitem-20260808183747-f7f04662) — the unchanged tap still discards it in the
+     *  INTERIM (a bounded regression, mint-race-transient exposure; mm2 has no occupant_tenures table
+     *  until 0.5.1). Kept DISTINCT from generationMismatch: ignorance and evidence get different verdicts,
+     *  and the paths must not collapse — at the store now, and at the tap when the follow-on lands. */
+    generationUnresolved(activity, referenceTime, reason) {
+        return {
+            ...activity,
+            state: "unknown",
+            reason,
+            generationProvenance: "unresolved",
+            evidenceSource: "runtime_hook",
+            sampledAt: referenceTime.toISOString(),
+            fallback: false,
+            stale: true,
+        };
+    }
+    /** W2a-1 — the resolver-EXCEPTION verdict: the live-generation resolver threw (a transient ledger/db
+     *  fault). DEGRADE to unknown + a DISTINCT reason (`generation_resolver_error`) + stale:true, so the
+     *  read never crashes and the claim is never rendered fresh; provenance `unresolved`. Kept separate
+     *  from a clean null (unresolvable) so a resolver FAULT is distinguishable from an honest ABSENCE. */
+    generationDegraded(activity, referenceTime) {
+        return {
+            ...activity,
+            state: "unknown",
+            reason: "generation_resolver_error",
+            generationProvenance: "unresolved",
+            evidenceSource: "runtime_hook",
+            sampledAt: referenceTime.toISOString(),
+            fallback: false,
+            stale: true,
+        };
+    }
+    resolveSession(input) {
+        const row = this._resolveSession(input);
+        if (!row)
+            return null;
+        const sessionRow = this.db.prepare("SELECT id FROM sessions WHERE session_name = ? ORDER BY id DESC LIMIT 1").get(row.session_name);
+        if (!sessionRow)
+            return null;
+        return { sessionId: sessionRow.id, rigId: row.rig_id, nodeId: row.node_id, sessionName: row.session_name };
+    }
+    _resolveSession(input) {
+        if (input.nodeId) {
+            const row = this.db.prepare(`
+        SELECT n.rig_id, n.id AS node_id, s.session_name, n.runtime
+        FROM nodes n
+        LEFT JOIN sessions s ON s.node_id = n.id
+          AND s.id = (SELECT s2.id FROM sessions s2 WHERE s2.node_id = n.id ORDER BY s2.id DESC LIMIT 1)
+        WHERE n.id = ?
+        LIMIT 1
+      `).get(input.nodeId);
+            if (row?.session_name)
+                return row;
+        }
+        if (!input.sessionName)
+            return null;
+        const row = this.db.prepare(`
+      SELECT n.rig_id, n.id AS node_id, s.session_name, n.runtime
+      FROM sessions s
+      JOIN nodes n ON n.id = s.node_id
+      WHERE s.session_name = ?
+      ORDER BY s.id DESC
+      LIMIT 1
+    `).get(input.sessionName);
+        return row ?? null;
+    }
+}
+function normalizeHookActivity(input) {
+    const rawEvent = input.hookEvent;
+    const rawSubtype = input.subtype;
+    const reason = normalizeReason(rawSubtype ?? rawEvent);
+    const runtime = input.runtime;
+    let state = "unknown";
+    let normalizedReason = reason;
+    if (rawEvent === "UserPromptSubmit" || rawEvent === "PreToolUse" || rawEvent === "active") {
+        state = "running";
+    }
+    else if (rawEvent === "PermissionRequest") {
+        // OPR.0.4.1.10 — Codex's official approval hook (openai/codex PR #17563). A PermissionRequest
+        // means the agent is BLOCKED waiting on a command / patch / network approval = needs_input. This is
+        // the HOOK-PRIMARY signal for Codex, which emits no Claude-style Notification; classifySendReadiness
+        // already prefers a fresh runtime_hook needs_input runtime-agnostically, so wiring this event makes
+        // the Codex rig-send guard hook-primary by construction (capture-pane scan stays as the fallback).
+        // The official payload carries session_id/turn_id/cwd/model/permission_mode/tool_name/tool_input;
+        // the relay forwards tool_name as the subtype, so `evidence` names the tool being approved.
+        state = "needs_input";
+        normalizedReason = "permission_request";
+    }
+    else if (rawEvent === "Notification") {
+        if (rawSubtype === "permission_prompt" || rawSubtype === "elicitation_dialog") {
+            state = "needs_input";
+        }
+        else if (rawSubtype === "idle_prompt") {
+            state = "idle";
+        }
+        else {
+            state = "unknown";
+            normalizedReason = rawSubtype ? reason : "notification";
+        }
+    }
+    else if (rawEvent === "Stop" || rawEvent === "SessionEnd" || rawEvent === "stop" || rawEvent === "idle") {
+        state = "idle";
+    }
+    else if (rawEvent === "SessionStart") {
+        state = "unknown";
+        normalizedReason = "session_start_observed";
+    }
+    else {
+        state = "unknown";
+        normalizedReason = "unmapped_runtime_hook";
+    }
+    return {
+        state,
+        reason: normalizedReason,
+        evidenceSource: "runtime_hook",
+        sampledAt: input.sampledAt,
+        evidence: rawSubtype ?? rawEvent,
+        eventAt: input.eventAt,
+        rawEvent,
+        rawSubtype,
+        runtime,
+        fallback: false,
+        stale: false,
+        generation: input.generation ?? null,
+    };
+}
+function normalizeReason(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .replace(/[^a-zA-Z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .toLowerCase();
+}
+function parseTimestamp(value) {
+    if (!value)
+        return null;
+    const ms = Date.parse(value);
+    if (!Number.isFinite(ms))
+        return null;
+    return new Date(ms).toISOString();
+}
+function parseActivityPayload(payload) {
+    try {
+        return JSON.parse(payload);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=agent-activity-store.js.map