@h-rig/server 0.0.6-alpha.0

package/dist/src/inspector/service.js

@@ -0,0 +1,1759 @@
+// @bun
+// packages/server/src/inspector/provider-session.ts
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))];
+}
+function withSupport(defaultValue, support, key) {
+  return typeof support?.[key] === "boolean" ? Boolean(support[key]) : defaultValue;
+}
+function normalizeProviderSession(run) {
+  const sessionLogPaths = uniqueStrings([run.sessionLogPath]);
+  const artifactRoots = uniqueStrings([run.artifactRoot]);
+  const eventSources = uniqueStrings([run.source, ...run.rawSourceKinds, run.sessionPath ? "session-file" : null]);
+  const capabilityHints = uniqueStrings([
+    sessionLogPaths.length > 0 ? "logs" : null,
+    artifactRoots.length > 0 ? "artifacts" : null,
+    run.worktreePath ? "workspace" : null,
+    run.conflictState !== "none" ? "conflict" : null,
+    run.threadId ? "thread" : null
+  ]);
+  const observabilityConfidence = sessionLogPaths.length > 0 && artifactRoots.length > 0 && run.threadId ? "high" : sessionLogPaths.length > 0 || artifactRoots.length > 0 || Boolean(run.threadId) ? "medium" : "low";
+  return {
+    provider: run.provider,
+    runId: run.runId,
+    taskId: run.taskId,
+    workspaceId: run.workspaceId,
+    workspaceDir: run.worktreePath,
+    runtimeAdapter: run.runtimeAdapter,
+    status: run.status,
+    startedAt: run.startedAt,
+    updatedAt: run.updatedAt,
+    completedAt: run.completedAt,
+    threadId: run.threadId,
+    sessionLogPaths,
+    artifactRoots,
+    eventSources,
+    observabilityConfidence,
+    rawSourceKinds: [...run.rawSourceKinds],
+    capabilityHints
+  };
+}
+function deriveInspectorCapabilitySet(session, support = {}) {
+  return {
+    discoverRuns: withSupport(true, support, "discoverRuns"),
+    inspectRuns: withSupport(true, support, "inspectRuns"),
+    readLogs: session.sessionLogPaths.length > 0 && withSupport(true, support, "readLogs"),
+    readArtifacts: session.artifactRoots.length > 0 && withSupport(true, support, "readArtifacts"),
+    callServerApis: withSupport(true, support, "callServerApis"),
+    interruptRuns: withSupport(false, support, "interruptRuns"),
+    stopRuns: withSupport(false, support, "stopRuns"),
+    resumeRuns: withSupport(false, support, "resumeRuns"),
+    relaunchRuns: withSupport(false, support, "relaunchRuns"),
+    patchRepo: session.workspaceDir !== null && withSupport(true, support, "patchRepo"),
+    patchHarness: session.workspaceDir !== null && withSupport(true, support, "patchHarness"),
+    createTasks: withSupport(false, support, "createTasks"),
+    runReviewerAgents: withSupport(false, support, "runReviewerAgents"),
+    provisionSkills: withSupport(true, support, "provisionSkills"),
+    scanUpstream: withSupport(false, support, "scanUpstream"),
+    writeJournal: withSupport(true, support, "writeJournal"),
+    spawnSpecialists: withSupport(false, support, "spawnSpecialists")
+  };
+}
+
+// packages/server/src/inspector/tools.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// packages/server/src/inspector/mission.ts
+import { randomUUID } from "crypto";
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, readdirSync, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join, resolve as resolve2 } from "path";
+
+// packages/server/src/bootstrap.ts
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { RIG_DEFINITION_DIRNAME, resolveMonorepoRoot } from "@rig/runtime";
+function normalizeOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function resolveRigServerPaths(projectRoot) {
+  const taskWorkspace = normalizeOptionalString(process.env.RIG_TASK_WORKSPACE);
+  const explicitStateDir = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  const explicitLogsDir = normalizeOptionalString(process.env.RIG_LOGS_DIR);
+  const explicitSessionFile = normalizeOptionalString(process.env.RIG_SESSION_FILE);
+  const hostStateRoot = resolve(projectRoot, ".rig");
+  const monorepoRoot = resolveMonorepoRoot(projectRoot);
+  const monorepoStateRoot = resolve(monorepoRoot, ".rig");
+  const stateRoot = taskWorkspace ? resolve(taskWorkspace, ".rig") : explicitStateDir ? dirname(resolve(explicitStateDir)) : explicitLogsDir ? dirname(resolve(explicitLogsDir)) : explicitSessionFile ? dirname(dirname(resolve(explicitSessionFile))) : existsSync(hostStateRoot) ? hostStateRoot : monorepoStateRoot;
+  const stateDir = explicitStateDir ? resolve(explicitStateDir) : resolve(stateRoot, "state");
+  const logsDir = explicitLogsDir ? resolve(explicitLogsDir) : resolve(stateRoot, "logs");
+  const taskConfigPath = taskWorkspace ? resolve(taskWorkspace, ".rig", "task-config.json") : existsSync(resolve(projectRoot, ".rig", "task-config.json")) ? resolve(projectRoot, ".rig", "task-config.json") : resolve(monorepoStateRoot, "task-config.json");
+  return {
+    stateRoot,
+    stateDir,
+    logsDir,
+    controlPlaneEventsFile: resolve(logsDir, "control-plane.events.jsonl"),
+    taskConfigPath,
+    notificationsFile: resolve(projectRoot, "rig", "notifications", "targets.json"),
+    keybindingsPath: resolve(projectRoot, "rig", "keybindings.json")
+  };
+}
+
+// packages/server/src/inspector/mission.ts
+function isJsonValue(value) {
+  if (value === null)
+    return true;
+  const valueType = typeof value;
+  if (valueType === "string" || valueType === "number" || valueType === "boolean") {
+    return Number.isFinite(value) || valueType !== "number";
+  }
+  if (Array.isArray(value)) {
+    return value.every(isJsonValue);
+  }
+  if (valueType === "object") {
+    for (const entry of Object.values(value)) {
+      if (!isJsonValue(entry))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function toJsonRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const record = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (isJsonValue(entry)) {
+      record[key] = entry;
+    }
+  }
+  return record;
+}
+function cloneJsonRecord(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readJsonRecord(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!isRecord(parsed)) {
+      return { ok: false, error: `Mission file ${path} does not contain an object` };
+    }
+    return { ok: true, record: parsed };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, error: message };
+  }
+}
+function parseMission(record) {
+  if (typeof record.missionId !== "string")
+    return { ok: false, error: "Mission is missing missionId" };
+  if (typeof record.owner !== "string")
+    return { ok: false, error: "Mission is missing owner" };
+  if (typeof record.status !== "string")
+    return { ok: false, error: "Mission is missing status" };
+  if (!isRecord(record.sourceTask))
+    return { ok: false, error: "Mission is missing sourceTask" };
+  if (!isJsonValue(record.sourceTask))
+    return { ok: false, error: "Mission sourceTask is not JSON-safe" };
+  const pendingEffects = Array.isArray(record.pendingEffects) ? record.pendingEffects.filter(isRecord).map((entry) => entry) : [];
+  const postedResults = Array.isArray(record.postedResults) ? record.postedResults.filter(isRecord).map((entry) => entry) : [];
+  const completionProof = isRecord(record.completionProof) ? record.completionProof : null;
+  return {
+    ok: true,
+    mission: {
+      missionId: record.missionId,
+      owner: record.owner,
+      sourceTask: cloneJsonRecord(record.sourceTask),
+      status: record.status,
+      summary: typeof record.summary === "string" ? record.summary : "Inspector mission",
+      pendingEffects,
+      postedResults,
+      completionProof,
+      createdAt: typeof record.createdAt === "string" ? record.createdAt : new Date(0).toISOString(),
+      updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : new Date(0).toISOString()
+    }
+  };
+}
+function sourceTaskId(sourceTask) {
+  for (const key of ["sourceTaskId", "taskId", "id"]) {
+    const value = sourceTask[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return null;
+}
+function terminalStatus(status) {
+  return status === "accepted" || status === "rejected";
+}
+function latestEffectResults(mission) {
+  const latestByEffect = new Map;
+  for (const result of mission.postedResults) {
+    latestByEffect.set(result.effectId, result);
+  }
+  return [...latestByEffect.values()];
+}
+function blockingResults(mission) {
+  return latestEffectResults(mission).filter((result) => result.status !== "completed");
+}
+function pendingEffects(mission) {
+  return mission.pendingEffects.filter((effect) => effect.status === "pending");
+}
+function missionStatusAfterPost(mission) {
+  if (blockingResults(mission).length > 0)
+    return "blocked";
+  if (pendingEffects(mission).length > 0)
+    return "awaiting_effect";
+  return "open";
+}
+function missionActionDetails(mission) {
+  return {
+    missionId: mission.missionId,
+    status: mission.status,
+    sourceTaskId: sourceTaskId(mission.sourceTask)
+  };
+}
+function writeJsonFile(path, value) {
+  mkdirSync2(dirname2(path), { recursive: true });
+  const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync2(tempPath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  renameSync(tempPath, path);
+}
+function resolveInspectorMissionPaths(projectRoot) {
+  const inspectorDir = resolve2(resolveRigServerPaths(projectRoot).stateDir, "inspector");
+  return {
+    inspectorDir,
+    missionsDir: join(inspectorDir, "missions"),
+    journalsDir: join(inspectorDir, "mission-journals")
+  };
+}
+function createInspectorMissionController(options) {
+  const paths = resolveInspectorMissionPaths(options.projectRoot);
+  mkdirSync2(paths.missionsDir, { recursive: true });
+  mkdirSync2(paths.journalsDir, { recursive: true });
+  const now = options.now ?? (() => new Date().toISOString());
+  const nextId = options.idGenerator ?? (() => `mission:${randomUUID()}`);
+  function missionPath(missionId) {
+    return join(paths.missionsDir, `${missionId}.json`);
+  }
+  function journalPath(missionId) {
+    return join(paths.journalsDir, `${missionId}.jsonl`);
+  }
+  function appendMissionJournal(entry) {
+    mkdirSync2(paths.journalsDir, { recursive: true });
+    appendFileSync(journalPath(entry.missionId), `${JSON.stringify(entry)}
+`, "utf8");
+  }
+  function listMissionJournal(missionId) {
+    const path = journalPath(missionId);
+    if (!existsSync2(path))
+      return [];
+    return readFileSync(path, "utf8").split(`
+`).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line)).filter(isRecord).map((entry) => ({
+      id: typeof entry.id === "string" ? entry.id : `journal:${randomUUID()}`,
+      missionId,
+      kind: typeof entry.kind === "string" ? entry.kind : "mission.event",
+      summary: typeof entry.summary === "string" ? entry.summary : "Mission event",
+      actor: typeof entry.actor === "string" ? entry.actor : null,
+      details: toJsonRecord(entry.details),
+      createdAt: typeof entry.createdAt === "string" ? entry.createdAt : new Date(0).toISOString()
+    }));
+  }
+  function saveMission(mission) {
+    writeJsonFile(missionPath(mission.missionId), mission);
+  }
+  function readMissionOnly(missionId) {
+    const path = missionPath(missionId);
+    if (!existsSync2(path)) {
+      return { ok: false, error: `Mission ${missionId} was not found` };
+    }
+    const read = readJsonRecord(path);
+    if (!read.ok)
+      return read;
+    return parseMission(read.record);
+  }
+  function recordDecision(mission, input) {
+    options.journal?.appendDecision({
+      id: `decision:${mission.missionId}:${input.type}:${randomUUID()}`,
+      runId: mission.missionId,
+      dedupeKey: null,
+      decisionType: input.type,
+      summary: input.summary,
+      rationale: input.rationale,
+      details: input.details ?? missionActionDetails(mission),
+      createdAt: input.at
+    });
+  }
+  function recordAction(mission, input) {
+    options.journal?.appendAction({
+      id: `action:${mission.missionId}:${input.type}:${randomUUID()}`,
+      runId: mission.missionId,
+      dedupeKey: null,
+      actionType: input.type,
+      status: input.status,
+      target: input.target ?? `mission:${mission.missionId}`,
+      input: input.input ?? missionActionDetails(mission),
+      result: input.result ?? missionActionDetails(mission),
+      startedAt: input.startedAt,
+      completedAt: input.completedAt ?? input.startedAt
+    });
+  }
+  function appendEvent(mission, input) {
+    appendMissionJournal({
+      id: `event:${mission.missionId}:${input.kind}:${randomUUID()}`,
+      missionId: mission.missionId,
+      kind: input.kind,
+      summary: input.summary,
+      actor: input.actor ?? null,
+      details: input.details ?? missionActionDetails(mission),
+      createdAt: input.at
+    });
+  }
+  return {
+    paths,
+    createMission(input) {
+      const source = cloneJsonRecord(input.sourceTask);
+      const missionId = nextId();
+      const path = missionPath(missionId);
+      if (existsSync2(path)) {
+        const existing = readMissionOnly(missionId);
+        if (!existing.ok)
+          return existing;
+        return { ok: true, mission: existing.mission, journal: listMissionJournal(missionId) };
+      }
+      const at = now();
+      const mission = {
+        missionId,
+        owner: input.owner ?? "inspector-agent",
+        sourceTask: source,
+        status: "open",
+        summary: input.summary ?? (typeof source.title === "string" ? source.title : "Inspector mission"),
+        pendingEffects: [],
+        postedResults: [],
+        completionProof: null,
+        createdAt: at,
+        updatedAt: at
+      };
+      saveMission(mission);
+      appendEvent(mission, {
+        kind: "mission.created",
+        summary: mission.summary,
+        actor: mission.owner,
+        details: { ...missionActionDetails(mission), sourceTask: source },
+        at
+      });
+      recordDecision(mission, {
+        type: "mission.create",
+        summary: mission.summary,
+        rationale: "Inspector-agent accepted agency/controller ownership for the source task contract.",
+        details: { ...missionActionDetails(mission), sourceTask: source },
+        at
+      });
+      recordAction(mission, {
+        type: "mission.create",
+        status: "completed",
+        result: missionActionDetails(mission),
+        startedAt: at
+      });
+      return { ok: true, mission, journal: listMissionJournal(missionId) };
+    },
+    listMissions() {
+      return readdirSync(paths.missionsDir).filter((entry) => entry.endsWith(".json")).map((entry) => readMissionOnly(entry.slice(0, -".json".length))).filter((entry) => entry.ok).map((entry) => entry.mission).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    },
+    readMission(missionId) {
+      const read = readMissionOnly(missionId);
+      if (!read.ok)
+        return read;
+      return { ok: true, mission: read.mission, journal: listMissionJournal(missionId) };
+    },
+    requestEffect(input) {
+      const read = readMissionOnly(input.missionId);
+      if (!read.ok)
+        return read;
+      const mission = read.mission;
+      if (terminalStatus(mission.status)) {
+        return { ok: false, error: `Mission ${mission.missionId} is terminal (${mission.status})` };
+      }
+      if (mission.pendingEffects.some((effect2) => effect2.effectId === input.effectId)) {
+        return { ok: false, error: `Mission ${mission.missionId} already has effect ${input.effectId}` };
+      }
+      const at = now();
+      const effect = {
+        effectId: input.effectId ?? `effect:${randomUUID()}`,
+        kind: input.kind,
+        executor: input.executor,
+        summary: input.summary,
+        input: input.input ?? null,
+        status: "pending",
+        requestedAt: at
+      };
+      mission.pendingEffects = [...mission.pendingEffects, effect];
+      mission.status = "awaiting_effect";
+      mission.updatedAt = at;
+      saveMission(mission);
+      appendEvent(mission, {
+        kind: "mission.effect.requested",
+        summary: input.summary,
+        actor: mission.owner,
+        details: { ...missionActionDetails(mission), effectId: effect.effectId, executor: effect.executor },
+        at
+      });
+      recordAction(mission, {
+        type: "mission.effect.request",
+        status: "completed",
+        target: effect.executor,
+        input: effect.input,
+        result: { ...missionActionDetails(mission), effectId: effect.effectId },
+        startedAt: at
+      });
+      return { ok: true, mission, journal: listMissionJournal(mission.missionId) };
+    },
+    postEffectResult(input) {
+      const read = readMissionOnly(input.missionId);
+      if (!read.ok)
+        return read;
+      const mission = read.mission;
+      if (terminalStatus(mission.status)) {
+        return { ok: false, error: `Mission ${mission.missionId} is terminal (${mission.status})` };
+      }
+      const effect = mission.pendingEffects.find((entry) => entry.effectId === input.effectId);
+      if (!effect) {
+        return { ok: false, error: `Mission ${mission.missionId} has no pending effect ${input.effectId}` };
+      }
+      if (effect.status !== "pending") {
+        const latestResult = mission.postedResults.filter((entry) => entry.effectId === input.effectId).at(-1);
+        if (!latestResult || latestResult.status !== "partial") {
+          return { ok: false, error: `Effect ${input.effectId} was already posted` };
+        }
+      }
+      const at = now();
+      effect.status = "posted";
+      const result = {
+        effectId: input.effectId,
+        status: input.status,
+        summary: input.summary,
+        result: input.result ?? null,
+        postedBy: input.postedBy ?? "provider-worker",
+        postedAt: at
+      };
+      mission.postedResults = [...mission.postedResults, result];
+      mission.status = missionStatusAfterPost(mission);
+      mission.updatedAt = at;
+      saveMission(mission);
+      appendEvent(mission, {
+        kind: "mission.effect.posted",
+        summary: input.summary,
+        actor: result.postedBy,
+        details: { ...missionActionDetails(mission), effectId: input.effectId, resultStatus: input.status },
+        at
+      });
+      recordAction(mission, {
+        type: "mission.effect.post",
+        status: input.status,
+        target: input.effectId,
+        input: { effectId: input.effectId },
+        result: result.result,
+        startedAt: at
+      });
+      if (input.status !== "completed") {
+        recordDecision(mission, {
+          type: "mission.block",
+          summary: input.summary,
+          rationale: "Provider-worker effect result was not complete; proof gate remains closed.",
+          details: { ...missionActionDetails(mission), effectId: input.effectId, resultStatus: input.status },
+          at
+        });
+      }
+      return { ok: true, mission, journal: listMissionJournal(mission.missionId) };
+    },
+    acceptMission(input) {
+      const read = readMissionOnly(input.missionId);
+      if (!read.ok)
+        return read;
+      const mission = read.mission;
+      const blockers = blockingResults(mission);
+      if (blockers.length > 0) {
+        return { ok: false, error: `Mission ${mission.missionId} has blocking effect result(s)` };
+      }
+      const pending = pendingEffects(mission);
+      if (pending.length > 0) {
+        return { ok: false, error: `Mission ${mission.missionId} has pending effect(s)` };
+      }
+      if (terminalStatus(mission.status)) {
+        return { ok: false, error: `Mission ${mission.missionId} is terminal (${mission.status})` };
+      }
+      const at = now();
+      const proof = {
+        proofId: `proof:${mission.missionId}:${randomUUID()}`,
+        missionId: mission.missionId,
+        sourceTaskId: sourceTaskId(mission.sourceTask),
+        status: "accepted",
+        acceptedBy: input.acceptedBy ?? "inspector-agent",
+        summary: input.summary,
+        evidence: input.evidence ?? [],
+        effectResultIds: latestEffectResults(mission).map((result) => result.effectId),
+        sourceTask: cloneJsonRecord(mission.sourceTask),
+        emittedAt: at
+      };
+      mission.status = "accepted";
+      mission.completionProof = proof;
+      mission.updatedAt = at;
+      saveMission(mission);
+      appendEvent(mission, {
+        kind: "mission.accepted",
+        summary: input.summary,
+        actor: proof.acceptedBy,
+        details: { ...missionActionDetails(mission), proofId: proof.proofId },
+        at
+      });
+      recordDecision(mission, {
+        type: "mission.accept",
+        summary: input.summary,
+        rationale: "All requested effects were posted as complete and the PR/source-task closeout readiness is accepted.",
+        details: { ...missionActionDetails(mission), proofId: proof.proofId, evidence: proof.evidence },
+        at
+      });
+      recordAction(mission, {
+        type: "mission.accept",
+        status: "completed",
+        result: { ...missionActionDetails(mission), proofId: proof.proofId },
+        startedAt: at
+      });
+      return { ok: true, mission, journal: listMissionJournal(mission.missionId), completionProof: proof };
+    },
+    rejectMission(input) {
+      const read = readMissionOnly(input.missionId);
+      if (!read.ok)
+        return read;
+      const mission = read.mission;
+      if (terminalStatus(mission.status)) {
+        return { ok: false, error: `Mission ${mission.missionId} is terminal (${mission.status})` };
+      }
+      const at = now();
+      mission.status = "rejected";
+      mission.completionProof = null;
+      mission.updatedAt = at;
+      saveMission(mission);
+      appendEvent(mission, {
+        kind: "mission.rejected",
+        summary: input.summary,
+        actor: input.rejectedBy ?? "inspector-agent",
+        details: { ...missionActionDetails(mission), rationale: input.rationale ?? "" },
+        at
+      });
+      recordDecision(mission, {
+        type: "mission.reject",
+        summary: input.summary,
+        rationale: input.rationale ?? "Inspector rejected mission closeout.",
+        details: missionActionDetails(mission),
+        at
+      });
+      recordAction(mission, {
+        type: "mission.reject",
+        status: "completed",
+        result: missionActionDetails(mission),
+        startedAt: at
+      });
+      return { ok: true, mission, journal: listMissionJournal(mission.missionId) };
+    },
+    blockMission(input) {
+      const read = readMissionOnly(input.missionId);
+      if (!read.ok)
+        return read;
+      const mission = read.mission;
+      if (terminalStatus(mission.status)) {
+        return { ok: false, error: `Mission ${mission.missionId} is terminal (${mission.status})` };
+      }
+      const at = now();
+      mission.status = "blocked";
+      mission.updatedAt = at;
+      saveMission(mission);
+      appendEvent(mission, {
+        kind: "mission.blocked",
+        summary: input.summary,
+        actor: input.blockedBy ?? "inspector-agent",
+        details: input.details ?? missionActionDetails(mission),
+        at
+      });
+      recordDecision(mission, {
+        type: "mission.block",
+        summary: input.summary,
+        rationale: "Inspector marked mission blocked; proof gate remains closed.",
+        details: input.details ?? missionActionDetails(mission),
+        at
+      });
+      return { ok: true, mission, journal: listMissionJournal(mission.missionId) };
+    },
+    completeMission(missionId) {
+      const read = readMissionOnly(missionId);
+      if (!read.ok)
+        return read;
+      const mission = read.mission;
+      if (mission.status !== "accepted" || !mission.completionProof) {
+        return { ok: false, error: `Mission ${missionId} must be accepted before completion proof can be completed` };
+      }
+      const at = now();
+      appendEvent(mission, {
+        kind: "mission.completed",
+        summary: "Mission completion proof read",
+        actor: mission.owner,
+        details: { ...missionActionDetails(mission), proofId: mission.completionProof.proofId },
+        at
+      });
+      recordAction(mission, {
+        type: "mission.complete",
+        status: "completed",
+        result: { ...missionActionDetails(mission), proofId: mission.completionProof.proofId },
+        startedAt: at
+      });
+      return {
+        ok: true,
+        mission,
+        journal: listMissionJournal(mission.missionId),
+        completionProof: mission.completionProof
+      };
+    }
+  };
+}
+
+// packages/server/src/inspector/review.ts
+function buildLocalReviewRequest(options) {
+  return {
+    reviewerType: "local-reviewer",
+    runId: options.runId,
+    taskId: options.taskId,
+    focus: options.focus
+  };
+}
+
+// packages/server/src/inspector/skills.ts
+var UNIVERSAL_REQUIRED_SKILLS = [
+  {
+    name: "test-driven-development",
+    rationale: "Write failing tests first for code and behavior changes unless a narrow exception is recorded."
+  }
+];
+var INSPECTOR_REQUIRED_SKILLS = [
+  {
+    name: "verification-before-completion",
+    rationale: "Do not claim completion or stability without direct verification evidence."
+  },
+  {
+    name: "no-bs",
+    rationale: "Respect the machine no-bs gates, keep evidence up to date, and do not stop early."
+  }
+];
+var UNIVERSAL_RECOMMENDED_SKILLS = [
+  {
+    name: "verification-before-completion",
+    rationale: "Gather direct evidence before claiming a repair, review result, or task completion."
+  },
+  {
+    name: "systematic-debugging",
+    rationale: "Use disciplined debugging when a run, harness path, or validator fails."
+  },
+  {
+    name: "dispatching-parallel-agents",
+    rationale: "Split independent analysis and review work when that shortens the critical path."
+  },
+  {
+    name: "subagent-driven-development",
+    rationale: "Delegate bounded work to specialist subagents while keeping one context owner."
+  },
+  {
+    name: "requesting-code-review",
+    rationale: "Run local review before landing meaningful implementation work."
+  },
+  {
+    name: "receiving-code-review",
+    rationale: "Handle review feedback rigorously instead of applying it blindly."
+  },
+  {
+    name: "using-git-worktrees",
+    rationale: "Use isolated worktrees for risky or parallel implementation branches."
+  },
+  {
+    name: "writing-plans",
+    rationale: "Plan multi-step changes explicitly when the work is broad or risky."
+  },
+  {
+    name: "executing-plans",
+    rationale: "Execute validated plans in a staged, reviewable way."
+  },
+  {
+    name: "writing-skills",
+    rationale: "Improve or add agent skills when the harness needs new reusable behavior."
+  },
+  {
+    name: "find-skills",
+    rationale: "Discover existing local skills before inventing new workflows."
+  },
+  {
+    name: "openai-docs",
+    rationale: "Use primary OpenAI documentation when the inspector needs current provider facts."
+  },
+  {
+    name: "linear",
+    rationale: "Create or update follow-up work in the task tracker when oversight detects needed action."
+  },
+  {
+    name: "playwright",
+    rationale: "Inspect browser flows directly when a run touches web behavior or UI verification."
+  },
+  {
+    name: "playwright-interactive",
+    rationale: "Keep a live browser session when iterative UI inspection is more efficient than restarts."
+  }
+];
+var INSPECTOR_ONLY_RECOMMENDED_SKILLS = [
+  {
+    name: "vercel:agent-browser",
+    rationale: "Perform high-fidelity browser inspection when a run or preview needs interactive verification."
+  },
+  {
+    name: "vercel:agent-browser-verify",
+    rationale: "Run an automated visual gut-check against dev servers and previews."
+  },
+  {
+    name: "vercel:verification",
+    rationale: "Verify end-to-end browser to API behavior when the change spans multiple surfaces."
+  },
+  {
+    name: "vercel:investigation-mode",
+    rationale: "Triages broken or stuck flows systematically when the harness or a preview misbehaves."
+  }
+];
+function uniqueSkills(skills) {
+  const seen = new Set;
+  const deduped = [];
+  for (const skill of skills) {
+    if (seen.has(skill.name)) {
+      continue;
+    }
+    seen.add(skill.name);
+    deduped.push(skill);
+  }
+  return deduped;
+}
+function buildInspectorSkillCatalog(options) {
+  const required = [...UNIVERSAL_REQUIRED_SKILLS];
+  const recommended = [...UNIVERSAL_RECOMMENDED_SKILLS];
+  if (options.role === "inspector") {
+    required.push(...INSPECTOR_REQUIRED_SKILLS);
+    recommended.push(...INSPECTOR_ONLY_RECOMMENDED_SKILLS);
+  } else if (options.role === "reviewer") {
+    recommended.push({
+      name: "receiving-code-review",
+      rationale: "Review lanes should reason about findings carefully and defensibly."
+    });
+  }
+  if (options.taskKind === "bugfix") {
+    recommended.push({
+      name: "systematic-debugging",
+      rationale: "Bugfix work should start from a disciplined failure-class analysis."
+    });
+  }
+  return {
+    required: uniqueSkills(required),
+    recommended: uniqueSkills(recommended)
+  };
+}
+function buildSkillProvisioningDecision(options) {
+  const exceptionRecorded = Boolean(options.exception);
+  const catalog = buildInspectorSkillCatalog({
+    role: options.role,
+    taskKind: options.taskKind
+  });
+  const requiredSkills = catalog.required.map((skill) => skill.name);
+  const preferredSkills = catalog.recommended.map((skill) => skill.name);
+  return {
+    role: options.role,
+    taskKind: options.taskKind,
+    requiredSkills,
+    preferredSkills,
+    tddMode: exceptionRecorded ? "exception-recorded" : "required",
+    exceptionRecorded,
+    exception: options.exception ?? null
+  };
+}
+
+// packages/server/src/inspector/tools.ts
+function toJsonRecord2(value, fallbackKey = "value") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    if (value == null) {
+      return null;
+    }
+    return { [fallbackKey]: value };
+  }
+  return value;
+}
+function toMissionJsonRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const parsed = JSON.parse(JSON.stringify(value));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
+  }
+  return parsed;
+}
+function toMissionJsonRecordOrNull(value) {
+  if (value == null)
+    return null;
+  return toMissionJsonRecord(value);
+}
+function missionFailureStatus(error) {
+  if (error.includes("was not found"))
+    return "missing";
+  return "blocked";
+}
+function activeRunStatuses() {
+  return new Set(["preparing", "running", "validating", "reviewing"]);
+}
+function stableFollowupDedupeKey(originRunId, summary) {
+  return `followup:${originRunId ?? "global"}:${summary.trim().toLowerCase()}`;
+}
+function createInspectorToolRegistry(options) {
+  const now = options.now ?? (() => new Date().toISOString());
+  const missionController = options.projectRoot ? createInspectorMissionController({
+    projectRoot: options.projectRoot,
+    journal: options.journal,
+    now,
+    idGenerator: options.missionIdGenerator
+  }) : null;
+  const descriptors = {
+    read_inspector_snapshot: {
+      enabled: Boolean(options.snapshotReader),
+      async handler() {
+        if (!options.snapshotReader) {
+          return {
+            status: "unavailable",
+            summary: "read_inspector_snapshot is not configured",
+            details: null
+          };
+        }
+        const snapshot = options.snapshotReader();
+        return {
+          status: "completed",
+          summary: "Read current inspector snapshot",
+          details: snapshot
+        };
+      }
+    },
+    discover_active_runs: {
+      enabled: true,
+      async handler() {
+        const runs = options.discoverRuns().filter((run) => activeRunStatuses().has(run.status));
+        return {
+          status: "completed",
+          summary: `Discovered ${runs.length} active run(s)`,
+          details: runs
+        };
+      }
+    },
+    inspect_run: {
+      enabled: true,
+      async handler(input) {
+        const runId = typeof input.runId === "string" ? input.runId : "";
+        const run = options.discoverRuns().find((entry) => entry.runId === runId) ?? null;
+        if (!run) {
+          return {
+            status: "missing",
+            summary: `Run ${runId} was not found`,
+            details: null
+          };
+        }
+        const session = normalizeProviderSession(run);
+        const findings = options.journal.listRecentFindings({ limit: 50 }).filter((entry) => entry.runId === runId);
+        return {
+          status: "completed",
+          summary: `Inspected run ${runId}`,
+          details: {
+            run,
+            session,
+            capabilities: deriveInspectorCapabilitySet(session, options.capabilitySupport),
+            observations: findings,
+            paths: {
+              workspaceDir: run.worktreePath,
+              artifactRoot: run.artifactRoot,
+              logRoot: run.logRoot,
+              sessionPath: run.sessionPath,
+              sessionLogPath: run.sessionLogPath
+            }
+          }
+        };
+      }
+    },
+    record_inspector_note: {
+      enabled: true,
+      async handler(input) {
+        const runId = typeof input.runId === "string" ? input.runId : null;
+        const summary = typeof input.summary === "string" ? input.summary : "Inspector note";
+        const details = toJsonRecord2(input.details);
+        const result = options.journal.appendObservation({
+          id: `note:${runId ?? "global"}:${randomUUID2()}`,
+          runId,
+          dedupeKey: null,
+          kind: "inspector.note",
+          severity: "info",
+          source: "inspector",
+          summary,
+          details,
+          createdAt: now()
+        });
+        return {
+          status: result.ok ? "completed" : "failed",
+          summary,
+          details: result.ok ? result.record : { error: result.error }
+        };
+      }
+    },
+    list_inspector_missions: {
+      enabled: Boolean(missionController),
+      async handler() {
+        if (!missionController) {
+          return { status: "unavailable", summary: "mission storage is not configured", details: null };
+        }
+        const missions = missionController.listMissions();
+        return {
+          status: "completed",
+          summary: `Listed ${missions.length} inspector mission(s)`,
+          details: { missions }
+        };
+      }
+    },
+    create_inspector_mission: {
+      enabled: Boolean(missionController),
+      async handler(input) {
+        if (!missionController) {
+          return { status: "unavailable", summary: "mission storage is not configured", details: null };
+        }
+        const sourceTask = toMissionJsonRecord(input.sourceTask);
+        if (!sourceTask) {
+          return { status: "failed", summary: "sourceTask must be a JSON object", details: null };
+        }
+        const result = missionController.createMission({
+          sourceTask,
+          owner: typeof input.owner === "string" ? input.owner : undefined,
+          summary: typeof input.summary === "string" ? input.summary : undefined
+        });
+        if (!result.ok) {
+          return { status: missionFailureStatus(result.error), summary: result.error, details: null };
+        }
+        return {
+          status: "completed",
+          summary: `Created inspector mission ${result.mission.missionId}`,
+          details: { ...result.mission, journal: result.journal }
+        };
+      }
+    },
+    read_inspector_mission: {
+      enabled: Boolean(missionController),
+      async handler(input) {
+        if (!missionController) {
+          return { status: "unavailable", summary: "mission storage is not configured", details: null };
+        }
+        const missionId = typeof input.missionId === "string" ? input.missionId : "";
+        const result = missionController.readMission(missionId);
+        if (!result.ok) {
+          return { status: missionFailureStatus(result.error), summary: result.error, details: null };
+        }
+        return {
+          status: "completed",
+          summary: `Read inspector mission ${missionId}`,
+          details: { ...result.mission, journal: result.journal }
+        };
+      }
+    },
+    request_inspector_effect: {
+      enabled: Boolean(missionController),
+      async handler(input) {
+        if (!missionController) {
+          return { status: "unavailable", summary: "mission storage is not configured", details: null };
+        }
+        const missionId = typeof input.missionId === "string" ? input.missionId : "";
+        const kind = typeof input.kind === "string" ? input.kind : "provider_worker";
+        const executor = typeof input.executor === "string" ? input.executor : "worker";
+        const summary = typeof input.summary === "string" ? input.summary : "Inspector effect requested";
+        const result = missionController.requestEffect({
+          missionId,
+          effectId: typeof input.effectId === "string" ? input.effectId : undefined,
+          kind,
+          executor,
+          summary,
+          input: toMissionJsonRecordOrNull(input.input)
+        });
+        if (!result.ok) {
+          return { status: missionFailureStatus(result.error), summary: result.error, details: null };
+        }
+        return {
+          status: "completed",
+          summary,
+          details: { ...result.mission, journal: result.journal }
+        };
+      }
+    },
+    post_inspector_effect_result: {
+      enabled: Boolean(missionController),
+      async handler(input) {
+        if (!missionController) {
+          return { status: "unavailable", summary: "mission storage is not configured", details: null };
+        }
+        const status = typeof input.status === "string" ? input.status : "failed";
+        if (!["completed", "partial", "blocked", "failed"].includes(status)) {
+          return { status: "failed", summary: `Unsupported effect result status: ${status}`, details: null };
+        }
+        const result = missionController.postEffectResult({
+          missionId: typeof input.missionId === "string" ? input.missionId : "",
+          effectId: typeof input.effectId === "string" ? input.effectId : "",
+          status,
+          summary: typeof input.summary === "string" ? input.summary : "Inspector effect result posted",
+          result: toMissionJsonRecordOrNull(input.result),
+          postedBy: typeof input.postedBy === "string" ? input.postedBy : undefined
+        });
+        if (!result.ok) {
+          return { status: missionFailureStatus(result.error), summary: result.error, details: null };
+        }
+        return {
+          status: result.mission.status === "blocked" ? "blocked" : "completed",
+          summary: typeof input.summary === "string" ? input.summary : "Inspector effect result posted",
+          details: { ...result.mission, journal: result.journal }
+        };
+      }
+    },
+    accept_inspector_mission: {
+      enabled: Boolean(missionController),
+      async handler(input) {
+        if (!missionController) {
+          return { status: "unavailable", summary: "mission storage is not configured", details: null };
+        }
+        const result = missionController.acceptMission({
+          missionId: typeof input.missionId === "string" ? input.missionId : "",
+          acceptedBy: typeof input.acceptedBy === "string" ? input.acceptedBy : undefined,
+          summary: typeof input.summary === "string" ? input.summary : "Inspector mission accepted",
+          evidence: Array.isArray(input.evidence) ? input.evidence.filter((entry) => typeof entry === "string") : undefined
+        });
+        if (!result.ok) {
+          return { status: missionFailureStatus(result.error), summary: result.error, details: null };
+        }
+        return {
+          status: "completed",
+          summary: result.completionProof.summary,
+          details: { ...result.mission, journal: result.journal, completionProof: result.completionProof }
+        };
+      }
+    },
+    reject_inspector_mission: {
+      enabled: Boolean(missionController),
+      async handler(input) {
+        if (!missionController) {
+          return { status: "unavailable", summary: "mission storage is not configured", details: null };
+        }
+        const result = missionController.rejectMission({
+          missionId: typeof input.missionId === "string" ? input.missionId : "",
+          rejectedBy: typeof input.rejectedBy === "string" ? input.rejectedBy : undefined,
+          summary: typeof input.summary === "string" ? input.summary : "Inspector mission rejected",
+          rationale: typeof input.rationale === "string" ? input.rationale : undefined
+        });
+        if (!result.ok) {
+          return { status: missionFailureStatus(result.error), summary: result.error, details: null };
+        }
+        return {
+          status: "completed",
+          summary: result.mission.summary,
+          details: { ...result.mission, journal: result.journal }
+        };
+      }
+    },
+    block_inspector_mission: {
+      enabled: Boolean(missionController),
+      async handler(input) {
+        if (!missionController) {
+          return { status: "unavailable", summary: "mission storage is not configured", details: null };
+        }
+        const result = missionController.blockMission({
+          missionId: typeof input.missionId === "string" ? input.missionId : "",
+          blockedBy: typeof input.blockedBy === "string" ? input.blockedBy : undefined,
+          summary: typeof input.summary === "string" ? input.summary : "Inspector mission blocked",
+          details: toMissionJsonRecordOrNull(input.details)
+        });
+        if (!result.ok) {
+          return { status: missionFailureStatus(result.error), summary: result.error, details: null };
+        }
+        return {
+          status: "blocked",
+          summary: result.mission.summary,
+          details: { ...result.mission, journal: result.journal }
+        };
+      }
+    },
+    complete_inspector_mission: {
+      enabled: Boolean(missionController),
+      async handler(input) {
+        if (!missionController) {
+          return { status: "unavailable", summary: "mission storage is not configured", details: null };
+        }
+        const missionId = typeof input.missionId === "string" ? input.missionId : "";
+        const result = missionController.completeMission(missionId);
+        if (!result.ok) {
+          return { status: missionFailureStatus(result.error), summary: result.error, details: null };
+        }
+        return {
+          status: "completed",
+          summary: `Completed inspector mission ${missionId}`,
+          details: { ...result.mission, journal: result.journal, completionProof: result.completionProof }
+        };
+      }
+    },
+    create_followup_task: {
+      enabled: true,
+      async handler(input) {
+        const originRunId = typeof input.originRunId === "string" ? input.originRunId : null;
+        const summary = typeof input.summary === "string" ? input.summary : "Inspector follow-up";
+        const details = toJsonRecord2(input.details);
+        const dedupeKey = typeof input.dedupeKey === "string" && input.dedupeKey.trim().length > 0 ? input.dedupeKey.trim() : stableFollowupDedupeKey(originRunId, summary);
+        const createdAt = now();
+        const record = {
+          id: `followup:${randomUUID2()}`,
+          originRunId,
+          dedupeKey,
+          taskId: null,
+          kind: "followup-task",
+          status: "proposed",
+          summary,
+          details,
+          createdAt
+        };
+        const result = options.journal.appendFollowup(record);
+        let createdTask = null;
+        if (result.ok && result.changed && options.followupTaskRunner) {
+          createdTask = await options.followupTaskRunner({
+            ...input,
+            summary,
+            originRunId,
+            dedupeKey
+          });
+          const taskDetails = toJsonRecord2(createdTask.details);
+          const taskId = typeof taskDetails?.taskId === "string" ? taskDetails.taskId : null;
+          if (taskId) {
+            options.journal.attachFollowupTask({
+              dedupeKey,
+              taskId,
+              status: "created",
+              details: taskDetails
+            });
+          }
+        }
+        options.journal.appendAction({
+          id: `action:followup:${randomUUID2()}`,
+          runId: originRunId,
+          dedupeKey: null,
+          actionType: "create_followup_task",
+          status: createdTask?.status ?? (result.ok ? "completed" : "failed"),
+          target: originRunId ? `run:${originRunId}` : "global",
+          input: {
+            summary,
+            dedupeKey
+          },
+          result: toJsonRecord2(createdTask?.details ?? record),
+          startedAt: createdAt,
+          completedAt: now()
+        });
+        return {
+          status: createdTask?.status ?? (result.ok ? "completed" : "failed"),
+          summary,
+          details: {
+            followup: result.ok ? record : { error: result.error },
+            createdTask: createdTask?.details ?? null
+          }
+        };
+      }
+    },
+    provision_skill: {
+      enabled: true,
+      async handler(input) {
+        const role = typeof input.role === "string" ? input.role : "worker";
+        const taskKind = typeof input.taskKind === "string" ? input.taskKind : "code-change";
+        const exception = input.exception && typeof input.exception === "object" ? input.exception : null;
+        const decision = buildSkillProvisioningDecision({
+          role,
+          taskKind,
+          exception: exception && typeof exception.reason === "string" && typeof exception.category === "string" ? { reason: exception.reason, category: exception.category } : undefined
+        });
+        const createdAt = now();
+        options.journal.appendDecision({
+          id: `decision:skills:${randomUUID2()}`,
+          runId: typeof input.runId === "string" ? input.runId : null,
+          dedupeKey: null,
+          decisionType: "skill-provisioning",
+          summary: `Provisioned skills for ${role}`,
+          rationale: "Inspector provisions role-aware skills before execution or review.",
+          details: decision,
+          createdAt
+        });
+        options.journal.appendAction({
+          id: `action:skills:${randomUUID2()}`,
+          runId: typeof input.runId === "string" ? input.runId : null,
+          dedupeKey: null,
+          actionType: "provision_skill",
+          status: "completed",
+          target: role,
+          input: { role, taskKind },
+          result: decision,
+          startedAt: createdAt,
+          completedAt: createdAt
+        });
+        return {
+          status: "completed",
+          summary: `Provisioned skills for ${role}`,
+          details: decision
+        };
+      }
+    },
+    run_local_review: {
+      enabled: Boolean(options.reviewRunner),
+      async handler(input) {
+        if (!options.reviewRunner) {
+          return {
+            status: "unavailable",
+            summary: "run_local_review is not configured",
+            details: null
+          };
+        }
+        const request = buildLocalReviewRequest({
+          runId: typeof input.runId === "string" ? input.runId : "",
+          taskId: typeof input.taskId === "string" ? input.taskId : null,
+          focus: Array.isArray(input.focus) ? input.focus.filter((entry) => typeof entry === "string") : []
+        });
+        const startedAt = now();
+        const result = await options.reviewRunner(request);
+        options.journal.appendReview({
+          id: `review:${request.runId || "global"}:${randomUUID2()}`,
+          runId: request.runId || null,
+          dedupeKey: null,
+          reviewerType: request.reviewerType,
+          status: result.status,
+          findings: {
+            summary: result.summary,
+            details: toJsonRecord2(result.details)
+          },
+          createdAt: startedAt
+        });
+        options.journal.appendAction({
+          id: `action:review:${randomUUID2()}`,
+          runId: request.runId || null,
+          dedupeKey: null,
+          actionType: "run_local_review",
+          status: result.status,
+          target: request.taskId ?? request.runId,
+          input: request,
+          result: {
+            summary: result.summary,
+            details: toJsonRecord2(result.details)
+          },
+          startedAt,
+          completedAt: now()
+        });
+        return result;
+      }
+    },
+    scan_upstream_drift: {
+      enabled: Boolean(options.upstreamScanRunner),
+      async handler(input) {
+        if (!options.upstreamScanRunner) {
+          return {
+            status: "unavailable",
+            summary: "scan_upstream_drift is not configured",
+            details: null
+          };
+        }
+        const startedAt = now();
+        const result = await options.upstreamScanRunner(input);
+        options.journal.appendAction({
+          id: `action:upstream:${randomUUID2()}`,
+          runId: typeof input.runId === "string" ? input.runId : null,
+          dedupeKey: null,
+          actionType: "scan_upstream_drift",
+          status: result.status,
+          target: "workspace",
+          input: toJsonRecord2(input),
+          result: {
+            summary: result.summary,
+            details: toJsonRecord2(result.details)
+          },
+          startedAt,
+          completedAt: now()
+        });
+        return result;
+      }
+    },
+    generate_analysis_report: {
+      enabled: Boolean(options.analysisRunner),
+      async handler(input) {
+        if (!options.analysisRunner) {
+          return {
+            status: "unavailable",
+            summary: "generate_analysis_report is not configured",
+            details: null
+          };
+        }
+        const startedAt = now();
+        const result = await options.analysisRunner(input);
+        options.journal.appendAction({
+          id: `action:analysis:${randomUUID2()}`,
+          runId: typeof input.runId === "string" ? input.runId : null,
+          dedupeKey: null,
+          actionType: "generate_analysis_report",
+          status: result.status,
+          target: typeof input.reportType === "string" ? input.reportType : "default",
+          input: toJsonRecord2(input),
+          result: {
+            summary: result.summary,
+            details: toJsonRecord2(result.details)
+          },
+          startedAt,
+          completedAt: now()
+        });
+        return result;
+      }
+    }
+  };
+  return {
+    list() {
+      return Object.entries(descriptors).filter(([, descriptor]) => descriptor.enabled).map(([name]) => name).sort();
+    },
+    async invoke(name, input) {
+      const descriptor = descriptors[name];
+      if (!descriptor) {
+        return {
+          status: "missing",
+          summary: `Unknown inspector tool: ${name}`,
+          details: null
+        };
+      }
+      if (!descriptor.enabled) {
+        return {
+          status: "unavailable",
+          summary: `${name} is not configured`,
+          details: null
+        };
+      }
+      return descriptor.handler(input);
+    }
+  };
+}
+
+// packages/server/src/inspector/discovery.ts
+import {
+  runStatus
+} from "@rig/runtime/control-plane/native/run-ops";
+import {
+  listAuthorityRuns,
+  readAuthorityRun
+} from "@rig/runtime/control-plane/authority-files";
+function providerFromRuntimeAdapter(runtimeAdapter) {
+  if (!runtimeAdapter) {
+    return null;
+  }
+  return runtimeAdapter;
+}
+function uniqueStrings2(values) {
+  return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))];
+}
+function preferString(...values) {
+  return values.find((value) => typeof value === "string" && value.length > 0) ?? null;
+}
+function chooseStatus(surfaces) {
+  const authority = surfaces.find((surface) => surface.source === "authority-record");
+  if (authority?.status) {
+    return authority.status;
+  }
+  return preferString(...surfaces.map((surface) => surface.status)) ?? "unknown";
+}
+function chooseUpdatedAt(surfaces) {
+  const timestamps = uniqueStrings2(surfaces.map((surface) => surface.updatedAt)).sort();
+  return timestamps.at(-1) ?? "";
+}
+function buildConflict(surfaces) {
+  const statuses = uniqueStrings2(surfaces.map((surface) => surface.status));
+  const titles = uniqueStrings2(surfaces.map((surface) => surface.title));
+  const activeSurface = surfaces.find((surface) => new Set(["preparing", "running", "validating", "reviewing"]).has(surface.status));
+  const authoritySurface = surfaces.find((surface) => surface.source === "authority-record");
+  if (activeSurface && authoritySurface && new Set(["failed", "stopped", "completed", "done"]).has(authoritySurface.status)) {
+    return {
+      state: "stale-active",
+      summary: `Run ${authoritySurface.runId} is still reported active by ${activeSurface.source} but authority says ${authoritySurface.status}.`
+    };
+  }
+  if (statuses.length > 1 || titles.length > 1) {
+    const sourceSummary = surfaces.map((surface) => `${surface.source}:${surface.status}:${surface.title}`).join(" | ");
+    return {
+      state: "source-disagreement",
+      summary: `Conflicting run surfaces for ${surfaces[0]?.runId ?? "unknown"}: ${sourceSummary}`
+    };
+  }
+  return { state: "none", summary: null };
+}
+function mergeRunSurfaces(surfaces) {
+  const authority = surfaces.find((surface) => surface.source === "authority-record") ?? null;
+  const conflict = buildConflict(surfaces);
+  return {
+    runId: surfaces[0].runId,
+    workspaceId: preferString(authority?.workspaceId, ...surfaces.map((surface) => surface.workspaceId)),
+    taskId: preferString(authority?.taskId, ...surfaces.map((surface) => surface.taskId)),
+    provider: preferString(authority?.provider, ...surfaces.map((surface) => surface.provider)),
+    runtimeAdapter: preferString(authority?.runtimeAdapter, ...surfaces.map((surface) => surface.runtimeAdapter)),
+    threadId: preferString(authority?.threadId, ...surfaces.map((surface) => surface.threadId)),
+    status: chooseStatus(surfaces),
+    title: preferString(authority?.title, ...surfaces.map((surface) => surface.title)) ?? surfaces[0].runId,
+    source: authority?.source ?? surfaces[0].source,
+    rawSourceKinds: uniqueStrings2(surfaces.map((surface) => surface.source)),
+    conflictState: conflict.state,
+    conflictSummary: conflict.summary,
+    worktreePath: preferString(authority?.worktreePath, ...surfaces.map((surface) => surface.worktreePath)),
+    artifactRoot: preferString(authority?.artifactRoot, ...surfaces.map((surface) => surface.artifactRoot)),
+    logRoot: preferString(authority?.logRoot, ...surfaces.map((surface) => surface.logRoot)),
+    sessionPath: preferString(authority?.sessionPath, ...surfaces.map((surface) => surface.sessionPath)),
+    sessionLogPath: preferString(authority?.sessionLogPath, ...surfaces.map((surface) => surface.sessionLogPath)),
+    startedAt: preferString(authority?.startedAt, ...surfaces.map((surface) => surface.startedAt)),
+    updatedAt: chooseUpdatedAt(surfaces),
+    completedAt: preferString(authority?.completedAt, ...surfaces.map((surface) => surface.completedAt))
+  };
+}
+function discoverInspectorRuns(options) {
+  const summary = options.statusSummary ?? runStatus(options.projectRoot);
+  const discovered = new Map;
+  const pushSurface = (surface) => {
+    const existing = discovered.get(surface.runId) ?? [];
+    existing.push(surface);
+    discovered.set(surface.runId, existing);
+  };
+  for (const authorityEntry of listAuthorityRuns(options.projectRoot)) {
+    const run = readAuthorityRun(options.projectRoot, authorityEntry.runId);
+    if (!run) {
+      continue;
+    }
+    pushSurface({
+      runId: run.runId,
+      workspaceId: run.workspaceId ?? null,
+      taskId: run.taskId ?? null,
+      provider: providerFromRuntimeAdapter(run.runtimeAdapter ?? null),
+      runtimeAdapter: run.runtimeAdapter ?? null,
+      threadId: run.threadId ?? null,
+      status: run.status ?? "unknown",
+      title: run.title ?? run.taskId ?? run.runId,
+      source: "authority-record",
+      worktreePath: run.worktreePath ?? null,
+      artifactRoot: run.artifactRoot ?? null,
+      logRoot: run.logRoot ?? null,
+      sessionPath: run.sessionPath ?? null,
+      sessionLogPath: run.sessionLogPath ?? null,
+      startedAt: run.startedAt ?? null,
+      updatedAt: run.updatedAt,
+      completedAt: run.completedAt ?? null
+    });
+  }
+  for (const entry of [...summary.activeRuns, ...summary.recentRuns]) {
+    pushSurface({
+      runId: entry.runId,
+      workspaceId: null,
+      taskId: entry.taskId ?? null,
+      provider: null,
+      runtimeAdapter: null,
+      threadId: null,
+      status: entry.status,
+      title: entry.title,
+      source: "run-status",
+      worktreePath: null,
+      artifactRoot: null,
+      logRoot: null,
+      sessionPath: null,
+      sessionLogPath: null,
+      startedAt: null,
+      updatedAt: "",
+      completedAt: null
+    });
+  }
+  return [...discovered.values()].map((surfaces) => mergeRunSurfaces(surfaces)).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+
+// packages/server/src/inspector/reconcile.ts
+function decisionTypeForStatus(status) {
+  switch (status) {
+    case "failed":
+      return "investigate-failure";
+    case "stopped":
+      return "inspect-stop";
+    default:
+      return null;
+  }
+}
+function reconcileInspectorRuns(options) {
+  const now = options.now ?? (() => new Date().toISOString());
+  let observedCount = 0;
+  let decisionCount = 0;
+  let actionCount = 0;
+  for (const run of options.runs) {
+    options.journal.upsertRun({
+      runId: run.runId,
+      workspaceId: run.workspaceId,
+      taskId: run.taskId,
+      runtimeAdapter: run.runtimeAdapter,
+      provider: run.provider,
+      status: run.status,
+      conflictState: run.conflictState,
+      conflictSummary: run.conflictSummary,
+      source: run.source,
+      title: run.title,
+      startedAt: run.startedAt,
+      updatedAt: run.updatedAt,
+      completedAt: run.completedAt
+    });
+    const observation = options.journal.appendObservation({
+      id: `observation:${run.runId}:${options.reason}:${run.updatedAt}`,
+      runId: run.runId,
+      dedupeKey: `run:${run.runId}:status:${run.status}:updated:${run.updatedAt}`,
+      kind: "run.observed",
+      severity: run.status === "failed" ? "warn" : "info",
+      source: run.source,
+      summary: `Observed run ${run.title}`,
+      details: {
+        reason: options.reason,
+        status: run.status,
+        provider: run.provider,
+        runtimeAdapter: run.runtimeAdapter,
+        conflictState: run.conflictState,
+        rawSourceKinds: run.rawSourceKinds
+      },
+      createdAt: now()
+    });
+    if (observation.ok && observation.changed) {
+      observedCount += 1;
+    }
+    const action = options.journal.appendAction({
+      id: `action:${run.runId}:${options.reason}:${run.updatedAt}`,
+      runId: run.runId,
+      dedupeKey: `action:${run.runId}:observe:${run.updatedAt}`,
+      actionType: "observe",
+      status: "completed",
+      target: `run:${run.runId}`,
+      input: { reason: options.reason },
+      result: { status: run.status },
+      startedAt: now(),
+      completedAt: now()
+    });
+    if (action.ok && action.changed) {
+      actionCount += 1;
+    }
+    const decisionType = decisionTypeForStatus(run.status);
+    if (decisionType) {
+      const decision = options.journal.appendDecision({
+        id: `decision:${run.runId}:${decisionType}:${run.updatedAt}`,
+        runId: run.runId,
+        dedupeKey: `decision:${run.runId}:${decisionType}:${run.updatedAt}`,
+        decisionType,
+        summary: `Investigate ${run.title}`,
+        rationale: `Run status ${run.status} requires inspector attention.`,
+        details: {
+          reason: options.reason,
+          status: run.status
+        },
+        createdAt: now()
+      });
+      if (decision.ok && decision.changed) {
+        decisionCount += 1;
+      }
+    }
+    if (run.conflictState !== "none") {
+      const conflictDecision = options.journal.appendDecision({
+        id: `decision:${run.runId}:conflict:${run.updatedAt}`,
+        runId: run.runId,
+        dedupeKey: `decision:${run.runId}:conflict:${run.updatedAt}`,
+        decisionType: "inspect-conflict",
+        summary: `Resolve ${run.title} observation conflict`,
+        rationale: run.conflictSummary ?? "Observed run surfaces disagree and require inspector review.",
+        details: {
+          reason: options.reason,
+          conflictState: run.conflictState,
+          conflictSummary: run.conflictSummary
+        },
+        createdAt: now()
+      });
+      if (conflictDecision.ok && conflictDecision.changed) {
+        decisionCount += 1;
+      }
+    }
+  }
+  return {
+    discoveredCount: options.runs.length,
+    observedCount,
+    decisionCount,
+    actionCount
+  };
+}
+
+// packages/server/src/inspector/service.ts
+function buildCapabilitySupport(options) {
+  return {
+    discoverRuns: true,
+    inspectRuns: true,
+    readLogs: true,
+    readArtifacts: true,
+    callServerApis: true,
+    createTasks: Boolean(options.followupTaskRunner),
+    runReviewerAgents: Boolean(options.reviewRunner),
+    provisionSkills: true,
+    scanUpstream: Boolean(options.upstreamSyncRunner),
+    writeJournal: true,
+    spawnSpecialists: Boolean(options.reviewRunner || options.analysisRunner || options.upstreamSyncRunner)
+  };
+}
+var ACTIVE_RUN_STATUSES = new Set(["preparing", "running", "validating", "reviewing"]);
+function rankRunRecency(run) {
+  const updatedAt = Date.parse(run.updatedAt);
+  if (Number.isFinite(updatedAt)) {
+    return updatedAt;
+  }
+  const startedAt = run.startedAt ? Date.parse(run.startedAt) : Number.NaN;
+  if (Number.isFinite(startedAt)) {
+    return startedAt;
+  }
+  return Number.NEGATIVE_INFINITY;
+}
+function visibleActiveRunKey(run) {
+  if (!run.taskId) {
+    return run.runId;
+  }
+  return [
+    run.workspaceId ?? "workspace:unknown",
+    run.taskId,
+    run.worktreePath ?? "worktree:unknown"
+  ].join("::");
+}
+function selectVisibleActiveRuns(runs) {
+  const latestByKey = new Map;
+  for (const run of runs) {
+    if (!ACTIVE_RUN_STATUSES.has(run.status) || run.conflictState === "stale-active") {
+      continue;
+    }
+    const key = visibleActiveRunKey(run);
+    const current = latestByKey.get(key);
+    if (!current || rankRunRecency(run) >= rankRunRecency(current)) {
+      latestByKey.set(key, run);
+    }
+  }
+  return [...latestByKey.values()].sort((left, right) => rankRunRecency(right) - rankRunRecency(left));
+}
+function createGlobalInspectorService(options) {
+  const discoverRuns = options.discoverRuns ?? (() => discoverInspectorRuns({ projectRoot: options.projectRoot }));
+  const now = options.now ?? (() => new Date().toISOString());
+  const pollMs = Math.max(10, options.pollMs ?? 1000);
+  const upstreamSyncMs = options.upstreamSyncMs == null ? 24 * 60 * 60 * 1000 : options.upstreamSyncMs > 0 ? Math.max(1000, options.upstreamSyncMs) : null;
+  const upstreamSyncOnStart = options.upstreamSyncOnStart ?? false;
+  const analysisMs = Math.max(1000, options.analysisMs ?? 60 * 60 * 1000);
+  const capabilitySupport = buildCapabilitySupport(options);
+  const readSnapshot = () => {
+    const activeRuns = selectVisibleActiveRuns(discoverRuns()).map((run) => {
+      const session = normalizeProviderSession(run);
+      return {
+        run,
+        session,
+        capabilities: deriveInspectorCapabilitySet(session, capabilitySupport)
+      };
+    });
+    return {
+      activeRuns,
+      recentFindings: options.journal.listRecentFindings({ limit: 20 }),
+      followups: options.journal.listFollowups(),
+      analysisReports: options.journal.listAnalysisReports(),
+      availableTools: toolRegistry.list()
+    };
+  };
+  const toolRegistry = createInspectorToolRegistry({
+    journal: options.journal,
+    projectRoot: options.projectRoot,
+    discoverRuns,
+    snapshotReader: readSnapshot,
+    reviewRunner: options.reviewRunner,
+    upstreamScanRunner: options.upstreamSyncRunner,
+    analysisRunner: options.analysisRunner,
+    followupTaskRunner: options.followupTaskRunner,
+    capabilitySupport,
+    now
+  });
+  let pollTimer = null;
+  let upstreamTimer = null;
+  let analysisTimer = null;
+  const reconcileOnce = (reason) => {
+    return reconcileInspectorRuns({
+      journal: options.journal,
+      runs: discoverRuns(),
+      reason,
+      now
+    });
+  };
+  return {
+    projectRoot: options.projectRoot,
+    start() {
+      if (pollTimer || upstreamTimer || analysisTimer) {
+        return false;
+      }
+      pollTimer = setInterval(() => {
+        try {
+          reconcileOnce("poll");
+        } catch {}
+      }, pollMs);
+      if (options.upstreamSyncRunner) {
+        if (upstreamSyncOnStart) {
+          Promise.resolve(options.upstreamSyncRunner({ trigger: "startup" })).catch(() => {});
+        }
+        if (upstreamSyncMs !== null) {
+          upstreamTimer = setInterval(() => {
+            Promise.resolve(options.upstreamSyncRunner?.({ trigger: "scheduled" })).catch(() => {});
+          }, upstreamSyncMs);
+        }
+      }
+      if (options.analysisRunner) {
+        analysisTimer = setInterval(() => {
+          Promise.resolve(options.analysisRunner?.({ trigger: "scheduled", reportType: "run-health" })).catch(() => {});
+        }, analysisMs);
+      }
+      return true;
+    },
+    stop() {
+      if (pollTimer)
+        clearInterval(pollTimer);
+      if (upstreamTimer)
+        clearInterval(upstreamTimer);
+      if (analysisTimer)
+        clearInterval(analysisTimer);
+      pollTimer = null;
+      upstreamTimer = null;
+      analysisTimer = null;
+    },
+    isRunning() {
+      return pollTimer !== null || upstreamTimer !== null || analysisTimer !== null;
+    },
+    snapshot() {
+      return readSnapshot();
+    },
+    async invokeTool(name, input) {
+      return toolRegistry.invoke(name, input);
+    },
+    reconcileOnce,
+    async runUpstreamSyncOnce(input = {}) {
+      await options.upstreamSyncRunner?.(input);
+    },
+    async runAnalysisOnce(input = {}) {
+      await options.analysisRunner?.(input);
+    }
+  };
+}
+export {
+  createGlobalInspectorService
+};