@openrig/cli 0.5.7 → 0.5.9

package/node_modules/@openrig/daemon/dist/startup.js

@@ -55,7 +55,7 @@ import { SeatActivityService } from "./domain/seat-activity-service.js";
 import { readClaudeSelfReportEvidence } from "./adapters/claude-code-adapter.js";
 import { SeatStructuralActivityService } from "./domain/seat-structural-activity-service.js";
 import { deriveSelfHostIdSource, SeatIdentityReconciler, reconcileSelfHostIdentity } from "./domain/seat-identity-reconciler.js";
-import { SelfHostIdentityStore } from "./domain/seat-identity-store.js";
+import { SeatIdentityStore, SelfHostIdentityStore } from "./domain/seat-identity-store.js";
 import { DaemonLifecycleStore } from "./domain/daemon-lifecycle-store.js";
 import { randomUUID } from "node:crypto";
 import { setSelfHostId, setSelfHostIdSource } from "./domain/hosts/fanout-contract.js";
@@ -84,7 +84,7 @@ import { wireViewEventBridge } from "./domain/view-event-bridge.js";
 import { WatchdogJobsRepository } from "./domain/watchdog-jobs-repository.js";
 import { WatchdogAutoRegistration } from "./domain/watchdog-auto-registration.js";
 import { WatchdogHistoryLog } from "./domain/watchdog-history-log.js";
-import { WatchdogPolicyEngine } from "./domain/watchdog-policy-engine.js";
+import { formatWatchdogDeliveryMessage, WatchdogPolicyEngine, } from "./domain/watchdog-policy-engine.js";
 import { WatchdogScheduler } from "./domain/watchdog-scheduler.js";
 import { ContinuityPolicyMaterializer, createContinuityCutoverBaton, findClaudeTranscriptByToken, recordManagedWidthReceipt, } from "./domain/continuity-policy-materializer.js";
 import { WorkflowRuntime } from "./domain/workflow-runtime.js";
@@ -99,6 +99,8 @@ import { PluginDiscoveryService } from "./domain/plugin-discovery-service.js";
 // Slice 28 Checkpoint C-3 — skill-library discovery (SC-29 #11 cumulative).
 import { SkillLibraryDiscoveryService } from "./domain/skill-library-discovery.js";
 import { ContextPackLibraryService } from "./domain/context-packs/context-pack-library-service.js";
+import { openRigContextLibraryRoots } from "./domain/instance-initialization.js";
+import { resolveSystemWorld } from "./domain/system-world.js";
 import { AgentImageLibraryService } from "./domain/agent-images/agent-image-library-service.js";
 import { SnapshotCapturer } from "./domain/agent-images/snapshot-capturer.js";
 import { SettingsStore as ContextPackSettingsStore } from "./domain/user-settings/settings-store.js";
@@ -107,6 +109,7 @@ import { NodeCmuxService } from "./domain/node-cmux-service.js";
 import { createAppWithWebSocket } from "./server.js";
 import { ProviderServiceImpl } from "./domain/provider/provider-service-impl.js";
 import { collectClaudeSignalsFromProviderUsageDirectory } from "./domain/provider/claude-usage-reader.js";
+import { legacyProviderUsageDirectory, providerUsageDirectory } from "./domain/telemetry-state-paths.js";
 import { execFile } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
@@ -125,7 +128,7 @@ import { NtfyNotificationAdapter } from "./domain/mission-control/notification-a
 import { WebhookNotificationAdapter } from "./domain/mission-control/notification-adapter-webhook.js";
 import { OPENRIG_HOME } from "./openrig-compat.js";
 import { materializeBuiltinPolicyReference } from "./domain/builtin-policy-reference.js";
