@h-rig/server 0.0.6-alpha.0

package/dist/src/inspector/mission.js

@@ -0,0 +1,562 @@
+// @bun
+// 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
+      };
+    }
+  };
+}
+export {
+  resolveInspectorMissionPaths,
+  createInspectorMissionController
+};

package/dist/src/inspector/prompt.js

@@ -0,0 +1,97 @@
+// @bun
+// packages/server/src/inspector/prompt.ts
+function renderSkills(skills) {
+  return skills.map((skill) => `- ${skill.name}: ${skill.rationale}`).join(`
+`);
+}
+function stableJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+function compactSnapshot(snapshot) {
+  const recentFindings = Array.isArray(snapshot.recentFindings) ? snapshot.recentFindings.filter((finding) => {
+    const kind = typeof finding.kind === "string" ? finding.kind : "";
+    const severity = typeof finding.severity === "string" ? finding.severity : "";
+    const source = typeof finding.source === "string" ? finding.source : "";
+    if (source === "inspector-agent") {
+      return false;
+    }
+    return kind !== "run.observed" || severity === "warn" || severity === "error";
+  }) : [];
+  return {
+    activeRuns: snapshot.activeRuns ?? [],
+    recentFindings,
+    followups: snapshot.followups ?? [],
+    analysisReports: snapshot.analysisReports ?? [],
+    availableTools: snapshot.availableTools ?? []
+  };
+}
+function buildInspectorBaseInstructions(options) {
+  return [
+    "You are Rig Global Inspector, the permanent supervisor for this workspace.",
+    "You operate as an out-of-band overlay around Rig execution, not inside the worker execution flow.",
+    "The lower runtime and provider layers are inspector-blind. Keep them that way.",
+    "App-server turns are transport boundaries only. They are not your operating model.",
+    "Stay broad, autonomous, and continuous in your judgment. Use turns only as a way to receive updates and emit progress.",
+    "Use full contextual judgment. There is no fixed intervention ladder.",
+    "You may patch task code or Rig itself, interrupt runs, relaunch runs, create follow-up tasks, run reviews, and improve the harness when confidence is high.",
+    "Be decisive, but stay surgical. Prefer the smallest action that materially improves the current situation.",
+    "Stay aware of all observable runs, the harness state, upstream drift tasks, and repeated failure patterns.",
+    "Document important findings and decisions through the inspector journal tools so the system retains a durable memory of what happened.",
+    "Treat TDD as the default for code and behavior changes unless a narrow recorded exception applies.",
+    "Before landing meaningful implementation work, run local review or another verification path that produces direct evidence.",
+    "When a human is not needed, do not wait. When a human is needed, create the right follow-up or journal note instead of stalling silently.",
+    "",
+    `Project root: ${options.projectRoot}`,
+    "",
+    "Required skills:",
+    renderSkills(options.requiredSkills),
+    "",
+    "Recommended skills:",
+    renderSkills(options.recommendedSkills)
+  ].join(`
+`);
+}
+function buildInspectorDeveloperInstructions(options) {
+  return [
+    "Operate pragmatically and keep momentum.",
+    "Use the native Codex capabilities and the semantic inspector tools together.",
+    "You are free to inspect, edit, test, relaunch, review, and continue as far as the current situation warrants.",
+    "Yield when you reach a useful checkpoint, need fresher external state, or detect that continued looping would be wasteful.",
+    "Prefer semantic inspector tools for journal, follow-up task, upstream-sync, review, and run-inspection operations.",
+    "Use shell, read, write, edit, and git directly when that is the fastest reliable way to diagnose or repair the system.",
+    "When you create or modify code, keep the red-green-refactor discipline visible in your reasoning and actions.",
+    "Before claiming something is fixed, verify it directly.",
+    "Spawn specialist child agents when parallel work is useful, but remain the full-context owner and take over when they are not doing the job well enough.",
+    "You are responsible both for task oversight and for Rig self-improvement when a clear win-win fix is available.",
+    "",
+    `Workspace root: ${options.projectRoot}`,
+    "",
+    "Skill catalog in scope:",
+    renderSkills([...options.requiredSkills, ...options.recommendedSkills])
+  ].join(`
+`);
+}
+function buildInspectorTurnPrompt(options) {
+  const compact = compactSnapshot(options.snapshot);
+  return [
+    "Rig inspector update.",
+    `reason: ${options.reason}`,
+    `timestamp: ${options.now}`,
+    "Review the current state and use broad judgment about whether intervention is warranted.",
+    "You may take multiple actions inside this turn if that is the most effective way to improve the situation.",
+    "Do not become noisy or repetitive when nothing material changed.",
+    "When you reach a useful checkpoint, emit one compact operator update in this form:",
+    "STATUS: <observed|acted|escalated|waiting>",
+    "NOTE: <one or two concise sentences>",
+    "Then yield so the server can deliver the next update when needed.",
+    "",
+    "Current snapshot:",
+    stableJson(compact)
+  ].join(`
+`);
+}
+export {
+  buildInspectorTurnPrompt,
+  buildInspectorDeveloperInstructions,
+  buildInspectorBaseInstructions
+};