@h-rig/server 0.0.6-alpha.0

package/dist/src/inspector/tools.js

@@ -0,0 +1,1592 @@
+// @bun
+// 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/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/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()}`;
+}
+var INSPECTOR_TOOL_DEFINITIONS = [
+  {
+    name: "read_inspector_snapshot",
+    description: "Read the current global inspector snapshot including active runs, recent findings, follow-ups, reports, and available semantic tools.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "discover_active_runs",
+    description: "List currently active Rig runs known to the inspector overlay.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "inspect_run",
+    description: "Inspect one run in detail, including session paths, capabilities, and recent journal observations.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        runId: { type: "string" }
+      },
+      required: ["runId"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "record_inspector_note",
+    description: "Append a durable note to the inspector journal.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        runId: { type: "string" },
+        summary: { type: "string" },
+        details: { type: "object" }
+      },
+      required: ["summary"],
+      additionalProperties: true
+    }
+  },
+  {
+    name: "list_inspector_missions",
+    description: "List durable inspector missions with status, pending effects, posted results, and completion proof state.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "create_inspector_mission",
+    description: "Create a durable inspector-owned mission for a source task contract. The sourceTask is preserved in the mission JSON state.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sourceTask: { type: "object" },
+        owner: { type: "string" },
+        summary: { type: "string" }
+      },
+      required: ["sourceTask"],
+      additionalProperties: true
+    }
+  },
+  {
+    name: "read_inspector_mission",
+    description: "Read a durable inspector mission, including sourceTask, pending effects, posted results, proof, and mission journal.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        missionId: { type: "string" }
+      },
+      required: ["missionId"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "request_inspector_effect",
+    description: "Request a provider-worker effect for an inspector mission. Pending effects gate acceptance until posted.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        missionId: { type: "string" },
+        effectId: { type: "string" },
+        kind: { type: "string" },
+        executor: { type: "string" },
+        summary: { type: "string" },
+        input: { type: "object" }
+      },
+      required: ["missionId", "kind", "executor", "summary"],
+      additionalProperties: true
+    }
+  },
+  {
+    name: "post_inspector_effect_result",
+    description: "Post a provider-worker effect result. Partial, blocked, or failed results block completion proof.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        missionId: { type: "string" },
+        effectId: { type: "string" },
+        status: { type: "string", enum: ["completed", "partial", "blocked", "failed"] },
+        summary: { type: "string" },
+        result: { type: "object" },
+        postedBy: { type: "string" }
+      },
+      required: ["missionId", "effectId", "status", "summary"],
+      additionalProperties: true
+    }
+  },
+  {
+    name: "accept_inspector_mission",
+    description: "Accept a mission closeout and emit completionProof when no pending/blocking effects remain.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        missionId: { type: "string" },
+        acceptedBy: { type: "string" },
+        summary: { type: "string" },
+        evidence: { type: "array", items: { type: "string" } }
+      },
+      required: ["missionId", "summary"],
+      additionalProperties: true
+    }
+  },
+  {
+    name: "reject_inspector_mission",
+    description: "Reject a mission closeout without emitting completionProof.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        missionId: { type: "string" },
+        rejectedBy: { type: "string" },
+        summary: { type: "string" },
+        rationale: { type: "string" }
+      },
+      required: ["missionId", "summary"],
+      additionalProperties: true
+    }
+  },
+  {
+    name: "block_inspector_mission",
+    description: "Mark a mission blocked without emitting completionProof.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        missionId: { type: "string" },
+        blockedBy: { type: "string" },
+        summary: { type: "string" },
+        details: { type: "object" }
+      },
+      required: ["missionId", "summary"],
+      additionalProperties: true
+    }
+  },
+  {
+    name: "complete_inspector_mission",
+    description: "Return the accepted mission completionProof. This fails until the mission has been accepted.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        missionId: { type: "string" }
+      },
+      required: ["missionId"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "create_followup_task",
+    description: "Create or dedupe a structured follow-up task for work the inspector discovered.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        originRunId: { type: "string" },
+        summary: { type: "string" },
+        dedupeKey: { type: "string" },
+        details: { type: "object" }
+      },
+      required: ["summary"],
+      additionalProperties: true
+    }
+  },
+  {
+    name: "provision_skill",
+    description: "Return the role-aware Rig skill set that should be in force for an agent or specialist lane.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        runId: { type: "string" },
+        role: { type: "string" },
+        taskKind: { type: "string" },
+        exception: { type: "object" }
+      },
+      additionalProperties: true
+    }
+  },
+  {
+    name: "run_local_review",
+    description: "Run the local Rig reviewer/validator flow for a task.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        runId: { type: "string" },
+        taskId: { type: "string" },
+        focus: { type: "array", items: { type: "string" } }
+      },
+      required: ["taskId"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "scan_upstream_drift",
+    description: "Run the separate upstream-sync workflow and create follow-up tasks for needed ports.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        scanId: { type: "string" }
+      },
+      additionalProperties: true
+    }
+  },
+  {
+    name: "generate_analysis_report",
+    description: "Generate an inspector analysis report from journaled run and oversight data.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        reportId: { type: "string" },
+        reportType: { type: "string" },
+        runId: { type: "string" }
+      },
+      additionalProperties: true
+    }
+  }
+];
+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);
+    }
+  };
+}
+export {
+  createInspectorToolRegistry,
+  INSPECTOR_TOOL_DEFINITIONS
+};