-import { ensureActivityHookToken, writeActivityEndpointFile, deriveActivityUrl } from "./domain/activity-endpoint.js";
+import { ensureActivityHookToken, writeActivityEndpointFile, deriveActivityUrl, readActivityEndpointFile } from "./domain/activity-endpoint.js";
 import { getCompatibleOpenRigPath, getDefaultOpenRigPath, readOpenRigEnv, } from "./openrig-compat.js";
 const KNOWN_PROVIDER_AUTH_ENV = new Set([
     "ANTHROPIC_API_KEY",
@@ -538,6 +541,7 @@ export async function createDaemon(opts) {
     const bundleSourceResolver = new BundleSourceResolver({ fsOps: resolverFsOps });
     // Pod-aware instantiator (AgentSpec reboot)
     const { PodRigInstantiator } = await import("./domain/rigspec-instantiator.js");
+    const { reconcileSkillLoadout } = await import("./domain/skill-catalog.js");
     const { StartupOrchestrator } = await import("./domain/startup-orchestrator.js");
     const { ClaudeCodeAdapter } = await import("./adapters/claude-code-adapter.js");
     // P20 — the projection manifest: record-at-apply so the projector can later
@@ -688,21 +692,24 @@ export async function createDaemon(opts) {
     // routes. Startup context-pack expansion is intentionally unsupported;
     // dedicated send/broadcast/walk/queue verbs own delivery.
     const contextPackLibrary = (() => {
-        // OPR.0.5.3.7 R4 — config-resolved (env > config > $OPENRIG_HOME/context-packs),
-        // the same key `rig context add` writes to, so both agree on the landing zone.
-        const userPacksRoot = new ContextPackSettingsStore().resolveOne("context.packs_root").value;
+        // OPR.0.5.9.5 Wave B — config-resolved canonical context library. The
+        // shared instance initializer normally creates both roots; the mkdirs keep
+        // direct createDaemon test harnesses compatible.
+        const userPacksRoot = new ContextPackSettingsStore().resolveOne("context.root").value;
+        const [contextRoot, systemPacksRoot] = openRigContextLibraryRoots(userPacksRoot);
         try {
-            fs.mkdirSync(userPacksRoot, { recursive: true });
+            fs.mkdirSync(systemPacksRoot, { recursive: true });
         }
         catch { /* best-effort */ }
         const roots = [
-            { path: userPacksRoot, sourceType: "user_file" },
+            { path: contextRoot, sourceType: "user_file" },
+            { path: systemPacksRoot, sourceType: "user_file" },
         ];
         try {
             const settingsStore = new ContextPackSettingsStore();
             const cfg = settingsStore.resolveConfig();
             const workspacePacksRoot = nodePath.join(cfg.workspaceRoot, ".openrig", "context-packs");
-            if (workspacePacksRoot !== userPacksRoot && fs.existsSync(workspacePacksRoot)) {
+            if (workspacePacksRoot !== userPacksRoot && workspacePacksRoot !== systemPacksRoot && fs.existsSync(workspacePacksRoot)) {
                 roots.push({ path: workspacePacksRoot, sourceType: "workspace" });
             }
         }
@@ -773,6 +780,18 @@ export async function createDaemon(opts) {
         // typed topology.root at materialization (copy-if-absent).
         topologyRootResolver: () => String(new ContextPackSettingsStore().resolveOne("topology.root").value),
         onboardingEnabledResolver: () => new ContextPackSettingsStore().resolveOne("onboarding.default_pack.enabled").value === true,
+        skillsRootResolver: () => String(new ContextPackSettingsStore().resolveOne("skills.root").value),
+        systemWorldResolver: () => {
+            const settings = new ContextPackSettingsStore();
+            const cfg = settings.resolveConfig();
+            const selected = settings.resolveOne("context.system_world");
+            return resolveSystemWorld({
+                contextRoot: cfg.contextRoot,
+                selection: String(selected.value),
+                source: selected.source,
+            });
+        },
+        skillReconciler: reconcileSkillLoadout,
     });
     const podBundleSourceResolver = new PodBundleSourceResolver();
     const bootstrapOrchestrator = new BootstrapOrchestrator({
@@ -897,7 +916,8 @@ export async function createDaemon(opts) {
     });
     const { SeatAttentionReconciler } = await import("./domain/seat-attention-reconciler.js");
     const seatAttentionReconciler = new SeatAttentionReconciler({
-        sessionRegistry, eventBus, agentActivityStore, db,
+        sessionRegistry, eventBus, agentActivityStore, db, tmux: tmuxAdapter,
+        reconcileRestoreOutcome: (rigId, nodeId) => restoreOrchestrator.reconcileNodeRuntimeTruth(rigId, nodeId),
         sendVerify: async (session, text, opts) => {
             const transport = deps.sessionTransport;
             if (!transport)
@@ -918,6 +938,7 @@ export async function createDaemon(opts) {
         daemonBootEpoch,
         eventBus,
         nodeLauncher,
+        startupOrchestrator,
         tmuxAdapter,
         tmuxOptionDefaults,
         sessionEnv: launchSessionEnv,
@@ -931,7 +952,7 @@ export async function createDaemon(opts) {
         providerService: new ProviderServiceImpl({
             db,
             listRigs: () => rigRepo.listRigs(),
-            collectClaudeSignals: () => collectClaudeSignalsFromProviderUsageDirectory(nodePath.join(OPENRIG_HOME, "provider-usage")),
+            collectClaudeSignals: () => collectClaudeSignalsFromProviderUsageDirectory(providerUsageDirectory(OPENRIG_HOME), undefined, legacyProviderUsageDirectory(OPENRIG_HOME)),
             agentActivityStore,
         }),
         restoreOrchestrator,
@@ -976,7 +997,16 @@ export async function createDaemon(opts) {
         runtimeAdapters: { "claude-code": claudeAdapter, "codex": codexAdapter, "pi": piAdapter, "stub": stubAdapter, "terminal": new (await import("./adapters/terminal-adapter.js")).TerminalAdapter() },
         transcriptStore,
         sessionTransport: (() => {
-            const t = new SessionTransport({ db, rigRepo, sessionRegistry, tmuxAdapter, agentActivityStore, eventBus, slowOpRecorder });
+            const t = new SessionTransport({
+                db,
+                rigRepo,
+                sessionRegistry,
+                tmuxAdapter,
+                agentActivityStore,
+                eventBus,
+                slowOpRecorder,
+                activityEndpointFile: () => readActivityEndpointFile(OPENRIG_HOME),
+            });
             // PL-004 Phase A revision (R1): wire QueueRepository's wake-path so
             // create / handoff / handoff-and-complete nudge by default.
             queueRepoInstance.attachTransport(t);
@@ -1368,8 +1398,7 @@ export async function createDaemon(opts) {
     //   OPENRIG_WORKSPACE_SLICES_ROOT   typed-key env override
     //   workspace.slices_root           typed setting in ~/.openrig/config.json
     //   workspace.root                  cascade fallback (default ~/.openrig/workspace)
-    //   workspace.dogfood_evidence_root typed setting for proof packet assets
-    //   OPENRIG_DOGFOOD_EVIDENCE_ROOT   env override for compatibility
+    //   OPENRIG_DOGFOOD_EVIDENCE_ROOT   legacy proof-packet relocation override
     //
     // When the resolved slicesRoot path doesn't exist on disk, the indexer
     // is still constructed but isReady() returns false — the routes return
@@ -1384,30 +1413,24 @@ export async function createDaemon(opts) {
         const legacyEnvSlicesRoot = readOpenRigEnv("OPENRIG_SLICES_ROOT", "RIGGED_SLICES_ROOT") ?? "";
         let resolvedSlicesRoot = "";
         let resolvedWorkspaceRoot = "";
-        let resolvedDogfoodRoot = "";
-        if (!legacyEnvSlicesRoot) {
-            try {
-                const { SettingsStore: SettingsStoreCtor } = await import("./domain/user-settings/settings-store.js");
-                const resolvedConfig = new SettingsStoreCtor().resolveConfig();
+        try {
+            const { SettingsStore: SettingsStoreCtor } = await import("./domain/user-settings/settings-store.js");
+            const resolvedConfig = new SettingsStoreCtor().resolveConfig();
+            if (!legacyEnvSlicesRoot) {
                 resolvedSlicesRoot = resolvedConfig.workspaceSlicesRoot;
-                resolvedWorkspaceRoot = resolvedConfig.workspaceRoot;
-                resolvedDogfoodRoot = resolvedConfig.workspaceDogfoodEvidenceRoot;
-            }
-            catch {
-                // SettingsStore unavailable — keep slicesRoot empty; routes return 503.
             }
+            resolvedWorkspaceRoot = resolvedConfig.workspaceRoot;
         }
-        else {
-            try {
-                const { SettingsStore: SettingsStoreCtor } = await import("./domain/user-settings/settings-store.js");
-                const resolvedConfig = new SettingsStoreCtor().resolveConfig();
-                resolvedDogfoodRoot = resolvedConfig.workspaceDogfoodEvidenceRoot;
-            }
-            catch {
-                // SettingsStore unavailable — proof packets remain disabled.
-            }
+        catch {
+            // SettingsStore unavailable — keep roots empty; routes return 503.
         }
         const slicesRoot = legacyEnvSlicesRoot || resolvedSlicesRoot;
+        // `workspace.dogfood_evidence_root` was retired with the eager legacy
+        // scaffold. Keep the existing proof-packet reader usable for old
+        // workspaces and explicit legacy relocations without exposing a second
+        // project-workspace setting.
+        const resolvedDogfoodRoot = readOpenRigEnv("OPENRIG_DOGFOOD_EVIDENCE_ROOT")
+            || (resolvedWorkspaceRoot ? nodePath.join(resolvedWorkspaceRoot, "dogfood-evidence") : "");
         const additionalSliceRoots = resolvedWorkspaceRoot
             ? [
                 nodePath.join(resolvedWorkspaceRoot, "missions"),
@@ -1625,14 +1648,14 @@ export async function createDaemon(opts) {
             jobsRepo: watchdogJobsRepoInstance,
             historyLog: watchdogHistoryLogInstance,
             eventBus,
-            deliver: async ({ targetSession, message, continuityAction }) => {
+            deliver: async ({ targetSession, message, continuityAction }, source) => {
                 let continuityActionCompleted = false;
                 try {
                     if (continuityAction) {
                         await createContinuityCutoverBaton(continuityAction, queueRepoInstance);
                         continuityActionCompleted = true;
                     }
-                    const result = await sessionTransport.send(targetSession, message);
+                    const result = await sessionTransport.send(targetSession, formatWatchdogDeliveryMessage(source, message));
                     return result.ok
                         ? { status: "ok", continuityActionCompleted }
                         : { status: "failed", error: result.error, continuityActionCompleted };
@@ -1650,6 +1673,7 @@ export async function createDaemon(opts) {
             // UNKNOWN (null) fails open → deliver. A drop of this line disables the gate silently (gen-bound
             // wakes would fire at the successor) — pinned in watchdog-target-gen-wiring.test.ts.
             resolveTargetGeneration: (s) => sessionRegistry.currentOccupantGenerationForSession(s),
+            resolvePreDeliveryTerminalReason: ({ jobId }) => queueRepoInstance.resolveWatchdogPreDeliveryTerminalReason(jobId),
             onWakeAttempt: ({ jobId, deliveryStatus }) => {
                 queueRepoInstance.recordWatchdogWakeAttempt(jobId, deliveryStatus);
             },
@@ -1658,8 +1682,8 @@ export async function createDaemon(opts) {
             // SQLite workflow_instances directly via the new Phase D tables
             // (audit row 18: SQLite-source-only, no markdown read).
             // OPR.0.4.3.16: register idle-gate-qitem — joins pending gate:*
-            // qitems (queue_items) with a FRESH idle runtime signal from the
-            // shared AgentActivityStore (constructed above, before the engine)
+            // qitems (queue_items) with the shared arbitrated activity verdict
+            // rendered by public surfaces
             // into one bounded wake. Wakes/flags only; cooldown via engine throttle.
             additionalPolicies: [
                 makeWorkflowKeepalivePolicy({
@@ -1669,7 +1693,7 @@ export async function createDaemon(opts) {
                     // spec (never-lost fallback inside the helper).
                     ensureStuckExceptionItem: workflowExceptionEnsurer,
                 }),
-                makeIdleGateQitemPolicy({ db, agentActivityStore }),
+                makeIdleGateQitemPolicy({ db, seatActivity: seatActivityService }),
                 // OPR.0.5.6.24 F-14: the parked-owner consumer — the WHOLE shipped
                 // parked diagnosis (diagnoseRigParked over the arbitrated oracle +
                 // destination-scoped obligations + wake status; the same derivation
@@ -1830,13 +1854,12 @@ export async function createDaemon(opts) {
         {
             const { ModelDivergenceMonitor } = await import("./domain/model-divergence/model-divergence-monitor.js");
             const { readClaudeEffectiveModel, readCodexEffectiveModel } = await import("./domain/model-divergence/effective-model-readers.js");
-            const { paneClaudeSessionIdArgument, LiveClaudeRecordSelector, resolveLiveCodexThreadId } = await import("./domain/model-divergence/current-generation-record.js");
-            const liveClaudeRecordSelector = new LiveClaudeRecordSelector();
+            const { resolveIdentityVerifiedClaudeRecord, resolveLiveCodexThreadId } = await import("./domain/model-divergence/current-generation-record.js");
             const { defaultListProcesses } = await import("./domain/resume-metadata-refresher.js");
             const { readCodexThreadIdFromCandidateHomes, defaultResolveHomeDirByPid } = await import("./domain/codex-thread-id.js");
             const nodeOs = await import("node:os");
-            const nodePathMod = await import("node:path");
             const nodeFs = await import("node:fs");
+            const seatIdentityStore = new SeatIdentityStore(db);
             // OPR.0.5.3.10 — ONE shared census + ONE PID-home resolver for the whole
             // divergence surface: no more `ps -Ao` per seat per poll, no more `ps eww`
             // per pid (default-home-first + bounded PID cache).
@@ -1867,11 +1890,10 @@ export async function createDaemon(opts) {
                         .filter((row) => row.sessionName !== null)
                         .map((row) => ({ ...row, generation: sessionRegistry.currentOccupantGenerationForSession(row.sessionName) }));
                 },
-                // D-a — the CURRENT GENERATION's record via the live pane process, never a name/token
-                // lookup alone: on the live specimen (dev.planner) the name-keyed sidecar AND the newest
-                // registry row were stale TOGETHER while the pane ran a different session — the old wiring
-                // read the old generation's transcript and MASKED a real divergence. The stored records are
-                // now only corroboration; the pane process is the join. Every no-answer is a named reason.
+                // D-a / OPR.0.5.9.13 — the CURRENT GENERATION's record through the canonical binding and
+                // verified pane identity, never a name, registry token, or transcript recency lookup. A
+                // retained predecessor may keep writing under the canonical launch-time name forever.
+                // Every missing or ambiguous identity join is an explicit no-answer.
                 readEffectiveModel: async (seat, cycle) => {
                     // OPR.0.5.3.10 mini-req 1 — the poll-scoped census (one ps per pass) when the
                     // monitor threads it; the shared coalescing census otherwise.
@@ -1887,35 +1909,30 @@ export async function createDaemon(opts) {
                         return model ? { ok: true, model } : { ok: false, reason: `no model signal in the bounded read of ${rollout}` };
                     }
                     if (seat.runtime === "claude-code") {
-                        // D-a — RECORD-LIVENESS selection: no single pointer (sidecar, registry row, pane
-                        // argument) is generation-true; the transcript being WRITTEN is. Gather all candidate
-                        // ids, anchor paths beside the sidecar's project dir, pick the freshest-mtime record.
-                        const usage = contextUsageStore.readAndNormalize(seat.sessionName);
-                        const projectDir = usage.transcriptPath ? nodePathMod.dirname(usage.transcriptPath) : null;
-                        const pathFor = (id) => id && projectDir ? nodePathMod.join(projectDir, `${id}.jsonl`) : null;
-                        const tokenRow = db.prepare("SELECT resume_token FROM sessions WHERE node_id = ? AND session_name = ? ORDER BY id DESC LIMIT 1")
-                            .get(seat.nodeId, seat.sessionName);
-                        const paneArg = await paneClaudeSessionIdArgument(seat.sessionName, genDeps);
-                        const selection = liveClaudeRecordSelector.select(`${seat.nodeId}:${seat.generation ?? seat.sessionName}`, [
-                            // every path variant rides per id — a dead sidecar path must not mask a readable
-                            // derived one (r2 round-4 adjacent pin)
-                            { source: "sidecar", id: usage.sessionId ?? "", path: usage.transcriptPath ?? null },
-                            { source: "sidecar", id: usage.sessionId ?? "", path: pathFor(usage.sessionId) },
-                            { source: "registry", id: tokenRow?.resume_token ?? "", path: pathFor(tokenRow?.resume_token) },
-                            { source: "pane-argument", id: paneArg.ok ? paneArg.id : "", path: pathFor(paneArg.ok ? paneArg.id : null) },
-                        ], (path) => { try {
-                            const st = nodeFs.statSync(path);
-                            return { mtimeMs: st.mtimeMs, size: st.size };
-                        }
-                        catch {
-                            return null;
-                        } });
+                        const tenure = sessionRegistry.currentOccupantTenure(seat.nodeId);
+                        const sidecar = contextUsageStore.readSidecar(seat.sessionName);
+                        const binding = sessionRegistry.getBindingForNode(seat.nodeId);
+                        const selection = await resolveIdentityVerifiedClaudeRecord({
+                            sessionName: seat.sessionName,
+                            generation: seat.generation,
+                            occupantBootAt: tenure?.bootAt ?? null,
+                            binding: binding ? { tmuxSession: binding.tmuxSession, tmuxPane: binding.tmuxPane } : null,
+                            identity: seatIdentityStore.getForNode(seat.nodeId),
+                            sidecar: sidecar.ok ? sidecar.data : null,
+                        }, genDeps, (path) => {
+                            try {
+                                return nodeFs.statSync(path).isFile();
+                            }
+                            catch {
+                                return false;
+                            }
+                        });
                         if (!selection.ok)
                             return { ok: false, reason: selection.reason };
                         const model = readClaudeEffectiveModel(selection.path);
                         return model
                             ? { ok: true, model }
-                            : { ok: false, reason: `no assistant turn yet in the live record ${selection.path} (selected by liveness from ${selection.source})` };
+                            : { ok: false, reason: `no assistant turn yet in the current occupant record ${selection.path} (selected from ${selection.source})` };
                     }
                     return { ok: false, reason: `runtime ${seat.runtime ?? "unknown"} has no effective-model reader yet` };
                 },
@@ -2029,7 +2046,7 @@ export async function createDaemon(opts) {
         "claude-code": claudeAdapter,
         codex: codexAdapter,
         pi: piAdapter,
-    }, usageSamplesStore, () => providerWindowSamplesFromSignals(collectClaudeSignalsFromProviderUsageDirectory(nodePath.join(OPENRIG_HOME, "provider-usage"))));
+    }, usageSamplesStore, () => providerWindowSamplesFromSignals(collectClaudeSignalsFromProviderUsageDirectory(providerUsageDirectory(OPENRIG_HOME), undefined, legacyProviderUsageDirectory(OPENRIG_HOME))));
     deps.contextMonitor = contextMonitor;
     // OPR.0.4.3.14 — expose the SAME enforcer instance to routes for the manual
     // compaction trigger. Sharing one instance with ContextMonitor is what makes