@iowarp/clio-coder 0.3.8 → 0.4.0

package/dist/{chunk-4DGYLA73.js → chunk-GXNLGKAB.js}

@@ -64,12 +64,20 @@ var DEFAULT_SETTINGS = {
       enabled: true,
       everyNTools: 10,
       windowSteps: 8,
-      maxTokens: 400,
-      // A memory step runs detached from the turn that triggered it, so a
-      // generous deadline costs no interactive latency. Measured steps on a
-      // small local route ranged past two minutes, and a deadline shorter than
-      // the model discards finished work as a timeout.
-      timeoutMs: 18e4
+      // 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. 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 },
@@ -155,6 +163,35 @@ var DEFAULT_SETTINGS = {
   context: {
     workingSet: DEFAULT_WORKING_SET_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,
@@ -236,8 +273,10 @@ memory:
     enabled: true
     everyNTools: 10
     windowSteps: 8
-    maxTokens: 400
-    timeoutMs: 180000
+    # 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
@@ -449,6 +488,38 @@ context:
     protectLastTurns: 6
     minEvictableTokens: 200
 
+# Prompt pre-warm. At session start, after a resume rebuilds the message array,
+# and after a compaction settles, Clio sends the prefix the next turn would send
+# (minus your text) so a local server has already prefilled it when you press
+# Enter. Local-native targets only, interactive sessions only, and never while a
+# turn or a dispatch is running.
+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.
@@ -497,4 +568,4 @@ export {
   DEFAULT_SETTINGS,
   DEFAULT_SETTINGS_YAML
 };
-//# sourceMappingURL=chunk-4DGYLA73.js.map
+//# sourceMappingURL=chunk-GXNLGKAB.js.map

package/dist/chunk-HHV2GANA.js

@@ -0,0 +1,88 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/path-boundary.ts
+init_esm_shims();
+import path 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(path.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 {
+  PATH_BOUNDARY_MAX_ENTRIES,
+  PathBoundaryError,
+  normalizePathBoundaryEntry,
+  normalizePathBoundary,
+  asDirectoryPathBoundary,
+  resolvePathBoundary,
+  pathBoundaryEntryCovers,
+  pathBoundaryCovers
+};
+//# sourceMappingURL=chunk-HHV2GANA.js.map

package/dist/{chunk-IIZWH4XA.js → chunk-HI63TFOG.js}

@@ -2,14 +2,14 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   resolveAuthTarget,
   resolveRuntimeAuthTarget
-} from "./chunk-EQ63NRB7.js";
+} from "./chunk-BBVYXMFO.js";
 import {
   getRuntimeRegistry
 } from "./chunk-NUGM5KR6.js";
 import {
   catalogProviderForRuntime,
   listCatalogModelsForRuntime
-} from "./chunk-PT7HYKEM.js";
+} from "./chunk-VO2LKSTM.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -34,7 +34,8 @@ var SUMMARY_BY_RUNTIME_ID = {
   lmstudio: "LM Studio chat over OpenAI-compatible REST with native REST model management",
   llamacpp: "llama.cpp server (auto-detect surface)",
   "anthropic-compat": "Generic Anthropic-compatible REST",
-  "openai-compat": "Generic OpenAI-compatible REST"
+  "openai-compat": "Generic OpenAI-compatible REST",
+  litellm: "LiteLLM gateway with per-alias capability discovery and routed-model attribution"
 };
 function groupPriority(group) {
   switch (group) {
@@ -169,4 +170,4 @@ export {
   configuredTargetsForRuntime,
   resolveProviderReference
 };
-//# sourceMappingURL=chunk-IIZWH4XA.js.map
+//# sourceMappingURL=chunk-HI63TFOG.js.map