@ycodium-ai/plugin-redteam-model 0.0.0-stage → 0.2.2942

package/dist/index.js

@@ -0,0 +1,1041 @@
+// src/index.ts
+import { definePlugin } from "@ycodium-ai/plugin-api";
+
+// src/catalog.ts
+var PLUGIN_ID = "redteam-model";
+var PHASES = ["authorization", "scope", "evidence", "report"];
+var MODES = [
+  { id: "redteam", group: "general" },
+  { id: "pentest", group: "professional" },
+  { id: "code-audit", group: "professional" },
+  { id: "binary-analysis", group: "professional" },
+  { id: "attack-defense", group: "professional" },
+  { id: "av-evasion", group: "professional" },
+  { id: "incident-response", group: "professional" },
+  { id: "cloud-security", group: "professional" },
+  { id: "ctf-solver", group: "professional" },
+  { id: "asset-mapping", group: "professional" }
+];
+var MODE_COPY = {
+  redteam: {
+    displayName: "Researcher",
+    detail: "General session. Gates are optional."
+  },
+  pentest: {
+    displayName: "Assessment",
+    detail: "Authorized review with the four gates required."
+  },
+  "code-audit": {
+    displayName: "Code review",
+    detail: "Source review with the four gates required."
+  },
+  "binary-analysis": {
+    displayName: "Binary review",
+    detail: "Binary review with the four gates required."
+  },
+  "attack-defense": {
+    displayName: "Exercise",
+    detail: "Authorized exercise with the four gates required."
+  },
+  "av-evasion": {
+    displayName: "Detection review",
+    detail: "Detection review. No evasion steps, payloads, or refusal bypass."
+  },
+  "incident-response": {
+    displayName: "Incident review",
+    detail: "Incident review with the four gates required."
+  },
+  "cloud-security": {
+    displayName: "Cloud review",
+    detail: "Cloud review with the four gates required."
+  },
+  "ctf-solver": {
+    displayName: "Puzzle workspace",
+    detail: "Puzzle workspace with the four gates required."
+  },
+  "asset-mapping": {
+    displayName: "Asset inventory",
+    detail: "Inventory workflow with the four gates required."
+  }
+};
+function modeById(id) {
+  const row = MODES.find((mode) => mode.id === id);
+  if (row === void 0) return null;
+  const copy = MODE_COPY[row.id];
+  return { id: row.id, group: row.group, ...copy };
+}
+function listModes() {
+  return MODES.map((mode) => modeById(mode.id)).filter((mode) => mode !== null);
+}
+var MODULES = [
+  { id: "stage-gate", plane: "host", availability: "active" },
+  { id: "route-boost", plane: "host", availability: "active" },
+  { id: "sec-enforce", plane: "host", availability: "active" },
+  { id: "refusal-guard", plane: "host", availability: "withheld" },
+  { id: "trace-vault", plane: "host", availability: "active" },
+  { id: "auto-advance", plane: "host", availability: "active" },
+  { id: "product-subagents", plane: "host", availability: "withheld" },
+  { id: "mcp-studio", plane: "host", availability: "record" },
+  { id: "results", plane: "host", availability: "active" },
+  { id: "hunter", plane: "host", availability: "withheld" },
+  { id: "campaign-memory", plane: "host", availability: "active" },
+  { id: "mode-group", plane: "host", availability: "active" },
+  { id: "session-pulse", plane: "host", availability: "active" },
+  { id: "coverage", plane: "host", availability: "active" },
+  { id: "scanner-tools", plane: "preset", availability: "withheld" },
+  { id: "semgrep-audit", plane: "preset", availability: "withheld" },
+  { id: "shell-desk", plane: "host", availability: "withheld" }
+];
+function moduleById(id) {
+  return MODULES.find((module) => module.id === id) ?? null;
+}
+var PROJECTION_NAME = "board";
+var WIRE = {
+  gates: `${PLUGIN_ID}_gates_list`,
+  goal: `${PLUGIN_ID}_operation_goal`,
+  progress: `${PLUGIN_ID}_operation_progress`,
+  publish: `${PLUGIN_ID}_publish`,
+  probe: `${PLUGIN_ID}_probe`,
+  note: `${PLUGIN_ID}_ledger_note`
+};
+var REMINDER_TEXT = "Continue the open workflow gates: authorization, scope, evidence, and report. If authorization is not recorded, stop and ask for it.";
+
+// src/model.ts
+var MAX_OPERATIONS = 50;
+var MAX_DENIALS = 12;
+var MAX_NOTES = 20;
+var MAX_TEXT = 500;
+function emptyModules() {
+  return Object.fromEntries(MODULES.map((module) => [module.id, "absent"]));
+}
+function emptyManager() {
+  return {
+    version: 1,
+    deployed: false,
+    modules: emptyModules(),
+    operations: [],
+    probeDenial: true,
+    lastDenial: null,
+    packageName: "",
+    directoryPath: "",
+    uninstallId: ""
+  };
+}
+function emptySession(modeId = null) {
+  return {
+    modeId,
+    phase: "authorization",
+    goal: "",
+    done: 0,
+    total: PHASES.length,
+    reportOpen: false,
+    authorizationRecorded: false,
+    denials: [],
+    notes: []
+  };
+}
+function clip(value) {
+  const text2 = value.trim();
+  return text2.length > MAX_TEXT ? text2.slice(0, MAX_TEXT) : text2;
+}
+function settleInterrupted(state, at) {
+  if (!state.operations.some((operation) => operation.status === "running")) return state;
+  return {
+    ...state,
+    operations: state.operations.map(
+      (operation) => operation.status === "running" ? { ...operation, status: "failed", detail: "interrupted", at } : operation
+    )
+  };
+}
+function push(state, record) {
+  return { ...state, operations: [record, ...state.operations].slice(0, MAX_OPERATIONS) };
+}
+function finishOperation(state, id, status, detail) {
+  return {
+    ...state,
+    operations: state.operations.map(
+      (operation) => operation.id === id ? { ...operation, status, detail: clip(detail) } : operation
+    )
+  };
+}
+function beginOperation(state, record) {
+  return push(state, record);
+}
+function setDeployed(state, deployed) {
+  return { ...state, deployed };
+}
+function installModule(state, id) {
+  const module = moduleById(id);
+  if (module === null) return { state, error: "unknown-module" };
+  if (module.availability === "withheld") return { state, error: "withheld" };
+  return {
+    state: { ...state, modules: { ...state.modules, [module.id]: "installed" } },
+    error: null
+  };
+}
+function updateModule(state, id) {
+  if (state.modules[id] !== "installed") return { state, error: "not-installed" };
+  return installModule(state, id);
+}
+function uninstallModule(state, id) {
+  if (moduleById(id) === null) return { state, error: "unknown-module" };
+  return { state: { ...state, modules: { ...state.modules, [id]: "absent" } }, error: null };
+}
+function installActiveModules(state) {
+  const modules = { ...state.modules };
+  const withheld = [];
+  for (const module of MODULES) {
+    if (module.availability === "withheld") {
+      withheld.push(module.id);
+      continue;
+    }
+    modules[module.id] = "installed";
+  }
+  const detail = withheld.length === 0 ? "installed" : `withheld:${withheld.join(",")}`;
+  return { state: { ...state, modules }, detail };
+}
+function toBoard(state) {
+  return {
+    deployed: state.deployed,
+    probeDenial: state.probeDenial,
+    packageName: state.packageName,
+    directoryPath: state.directoryPath,
+    uninstallId: state.uninstallId,
+    lastDenial: state.lastDenial,
+    operations: state.operations,
+    modules: MODULES.map((module) => ({
+      id: module.id,
+      plane: module.plane,
+      availability: module.availability,
+      installed: state.modules[module.id] === "installed"
+    })),
+    modes: listModes()
+  };
+}
+function rememberDenial(state, denial) {
+  return { ...state, lastDenial: denial };
+}
+function patchManagerFields(state, patch) {
+  return {
+    ...state,
+    ...patch.probeDenial === void 0 ? {} : { probeDenial: patch.probeDenial },
+    ...patch.packageName === void 0 ? {} : { packageName: clip(patch.packageName) },
+    ...patch.directoryPath === void 0 ? {} : { directoryPath: clip(patch.directoryPath) },
+    ...patch.uninstallId === void 0 ? {} : { uninstallId: clip(patch.uninstallId) }
+  };
+}
+function isPhase(value) {
+  return PHASES.includes(value);
+}
+function withMode(session, modeId) {
+  return session.modeId === modeId ? session : { ...session, modeId };
+}
+function setPhase(session, phase) {
+  const index = PHASES.indexOf(phase);
+  const done = phase === "report" && session.reportOpen ? PHASES.length : index;
+  return { ...session, phase, done, total: Math.max(session.total, PHASES.length) };
+}
+function setGoal(session, goal) {
+  return { ...session, goal: clip(goal) };
+}
+function setProgress(session, done, total) {
+  const safeTotal = Number.isFinite(total) ? Math.max(0, Math.min(999, Math.trunc(total))) : session.total;
+  const safeDone = Number.isFinite(done) ? Math.max(0, Math.min(safeTotal, Math.trunc(done))) : session.done;
+  return { ...session, done: safeDone, total: safeTotal };
+}
+function recordAuthorization(session) {
+  return { ...session, authorizationRecorded: true };
+}
+function openReport(session) {
+  if (!session.authorizationRecorded) return { session, error: "authorization-missing" };
+  return {
+    session: {
+      ...session,
+      reportOpen: true,
+      phase: "report",
+      done: Math.max(session.done, session.total)
+    },
+    error: null
+  };
+}
+function pushDenial(session, denial) {
+  return { ...session, denials: [denial, ...session.denials].slice(0, MAX_DENIALS) };
+}
+function pushNote(session, note) {
+  const text2 = clip(note);
+  if (text2.length === 0) return session;
+  return { ...session, notes: [text2, ...session.notes].slice(0, MAX_NOTES) };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readFlag(value) {
+  return value === "installed" ? "installed" : "absent";
+}
+function parseManager(value) {
+  if (!isRecord(value)) return emptyManager();
+  const modules = emptyModules();
+  if (isRecord(value["modules"])) {
+    for (const module of MODULES) modules[module.id] = readFlag(value["modules"][module.id]);
+  }
+  const operations = Array.isArray(value["operations"]) ? value["operations"].flatMap((entry) => {
+    if (!isRecord(entry)) return [];
+    const status = entry["status"];
+    if (status !== "running" && status !== "succeeded" && status !== "failed") return [];
+    if (typeof entry["id"] !== "string" || typeof entry["kind"] !== "string") return [];
+    return [
+      {
+        id: entry["id"],
+        kind: entry["kind"],
+        status,
+        detail: typeof entry["detail"] === "string" ? entry["detail"] : "",
+        at: typeof entry["at"] === "string" ? entry["at"] : ""
+      }
+    ];
+  }) : [];
+  const base = emptyManager();
+  return {
+    ...base,
+    deployed: value["deployed"] === true,
+    modules,
+    operations: operations.slice(0, MAX_OPERATIONS),
+    probeDenial: value["probeDenial"] !== false,
+    lastDenial: parseDenial(value["lastDenial"]),
+    packageName: typeof value["packageName"] === "string" ? value["packageName"] : "",
+    directoryPath: typeof value["directoryPath"] === "string" ? value["directoryPath"] : "",
+    uninstallId: typeof value["uninstallId"] === "string" ? value["uninstallId"] : ""
+  };
+}
+function parseDenial(value) {
+  if (!isRecord(value)) return null;
+  if (typeof value["tool"] !== "string" || typeof value["reason"] !== "string") return null;
+  return {
+    tool: value["tool"],
+    code: typeof value["code"] === "string" ? value["code"] : "denied",
+    reason: value["reason"],
+    at: typeof value["at"] === "string" ? value["at"] : ""
+  };
+}
+function parseSession(value) {
+  if (!isRecord(value)) return emptySession();
+  const phase = typeof value["phase"] === "string" && isPhase(value["phase"]) ? value["phase"] : "authorization";
+  const denials = Array.isArray(value["denials"]) ? value["denials"].flatMap((entry) => {
+    const denial = parseDenial(entry);
+    return denial === null ? [] : [denial];
+  }) : [];
+  const notes = Array.isArray(value["notes"]) ? value["notes"].filter((entry) => typeof entry === "string").slice(0, MAX_NOTES) : [];
+  return {
+    modeId: typeof value["modeId"] === "string" ? value["modeId"] : null,
+    phase,
+    goal: typeof value["goal"] === "string" ? value["goal"] : "",
+    done: typeof value["done"] === "number" ? value["done"] : 0,
+    total: typeof value["total"] === "number" ? value["total"] : PHASES.length,
+    reportOpen: value["reportOpen"] === true,
+    authorizationRecorded: value["authorizationRecorded"] === true,
+    denials: denials.slice(0, MAX_DENIALS),
+    notes
+  };
+}
+
+// src/commands.ts
+var objectSchema = { type: "object", properties: {} };
+function readString(value) {
+  return typeof value === "string" ? value : "";
+}
+function registerCommands(ctx, runtime) {
+  const emit = /* @__PURE__ */ new Set();
+  const bump = () => {
+    for (const listener of emit) listener();
+  };
+  runtime.subscribe(bump);
+  ctx.command({
+    name: "state.get",
+    description: "Read the mode manager board.",
+    scope: "read",
+    payloadSchema: objectSchema,
+    handle: async () => ({ board: await runtime.board() })
+  });
+  ctx.command({
+    name: "session.get",
+    description: "Read one session's gates, denials, and notes.",
+    scope: "read",
+    payloadSchema: {
+      type: "object",
+      properties: { threadId: { type: "string" } }
+    },
+    handle: async (payload) => ({
+      session: await runtime.readSession(readString(payload["threadId"]) || null)
+    })
+  });
+  ctx.stream({
+    name: "live",
+    description: "Follow the mode manager board.",
+    scope: "read",
+    buffer: { latest: 1 },
+    payloadSchema: objectSchema,
+    handle: async (_payload, send, signal) => {
+      const push2 = async () => {
+        send({ board: await runtime.board() });
+      };
+      await push2();
+      const listener = () => {
+        void push2();
+      };
+      emit.add(listener);
+      try {
+        await new Promise((resolve) => {
+          signal.addEventListener("abort", () => resolve(), { once: true });
+        });
+      } finally {
+        emit.delete(listener);
+      }
+    }
+  });
+  ctx.command({
+    name: "deploy",
+    description: "Register the ten mode presets.",
+    scope: "operate",
+    payloadSchema: objectSchema,
+    handle: async () => {
+      const board = await runtime.deploy();
+      bump();
+      return { board };
+    }
+  });
+  ctx.command({
+    name: "remove",
+    description: "Unregister the mode presets.",
+    scope: "operate",
+    payloadSchema: objectSchema,
+    handle: async () => ({ board: await runtime.removeModes() })
+  });
+  ctx.command({
+    name: "module.install",
+    description: "Install one runtime module. Withheld modules fail.",
+    scope: "operate",
+    payloadSchema: {
+      type: "object",
+      properties: { id: { type: "string" } },
+      required: ["id"]
+    },
+    handle: async (payload) => ({ board: await runtime.install(readString(payload["id"])) })
+  });
+  ctx.command({
+    name: "module.update",
+    description: "Update one installed module.",
+    scope: "operate",
+    payloadSchema: {
+      type: "object",
+      properties: { id: { type: "string" } },
+      required: ["id"]
+    },
+    handle: async (payload) => ({ board: await runtime.update(readString(payload["id"])) })
+  });
+  ctx.command({
+    name: "module.uninstall",
+    description: "Mark one runtime module absent.",
+    scope: "operate",
+    payloadSchema: {
+      type: "object",
+      properties: { id: { type: "string" } },
+      required: ["id"]
+    },
+    handle: async (payload) => ({ board: await runtime.uninstall(readString(payload["id"])) })
+  });
+  ctx.command({
+    name: "repair",
+    description: "Install every module this package is allowed to run.",
+    scope: "operate",
+    payloadSchema: objectSchema,
+    handle: async () => ({ board: await runtime.repair() })
+  });
+  ctx.command({
+    name: "fields.set",
+    description: "Store the probe hold and the package install fields.",
+    scope: "operate",
+    payloadSchema: {
+      type: "object",
+      properties: {
+        probeDenial: { type: "boolean" },
+        packageName: { type: "string" },
+        directoryPath: { type: "string" },
+        uninstallId: { type: "string" }
+      }
+    },
+    handle: async (payload) => ({
+      board: await runtime.setFields({
+        ...typeof payload["probeDenial"] === "boolean" ? { probeDenial: payload["probeDenial"] } : {},
+        ...typeof payload["packageName"] === "string" ? { packageName: payload["packageName"] } : {},
+        ...typeof payload["directoryPath"] === "string" ? { directoryPath: payload["directoryPath"] } : {},
+        ...typeof payload["uninstallId"] === "string" ? { uninstallId: payload["uninstallId"] } : {}
+      })
+    })
+  });
+  ctx.command({
+    name: "authorization.record",
+    description: "Record that authorization was captured for this session.",
+    scope: "operate",
+    payloadSchema: {
+      type: "object",
+      properties: { threadId: { type: "string" } },
+      required: ["threadId"]
+    },
+    handle: async (payload) => ({
+      session: await runtime.markAuthorization(readString(payload["threadId"]))
+    })
+  });
+  ctx.command({
+    name: "report.open",
+    description: "Open the report gate after authorization is recorded.",
+    scope: "operate",
+    payloadSchema: {
+      type: "object",
+      properties: { threadId: { type: "string" } },
+      required: ["threadId"]
+    },
+    handle: async (payload) => runtime.markReport(readString(payload["threadId"]))
+  });
+  ctx.command({
+    name: "phase.set",
+    description: "Move the session phase rail.",
+    scope: "operate",
+    payloadSchema: {
+      type: "object",
+      properties: { threadId: { type: "string" }, phase: { type: "string" } },
+      required: ["threadId", "phase"]
+    },
+    handle: async (payload) => {
+      const phase = readString(payload["phase"]);
+      return {
+        session: await runtime.markPhase(
+          readString(payload["threadId"]),
+          isPhase(phase) ? phase : ""
+        )
+      };
+    }
+  });
+  ctx.command({
+    name: "reminder",
+    description: "Send the gate reminder as a user turn. Requires the auto-advance module.",
+    scope: "operate",
+    payloadSchema: {
+      type: "object",
+      properties: { threadId: { type: "string" } },
+      required: ["threadId"]
+    },
+    handle: async (payload) => runtime.remind(readString(payload["threadId"]))
+  });
+}
+
+// src/runtime.ts
+import * as NodeCrypto from "node:crypto";
+
+// src/guard.ts
+var PROBE_REASON = "Probe is held by the mode manager. Turn the hold off to let this harmless call run.";
+var REPORT_REASON = "The report gate is closed. Record authorization and open the report gate before publishing.";
+var PATH_REASON = "The report gate is closed for paths under reports/.";
+function guardDecision(input) {
+  if (modeById(input.session.modeId) === null) return { decision: "allow" };
+  if (input.manager.probeDenial && isNamed(input.name, "probe", WIRE.probe)) {
+    return { decision: "deny", reason: PROBE_REASON, code: "probe-held" };
+  }
+  const mode = modeById(input.session.modeId);
+  const enforced = input.manager.modules["sec-enforce"] === "installed" && mode?.group === "professional";
+  if (!enforced || input.session.reportOpen) return { decision: "allow" };
+  if (isNamed(input.name, "publish", WIRE.publish)) {
+    return { decision: "deny", reason: REPORT_REASON, code: "report-closed" };
+  }
+  if (mentionsReportPath(input.args)) {
+    return { decision: "deny", reason: PATH_REASON, code: "report-path" };
+  }
+  return { decision: "allow" };
+}
+function isNamed(name, short, wire) {
+  return name === short || name === wire;
+}
+function mentionsReportPath(value) {
+  if (typeof value === "string") {
+    const text2 = value.trim();
+    return text2 === "reports" || text2.startsWith("reports/") || text2.startsWith("reports\\");
+  }
+  if (Array.isArray(value)) return value.some((entry) => mentionsReportPath(entry));
+  if (typeof value === "object" && value !== null) {
+    return Object.values(value).some((entry) => entry !== void 0 && mentionsReportPath(entry));
+  }
+  return false;
+}
+
+// src/prompt.ts
+var SECTION_TEXT = "Mode manager is active. A session without one of its presets gets no mode envelope. Model connection stays on the executor. Gates, when a preset is selected, are authorization, scope, evidence, and report.";
+function prefixFor(mode) {
+  const hold = mode.id === "av-evasion" ? " This preset does not include evasion steps, payloads, or refusal bypass." : "";
+  return `Mode ${mode.id} (${mode.displayName}, ${mode.group}). Follow authorization, scope, evidence, and report. Do not treat the preset as permission.${hold}`;
+}
+function sessionPrompt(session, routeBoost) {
+  if (modeById(session.modeId) === null) return null;
+  const envelope = envelopeFor(session, routeBoost);
+  return envelope === null ? SECTION_TEXT : `${SECTION_TEXT}
+${envelope}`;
+}
+function envelopeFor(session, routeBoost) {
+  if (!routeBoost) return null;
+  const mode = modeById(session.modeId);
+  if (mode === null) return null;
+  const report = session.reportOpen ? "open" : "closed";
+  return `[mode-manager] mode=${mode.id} group=${mode.group} phase=${session.phase} gates=authorization,scope,evidence,report report=${report} done=${session.done}/${session.total}`;
+}
+
+// src/store.ts
+import * as NodeFSP from "node:fs/promises";
+import * as NodePath from "node:path";
+function emptySnapshot(at) {
+  return { manager: settleInterrupted(emptyManager(), at), sessions: {}, modes: {} };
+}
+function parseSnapshot(value, at) {
+  if (typeof value !== "object" || value === null) return emptySnapshot(at);
+  const record = value;
+  const sessions = {};
+  if (typeof record["sessions"] === "object" && record["sessions"] !== null) {
+    for (const [id, session] of Object.entries(record["sessions"])) {
+      sessions[id] = parseSession(session);
+    }
+  }
+  const modes = {};
+  if (typeof record["modes"] === "object" && record["modes"] !== null) {
+    for (const [id, mode] of Object.entries(record["modes"])) {
+      modes[id] = typeof mode === "string" ? mode : null;
+    }
+  }
+  return {
+    manager: settleInterrupted(parseManager(record["manager"]), at),
+    sessions,
+    modes
+  };
+}
+function openManagerDisk(dataDir, now = () => (/* @__PURE__ */ new Date()).toISOString()) {
+  const file = NodePath.join(dataDir, "manager.json");
+  let chain = Promise.resolve();
+  const read = async () => {
+    try {
+      const raw = await NodeFSP.readFile(file, "utf8");
+      return parseSnapshot(JSON.parse(raw), now());
+    } catch {
+      return emptySnapshot(now());
+    }
+  };
+  return {
+    read,
+    update: (change) => {
+      const run = chain.then(async () => {
+        const current = await read();
+        const next = change(current);
+        await NodeFSP.mkdir(dataDir, { recursive: true });
+        const temporary = `${file}.${process.pid}.tmp`;
+        await NodeFSP.writeFile(temporary, JSON.stringify(next), "utf8");
+        await NodeFSP.rename(temporary, file);
+        return next;
+      });
+      chain = run.then(
+        () => void 0,
+        () => void 0
+      );
+      return run;
+    }
+  };
+}
+
+// src/runtime.ts
+function sessionValue(session) {
+  return {
+    modeId: session.modeId,
+    phase: session.phase,
+    goal: session.goal,
+    done: session.done,
+    total: session.total,
+    reportOpen: session.reportOpen,
+    authorizationRecorded: session.authorizationRecorded,
+    denials: session.denials.map((denial) => ({ ...denial })),
+    notes: [...session.notes]
+  };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function openRuntime(ctx, now = () => (/* @__PURE__ */ new Date()).toISOString()) {
+  const disk = openManagerDisk(ctx.paths.dataDir, now);
+  let current = { manager: emptyManager(), sessions: {}, modes: {} };
+  let presetDisposers = [];
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const listener of listeners) listener();
+  };
+  const syncPresets = (deployed) => {
+    for (const dispose of presetDisposers) dispose();
+    presetDisposers = [];
+    if (!deployed) return [];
+    const skipped = [];
+    for (const mode of listModes()) {
+      try {
+        presetDisposers.push(
+          ctx.agentPresets.register({
+            id: mode.id,
+            displayName: mode.displayName,
+            description: mode.detail,
+            promptPrefix: prefixFor(mode)
+          })
+        );
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "";
+        if (!message.includes("already registered")) throw error;
+        skipped.push(mode.id);
+      }
+    }
+    return skipped;
+  };
+  const project = async (threadId, session) => {
+    await ctx.sessionProjections.set({
+      name: PROJECTION_NAME,
+      threadId,
+      value: sessionValue(session)
+    });
+  };
+  const ready = (async () => {
+    const snap = await disk.read();
+    current = await disk.update(() => snap);
+    syncPresets(current.manager.deployed);
+    notify();
+  })();
+  const update = async (change) => {
+    await ready;
+    current = await disk.update(change);
+    notify();
+    return current;
+  };
+  const sessionFor = (threadId) => {
+    if (threadId === null || threadId.length === 0) return emptySession();
+    return current.sessions[threadId] ?? emptySession(current.modes[threadId] ?? null);
+  };
+  const saveSession = async (threadId, session) => {
+    await update((snap) => ({ ...snap, sessions: { ...snap.sessions, [threadId]: session } }));
+    await project(threadId, session);
+  };
+  const logged = async (kind, patch) => {
+    const id = NodeCrypto.randomUUID();
+    const at = now();
+    await update((snap) => ({
+      ...snap,
+      manager: beginOperation(snap.manager, { id, kind, status: "running", detail: "", at })
+    }));
+    try {
+      await update((snap) => {
+        const result = patch(snap.manager);
+        return {
+          ...snap,
+          manager: finishOperation(
+            result.state,
+            id,
+            result.error === null ? "succeeded" : "failed",
+            result.error ?? result.detail ?? "ok"
+          )
+        };
+      });
+      const finished = current.manager.operations.find((operation) => operation.id === id);
+      const skipped = syncPresets(current.manager.deployed);
+      if (skipped.length > 0 && finished?.status === "succeeded") {
+        await update((snap) => ({
+          ...snap,
+          manager: finishOperation(
+            snap.manager,
+            id,
+            "succeeded",
+            `deployed; skipped ${skipped.join(",")}`
+          )
+        }));
+      }
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : "failed";
+      await update((snap) => ({
+        ...snap,
+        manager: finishOperation(snap.manager, id, "failed", detail)
+      }));
+    }
+    return toBoard(current.manager);
+  };
+  const runtime = {
+    ready: () => ready,
+    moduleInstalled: (id) => current.manager.modules[id] === "installed",
+    sessionFor,
+    save: async (threadId, session) => {
+      if (threadId === null || threadId.length === 0) return;
+      await saveSession(threadId, session);
+    },
+    board: async () => {
+      await ready;
+      return toBoard(current.manager);
+    },
+    readSession: async (threadId) => {
+      await ready;
+      return sessionFor(threadId);
+    },
+    contextFor: async (threadId) => {
+      await ready;
+      return sessionPrompt(
+        sessionFor(threadId),
+        current.manager.modules["route-boost"] === "installed"
+      );
+    },
+    guard: async (input) => {
+      await ready;
+      const outcome = guardDecision({
+        name: input.name,
+        args: input.args,
+        manager: current.manager,
+        session: sessionFor(input.threadId)
+      });
+      if (outcome.decision === "allow") return { decision: "allow" };
+      const denial = {
+        tool: input.name,
+        code: outcome.code ?? "denied",
+        reason: outcome.reason,
+        at: now()
+      };
+      const threadId = input.threadId;
+      await update((snap) => {
+        const next = threadId === null || threadId.length === 0 ? null : pushDenial(
+          snap.sessions[threadId] ?? emptySession(snap.modes[threadId] ?? null),
+          denial
+        );
+        return {
+          ...snap,
+          manager: rememberDenial(snap.manager, denial),
+          sessions: next === null || threadId === null ? snap.sessions : { ...snap.sessions, [threadId]: next }
+        };
+      });
+      if (threadId !== null && threadId.length > 0 && current.sessions[threadId] !== void 0) {
+        await project(threadId, current.sessions[threadId]);
+      }
+      return { decision: "deny", reason: outcome.reason };
+    },
+    rememberCreated: async (event) => {
+      if (event.type !== "thread.created" || event.aggregateId.length === 0) return;
+      const payload = isRecord2(event.payload) ? event.payload : {};
+      const raw = payload["presetId"];
+      const presetId = typeof raw === "string" && modeById(raw) !== null ? raw : null;
+      const threadId = event.aggregateId;
+      await update((snap) => ({
+        ...snap,
+        modes: { ...snap.modes, [threadId]: presetId },
+        sessions: {
+          ...snap.sessions,
+          [threadId]: withMode(snap.sessions[threadId] ?? emptySession(presetId), presetId)
+        }
+      }));
+      const saved = current.sessions[threadId];
+      if (saved !== void 0) await project(threadId, saved);
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    deploy: () => logged("deploy-modes", (manager) => ({
+      state: setDeployed(manager, true),
+      error: null,
+      detail: "deployed"
+    })),
+    removeModes: () => logged("remove-modes", (manager) => ({
+      state: setDeployed(manager, false),
+      error: null,
+      detail: "removed"
+    })),
+    install: (id) => logged("install", (manager) => installModule(manager, id)),
+    update: (id) => logged("update", (manager) => updateModule(manager, id)),
+    uninstall: (id) => logged("uninstall", (manager) => uninstallModule(manager, id)),
+    repair: () => logged("repair", (manager) => {
+      const repaired = installActiveModules(manager);
+      return { state: repaired.state, error: null, detail: repaired.detail };
+    }),
+    setFields: async (patch) => {
+      await update((snap) => ({ ...snap, manager: patchManagerFields(snap.manager, patch) }));
+      return toBoard(current.manager);
+    },
+    markAuthorization: async (threadId) => {
+      await ready;
+      const session = recordAuthorization(sessionFor(threadId));
+      if (threadId.length > 0) await saveSession(threadId, session);
+      return session;
+    },
+    markReport: async (threadId) => {
+      await ready;
+      const opened = openReport(sessionFor(threadId));
+      if (opened.error === null && threadId.length > 0) await saveSession(threadId, opened.session);
+      return opened;
+    },
+    markPhase: async (threadId, phase) => {
+      await ready;
+      const session = sessionFor(threadId);
+      if (phase !== "authorization" && phase !== "scope" && phase !== "evidence" && phase !== "report") {
+        return session;
+      }
+      const next = setPhase(session, phase);
+      if (threadId.length > 0) await saveSession(threadId, next);
+      return next;
+    },
+    remind: async (threadId) => {
+      await ready;
+      if (current.manager.modules["auto-advance"] !== "installed") {
+        return { ok: false, error: "auto-advance is not installed" };
+      }
+      if (threadId.length === 0) return { ok: false, error: "thread-missing" };
+      const execution = await ctx.projections.getThreadExecution(threadId);
+      if (execution === null) return { ok: false, error: "thread-missing" };
+      await ctx.commands.dispatch(reminderCommand(threadId, execution, now()));
+      return { ok: true };
+    }
+  };
+  return runtime;
+}
+function reminderCommand(threadId, execution, at) {
+  return {
+    type: "thread.turn.start",
+    commandId: NodeCrypto.randomUUID(),
+    threadId,
+    message: {
+      messageId: NodeCrypto.randomUUID(),
+      role: "user",
+      text: REMINDER_TEXT,
+      attachments: []
+    },
+    runtimeMode: execution.runtimeMode,
+    interactionMode: execution.interactionMode,
+    createdAt: at,
+    ...execution.modelSelection == null ? {} : { modelSelection: execution.modelSelection }
+  };
+}
+
+// src/tools.ts
+var objectSchema2 = (properties, required = []) => ({
+  type: "object",
+  properties,
+  ...required.length === 0 ? {} : { required: [...required] }
+});
+function text(value, isError = false) {
+  return isError ? { text: value, isError: true } : { text: value };
+}
+function readString2(value) {
+  return typeof value === "string" ? value : "";
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : Number.NaN;
+}
+function createTools(host) {
+  return [
+    {
+      name: "gates_list",
+      description: "List the four workflow gates for the selected mode: authorization, scope, evidence, and report. Does not describe a procedure.",
+      inputSchema: objectSchema2({}),
+      handle: async (_input, invocation) => {
+        await host.ready();
+        if (!host.moduleInstalled("stage-gate")) return text("stage-gate is not installed.", true);
+        const session = host.sessionFor(invocation.threadId);
+        const mode = modeById(session.modeId);
+        const forced = mode?.group === "professional";
+        return text(
+          `mode=${mode?.id ?? "none"} forced=${forced ? "yes" : "no"} gates=${PHASES.join(",")} phase=${session.phase}`
+        );
+      }
+    },
+    {
+      name: "operation_goal",
+      description: "Store a short goal for this session. The text is a label, not a procedure.",
+      inputSchema: objectSchema2({ goal: { type: "string", description: "Short goal label." } }, [
+        "goal"
+      ]),
+      handle: async (input, invocation) => {
+        await host.ready();
+        if (!host.moduleInstalled("results")) return text("results is not installed.", true);
+        const session = setGoal(host.sessionFor(invocation.threadId), readString2(input["goal"]));
+        await host.save(invocation.threadId, session);
+        return text(`goal=${session.goal}`);
+      }
+    },
+    {
+      name: "operation_progress",
+      description: "Store done and total counts for the session progress chip.",
+      inputSchema: objectSchema2(
+        {
+          done: { type: "number", description: "Completed count." },
+          total: { type: "number", description: "Total count." }
+        },
+        ["done", "total"]
+      ),
+      handle: async (input, invocation) => {
+        await host.ready();
+        if (!host.moduleInstalled("results")) return text("results is not installed.", true);
+        const session = setProgress(
+          host.sessionFor(invocation.threadId),
+          readNumber(input["done"]),
+          readNumber(input["total"])
+        );
+        await host.save(invocation.threadId, session);
+        return text(`progress=${session.done}/${session.total}`);
+      }
+    },
+    {
+      name: "publish",
+      description: "Open the report gate after authorization is recorded. The guard can refuse this call before it runs.",
+      inputSchema: objectSchema2({}),
+      handle: async (_input, invocation) => {
+        await host.ready();
+        const current = host.sessionFor(invocation.threadId);
+        const opened = openReport(recordAuthorization(current));
+        if (opened.error !== null) return text(opened.error, true);
+        await host.save(invocation.threadId, opened.session);
+        return text("report gate open");
+      }
+    },
+    {
+      name: "probe",
+      description: "Harmless call used to show a guard refusal. It does not touch the workspace.",
+      inputSchema: objectSchema2({}),
+      handle: async () => text("probe ran")
+    },
+    {
+      name: "ledger_note",
+      description: "Append a short note to this session ledger.",
+      inputSchema: objectSchema2({ note: { type: "string", description: "Short note." } }, ["note"]),
+      handle: async (input, invocation) => {
+        await host.ready();
+        if (!host.moduleInstalled("trace-vault"))
+          return text("trace-vault is not installed.", true);
+        const session = pushNote(host.sessionFor(invocation.threadId), readString2(input["note"]));
+        await host.save(invocation.threadId, session);
+        return text("note stored");
+      }
+    }
+  ];
+}
+
+// src/index.ts
+var redteamModelPlugin = definePlugin({
+  id: "redteam-model",
+  apiVersion: 4,
+  activate(ctx) {
+    const runtime = openRuntime(ctx);
+    ctx.sessionProjections.register({ name: PROJECTION_NAME });
+    ctx.systemPrompt.context((turn) => runtime.contextFor(turn.threadId));
+    ctx.tools.guard((input) => runtime.guard(input));
+    ctx.toolkit({ name: "modes", tools: createTools(runtime) });
+    ctx.reactor({
+      name: "remember-preset",
+      events: ["thread.created"],
+      handle: (event) => runtime.rememberCreated(event)
+    });
+    registerCommands(ctx, runtime);
+  }
+});
+var index_default = redteamModelPlugin;
+export {
+  index_default as default
+};