@iowarp/clio-coder 0.3.0

package/dist/chunk-JPOWPFCU.js

@@ -0,0 +1,1010 @@
+import {
+  assertAgentIdNamespace
+} from "./chunk-527KG6XR.js";
+import {
+  CONFIRMED_SCOPE,
+  READONLY_SCOPE,
+  WORKSPACE_SCOPE,
+  createLoopState,
+  createSafetyPolicyEngine,
+  isSubset,
+  observe,
+  parseFrontmatter,
+  parseResultContract
+} from "./chunk-XV4ZJ6ZM.js";
+import {
+  loadSkills
+} from "./chunk-26BZQOAD.js";
+import {
+  assertAgentSpecPolicy,
+  classify,
+  isAgentAudience,
+  isAgentCapabilityClass,
+  isAgentCategory,
+  isAgentLatencyClass,
+  isAgentProduct,
+  isAgentProjectContextTier,
+  isShadowAgent,
+  normalizeAgentSpec
+} from "./chunk-WD6AJM35.js";
+import {
+  BusChannels,
+  isRunAbortedPayload
+} from "./chunk-D5YD55AR.js";
+import {
+  clioConfigDir,
+  clioStateDir,
+  stateRootRemoved
+} from "./chunk-X3NE4WVW.js";
+import {
+  resolvePackageRoot
+} from "./chunk-DXQNI4PC.js";
+
+// src/domains/agents/extension.ts
+import path3 from "node:path";
+
+// src/domains/agents/registry.ts
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import path2 from "node:path";
+
+// src/domains/agents/recipe.ts
+import path from "node:path";
+var AGENT_BUDGET_KEYS = ["toolCalls", "readReserve", "synthesis"];
+function parseAgentBudget(value, sourcePath) {
+  if (value === void 0) return void 0;
+  const prefix = `agent budget: ${sourcePath}: budget`;
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${prefix} must be a non-null YAML object`);
+  }
+  const record = value;
+  for (const key of Object.keys(record)) {
+    if (!AGENT_BUDGET_KEYS.includes(key)) {
+      throw new Error(`${prefix}.${key} is unknown`);
+    }
+  }
+  for (const key of AGENT_BUDGET_KEYS) {
+    if (!Object.hasOwn(record, key)) throw new Error(`${prefix}.${key} is required`);
+  }
+  const toolCalls = record.toolCalls;
+  if (typeof toolCalls !== "number" || !Number.isSafeInteger(toolCalls)) {
+    throw new Error(`${prefix}.toolCalls must be a finite safe integer`);
+  }
+  if (toolCalls <= 0) throw new Error(`${prefix}.toolCalls must be greater than 0`);
+  const readReserve = record.readReserve;
+  if (typeof readReserve !== "number" || !Number.isSafeInteger(readReserve)) {
+    throw new Error(`${prefix}.readReserve must be a finite safe integer`);
+  }
+  if (readReserve < 0) throw new Error(`${prefix}.readReserve must be greater than or equal to 0`);
+  if (readReserve >= toolCalls) throw new Error(`${prefix}.readReserve must be less than budget.toolCalls`);
+  const synthesis = record.synthesis;
+  if (typeof synthesis !== "boolean") throw new Error(`${prefix}.synthesis must be a boolean`);
+  return { toolCalls, readReserve, synthesis };
+}
+function recipeIdFromPath(absPath, rootDir) {
+  const resolvedRoot = path.resolve(rootDir);
+  const resolvedPath = path.resolve(absPath);
+  const relPath = path.relative(resolvedRoot, resolvedPath);
+  if (relPath === "" || relPath.startsWith("..") || path.isAbsolute(relPath)) {
+    throw new Error(`recipe: path must live under rootDir (${resolvedPath} not under ${resolvedRoot})`);
+  }
+  if (path.dirname(relPath) !== ".") {
+    throw new Error(`recipe: recipes must live directly under rootDir (${resolvedPath})`);
+  }
+  if (path.extname(relPath) !== ".md") {
+    throw new Error(`recipe: recipe files must end in .md (${resolvedPath})`);
+  }
+  const id = path.basename(relPath, ".md");
+  if (id === "") {
+    throw new Error(`recipe: recipe filename must not be empty (${resolvedPath})`);
+  }
+  return id;
+}
+
+// src/domains/agents/recipe-schema.ts
+var RECIPE_KEYS = [
+  "version",
+  "name",
+  "description",
+  "tools",
+  "skills",
+  "audience",
+  "category",
+  "capabilityClass",
+  "latencyClass",
+  "projectContextTier",
+  "budget",
+  "resultContract",
+  "tags"
+];
+var OPTIONAL_RECIPE_KEYS = ["product"];
+var ALL_RECIPE_KEYS = [...RECIPE_KEYS, ...OPTIONAL_RECIPE_KEYS];
+function requiredString(value, path4) {
+  if (typeof value !== "string" || value.trim().length === 0)
+    throw new Error(`agent recipe: ${path4} must be a non-empty string`);
+  return value;
+}
+function requiredStringArray(value, path4) {
+  if (!Array.isArray(value)) throw new Error(`agent recipe: ${path4} must be an array of strings`);
+  const entries = value.map((entry, index) => requiredString(entry, `${path4}[${index}]`));
+  if (new Set(entries).size !== entries.length) throw new Error(`agent recipe: ${path4} must not contain duplicates`);
+  return entries;
+}
+function enumValue(value, path4, predicate) {
+  if (!predicate(value)) throw new Error(`agent recipe: ${path4} has an unsupported value`);
+  return value;
+}
+function parseAudience(value, source, filepath) {
+  const audience = enumValue(value, `${filepath}: audience`, isAgentAudience);
+  if (source === "builtin") {
+    if (audience === "custom") {
+      throw new Error(`agent recipe: ${filepath}: a builtin recipe must not declare audience 'custom'`);
+    }
+    return audience;
+  }
+  if (audience !== "custom") {
+    throw new Error(
+      `agent recipe: ${filepath}: a ${source} recipe must declare audience 'custom', not '${audience}'; audience follows where the recipe was discovered and cannot be claimed in frontmatter`
+    );
+  }
+  return audience;
+}
+function parseTools(value, filepath) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`agent recipe: ${filepath}: tools must be a { required, optional } object`);
+  }
+  const record = value;
+  if (Object.keys(record).some((key) => key !== "required" && key !== "optional")) {
+    throw new Error(`agent recipe: ${filepath}: tools has an unknown key`);
+  }
+  if (!("required" in record) || !("optional" in record)) {
+    throw new Error(`agent recipe: ${filepath}: tools.required and tools.optional are required`);
+  }
+  if (!Array.isArray(record.required) || !Array.isArray(record.optional)) {
+    throw new Error(`agent recipe: ${filepath}: tools.required and tools.optional must be arrays`);
+  }
+  const required = record.required.map((entry, index) => {
+    const entryPath = `${filepath}: tools.required[${index}]`;
+    if (typeof entry === "string") return requiredString(entry, entryPath);
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`agent recipe: ${entryPath} must be a tool name or { anyOf: [...] }`);
+    }
+    const group = entry;
+    if (Object.keys(group).length !== 1 || !("anyOf" in group)) {
+      throw new Error(`agent recipe: ${entryPath} must contain only anyOf`);
+    }
+    const anyOf = requiredStringArray(group.anyOf, `${entryPath}.anyOf`);
+    if (anyOf.length === 0) throw new Error(`agent recipe: ${entryPath}.anyOf must not be empty`);
+    return { anyOf };
+  });
+  const optional = requiredStringArray(record.optional, `${filepath}: tools.optional`);
+  const tools = [
+    ...required.flatMap((requirement) => typeof requirement === "string" ? [requirement] : requirement.anyOf),
+    ...optional
+  ];
+  if (new Set(tools).size !== tools.length)
+    throw new Error(`agent recipe: ${filepath}: tools contains duplicate requirements`);
+  return { tools, toolRequirements: { required, optional } };
+}
+function parseAgentRecipeSchema(input) {
+  const { frontmatter, filepath } = input;
+  for (const key of Object.keys(frontmatter)) {
+    if (!ALL_RECIPE_KEYS.includes(key)) {
+      throw new Error(`agent recipe: ${filepath}: unknown key '${key}'`);
+    }
+  }
+  for (const key of RECIPE_KEYS) {
+    if (!(key in frontmatter)) throw new Error(`agent recipe: ${filepath}: ${key} is required`);
+  }
+  if (frontmatter.version !== 1) throw new Error(`agent recipe: ${filepath}: version must be the supported integer 1`);
+  if (input.body.trim().length === 0) throw new Error(`agent recipe: ${filepath}: persona body must not be empty`);
+  const parsedTools = parseTools(frontmatter.tools, filepath);
+  const budget = parseAgentBudget(frontmatter.budget, filepath);
+  if (budget === void 0) throw new Error(`agent recipe: ${filepath}: budget is required`);
+  return {
+    version: 1,
+    id: input.id,
+    name: requiredString(frontmatter.name, `${filepath}: name`),
+    description: requiredString(frontmatter.description, `${filepath}: description`),
+    tools: parsedTools.tools,
+    toolRequirements: parsedTools.toolRequirements,
+    skills: requiredStringArray(frontmatter.skills, `${filepath}: skills`),
+    boundSkillPaths: [],
+    audience: parseAudience(frontmatter.audience, input.source, filepath),
+    category: enumValue(frontmatter.category, `${filepath}: category`, isAgentCategory),
+    capabilityClass: enumValue(
+      frontmatter.capabilityClass,
+      `${filepath}: capabilityClass`,
+      isAgentCapabilityClass
+    ),
+    latencyClass: enumValue(
+      frontmatter.latencyClass,
+      `${filepath}: latencyClass`,
+      isAgentLatencyClass
+    ),
+    projectContextTier: enumValue(
+      frontmatter.projectContextTier,
+      `${filepath}: projectContextTier`,
+      isAgentProjectContextTier
+    ),
+    budget,
+    resultContract: parseResultContract(frontmatter.resultContract, filepath),
+    // Optional, but not lenient. A misspelled product silently costs the run
+    // the delivery tools its reserve window was supposed to keep, and the
+    // only symptom is a blocked tool call deep in a dispatch log.
+    ...frontmatter.product === void 0 ? {} : { product: enumValue(frontmatter.product, `${filepath}: product`, isAgentProduct) },
+    tags: requiredStringArray(frontmatter.tags, `${filepath}: tags`),
+    source: input.source,
+    filepath,
+    body: input.body
+  };
+}
+
+// src/domains/agents/registry.ts
+var RESERVED_CUSTOM_AGENT_IDS = /* @__PURE__ */ new Set(["worker", "delegate", "auto"]);
+function resolveBoundSkills(recipe, source) {
+  if (recipe.skills.length === 0) return { ...recipe, boundSkillPaths: [] };
+  const packageSkills = path2.resolve(source.dir, "..", "..", "..", "..", "skills");
+  const skills = loadSkills({
+    cwd: process.cwd(),
+    ...source.source === "builtin" && existsSync(packageSkills) ? { explicitSkillPaths: [packageSkills] } : {}
+  });
+  const byName = new Map(skills.items.map((skill) => [skill.name, skill.filePath]));
+  const missing = recipe.skills.filter((skill) => !byName.has(skill));
+  if (missing.length > 0) {
+    throw new Error(`agent recipe: ${recipe.filepath}: bound skill(s) unavailable: ${missing.join(", ")}`);
+  }
+  const boundSkillPaths = recipe.skills.map((skill) => {
+    const filePath = byName.get(skill);
+    if (filePath === void 0) throw new Error(`agent recipe: ${recipe.filepath}: bound skill unavailable: ${skill}`);
+    return filePath;
+  });
+  return { ...recipe, boundSkillPaths };
+}
+function loadRecipesFromDir(source, diagnostics = []) {
+  let entries;
+  try {
+    entries = readdirSync(source.dir, { withFileTypes: true });
+  } catch (err) {
+    const error = err;
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") return [];
+    throw err;
+  }
+  const recipes = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    const filepath = path2.join(source.dir, entry.name);
+    try {
+      const id = recipeIdFromPath(filepath, source.dir);
+      const raw = readFileSync(filepath, "utf8");
+      const { frontmatter, body } = parseFrontmatter(raw, filepath);
+      const parsedRecipe = parseAgentRecipeSchema({ id, source: source.source, filepath, body, frontmatter });
+      const recipe = resolveBoundSkills(parsedRecipe, source);
+      assertAgentSpecPolicy(normalizeAgentSpec(recipe));
+      recipes.push(recipe);
+    } catch (error) {
+      if (source.source === "builtin") throw error;
+      const message = error instanceof Error ? error.message : String(error);
+      diagnostics.push({ source: source.source, filepath, message });
+      process.stderr.write(`[clio:agents] quarantine path=${filepath} source=${source.source} reason=${message}
+`);
+    }
+  }
+  recipes.sort((left, right) => left.id.localeCompare(right.id));
+  return recipes;
+}
+function mergeRecipes(...sources) {
+  const byId = /* @__PURE__ */ new Map();
+  const builtinById = /* @__PURE__ */ new Map();
+  for (const group of sources) {
+    for (const recipe of group) {
+      if (recipe.source === "builtin") builtinById.set(recipe.id, recipe);
+    }
+  }
+  for (const group of sources) {
+    for (const recipe of group) {
+      if (recipe.source !== "builtin" && RESERVED_CUSTOM_AGENT_IDS.has(recipe.id)) {
+        process.stderr.write(`[clio:agents] ignore id=${recipe.id} by=${recipe.source} reason=reserved-agent-id
+`);
+        continue;
+      }
+      const builtin = builtinById.get(recipe.id);
+      if (recipe.source === "user" && builtin && isShadowAgent(normalizeAgentSpec(builtin))) {
+        process.stderr.write(`[clio:agents] ignore override id=${recipe.id} by=user reason=reserved-shadow
+`);
+        continue;
+      }
+      if (recipe.source === "project" && builtin) {
+        process.stderr.write(`[clio:agents] ignore override id=${recipe.id} by=project reason=reserved-builtin
+`);
+        continue;
+      }
+      if (byId.has(recipe.id)) process.stderr.write(`[clio:agents] override id=${recipe.id} by=${recipe.source}
+`);
+      byId.set(recipe.id, recipe);
+    }
+  }
+  return Array.from(byId.values()).sort((left, right) => left.id.localeCompare(right.id));
+}
+
+// src/domains/agents/extension.ts
+function createAgentsBundle(_context) {
+  let recipes = [];
+  let specs = [];
+  let diagnostics = [];
+  function discover() {
+    const builtinDir = path3.join(resolvePackageRoot(), "src", "domains", "agents", "builtins");
+    const userDir = path3.join(clioConfigDir(), "agents");
+    const projectDir = path3.join(process.cwd(), ".clio-coder", "agents");
+    const nextDiagnostics = [];
+    const builtin = loadRecipesFromDir({ dir: builtinDir, source: "builtin" }, nextDiagnostics);
+    const user = loadRecipesFromDir({ dir: userDir, source: "user" }, nextDiagnostics);
+    const project = loadRecipesFromDir({ dir: projectDir, source: "project" }, nextDiagnostics);
+    const merged = mergeRecipes(builtin, user, project);
+    const config = _context.getContract("config");
+    assertAgentIdNamespace(merged, config?.get()?.delegation?.agents ?? []);
+    recipes = merged;
+    specs = recipes.map(normalizeAgentSpec);
+    diagnostics = nextDiagnostics;
+  }
+  const extension = {
+    async start() {
+      discover();
+    },
+    async stop() {
+    }
+  };
+  const contract = {
+    list() {
+      return recipes;
+    },
+    get(id) {
+      return recipes.find((r) => r.id === id) ?? null;
+    },
+    diagnostics() {
+      return diagnostics.map((diagnostic) => ({ ...diagnostic }));
+    },
+    listSpecs() {
+      const config = _context.getContract("config");
+      const delegationAgents = config?.get()?.delegation?.agents ?? [];
+      const delegationSpecs = delegationAgents.map((agent) => ({
+        version: 1,
+        id: agent.id,
+        name: agent.id,
+        description: `External ACP delegation agent: ${agent.command} ${(agent.args ?? []).join(" ")}`,
+        source: "custom",
+        filepath: "settings.yaml",
+        tools: [],
+        toolRequirements: { required: [], optional: [] },
+        category: "explore",
+        capabilityClass: "orchestration",
+        latencyClass: "deep",
+        projectContextTier: "none",
+        audience: "custom",
+        tags: ["delegation", "acp"],
+        skills: [],
+        resultContract: { kind: "external-delegation" },
+        budget: { toolCalls: 1, readReserve: 0, synthesis: false },
+        body: "External ACP delegation."
+      }));
+      return [...specs, ...delegationSpecs];
+    },
+    getSpec(id) {
+      const found = specs.find((r) => r.id === id);
+      if (found) return found;
+      const config = _context.getContract("config");
+      const agent = config?.get()?.delegation?.agents?.find((entry) => entry.id === id);
+      if (agent) {
+        return {
+          version: 1,
+          id: agent.id,
+          name: agent.id,
+          description: `External ACP delegation agent: ${agent.command} ${(agent.args ?? []).join(" ")}`,
+          source: "custom",
+          filepath: "settings.yaml",
+          tools: [],
+          toolRequirements: { required: [], optional: [] },
+          category: "explore",
+          capabilityClass: "orchestration",
+          latencyClass: "deep",
+          projectContextTier: "none",
+          audience: "custom",
+          tags: ["delegation", "acp"],
+          skills: [],
+          resultContract: { kind: "external-delegation" },
+          budget: { toolCalls: 1, readReserve: 0, synthesis: false },
+          body: "External ACP delegation."
+        };
+      }
+      return null;
+    },
+    reload() {
+      discover();
+    }
+  };
+  return { extension, contract };
+}
+
+// src/domains/agents/manifest.ts
+var AgentsManifest = {
+  name: "agents",
+  dependsOn: ["config"]
+};
+
+// src/domains/agents/index.ts
+var AgentsDomainModule = {
+  manifest: AgentsManifest,
+  createExtension: createAgentsBundle
+};
+
+// src/domains/safety/audit.ts
+import { randomBytes } from "node:crypto";
+import { closeSync, fsyncSync, mkdirSync, openSync, writeSync } from "node:fs";
+import { join } from "node:path";
+var REDACT_KEY_RE = /(password|token|secret|key|auth|credential)/i;
+var MAX_STRING_LEN = 200;
+function localDateString(d) {
+  const fmt = new Intl.DateTimeFormat("en-CA", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+  return fmt.format(d);
+}
+function newCorrelationId() {
+  const n = BigInt(`0x${randomBytes(8).toString("hex")}`);
+  const raw = n.toString(36);
+  if (raw.length >= 12) return raw.slice(0, 12);
+  return raw.padStart(12, "0");
+}
+function redactString(s) {
+  if (s.length <= MAX_STRING_LEN) return s;
+  const truncated = s.length - MAX_STRING_LEN;
+  return `${s.slice(0, MAX_STRING_LEN)}\u2026 [truncated ${truncated} chars]`;
+}
+function redactArgs(value, depth = 0) {
+  if (depth > 8) return "[redacted:depth]";
+  if (value == null) return value;
+  if (typeof value === "string") return redactString(value);
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (Array.isArray(value)) return value.map((item) => redactArgs(item, depth + 1));
+  if (typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (REDACT_KEY_RE.test(k)) {
+        out[k] = "[redacted]";
+        continue;
+      }
+      out[k] = redactArgs(v, depth + 1);
+    }
+    return out;
+  }
+  return String(value);
+}
+function buildAuditRecord(input) {
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const record = {
+    kind: "tool_call",
+    ts: now.toISOString(),
+    correlationId: newCorrelationId(),
+    tool: input.tool,
+    actionClass: input.classification.actionClass,
+    decision: input.decision,
+    reasons: input.reasons ?? input.policy?.reasons ?? input.classification.reasons
+  };
+  if (input.requestId !== void 0) record.requestId = input.requestId;
+  if (input.posture !== void 0) record.posture = input.posture;
+  if (input.policy?.ruleId !== void 0) record.ruleId = input.policy.ruleId;
+  const reasonCode = input.reasonCode ?? input.policy?.reasonCode;
+  if (reasonCode !== void 0) record.reasonCode = reasonCode;
+  if (input.policy?.policySource !== void 0) record.policySource = input.policy.policySource;
+  if (input.policy?.policyHash !== void 0) record.policyHash = input.policy.policyHash;
+  if (input.policy?.command !== void 0) record.command = redactString(input.policy.command);
+  if (input.policy?.cwd !== void 0) record.cwd = input.policy.cwd;
+  if (input.args !== void 0) record.args = redactArgs(input.args);
+  return record;
+}
+function buildAbortAuditRecord(input) {
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const record = {
+    kind: "abort",
+    ts: now.toISOString(),
+    correlationId: newCorrelationId(),
+    source: input.source,
+    runId: input.runId,
+    startedAt: input.startedAt,
+    elapsedMs: input.elapsedMs
+  };
+  if (input.reason !== void 0) record.reason = input.reason;
+  return record;
+}
+function buildSessionParkAuditRecord(input) {
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  return {
+    kind: "session_park",
+    ts: now.toISOString(),
+    correlationId: newCorrelationId(),
+    sessionId: input.sessionId,
+    reason: input.reason
+  };
+}
+function buildSessionResumeAuditRecord(input) {
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  return {
+    kind: "session_resume",
+    ts: now.toISOString(),
+    correlationId: newCorrelationId(),
+    sessionId: input.sessionId,
+    via: input.via
+  };
+}
+function buildPermissionAuditRecord(input) {
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const record = {
+    kind: "permission",
+    ts: now.toISOString(),
+    correlationId: newCorrelationId(),
+    status: input.status
+  };
+  if (input.tool !== void 0) record.tool = input.tool;
+  if (input.requestId !== void 0) record.requestId = input.requestId;
+  if (input.origin !== void 0) record.origin = input.origin;
+  if (input.decidedBy !== void 0) record.decidedBy = input.decidedBy;
+  if (input.actionClass !== void 0) record.actionClass = input.actionClass;
+  if (input.reason !== void 0) record.reason = input.reason;
+  if (input.requestedBy !== void 0) record.requestedBy = input.requestedBy;
+  return record;
+}
+function buildAgentStatusChangeAuditRecord(input) {
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const record = {
+    kind: "agent_status_change",
+    ts: now.toISOString(),
+    correlationId: newCorrelationId(),
+    runId: input.runId,
+    phase: input.phase,
+    prevPhase: input.prevPhase,
+    elapsedFromStart: Math.max(0, Math.floor(input.elapsedFromStart)),
+    watchdogTier: Math.max(0, Math.floor(input.watchdogTier))
+  };
+  if (input.metadata !== void 0) record.metadata = redactArgs(input.metadata);
+  return record;
+}
+function buildCompletionContractAuditRecord(input) {
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const record = {
+    kind: "completion_contract",
+    ts: now.toISOString(),
+    correlationId: newCorrelationId(),
+    turnId: input.turnId,
+    decision: input.decision,
+    reason: input.reason,
+    rigor: input.rigor,
+    mutatedPaths: input.mutatedPaths.map((path4) => redactString(path4)),
+    evidenceKinds: [...input.evidenceKinds]
+  };
+  if (input.runId !== void 0) record.runId = input.runId;
+  if (input.sessionId !== void 0) record.sessionId = input.sessionId;
+  return record;
+}
+function logAuditError(err, path4) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const where = path4 ? ` (${path4})` : "";
+  process.stderr.write(`[clio:audit] ${msg}${where}
+`);
+}
+var AUDIT_FLUSH_INTERVAL_MS = 5e3;
+function openAuditWriter(opts) {
+  const dateFn = opts?.dateFn ?? (() => /* @__PURE__ */ new Date());
+  let current = null;
+  let closed = false;
+  let dirty = false;
+  function flushCurrent() {
+    if (current === null || !dirty) return;
+    try {
+      fsyncSync(current.fd);
+      dirty = false;
+    } catch (err) {
+      logAuditError(err, current.path);
+    }
+  }
+  const flushTimer = setInterval(flushCurrent, AUDIT_FLUSH_INTERVAL_MS);
+  flushTimer.unref();
+  function closeCurrent() {
+    if (current === null) return;
+    flushCurrent();
+    try {
+      closeSync(current.fd);
+    } catch (err) {
+      logAuditError(err, current.path);
+    }
+    current = null;
+    dirty = false;
+  }
+  function ensureFor(date) {
+    if (current !== null && current.date === date) return current;
+    if (current !== null) closeCurrent();
+    if (stateRootRemoved()) return null;
+    try {
+      const dir = join(clioStateDir(), "audit");
+      mkdirSync(dir, { recursive: true });
+      const filePath = join(dir, `${date}.jsonl`);
+      const fd = openSync(filePath, "a");
+      current = { fd, date, path: filePath };
+      return current;
+    } catch (err) {
+      logAuditError(err);
+      return null;
+    }
+  }
+  return {
+    write(record) {
+      if (closed) return;
+      try {
+        const date = localDateString(dateFn());
+        const handle = ensureFor(date);
+        if (handle === null) return;
+        const line = `${JSON.stringify(record)}
+`;
+        writeSync(handle.fd, line);
+        dirty = true;
+      } catch (err) {
+        logAuditError(err, current?.path);
+      }
+    },
+    flush() {
+      flushCurrent();
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      clearInterval(flushTimer);
+      closeCurrent();
+    }
+  };
+}
+
+// src/domains/safety/extension.ts
+function isPermissionResolvedPayload(value) {
+  if (!value || typeof value !== "object") return false;
+  const p = value;
+  if (p.status !== "granted" && p.status !== "denied") return false;
+  if (p.tool !== void 0 && typeof p.tool !== "string") return false;
+  if (p.actionClass !== void 0 && typeof p.actionClass !== "string") return false;
+  if (p.reason !== void 0 && typeof p.reason !== "string") return false;
+  if (p.requestedBy !== void 0 && typeof p.requestedBy !== "string") return false;
+  if (p.requestId !== void 0 && typeof p.requestId !== "string") return false;
+  if (p.origin !== void 0 && typeof p.origin !== "string") return false;
+  if (p.decidedBy !== void 0 && typeof p.decidedBy !== "string") return false;
+  return true;
+}
+function isPermissionRequestedPayload(value) {
+  if (!value || typeof value !== "object") return false;
+  const p = value;
+  if (typeof p.tool !== "string" || p.tool.length === 0) return false;
+  if (typeof p.actionClass !== "string" || p.actionClass.length === 0) return false;
+  if (p.origin !== void 0 && typeof p.origin !== "string") return false;
+  if (p.requestId !== void 0 && typeof p.requestId !== "string") return false;
+  if (p.requestedBy !== void 0 && typeof p.requestedBy !== "string") return false;
+  if (p.summary !== void 0 && typeof p.summary !== "string") return false;
+  if (p.rejection !== void 0) {
+    const rejection = p.rejection;
+    if (!rejection || typeof rejection !== "object" || Array.isArray(rejection)) return false;
+    if (typeof rejection.short !== "string") return false;
+  }
+  return true;
+}
+var PARK_REASONS = /* @__PURE__ */ new Set([
+  "create_new",
+  "resume_other",
+  "fork",
+  "switch_branch",
+  "close",
+  "shutdown"
+]);
+var RESUME_VIAS = /* @__PURE__ */ new Set(["resume", "switch_branch"]);
+var MAX_REQUESTED_PERMISSION_AUDIT_IDS = 4096;
+function isSessionParkedPayload(value) {
+  if (!value || typeof value !== "object") return false;
+  const p = value;
+  if (typeof p.sessionId !== "string") return false;
+  if (typeof p.reason !== "string" || !PARK_REASONS.has(p.reason)) return false;
+  return true;
+}
+function isSessionResumedPayload(value) {
+  if (!value || typeof value !== "object") return false;
+  const p = value;
+  if (typeof p.sessionId !== "string") return false;
+  if (typeof p.via !== "string" || !RESUME_VIAS.has(p.via)) return false;
+  return true;
+}
+function isAgentStatusChangedPayload(value) {
+  if (!value || typeof value !== "object") return false;
+  const p = value;
+  if (p.runId !== null && typeof p.runId !== "string") return false;
+  if (typeof p.phase !== "string" || typeof p.prevPhase !== "string") return false;
+  if (typeof p.elapsedFromStart !== "number" || !Number.isFinite(p.elapsedFromStart)) return false;
+  if (typeof p.watchdogTier !== "number" || !Number.isFinite(p.watchdogTier)) return false;
+  if (p.metadata !== void 0 && (!p.metadata || typeof p.metadata !== "object" || Array.isArray(p.metadata)))
+    return false;
+  return true;
+}
+function isAlarmableStatus(payload) {
+  if (payload.phase === "stuck" || payload.phase === "tool_blocked" || payload.phase === "retrying") return true;
+  return payload.phase === "ended" && payload.metadata?.reason === "cancelled";
+}
+function createSafetyBundle(context) {
+  let writer = null;
+  let policyEngine = null;
+  let loopState = createLoopState();
+  let recordCount = 0;
+  let unsubscribePermissionRequested = null;
+  let unsubscribePermissionResolved = null;
+  let unsubscribeRunAborted = null;
+  let unsubscribeSessionParked = null;
+  let unsubscribeSessionResumed = null;
+  let unsubscribeAgentStatusChanged = null;
+  let unsubscribeDispatchCompleted = null;
+  let unsubscribeDispatchFailed = null;
+  const recordedRequestedPermissionIds = /* @__PURE__ */ new Set();
+  function writeAudit(rec) {
+    if (writer === null) return;
+    writer.write(rec);
+    recordCount += 1;
+  }
+  function recordToolCallAudit(input) {
+    writeAudit(buildAuditRecord(input));
+  }
+  function recordCompletionContractAudit(input) {
+    writeAudit(buildCompletionContractAuditRecord(input));
+  }
+  const extension = {
+    async start() {
+      policyEngine = createSafetyPolicyEngine();
+      writer = openAuditWriter();
+      unsubscribePermissionRequested = context.bus.on(BusChannels.PermissionRequested, (payload) => {
+        if (!isPermissionRequestedPayload(payload)) return;
+        if (payload.origin === void 0 || payload.origin === "main") return;
+        if (payload.requestId === void 0) return;
+        if (recordedRequestedPermissionIds.has(payload.requestId)) return;
+        recordedRequestedPermissionIds.add(payload.requestId);
+        if (recordedRequestedPermissionIds.size > MAX_REQUESTED_PERMISSION_AUDIT_IDS) {
+          const oldest = recordedRequestedPermissionIds.values().next().value;
+          if (oldest !== void 0) recordedRequestedPermissionIds.delete(oldest);
+        }
+        const reason = payload.rejection?.short ?? payload.summary;
+        writeAudit(
+          buildPermissionAuditRecord({
+            status: "requested",
+            requestId: payload.requestId,
+            origin: payload.origin,
+            tool: payload.tool,
+            actionClass: payload.actionClass,
+            ...reason !== void 0 ? { reason } : {},
+            ...payload.requestedBy !== void 0 ? { requestedBy: payload.requestedBy } : {}
+          })
+        );
+      });
+      unsubscribePermissionResolved = context.bus.on(BusChannels.PermissionResolved, (payload) => {
+        if (!isPermissionResolvedPayload(payload)) return;
+        writeAudit(
+          buildPermissionAuditRecord({
+            status: payload.status,
+            ...payload.requestId !== void 0 ? { requestId: payload.requestId } : {},
+            ...payload.origin !== void 0 ? { origin: payload.origin } : {},
+            ...payload.decidedBy !== void 0 ? { decidedBy: payload.decidedBy } : {},
+            ...payload.tool !== void 0 ? { tool: payload.tool } : {},
+            ...payload.actionClass !== void 0 ? { actionClass: payload.actionClass } : {},
+            ...payload.reason !== void 0 ? { reason: payload.reason } : {},
+            ...payload.requestedBy !== void 0 ? { requestedBy: payload.requestedBy } : {}
+          })
+        );
+      });
+      unsubscribeRunAborted = context.bus.on(BusChannels.RunAborted, (payload) => {
+        if (!isRunAbortedPayload(payload)) return;
+        const recordInput = {
+          source: payload.source,
+          runId: payload.runId,
+          startedAt: payload.startedAt,
+          elapsedMs: payload.elapsedMs
+        };
+        if (payload.reason !== void 0) recordInput.reason = payload.reason;
+        writeAudit(buildAbortAuditRecord(recordInput));
+      });
+      unsubscribeSessionParked = context.bus.on(BusChannels.SessionParked, (payload) => {
+        if (!isSessionParkedPayload(payload)) return;
+        writeAudit(buildSessionParkAuditRecord({ sessionId: payload.sessionId, reason: payload.reason }));
+      });
+      unsubscribeSessionResumed = context.bus.on(BusChannels.SessionResumed, (payload) => {
+        if (!isSessionResumedPayload(payload)) return;
+        writeAudit(buildSessionResumeAuditRecord({ sessionId: payload.sessionId, via: payload.via }));
+      });
+      unsubscribeAgentStatusChanged = context.bus.on(BusChannels.AgentStatusChanged, (payload) => {
+        if (!isAgentStatusChangedPayload(payload) || !isAlarmableStatus(payload)) return;
+        writeAudit(
+          buildAgentStatusChangeAuditRecord({
+            runId: payload.runId,
+            phase: payload.phase,
+            prevPhase: payload.prevPhase,
+            elapsedFromStart: payload.elapsedFromStart,
+            watchdogTier: payload.watchdogTier,
+            ...payload.metadata ? { metadata: payload.metadata } : {}
+          })
+        );
+      });
+      const auditDispatchTerminal = (raw) => {
+        if (!raw || typeof raw !== "object") return;
+        const payload = raw;
+        if (typeof payload.runId !== "string" || typeof payload.outcome !== "string") return;
+        const lineage = payload.lineage && typeof payload.lineage === "object" && !Array.isArray(payload.lineage) ? payload.lineage : null;
+        const durationMs = typeof payload.durationMs === "number" ? payload.durationMs : 0;
+        writeAudit(
+          buildAgentStatusChangeAuditRecord({
+            runId: payload.runId,
+            phase: payload.outcome,
+            prevPhase: "running",
+            elapsedFromStart: durationMs,
+            watchdogTier: 0,
+            metadata: {
+              outcome: payload.outcome,
+              ...payload.outcomeDetail !== void 0 && payload.outcomeDetail !== null ? { outcomeDetail: payload.outcomeDetail } : {},
+              ...typeof payload.agentId === "string" ? { agentId: payload.agentId } : {},
+              ...lineage !== null ? {
+                parentRunId: lineage.parentRunId ?? null,
+                rootRunId: lineage.rootRunId ?? null,
+                attempt: lineage.attempt ?? 0,
+                depth: lineage.depth ?? 0
+              } : {}
+            }
+          })
+        );
+      };
+      unsubscribeDispatchCompleted = context.bus.on(BusChannels.DispatchCompleted, auditDispatchTerminal);
+      unsubscribeDispatchFailed = context.bus.on(BusChannels.DispatchFailed, auditDispatchTerminal);
+    },
+    async stop() {
+      unsubscribePermissionRequested?.();
+      unsubscribePermissionRequested = null;
+      unsubscribePermissionResolved?.();
+      unsubscribePermissionResolved = null;
+      unsubscribeRunAborted?.();
+      unsubscribeRunAborted = null;
+      unsubscribeSessionParked?.();
+      unsubscribeSessionParked = null;
+      unsubscribeSessionResumed?.();
+      unsubscribeSessionResumed = null;
+      unsubscribeAgentStatusChanged?.();
+      unsubscribeAgentStatusChanged = null;
+      unsubscribeDispatchCompleted?.();
+      unsubscribeDispatchCompleted = null;
+      unsubscribeDispatchFailed?.();
+      unsubscribeDispatchFailed = null;
+      recordedRequestedPermissionIds.clear();
+      await writer?.close();
+      writer = null;
+    }
+  };
+  const contract = {
+    classify(call) {
+      return classify(call);
+    },
+    evaluate(call, posture) {
+      const policy = (policyEngine ?? createSafetyPolicyEngine()).evaluate(call, posture);
+      const classification = policy.classification;
+      context.bus.emit(BusChannels.SafetyClassified, {
+        tool: call.tool,
+        actionClass: classification.actionClass,
+        reasons: classification.reasons,
+        ruleId: policy.ruleId,
+        posture,
+        policySource: policy.policySource,
+        reasonCode: policy.reasonCode
+      });
+      if (policy.kind === "block") {
+        const auditInput2 = {
+          tool: call.tool,
+          classification,
+          decision: "blocked",
+          args: call.args,
+          policy
+        };
+        if (posture !== void 0) auditInput2.posture = posture;
+        recordToolCallAudit(auditInput2);
+        context.bus.emit(BusChannels.SafetyBlocked, {
+          tool: call.tool,
+          actionClass: classification.actionClass,
+          ruleId: policy.ruleId,
+          posture,
+          rejection: policy.rejection,
+          policySource: policy.policySource,
+          reasonCode: policy.reasonCode
+        });
+        const decision = {
+          kind: "block",
+          classification,
+          rejection: policy.rejection ?? fallbackRejection(policy),
+          policy
+        };
+        if (policy.match) decision.match = policy.match;
+        return decision;
+      }
+      if (policy.kind === "ask") {
+        const auditInput2 = {
+          tool: call.tool,
+          classification,
+          decision: "classified",
+          args: call.args,
+          policy
+        };
+        if (posture !== void 0) auditInput2.posture = posture;
+        recordToolCallAudit(auditInput2);
+        const decision = {
+          kind: "ask",
+          classification,
+          rejection: policy.rejection ?? fallbackRejection(policy),
+          policy
+        };
+        if (policy.match) decision.match = policy.match;
+        return decision;
+      }
+      const auditInput = {
+        tool: call.tool,
+        classification,
+        // Non-confirmed net passes are not final: registry admission still
+        // applies autonomy and writes the resolved allowed/park/denied row.
+        decision: posture === "confirmed" ? "allowed" : "classified",
+        args: call.args,
+        policy
+      };
+      if (posture !== void 0) auditInput.posture = posture;
+      recordToolCallAudit(auditInput);
+      context.bus.emit(BusChannels.SafetyAllowed, {
+        tool: call.tool,
+        actionClass: classification.actionClass,
+        posture,
+        ruleId: policy.ruleId,
+        policySource: policy.policySource,
+        reasonCode: policy.reasonCode
+      });
+      return { kind: "allow", classification, policy };
+    },
+    observeLoop(key, now) {
+      const [next, verdict] = observe(loopState, key, now ?? Date.now());
+      loopState = next;
+      return verdict;
+    },
+    scopes: { readonly: READONLY_SCOPE, workspace: WORKSPACE_SCOPE, confirmed: CONFIRMED_SCOPE },
+    isSubset,
+    policy: { metadata: (posture) => (policyEngine ?? createSafetyPolicyEngine()).metadata(posture) },
+    audit: {
+      recordCount: () => recordCount,
+      recordToolCall: recordToolCallAudit,
+      recordCompletionContract: recordCompletionContractAudit
+    }
+  };
+  return { extension, contract };
+}
+function fallbackRejection(policy) {
+  return {
+    short: `${policy.tool} blocked: ${policy.actionClass}`,
+    detail: policy.reasons.join("\n"),
+    hints: []
+  };
+}
+
+// src/domains/safety/manifest.ts
+var SafetyManifest = {
+  name: "safety",
+  dependsOn: ["config"]
+};
+
+// src/domains/safety/index.ts
+var SafetyDomainModule = {
+  manifest: SafetyManifest,
+  createExtension: createSafetyBundle
+};
+
+export {
+  AgentsDomainModule,
+  SafetyDomainModule
+};
+//# sourceMappingURL=chunk-JPOWPFCU.js.map