@iowarp/clio-coder 0.3.9 → 0.4.0

package/dist/{chunk-S4COXYBG.js → chunk-DYJP44XW.js}

@@ -3,14 +3,14 @@ import {
   artifactDefaultPath,
   extractCommandCdTargets,
   extractCommandWriteTargets
-} from "./chunk-MV3K5QF2.js";
+} from "./chunk-GCSMB2KY.js";
 import {
   canonicalizeExistingPath
 } from "./chunk-ECH6PKUQ.js";
 import {
   ToolNames,
   isBuiltinToolName
-} from "./chunk-CGKSTWHD.js";
+} from "./chunk-K6BSR66V.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -98,6 +98,12 @@ function baseClassify(tool) {
     // local mirror. Neither touches the workspace, so it is never gated
     // behind a confirmation.
     case ToolNames.Ledger:
+    // panes focuses, opens, and closes terminal panes Clio itself created, in
+    // a pane host that lives outside the workspace. Nothing it does writes a
+    // file, runs a model-supplied command (its schema exposes presets only),
+    // or survives the session, so it is reversible, local, and never gated
+    // behind a confirmation.
+    case ToolNames.Panes:
       return "read";
     case ToolNames.Write:
     case ToolNames.Edit:
@@ -782,13 +788,24 @@ function parseChecks(value) {
   }
   return checks;
 }
