@iowarp/clio-coder 0.3.4 → 0.3.7

package/dist/{chunk-WR67VIZY.js → chunk-FOT2FX5J.js}

@@ -1,12 +1,23 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  parseAgentRecipeSchema
+} from "./chunk-UVDSQ6LW.js";
+import {
+  parseFleetContract,
+  parseFrontmatter
+} from "./chunk-KCMKRQX4.js";
+import {
+  assertAgentSpecPolicy,
+  normalizeAgentSpec
+} from "./chunk-AOCYTWAV.js";
 import {
   readSettings,
   settingsPath,
   updateSettings
-} from "./chunk-AD2SYQYC.js";
+} from "./chunk-UHXRNZ2J.js";
 import {
   DEFAULT_SETTINGS
-} from "./chunk-4OC57DA6.js";
+} from "./chunk-4DGYLA73.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -113,11 +124,13 @@ function requestedScopes(scope) {
   return [scope ?? "project"];
 }
 function defaultedIncludes(options) {
-  const hasExplicitInclude = options.includeContext !== void 0 || options.includePrompts !== void 0 || options.includeSkills !== void 0 || options.includeSettings !== void 0 || options.includeExtensions !== void 0;
+  const hasExplicitInclude = options.includeContext !== void 0 || options.includePrompts !== void 0 || options.includeSkills !== void 0 || options.includeAgents !== void 0 || options.includeFleets !== void 0 || options.includeSettings !== void 0 || options.includeExtensions !== void 0;
   return {
     includeContext: hasExplicitInclude ? options.includeContext === true : true,
     includePrompts: hasExplicitInclude ? options.includePrompts === true : true,
     includeSkills: hasExplicitInclude ? options.includeSkills === true : true,
+    includeAgents: hasExplicitInclude ? options.includeAgents === true : true,
+    includeFleets: hasExplicitInclude ? options.includeFleets === true : true,
     includeSettings: hasExplicitInclude ? options.includeSettings === true : true,
     includeExtensions: hasExplicitInclude ? options.includeExtensions === true : true
   };
@@ -155,6 +168,18 @@ function createShareArchive(options = {}) {
       addTree(files, "skill", scope, root, `${scope}/skills`);
     }
   }