+function citationWithinWorkspace(cwd, citedPath) {
+  const relative = path2.relative(cwd, citedPath);
+  if (relative === "") return true;
+  return !(relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative));
+}
+function directoryCitationDigest(cwd, citedPath) {
+  const relative = path2.relative(cwd, citedPath);
+  return createHash2("sha256").update(`directory:${relative === "" ? "." : relative}`, "utf8").digest("hex");
+}
 function validateScoutCitation(input, citation) {
   const cwd = path2.resolve(input.cwd);
   const citedPath = path2.resolve(cwd, citation.path);
-  const relative = path2.relative(cwd, citedPath);
-  if (relative === "" || relative.startsWith(`..${path2.sep}`) || relative === ".." || path2.isAbsolute(relative)) {
+  if (!citationWithinWorkspace(cwd, citedPath)) {
     return { ok: false, reason: `Scout citation path escapes the workspace: ${citation.path}` };
   }
+  if (input.filesystem.isDirectory?.(citedPath) === true) {
+    return { ok: true, evidence: { ...citation, contentDigest: directoryCitationDigest(cwd, citedPath) } };
+  }
   const content = input.filesystem.readFile(citedPath);
   if (content === null) return { ok: false, reason: `Scout citation cannot be read: ${citation.path}` };
   const lineCount = content.split(/\r\n|\r|\n/u).length;
@@ -844,14 +861,57 @@ function groundDegradedScout(contract, input, scout, degradedReason) {
 }
 function validateVerifier(contract, output) {
   const parsed = parseJson(output);
-  if (!parsed.ok) return failure(contract, "fail", parsed.reason);
+  if (!parsed.ok) return failure(contract, "fail", `Verifier result payload failed: ${parsed.reason}`);
   const value = parsed.value;
-  if (!hasOnlyKeys(value, ["verdict", "checks"]) || value.verdict !== "pass" && value.verdict !== "fail") {
-    return failure(contract, "fail", "Verifier result must carry pass or fail verdict and checks");
+  const unknown = Object.keys(value).filter((key) => key !== "verdict" && key !== "checks");
+  if (unknown.length > 0) {
+    return failure(
+      contract,
+      "fail",
+      `Verifier result field${unknown.length === 1 ? "" : "s"} ${unknown.join(", ")} ${unknown.length === 1 ? "is" : "are"} not legal; legal top-level fields are verdict and checks`
+    );
   }
-  const checks = parseChecks(value.checks);
-  if (checks === null || value.verdict === "pass" !== checks.every((check) => check.passed)) {
-    return failure(contract, "fail", "Verifier verdict must agree with every typed check");
+  if (value.verdict !== "pass" && value.verdict !== "fail") {
+    return failure(contract, "fail", 'Verifier field "verdict" must be one of: pass | fail');
+  }
+  if (!Array.isArray(value.checks) || value.checks.length === 0) {
+    return failure(
+      contract,
+      "fail",
+      'Verifier field "checks" must be a non-empty array of {name, passed, evidence}; each checks[].passed value must be one of: true | false'
+    );
+  }
+  const checks = [];
+  for (const [index, raw] of value.checks.entries()) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+      return failure(contract, "fail", `Verifier field "checks[${index}]" must be an object`);
+    }
+    const check = raw;
+    const checkUnknown = Object.keys(check).filter((key) => key !== "name" && key !== "passed" && key !== "evidence");
+    if (checkUnknown.length > 0) {
+      return failure(
+        contract,
+        "fail",
+        `Verifier field "checks[${index}].${checkUnknown[0]}" is not legal; legal check fields are name, passed, and evidence`
+      );
+    }
+    if (!string(check.name)) {
+      return failure(contract, "fail", `Verifier field "checks[${index}].name" must be a non-empty string`);
+    }
+    if (typeof check.passed !== "boolean") {
+      return failure(contract, "fail", `Verifier field "checks[${index}].passed" must be one of: true | false`);
+    }
+    if (!string(check.evidence)) {
+      return failure(contract, "fail", `Verifier field "checks[${index}].evidence" must be a non-empty string`);
+    }
+    checks.push({ name: check.name, passed: check.passed, evidence: check.evidence });
+  }
+  if (value.verdict === "pass" !== checks.every((check) => check.passed)) {
+    return failure(
+      contract,
+      "fail",
+      'Verifier field "verdict" must agree with every checks[].passed value; verdict legal values are pass | fail and checks[].passed legal values are true | false'
+    );
   }
   const verifier = { verdict: value.verdict, checks };
   return success(contract, value.verdict, verifier, { verifier });
@@ -944,38 +1004,80 @@ function resultContractAuthorship(contract, output) {
 }
 function validateDebugger(contract, output) {
   const parsed = parseJson(output);
-  if (!parsed.ok) return failure(contract, "unmeasured", parsed.reason);
+  if (!parsed.ok) return failure(contract, "unmeasured", `Debugger result payload failed: ${parsed.reason}`);
   const value = parsed.value;
-  if (!hasOnlyKeys(value, ["diagnosis", "reproduction", "evidence"]) || !string(value.diagnosis) || value.reproduction !== "reproduced" && value.reproduction !== "not-reproduced" && value.reproduction !== "unknown" || !Array.isArray(value.evidence) || value.evidence.some((entry) => !string(entry))) {
+  const unknown = Object.keys(value).filter(
+    (key) => key !== "diagnosis" && key !== "reproduction" && key !== "evidence"
+  );
+  if (unknown.length > 0) {
     return failure(
       contract,
       "unmeasured",
-      "Debugger result must carry diagnosis, reproduction status, and evidence without a verdict"
+      `Debugger result field${unknown.length === 1 ? "" : "s"} ${unknown.join(", ")} ${unknown.length === 1 ? "is" : "are"} not legal; legal top-level fields are diagnosis, reproduction, and evidence`
     );
   }
+  if (!string(value.diagnosis)) {
+    return failure(contract, "unmeasured", 'Debugger field "diagnosis" must be a non-empty string');
+  }
+  if (value.reproduction !== "reproduced" && value.reproduction !== "not-reproduced" && value.reproduction !== "unknown") {
+    return failure(
+      contract,
+      "unmeasured",
+      'Debugger field "reproduction" must be one of: reproduced | not-reproduced | unknown'
+    );
+  }
+  if (!Array.isArray(value.evidence)) {
+    return failure(contract, "unmeasured", 'Debugger field "evidence" must be an array of strings');
+  }
+  const malformedEvidence = value.evidence.findIndex((entry) => !string(entry));
+  if (malformedEvidence >= 0) {
+    return failure(contract, "unmeasured", `Debugger field "evidence[${malformedEvidence}]" must be a non-empty string`);
+  }
   return success(contract, "unmeasured", value);
 }
 function validateResearch(contract, output, networkAllowed) {
   const parsed = parseJson(output);
-  if (!parsed.ok) return failure(contract, "unmeasured", parsed.reason);
+  if (!parsed.ok) return failure(contract, "unmeasured", `Research result payload failed: ${parsed.reason}`);
   const value = parsed.value;
-  if (!hasOnlyKeys(value, ["source", "findings"]) || value.source !== "local" && value.source !== "external" || !Array.isArray(value.findings)) {
+  const unknown = Object.keys(value).filter((key) => key !== "source" && key !== "findings");
+  if (unknown.length > 0) {
     return failure(
       contract,
       "unmeasured",
-      "Research result must distinguish local or external sources and carry findings"
+      `Research result field${unknown.length === 1 ? "" : "s"} ${unknown.join(", ")} ${unknown.length === 1 ? "is" : "are"} not legal; legal top-level fields are source and findings`
     );
   }
+  if (value.source !== "local" && value.source !== "external") {
+    return failure(contract, "unmeasured", 'Research field "source" must be one of: local | external');
+  }
+  if (!Array.isArray(value.findings)) {
+    return failure(contract, "unmeasured", 'Research field "findings" must be an array of {claim, evidence} objects');
+  }
   if (value.source === "external" && !networkAllowed) {
-    return failure(contract, "unmeasured", "external research requires an allowed network posture");
+    return failure(
+      contract,
+      "unmeasured",
+      'Research field "source" is external but the run has no allowed network posture; legal values are local | external, and use local for workspace-only evidence'
+    );
   }
-  for (const finding of value.findings) {
+  for (const [index, finding] of value.findings.entries()) {
     if (finding === null || typeof finding !== "object" || Array.isArray(finding)) {
-      return failure(contract, "unmeasured", "Research findings must be objects");
+      return failure(contract, "unmeasured", `Research field "findings[${index}]" must be an object`);
     }
     const record = finding;
-    if (!hasOnlyKeys(record, ["claim", "evidence"]) || !string(record.claim) || !string(record.evidence)) {
-      return failure(contract, "unmeasured", "Research findings must carry claim and evidence");
+    const findingUnknown = Object.keys(record).filter((key) => key !== "claim" && key !== "evidence");
+    if (findingUnknown.length > 0) {
+      return failure(
+        contract,
+        "unmeasured",
+        `Research field "findings[${index}].${findingUnknown[0]}" is not legal; legal finding fields are claim and evidence`
+      );
+    }
+    if (!string(record.claim)) {
+      return failure(contract, "unmeasured", `Research field "findings[${index}].claim" must be a non-empty string`);
+    }
+    if (!string(record.evidence)) {
+      return failure(contract, "unmeasured", `Research field "findings[${index}].evidence" must be a non-empty string`);
     }
   }
   return success(contract, "unmeasured", value);
@@ -1166,15 +1268,15 @@ function resultContractShape(contract) {
     case "scout-report":
       return '{"findings":[{"claim":"what you observed","path":"src/file.ts","line":1}],"needsSplit":false,"proposedSubtasks":[]} or {"findings":[],"needsSplit":true,"proposedSubtasks":[{"id":"inspect","task":"Inspect the boundary","dependencies":[],"expectedResultContract":"scout-report","requestedAuthority":"read-only"}]} or, if you cannot produce a citation you are sure of, at least {"findings":[{"claim":"what you observed"}]}, which is accepted as an ungrounded lead rather than losing the run';
     case "verifier-report":
-      return '{"verdict":"pass","checks":[{"name":"npm run typecheck","passed":true,"evidence":"exit 0"}]}';
+      return 'one of {"verdict":"pass","checks":[{"name":"npm run typecheck","passed":true,"evidence":"exit 0"}]} or {"verdict":"fail","checks":[{"name":"npm run typecheck","passed":false,"evidence":"exit 1"}]}; verdict legal values are pass | fail and checks[].passed legal values are true | false';
     case "council-report":
       return '{"members":[{"label":"alpha","runId":"run-1","round":1,"answer":"..."}],"synthesis":{"kind":"none"}}';
     case "council-ballot":
       return COUNCIL_BALLOT_SHAPE;
     case "debugger-report":
-      return '{"diagnosis":"...","reproduction":"reproduced","evidence":["..."]}';
+      return 'one of {"diagnosis":"...","reproduction":"reproduced","evidence":["..."]}, {"diagnosis":"...","reproduction":"not-reproduced","evidence":["..."]}, or {"diagnosis":"...","reproduction":"unknown","evidence":["..."]}; reproduction legal values are reproduced | not-reproduced | unknown';
     case "research-report":
-      return '{"source":"local","findings":[{"claim":"...","evidence":"..."}]}';
+      return 'one of {"source":"local","findings":[{"claim":"...","evidence":"..."}]} or {"source":"external","findings":[{"claim":"...","evidence":"..."}]}; source legal values are local | external';
     case "mutation-report":
       return '{"mutatedPaths":["src/file.ts"],"validations":[{"name":"npm test","passed":true,"evidence":"exit 0"}],"commitMessage":"optional: the commit message for this change","summary":"optional: one line"}';
     case "provenance-report":
@@ -1285,78 +1387,6 @@ function parseWorkerResultContract(value, sourcePath) {
   return parseContract(value, sourcePath, [...RECIPE_DECLARABLE_KINDS, ...COORDINATOR_AUTHORED_KINDS]);
 }
 
-// src/core/path-boundary.ts
-init_esm_shims();
-import path3 from "node:path";
-var PATH_BOUNDARY_MAX_ENTRIES = 32;
-var PathBoundaryError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "PathBoundaryError";
-    this.code = code;
-  }
-};
-var GLOB_CHARACTERS = /[*?[\]{}]/u;
-function normalizePathBoundaryEntry(entry) {
-  const raw = entry.trim();
-  if (raw.length === 0) throw new PathBoundaryError("empty", "write boundary: entry must be a non-empty path");
-  if (raw.includes("\\")) {
-    throw new PathBoundaryError("separator", `write boundary: entry '${entry}' must use '/' separators`);
-  }
-  if (GLOB_CHARACTERS.test(raw)) {
-    throw new PathBoundaryError("glob", `write boundary: entry '${entry}' looks like a glob, which v1 does not support`);
-  }
-  if (raw.startsWith("/") || /^[A-Za-z]:/u.test(raw)) {
-    throw new PathBoundaryError("absolute", `write boundary: entry '${entry}' must be repository-relative, not absolute`);
-  }
-  const subtree = raw.endsWith("/");
-  const segments = raw.split("/").filter((segment) => segment.length > 0);
-  if (segments.length === 0) {
-    throw new PathBoundaryError("empty", `write boundary: entry '${entry}' must name a path inside the repository`);
-  }
-  for (const segment of segments) {
-    if (segment === "..") {
-      throw new PathBoundaryError("parent", `write boundary: entry '${entry}' must not contain '..'`);
-    }
-    if (segment === ".") {
-      throw new PathBoundaryError("dot", `write boundary: entry '${entry}' must not contain '.' segments`);
-    }
-  }
-  const joined = segments.join("/");
-  return subtree ? `${joined}/` : joined;
-}
-function normalizePathBoundary(entries) {
-  if (entries.length > PATH_BOUNDARY_MAX_ENTRIES) {
-    throw new Error(`write boundary: at most ${PATH_BOUNDARY_MAX_ENTRIES} entries may be declared`);
-  }
-  return [...new Set(entries.map(normalizePathBoundaryEntry))].sort();
-}
-function toPosixBoundaryPath(value) {
-  return value.split("\\").join("/");
-}
-function isDirectoryPathBoundary(entry) {
-  return toPosixBoundaryPath(entry).endsWith("/");
-}
-function asDirectoryPathBoundary(entry) {
-  const normalized = toPosixBoundaryPath(entry);
-  return normalized.endsWith("/") ? normalized : `${normalized}/`;
-}
-function resolvePathBoundary(cwd, entry) {
-  const directory = isDirectoryPathBoundary(entry);
-  const withoutMarker = directory ? entry.slice(0, -1) : entry;
-  const resolved = toPosixBoundaryPath(path3.resolve(cwd, withoutMarker));
-  return directory ? asDirectoryPathBoundary(resolved) : resolved;
-}
-function pathBoundaryEntryCovers(outer, inner) {
-  const normalizedOuter = toPosixBoundaryPath(outer);
-  const normalizedInner = toPosixBoundaryPath(inner);
-  return normalizedOuter.endsWith("/") ? normalizedInner.startsWith(normalizedOuter) : !normalizedInner.endsWith("/") && normalizedInner === normalizedOuter;
-}
-function pathBoundaryCovers(boundary, candidate) {
-  return boundary.some((entry) => pathBoundaryEntryCovers(entry, candidate));
-}
-
 export {
   parseJsonObjectPayload,
   classify,
@@ -1384,16 +1414,9 @@ export {
   validateResultContract,
   validateRecipeResult,
   RESULT_CONTRACT_REPAIR_LIMIT,
+  resultContractShape,
   resultContractRepairMessages,
   parseResultContract,
-  parseWorkerResultContract,
-  PATH_BOUNDARY_MAX_ENTRIES,
-  PathBoundaryError,
-  normalizePathBoundaryEntry,
-  normalizePathBoundary,
-  asDirectoryPathBoundary,
-  resolvePathBoundary,
-  pathBoundaryEntryCovers,
-  pathBoundaryCovers
+  parseWorkerResultContract
 };
-//# sourceMappingURL=chunk-S4COXYBG.js.map
+//# sourceMappingURL=chunk-DYJP44XW.js.map

package/dist/{chunk-N5XKWMDW.js → chunk-F4CKPOEQ.js}

@@ -2,25 +2,25 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   canonicalJson,
   sha256
-} from "./chunk-MLOK6ZOS.js";
+} from "./chunk-B7OBL7PK.js";
 import {
   addResponseModelIdObservationCount,
   emptyResponseModelIdObservationCounts,
   responseModelIdObservationFromRecord
-} from "./chunk-LXPJXFM5.js";
+} from "./chunk-QREDIESB.js";
 import {
   uncachedPrefillTokens
 } from "./chunk-3DPEIQKN.js";
 import {
   ToolNames
-} from "./chunk-CGKSTWHD.js";
+} from "./chunk-K6BSR66V.js";
 import {
   ceilChars,
   extractReasoningTokens
-} from "./chunk-AEYBF3TB.js";
+} from "./chunk-UM7N4G5A.js";
 import {
   settingsPath
-} from "./chunk-PNY46YEY.js";
+} from "./chunk-VFA6GDY5.js";
 import {
   expandConfigPath
 } from "./chunk-SST6Z5JA.js";
@@ -1104,4 +1104,4 @@ export {
   readFileArgsAsync,
   expandInlineFileReferencesAsync
 };
-//# sourceMappingURL=chunk-N5XKWMDW.js.map
+//# sourceMappingURL=chunk-F4CKPOEQ.js.map

package/dist/{chunk-AMKHQW3C.js → chunk-FEFIFZTL.js}

@@ -1,13 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   enabledExtensionResourceRoots
-} from "./chunk-5QKCQQ3E.js";
+} from "./chunk-SUW5DORT.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
 import {
   clioConfigDir
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   __toESM,
   init_esm_shims
@@ -120,4 +120,4 @@ export {
   splitYamlFrontmatter,
   stringField
 };
-//# sourceMappingURL=chunk-AMKHQW3C.js.map
+//# sourceMappingURL=chunk-FEFIFZTL.js.map

package/dist/{chunk-MV3K5QF2.js → chunk-GCSMB2KY.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-ECH6PKUQ.js";
 import {
   ToolNames
-} from "./chunk-CGKSTWHD.js";
+} from "./chunk-K6BSR66V.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -761,4 +761,4 @@ export {
   extractCommandDeleteTargets,
   tokenizeShellLike
 };
-//# sourceMappingURL=chunk-MV3K5QF2.js.map
+//# sourceMappingURL=chunk-GCSMB2KY.js.map

package/dist/{chunk-7C6RYZGQ.js → chunk-GKF55TAZ.js}

@@ -4,14 +4,14 @@ import {
   extractCommandDeleteTargets,
   extractCommandWriteTargets,
   toolMutationPaths
-} from "./chunk-MV3K5QF2.js";
+} from "./chunk-GCSMB2KY.js";
 import {
   isProjectVerifierCheckId,
   isVerificationScriptName
 } from "./chunk-UL3WSD3F.js";
 import {
   ToolNames
-} from "./chunk-CGKSTWHD.js";
+} from "./chunk-K6BSR66V.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -388,4 +388,4 @@ export {
   assessFinishContract,
   typedValidationSummary
 };
-//# sourceMappingURL=chunk-7C6RYZGQ.js.map
+//# sourceMappingURL=chunk-GKF55TAZ.js.map

package/dist/{chunk-B5XRQOLB.js → chunk-GR5G2PVF.js}

@@ -2,22 +2,22 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   readLayeredSettings,
   readStrictLayeredSettings
-} from "./chunk-FALJGAWU.js";
+} from "./chunk-7MCTRUCE.js";
 import {
   formatBootTrace
 } from "./chunk-HKIYEGME.js";
 import {
   initializeClioHome
-} from "./chunk-56KB5IJP.js";
+} from "./chunk-2OQE55CK.js";
 import {
   readSettings
-} from "./chunk-PNY46YEY.js";
+} from "./chunk-VFA6GDY5.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
 import {
   clioConfigDir
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   findEngineEnvKeys,
   getEngineEnvApiKey
@@ -100,6 +100,7 @@ var BUILTIN_RUNTIME_BOOT_MANIFEST = [
   { id: "lmstudio", aliases: ["lmstudio-native"], kind: "http", tier: "local-native", auth: "api-key" },
   { id: "ollama-native", kind: "http", tier: "local-native", auth: "none" },
   { id: "anthropic-compat", kind: "http", tier: "protocol", auth: "api-key" },
+  { id: "litellm", kind: "http", tier: "protocol", auth: "api-key" },
   { id: "openai-compat", kind: "http", tier: "protocol", auth: "api-key" },
   { id: "sglang", kind: "http", tier: "local-native", auth: "api-key" },
   { id: "vllm", kind: "http", tier: "local-native", auth: "api-key" },
@@ -158,7 +159,7 @@ Run \`clio-coder auth login ${verdict.store}\` if the endpoint requires one; loc
     } else if (verdict.kind !== "usable") {
       process.stdout.write(`${describeVerdict(verdict)} Starting \`clio-coder configure\`.
 `);
-      const { runConfigureCommand } = await import("./configure-2WYWSCSD.js");
+      const { runConfigureCommand } = await import("./configure-TEGEBYCA.js");
       const configured = await runConfigureCommand([]);
       if (configured !== 0) return configured;
       startupSettings = readStrictLayeredSettings(process.cwd()).settings;
@@ -167,7 +168,7 @@ Run \`clio-coder auth login ${verdict.store}\` if the endpoint requires one; loc
   let terminalLease;
   try {
     if (terminalLeaseEligible(options)) {
-      const { createProcessTerminalLease, instantShellEnabled } = await import("./terminal-lease-QYVORFR4.js");
+      const { createProcessTerminalLease, instantShellEnabled } = await import("./terminal-lease-44SV3YCN.js");
       if (instantShellEnabled()) {
         let stage0FrameId = null;
         terminalLease = createProcessTerminalLease({
@@ -190,7 +191,7 @@ Run \`clio-coder auth login ${verdict.store}\` if the endpoint requires one; loc
         throw new Error("injected Stage 1 hydration failure");
       }
     }
-    const { bootOrchestrator } = await import("./orchestrator-ZKBPCHW6.js");
+    const { bootOrchestrator } = await import("./orchestrator-GCGQ4N5I.js");
     const result = await bootOrchestrator({
       ...options,
       ...startupSettings ? { startupSettings } : {},
@@ -214,4 +215,4 @@ export {
   terminalLeaseEligible,
   runClioCommand
 };
-//# sourceMappingURL=chunk-B5XRQOLB.js.map
+//# sourceMappingURL=chunk-GR5G2PVF.js.map

package/dist/{chunk-XDOQXGFO.js → chunk-GXNLGKAB.js}

@@ -64,16 +64,20 @@ var DEFAULT_SETTINGS = {
       enabled: true,
       everyNTools: 10,
       windowSteps: 8,
-      maxTokens: 400,
+      // Budget for the answer and any reasoning tokens that precede it.
+      // An always-on-thinking 35B spent the measured 400/400 completion
+      // tokens on reasoning and stopped with finish_reason=length before it
+      // emitted content, so the old budget made a useful step unreachable.
+      maxTokens: 2e3,
       // A memory step runs detached from the turn that triggered it, but it
       // runs on a real inference endpoint that the operator's own turns and
       // dispatched workers also queue against. The operator's ledger over 14
       // days recorded 60 llm-tier steps spending 1,666 seconds of model time
       // for 6 injections, with one step holding a local server for 102.5
-      // seconds to answer nothing. The deadline is what a turn boundary can
-      // actually wait for; a step that runs past it is recorded as timed out
-      // rather than spending the remaining minutes unobserved.
-      timeoutMs: 3e4
+      // seconds to answer nothing. A viable output budget earns one minute,
+      // while consecutive timeouts degrade the plane to its free rules tier
+      // instead of repeatedly occupying the endpoint for that full minute.
+      timeoutMs: 6e4
     }
   },
   watchdog: { enabled: false },
@@ -162,6 +166,32 @@ var DEFAULT_SETTINGS = {
   prewarm: {
     enabled: true
   },
+  panes: {
+    /**
+     * Off: a plain `clio-coder` performs zero pane-host work, and none of the
+     * mux domain even loads. The extension is activated per session with
+     * `clio-coder --with-panes`, or durably by setting this to `auto` (guest
+     * mode when a pane host is detected). The flag beats the setting in both
+     * directions.
+     */
+    enabled: "off",
+    /** A toast per finished run is noise; a toast per failure is the signal. */
+    notifications: "failures",
+    /**
+     * Tee every dispatched run's display event tail to
+     * `<state>/runs/<runId>/events.ndjson`. The live tail is otherwise
+     * in-process only, so this is what lets `clio-coder fleet view` follow a
+     * run from a second terminal. Written regardless of any pane host being
+     * present; turning it off costs the viewer its transcript and nothing else.
+     */
+    journal: true,
+    yazi: {
+      enabled: true,
+      mode: "companion",
+      profile: "managed",
+      followCwd: true
+    }
+  },
   retry: {
     enabled: true,
     maxRetries: 3,
@@ -243,8 +273,10 @@ memory:
     enabled: true
     everyNTools: 10
     windowSteps: 8
-    maxTokens: 400
-    timeoutMs: 30000
+    # Covers the answer and any thinking before it. An always-on-thinking 35B
+    # spent the measured 400/400 tokens on reasoning, then stopped at length.
+    maxTokens: 2000
+    timeoutMs: 60000
 
 # Opt-in turn-end watchdog. When enabled, a turn that changed the tree is
 # reviewed by one read-only verifier run briefed with the turn's coalesced diff
@@ -464,6 +496,30 @@ context:
 prewarm:
   enabled: true
 
+# The pane layer. Off by default: plain \`clio-coder\` does no pane-host work at
+# all. Start \`clio-coder --with-panes\` to activate the extension for one
+# session, or set enabled: auto to activate it whenever a pane host is
+# detected (embedded, a Clio-owned private session, is not implemented yet).
+# The command-line flag beats this setting in both directions. notifications
+# picks which terminal run states raise a toast. journal tees every dispatched
+# run's event tail to <state>/runs/<runId>/events.ndjson so
+# \`clio-coder fleet view <runId> --follow\` can watch a run from a second
+# terminal; it is written regardless of any pane host being present. Journal
+# directories are removed when their run leaves the run ledger ring, and
+# \`clio-coder reset --state\` clears them with the rest of the state root.
+panes:
+  enabled: off
+  notifications: failures
+  journal: true
+  # The files pane uses a managed, reproducible Yazi profile by default.
+  # profile: user preserves the operator's Yazi configuration and therefore
+  # forces one-shot chooser mode, since that profile has no Clio pick chord.
+  yazi:
+    enabled: true
+    mode: companion
+    profile: managed
+    followCwd: true
+
 # Transient provider/stream retry controls for interactive chat.
 # Retryable errors include overloads, rate limits, 5xx responses, network
 # resets, and timeouts. Context overflow uses compaction recovery instead.
@@ -512,4 +568,4 @@ export {
   DEFAULT_SETTINGS,
   DEFAULT_SETTINGS_YAML
 };
-//# sourceMappingURL=chunk-XDOQXGFO.js.map
+//# sourceMappingURL=chunk-GXNLGKAB.js.map