+  if (includes.includeAgents) {
+    for (const scope of scopes) {
+      const root = scope === "user" ? path.join(clioConfigDir(), "agents") : path.join(cwd, ".clio-coder", "agents");
+      addTree(files, "agent", scope, root, `${scope}/agents`);
+    }
+  }
+  if (includes.includeFleets) {
+    for (const scope of scopes) {
+      const root = scope === "user" ? path.join(clioConfigDir(), "fleets") : path.join(cwd, ".clio-coder", "fleets");
+      addTree(files, "fleet", scope, root, `${scope}/fleets`);
+    }
+  }
   if (includes.includeExtensions) {
     for (const scope of scopes) {
       const root = scope === "user" ? path.join(clioConfigDir(), "extensions") : path.join(cwd, ".clio-coder", "extensions");
@@ -201,8 +226,17 @@ function parseArchive(raw) {
     throw new Error("share archive manifest is malformed");
   }
   const archive = raw;
+  const allowedTypes = /* @__PURE__ */ new Set([
+    "project-context",
+    "prompt",
+    "skill",
+    "agent",
+    "fleet",
+    "settings",
+    "extension"
+  ]);
   for (const file of archive.files) {
-    if (!isRecord(file) || typeof file.archivePath !== "string" || typeof file.relativePath !== "string" || typeof file.sha256 !== "string" || file.encoding !== "base64" || typeof file.data !== "string") {
+    if (!isRecord(file) || !allowedTypes.has(file.type) || typeof file.archivePath !== "string" || typeof file.relativePath !== "string" || typeof file.sha256 !== "string" || file.encoding !== "base64" || typeof file.data !== "string") {
       throw new Error("share archive file entry is malformed");
     }
     const actual = sha256(decodeArchiveFile(file));
@@ -244,6 +278,10 @@ function targetRootForFile(entry, options) {
       return scope === "user" ? { root: path.join(config, "prompts"), containmentRoot: config, scope } : { root: path.join(cwd, ".clio-coder", "prompts"), containmentRoot: cwd, scope };
     case "skill":
       return scope === "user" ? { root: path.join(config, "skills"), containmentRoot: config, scope } : { root: path.join(cwd, ".clio-coder", "skills"), containmentRoot: cwd, scope };
+    case "agent":
+      return { root: path.join(config, "agents"), containmentRoot: config, scope: "user" };
+    case "fleet":
+      return { root: path.join(config, "fleets"), containmentRoot: config, scope: "user" };
     case "extension":
       return scope === "user" ? { root: path.join(config, "extensions"), containmentRoot: config, scope } : { root: path.join(cwd, ".clio-coder", "extensions"), containmentRoot: cwd, scope };
     case "settings":
@@ -393,6 +431,26 @@ function prepareShareImport(filePath, options = {}) {
   }
   for (const targetInfo of preflight.targets) {
     const { entry, target, scope, buffer } = targetInfo;
+    if (entry.type === "fleet") {
+      try {
+        parseFleetContract(buffer.toString("utf8"), target);
+      } catch (error) {
+        diagnostics.push({ type: "error", message: error instanceof Error ? error.message : String(error), path: target });
+        continue;
+      }
+    }
+    if (entry.type === "agent") {
+      try {
+        const parsed = parseFrontmatter(buffer.toString("utf8"), target);
+        const id = path.basename(target, ".md");
+        assertAgentSpecPolicy(
+          normalizeAgentSpec(parseAgentRecipeSchema({ id, source: "user", filepath: target, ...parsed }))
+        );
+      } catch (error) {
+        diagnostics.push({ type: "error", message: error instanceof Error ? error.message : String(error), path: target });
+        continue;
+      }
+    }
     if (entry.type === "settings") {
       diagnostics.push(...settingsPlan(buffer, options));
       actions.push({ action: "settings", type: entry.type, scope, path: target });
@@ -552,4 +610,4 @@ export {
   importShareArchive,
   ShareDomainModule
 };
-//# sourceMappingURL=chunk-WR67VIZY.js.map
+//# sourceMappingURL=chunk-FOT2FX5J.js.map

package/dist/{chunk-BPGS2WCQ.js → chunk-GEYXPTRF.js}

@@ -191,6 +191,7 @@ function buildContextLedger(input) {
     model: input.model ?? null,
     contextWindow: window,
     contextWindowSource: input.contextWindowSource ?? null,
+    contextWindowSlots: input.contextWindowSlots ?? null,
     usedTokens,
     reserveTokens,
     freeTokens,
@@ -609,4 +610,4 @@ export {
   snapshotInputTokens,
   reconcileSnapshot
 };
-//# sourceMappingURL=chunk-BPGS2WCQ.js.map
+//# sourceMappingURL=chunk-GEYXPTRF.js.map

package/dist/{chunk-FYYLNIL5.js → chunk-GH5622CP.js}

@@ -5,7 +5,7 @@ import {
 import {
   SAFE_EXEC_DEFAULT_TIMEOUT_MS,
   resolveSafeCwd
-} from "./chunk-VEZEGCGW.js";
+} from "./chunk-D4MDIG46.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -310,4 +310,4 @@ export {
   parseProjectVerifierCatalogText,
   packageDeclaredCheck
 };
-//# sourceMappingURL=chunk-FYYLNIL5.js.map
+//# sourceMappingURL=chunk-GH5622CP.js.map

package/dist/{chunk-BEY543CS.js → chunk-GOXNB3AO.js}

@@ -1,4 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  AUTONOMY_EXPOSURES
+} from "./chunk-HWUFFB6L.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -234,7 +237,7 @@ function isSessionEntry(value) {
     case "taskLedger":
       return isOptionalString(v.boardId) && Array.isArray(v.goals) && v.goals.every(isTaskLedgerGoal) && Array.isArray(v.subgoals) && v.subgoals.every(isTaskLedgerGoal) && isStringArray(v.activeRunIds) && Array.isArray(v.requiredValidationEvidence) && v.requiredValidationEvidence.every(isTaskLedgerEvidence);
     case "decisionLedger":
-      return isString(v.interviewId) && isOneOf(v.interviewStatus, DECISION_INTERVIEW_STATUSES) && isString(v.startedAt) && isString(v.endedAt) && isNumber(v.roundCount) && Number.isInteger(v.roundCount) && v.roundCount >= 0 && isOptionalString(v.summary) && isOptionalString(v.transcriptPath) && Array.isArray(v.decisions) && v.decisions.every(isDecisionRecord);
+      return isString(v.interviewId) && isOneOf(v.interviewStatus, DECISION_INTERVIEW_STATUSES) && isString(v.startedAt) && isString(v.endedAt) && isNumber(v.roundCount) && Number.isInteger(v.roundCount) && v.roundCount >= 0 && isOptionalString(v.summary) && isOptionalString(v.transcriptPath) && (v.exposure === void 0 || isOneOf(v.exposure, AUTONOMY_EXPOSURES)) && Array.isArray(v.decisions) && v.decisions.every(isDecisionRecord);
     case "workerRun":
       return isString(v.assignmentId) && isString(v.runId) && isOneOf(v.origin, WORKER_RUN_ORIGINS) && isString(v.agentId) && isWorkerRunRuntime(v.runtime) && isOptionalString(v.parentToolCallId);
     case "contextEviction":
@@ -255,4 +258,4 @@ export {
   isSessionHeader,
   isSessionEntry
 };
-//# sourceMappingURL=chunk-BEY543CS.js.map
+//# sourceMappingURL=chunk-GOXNB3AO.js.map

package/dist/chunk-GWS3VEIW.js

@@ -0,0 +1,195 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  withStateFileLock,
+  withStateFileLockSync
+} from "./chunk-IKCO5N3L.js";
+import {
+  safeResourceWrite
+} from "./chunk-WEPFGWHJ.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/observability/evidence-index.ts
+init_esm_shims();
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+var MAX_EVIDENCE_INDEX_ROWS = 1e3;
+var EVIDENCE_INDEX_FILE = "evidence-index.json";
+var evidenceIndexWriteQueue = Promise.resolve();
+function indexPath(stateDir) {
+  return join(stateDir, EVIDENCE_INDEX_FILE);
+}
+function isEvidenceIndexRow(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const row = value;
+  return typeof row.runId === "string" && typeof row.evidenceId === "string" && Array.isArray(row.tags) && row.tags.every((tag) => typeof tag === "string") && typeof row.firstPassSuccess === "boolean" && typeof row.findingCount === "number" && typeof row.generatedAt === "string";
+}
+function readEvidenceIndex(stateDir) {
+  let raw;
+  try {
+    raw = readFileSync(indexPath(stateDir), "utf8");
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  return parsed.filter(isEvidenceIndexRow);
+}
+async function writeEvidenceIndexRow(stateDir, row) {
+  let bounded = [];
+  await withStateFileLock(indexPath(stateDir), () => {
+    const existing = readEvidenceIndex(stateDir).filter((entry) => entry.runId !== row.runId);
+    existing.push(row);
+    bounded = existing.length > MAX_EVIDENCE_INDEX_ROWS ? existing.slice(-MAX_EVIDENCE_INDEX_ROWS) : existing;
+    safeResourceWrite(indexPath(stateDir), `${JSON.stringify(bounded, null, 2)}
+`, { encoding: "utf8" });
+  });
+  return bounded;
+}
+async function writeEvidenceIndexRowQueued(stateDir, row) {
+  let written = [];
+  const write = evidenceIndexWriteQueue.then(async () => {
+    written = await writeEvidenceIndexRow(stateDir, row);
+  });
+  evidenceIndexWriteQueue = write.catch(() => void 0);
+  await write;
+  return written;
+}
+
+// src/domains/observability/out-of-turn-usage.ts
+init_esm_shims();
+import { closeSync, mkdirSync, openSync, readFileSync as readFileSync2, writeSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+var OUT_OF_TURN_USAGE_DIR = "usage";
+var OUT_OF_TURN_USAGE_FILE = "out-of-turn.jsonl";
+var MAX_OUT_OF_TURN_USAGE_ROWS = 1e3;
+var BOUND_CHECK_INTERVAL = 64;
+function outOfTurnUsagePath(stateDir) {
+  return join2(stateDir, OUT_OF_TURN_USAGE_DIR, OUT_OF_TURN_USAGE_FILE);
+}
+var appendsSinceBoundCheck = BOUND_CHECK_INTERVAL;
+function appendOutOfTurnUsageRow(stateDir, row) {
+  const path = outOfTurnUsagePath(stateDir);
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    const fd = openSync(path, "a");
+    try {
+      writeSync(fd, `${JSON.stringify(row)}
+`);
+    } finally {
+      closeSync(fd);
+    }
+  } catch (error) {
+    process.stderr.write(`[clio:usage] out-of-turn usage row not written: ${messageOf(error)}
+`);
+    return;
+  }
+  appendsSinceBoundCheck += 1;
+  if (appendsSinceBoundCheck < BOUND_CHECK_INTERVAL) return;
+  appendsSinceBoundCheck = 0;
+  try {
+    boundOutOfTurnUsageFile(path);
+  } catch (error) {
+    process.stderr.write(`[clio:usage] out-of-turn usage ring not bounded: ${messageOf(error)}
+`);
+  }
+}
+function boundOutOfTurnUsageFile(path) {
+  withStateFileLockSync(path, () => {
+    let raw;
+    try {
+      raw = readFileSync2(path, "utf8");
+    } catch {
+      return;
+    }
+    const lines = raw.split("\n").filter((line) => line.trim().length > 0);
+    if (lines.length <= MAX_OUT_OF_TURN_USAGE_ROWS) return;
+    const kept = lines.slice(-MAX_OUT_OF_TURN_USAGE_ROWS);
+    safeResourceWrite(path, `${kept.join("\n")}
+`, { encoding: "utf8" });
+  });
+}
+function readOutOfTurnUsageRows(stateDir) {
+  const path = outOfTurnUsagePath(stateDir);
+  let raw;
+  try {
+    raw = readFileSync2(path, "utf8");
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT" || err.code === "ENOTDIR") return { rows: [], errors: [] };
+    return { rows: [], errors: [`out-of-turn usage store unreadable: ${messageOf(error)}`] };
+  }
+  const rows = [];
+  const errors = [];
+  const lines = raw.split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line === void 0 || line.trim().length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch (error) {
+      errors.push(`${path}:${index + 1}: invalid JSON: ${messageOf(error)}`);
+      continue;
+    }
+    const row = asOutOfTurnUsageRow(parsed);
+    if (row === null) {
+      errors.push(`${path}:${index + 1}: not an out-of-turn usage row`);
+      continue;
+    }
+    rows.push(row);
+  }
+  return { rows, errors };
+}
+function asOutOfTurnUsageRow(value) {
+  if (!isRecord(value)) return null;
+  const label = value.label;
+  if (label !== "side-question" && label !== "handoff") return null;
+  if (typeof value.timestamp !== "string" || value.timestamp.length === 0) return null;
+  if (!isRecord(value.usage)) return null;
+  const usage = value.usage;
+  return {
+    label,
+    sessionId: typeof value.sessionId === "string" ? value.sessionId : null,
+    repoIdentity: typeof value.repoIdentity === "string" ? value.repoIdentity : null,
+    timestamp: value.timestamp,
+    target: typeof value.target === "string" && value.target.length > 0 ? value.target : "unknown",
+    attributedModelId: typeof value.attributedModelId === "string" && value.attributedModelId.length > 0 ? value.attributedModelId : "unknown",
+    usage: {
+      input: numberOr0(usage.input),
+      output: numberOr0(usage.output),
+      cacheRead: numberOr0(usage.cacheRead),
+      cacheWrite: numberOr0(usage.cacheWrite),
+      reasoning: numberOr0(usage.reasoning),
+      totalTokens: numberOr0(usage.totalTokens),
+      costUsd: numberOr0(usage.costUsd),
+      costProvenance: asCostProvenance(usage.costProvenance)
+    }
+  };
+}
+function asCostProvenance(value) {
+  return value === "known" || value === "known_free" || value === "estimated" ? value : "unknown";
+}
+function numberOr0(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export {
+  readEvidenceIndex,
+  writeEvidenceIndexRowQueued,
+  appendOutOfTurnUsageRow,
+  readOutOfTurnUsageRows
+};
+//# sourceMappingURL=chunk-GWS3VEIW.js.map

package/dist/{chunk-G4BMMOKF.js → chunk-HVDIIIQW.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   detectProjectType
-} from "./chunk-YHZX5GEU.js";
+} from "./chunk-XAKHZX5N.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -179,4 +179,4 @@ export {
   probeWorkspace,
   probeWorkspaceAsync
 };
-//# sourceMappingURL=chunk-G4BMMOKF.js.map
+//# sourceMappingURL=chunk-HVDIIIQW.js.map

package/dist/chunk-HWUFFB6L.js

@@ -0,0 +1,83 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/safety/autonomy.ts
+init_esm_shims();
+var AUTONOMY_LEVELS = ["read-only", "suggest", "auto-edit", "full-auto"];
+var DEFAULT_AUTONOMY_LEVEL = "auto-edit";
+function isAutonomyLevel(value) {
+  return typeof value === "string" && AUTONOMY_LEVELS.includes(value);
+}
+var AUTONOMY_EXPOSURES = ["local", "outward"];
+var DEFAULT_AUTONOMY_EXPOSURE = "local";
+function mapAutonomy(level, actionClass, options = {}) {
+  if (actionClass === "git_destructive") return "deny";
+  if ((level === "auto-edit" || level === "suggest") && options.exposure === "outward") return "ask";
+  if (actionClass === "read") return "allow";
+  if (level === "read-only") return "deny";
+  if (level === "suggest") return "ask";
+  switch (actionClass) {
+    case "write":
+      return "allow";
+    case "dispatch":
+      if (options.dispatchPlanScale === true && level !== "full-auto") return "ask";
+      return "allow";
+    case "execute": {
+      if (options.executeRecognized !== false) return "allow";
+      return level === "full-auto" ? "allow" : "ask";
+    }
+    case "unknown":
+      return "ask";
+    default:
+      return "ask";
+  }
+}
+function autonomyDenyRejection(level, tool, actionClass) {
+  return {
+    short: `${tool} denied: autonomy level is ${level}`,
+    detail: `Clio is at autonomy ${level}: ${actionClass} actions are denied without prompting. Describe the change you would make instead, so the operator can apply it or raise the autonomy level.`,
+    hints: ["Propose the exact edit or command as text.", "The operator can change the level in /settings."]
+  };
+}
+function autonomyAskRejection(level, tool, actionClass, exposure = DEFAULT_AUTONOMY_EXPOSURE) {
+  if (exposure === "outward") {
+    return {
+      short: `${tool} needs approval: outward-facing gate at autonomy ${level}`,
+      detail: `The call declared exposure=outward, so answering it publishes or sends something outside the workspace. Autonomy ${level} auto-answers local gates and parks outward-facing ones for the operator.`,
+      hints: [
+        "Approving resumes only this call.",
+        "Autonomy full-auto answers outward gates too; the safety net still applies there."
+      ]
+    };
+  }
+  return {
+    short: `${tool} needs approval (${actionClass}) at autonomy ${level}`,
+    detail: `Autonomy ${level} routes ${actionClass} actions through operator approval. The call is parked until the operator approves it once or cancels it.`,
+    hints: [
+      "Approving resumes only this call.",
+      "Recognized commands can be added to .clio-coder/safety.yaml.",
+      // The sanctioned pivots for a gated shell command: typed verification
+      // and read-class observe tools run without approval at this level,
+      // and models otherwise stall retrying denied bash for checks or
+      // directory listings.
+      ...actionClass === "execute" ? [
+        'A declared package or project-catalog check runs without approval through the verify tool: verify(check="<id>").',
+        "Read-only inspection runs without approval through the ls, read, grep, and find tools."
+      ] : []
+    ]
+  };
+}
+
+export {
+  AUTONOMY_LEVELS,
+  DEFAULT_AUTONOMY_LEVEL,
+  isAutonomyLevel,
+  AUTONOMY_EXPOSURES,
+  DEFAULT_AUTONOMY_EXPOSURE,
+  mapAutonomy,
+  autonomyDenyRejection,
+  autonomyAskRejection
+};
+//# sourceMappingURL=chunk-HWUFFB6L.js.map