@cruxy/cli 1.10.0 → 1.11.0

package/dist/routing/router.js

@@ -2,16 +2,11 @@ import { MODEL_TIERS } from "../brand/voice.js";
 import { routingTierUnavailable } from "../errors/index.js";
 import { resolveModelId } from "./resolve.js";
 import { AUTO_MODEL, } from "./types.js";
-/**
- * The tier a config resolves to when nothing else pins one down — mirrors the
- * gateway's `auto` fallback (`AUTO_FALLBACK_TIER` in the SDK), so an unrouted
- * cruxy session lands on exactly the tier it does today.
- */
-export const DEFAULT_TIER = "vaani";
 /**
  * The config-driven {@link Router}: maps a declared task class to a tier from
  * `{ default, map }`, and fails loud when the resolved tier is not offered. It
- * NEVER inspects prompt content — selection is purely `map[taskClass] ?? default`.
+ * NEVER inspects prompt content — selection is purely
+ * `map[taskClass] ?? default ?? null`.
  */
 export class ConfigRouter {
     cfg;
@@ -28,9 +23,17 @@ export class ConfigRouter {
         this.offered = new Set(offered);
     }
     select(taskClass) {
-        // Explicit override, else the default — an unmapped/unknown class is not an
-        // error, it just takes the default (never a crash, never the cheapest).
-        const tier = this.cfg.map[taskClass] ?? this.cfg.default;
+        // Explicit override, else the table's default, else DECLINE. An unmapped
+        // class is not an error and never a crash — but with no `default` it is not
+        // a tier either. Declining means `auto`: the gateway routes that request
+        // (see `Router.select`), which is what a table saying nothing about a class
+        // actually asked for. Picking some tier here instead would be the same
+        // silent substitution the throw below refuses, just quieter — a user who
+        // wrote `map: { summarize: kavi }` and no default said nothing whatsoever
+        // about the other four classes, and "nothing" is not a vote for a tier.
+        const tier = this.cfg.map[taskClass] ?? this.cfg.default ?? null;
+        if (tier === null)
+            return null;
         // Fail loud: a configured tier the gateway does not offer is a usage error
         // to fix, NOT a silent substitution to some other tier (a user who asked for
         // mira reasoning must never be quietly handed kavi).
@@ -42,14 +45,16 @@ export class ConfigRouter {
 }
 /**
  * The base tier implied by the session's `model.model`: a real tier passes
- * through; `auto` (and any non-tier value) falls back to {@link DEFAULT_TIER}.
- * Used so that when a user has pinned a single tier, an opt-in routing table
- * that omits `routing.default` still defaults to THEIR tier, not a fixed one.
+ * through, and `auto` (or any non-tier value) implies none — `undefined`, not a
+ * stand-in. Used so that when a user has pinned a single tier, an opt-in routing
+ * table that omits `routing.default` still defaults to THEIR tier, not a fixed
+ * one; and so that when they pinned nothing, the table does not acquire a
+ * default they never wrote.
  */
 function baseTierFromModel(model) {
     return MODEL_TIERS.includes(model)
         ? model
-        : DEFAULT_TIER;
+        : undefined;
 }
 /**
  * Build a router from resolved config, or `null` when routing should stay
@@ -68,6 +73,21 @@ export function routerForConfig(config) {
     const configured = def !== undefined || Object.keys(map).length > 0;
     if (!configured)
         return null;
+    // The fill is deliberate in ONE direction. When `model.model` names a real
+    // tier the user declared a session-wide model, so a table without a `default`
+    // inherits it — dropping those classes to `auto` would substitute the
+    // gateway's judgement for a choice they made, which is the same wrong as
+    // substituting vaani for `auto`, from the other side. When it names no tier
+    // (`auto`, the schema default) `baseTierFromModel` returns undefined and the
+    // table keeps its silence.
+    //
+    // NOT DEAD CODE, despite looking it from the session path: `session-factory`
+    // hands this router to a `SessionModel` that consults it only while the choice
+    // is `auto` (session-factory.ts:341), and a `model.model` naming a tier makes
+    // the choice that tier — so the tier branch never fires there. `cruxy pr`
+    // calls `routerForConfig` directly (cli/commands/pr.ts:69) with no
+    // `SessionModel` in front of it, and that is where a pinned `model.model`
+    // reaches this line.
     return new ConfigRouter({
         default: def ?? baseTierFromModel(config.model.model),
         map,

package/dist/routing/types.js

@@ -20,8 +20,6 @@ export const TASK_CLASSES = [
     "plan",
     /** Commit / pull-request text generation. */
     "commit-msg",
-    /** A cheap one-shot classification. */
-    "classify",
     /** Context compaction / summarization. */
     "summarize",
 ];

package/dist/session/prune.js

@@ -1,5 +1,6 @@
 import { unlinkSync } from "node:fs";
 import path from "node:path";
+import { INTERRUPTED, idKey, jobLogFilesByRecency, readJobLogTerminal, sessionKeysPresent, } from "../jobs/log-store.js";
 import { SESSION_RETENTION_FLOOR, } from "../config/index.js";
 import { sessionFilesByRecency } from "./list.js";
 import { SESSION_FILE_EXT } from "./paths.js";
@@ -30,6 +31,8 @@ export function pruneSessions(cwd, opts) {
         kept: 0,
         bytesFreed: 0,
         failed: 0,
+        jobLogsRemoved: 0,
+        jobLogBytesFreed: 0,
     };
     if (!opts.sessions.enabled)
         return result;
@@ -72,35 +75,92 @@ export function pruneSessions(cwd, opts) {
             result.kept++;
         }
     }
-    sweepOrphanedJobLogs();
+    sweepOrphanedJobLogs(cwd, result, opts);
     return result;
 }
 /**
- * Drop retained job logs whose owning session has just been pruned.
+ * Drop the job logs this project no longer has a reason to keep (#172 item 1).
  *
- * DELIBERATELY EMPTY, and reserved rather than forgotten. #172 item 1 will
- * write background-job output to the `subagents/` subtree `paths.ts` reserves
- * under this same project directory, and #257 exists because that issue asked
- * "whether the retained-on-disk log is pruned with the session or independently"
- * and found no answer. The answer is HERE, and it is: with the session, keyed on
- * the session.
+ * This is the second phase of the same mark-and-sweep `CheckpointService.prune`
+ * runs: the doomed sessions are already gone above, and what follows is the
+ * content that belonged to them. A job log IS content owned by its session,
+ * keyed on the session, exactly as a checkpoint's shadow objects are content
+ * owned by its manifest — which is the answer #172 asked for in passing and
+ * #257 was filed to settle: pruned WITH the session, not independently.
  *
- * That makes a job log content owned by its session in exactly the way a
- * checkpoint's shadow objects are content owned by its manifest — so this is
- * `CheckpointService.prune`'s second phase, the mark-and-sweep that runs after
- * the doomed manifests are gone. Filling it in needs one thing the writer does
- * not have yet: a job log has to record which session owns it, in its path or
- * its first line.
+ * ## The three rules, and why each one is where the line falls
  *
- * The hook is here so item 1 fills it rather than inventing a parallel
- * retention policy alongside this one. Whatever lands must not `rm -r` this
- * directory and must not assume every entry is a session's — `subagents/` is a
- * sibling of the session files, not one of them.
+ * **A finished job's log goes at the next start.** A `done` job's OUTCOME is
+ * already durable somewhere better: the dispatch tool's result is a
+ * `tool_result` in the session's own transcript, its file mutations are a
+ * checkpoint set `cruxy rollback <id>` still finds, and its spend is a usage
+ * record under the same id. What only this file holds is the intermediate
+ * chatter of a run that went fine — the least interesting artefact in the set.
+ * Dropping it eagerly is what keeps the steady-state cost of this subtree near
+ * zero, so the logs that survive are the ones somebody would actually open: the
+ * failed and the interrupted.
  *
- * It takes nothing today because it does nothing; item 1 will want the `cwd`
- * and the {@link PruneResult} whose `removed` names the sessions whose logs are
- * now orphaned.
+ * **An orphan goes when its session does.** Not only the sessions THIS prune
+ * removed: the rule is "no session file with this key is present", which also
+ * covers `cruxy sessions rm`, a prune from another process, and a file the user
+ * deleted by hand. Keying it on what the directory holds rather than on
+ * `result.removed` means there is no path by which a log outlives its session
+ * unnoticed.
+ *
+ * **Nothing without a terminal record is deleted while it is young.** A log
+ * with no `end` record is one of two things, and this sweep cannot tell them
+ * apart: a job that was interrupted (the whole reason to keep logs at all) or a
+ * job that is RUNNING RIGHT NOW in another terminal, whose session may not have
+ * flushed its own file yet. Treating it as garbage would delete a live job's
+ * output from under it. Both cases are handled by leaving it alone until it is
+ * older than `maxAgeDays`, at which point it is certainly not live and its
+ * session is certainly gone.
+ *
+ * The active session is skipped outright, for the reason `pruneSessions` spares
+ * its own file: "almost always survives" is not a policy to hand a user's
+ * running work.
+ *
+ * ## What it must not do
+ *
+ * No `rm -r`, and no assumption that every entry here is a session's — the
+ * scan behind {@link jobLogFilesByRecency} filters to regular `.jsonl` files
+ * whose name splits into exactly two ids, so anything else in `subagents/`
+ * (including the subtree's own subdirectories, should P3 add any) is never even
+ * considered. Never throws: a log that cannot be unlinked is left, exactly as a
+ * session that cannot be is.
  */
-function sweepOrphanedJobLogs() {
-    // #172 item 1.
+function sweepOrphanedJobLogs(cwd, result, opts) {
+    const refs = jobLogFilesByRecency(cwd);
+    if (refs.length === 0)
+        return;
+    // Derived from the directory as it stands NOW — after the deletes above — so
+    // the sessions this prune just removed are absent from it by construction and
+    // need no separate bookkeeping.
+    const present = sessionKeysPresent(sessionFilesByRecency(cwd));
+    const activeKey = opts.activeSessionId === undefined
+        ? undefined
+        : idKey(opts.activeSessionId);
+    const now = opts.now ?? Date.now();
+    const cutoff = now - opts.sessions.maxAgeDays * 24 * 60 * 60 * 1000;
+    for (const ref of refs) {
+        if (activeKey !== undefined && ref.sessionKey === activeKey)
+            continue;
+        // One bounded tail read per file, never a full one: see `TAIL_BYTES`.
+        const status = readJobLogTerminal(ref.file);
+        const orphaned = !present.has(ref.sessionKey);
+        const doomed = status === "done" ||
+            (orphaned && (status !== INTERRUPTED || ref.mtimeMs < cutoff));
+        if (!doomed)
+            continue;
+        try {
+            unlinkSync(ref.file);
+            result.jobLogsRemoved++;
+            result.jobLogBytesFreed += ref.size;
+        }
+        catch {
+            // Left in place, and deliberately NOT counted in `failed` — that field
+            // counts sessions, and inflating it here would report a conversation that
+            // could not be deleted when none was even tried.
+        }
+    }
 }

package/dist/subagent/orchestrator.js

@@ -147,7 +147,6 @@ export class SubagentOrchestrator {
         const startedAt = new Date().toISOString();
         try {
             return await this.runChild({
-                spec,
                 opts,
                 messages,
                 registry,
@@ -193,7 +192,7 @@ export class SubagentOrchestrator {
      * usage fold above can be a `finally` over every path this can leave by. */
     async runChild(args) {
         const { deps } = this;
-        const { spec, opts, messages, registry, budget, ctx, artifacts } = args;
+        const { opts, messages, registry, budget, ctx, artifacts } = args;
         const { label, noun, tag, usage } = args;
         let run;
         try {
@@ -211,7 +210,13 @@ export class SubagentOrchestrator {
                 subagent: true,
                 budget,
                 router: deps.router,
-                taskClass: spec.taskClass ?? "subagent",
+                // A LITERAL, not a per-spawn override (cli#281). Every child is a
+                // `subagent` by construction; letting the spec name its own class would
+                // hand the model a lever to route itself out of `routing.map.subagent`
+                // by relabelling, and would put the difficulty guess back in a call site
+                // whose whole contract (`routing/types.ts`) is that callers declare and
+                // nobody sniffs.
+                taskClass: "subagent",
                 signal: opts.signal,
                 // Both, and in this order (cli#244). The child's OWN collector is what
                 // the budget fold below reads — it needs a per-child record — while the
@@ -439,6 +444,14 @@ export class SubagentOrchestrator {
             return undefined; // no cruxy routing — not a weighted-pool request
         // No tier means the router chose `auto` and the gateway decides — a request
         // that still draws on the pool, so it is weighed at the worst case.
+        //
+        // A routing table that maps some classes and declares no `default` now
+        // lands here for `subagent` (it used to be filled with vaani), so such a
+        // fan-out is weighed at MAX_TIER_MULTIPLIER 3.8 rather than vaani's 3.25 —
+        // about 17% heavier against the pool. That is the intended answer, not
+        // drift: the tier genuinely is not known before the request, and a
+        // fan-out the gateway sends to kavi must not have been admitted on
+        // vaani's arithmetic.
         return resolveTaskModel(router, "subagent").tier ?? UNRESOLVED_TIER;
     }
     /**

package/dist/usage/types.js

@@ -108,6 +108,31 @@ export const UsageEntrySchema = z
      *
      * Absent means the gateway reported nothing, NOT that no reasoning ran; a
      * gateway saying so writes the literal `"none"`.
+     *
+     * FORENSIC ONLY, AND IT CANNOT BE MADE INTO A CONTROL BY READING HARDER.
+     * cli#195 proposed a per-task-class effort FLOOR — a config table whose most
+     * valuable entry was `none` on the cheap classes — and its stated ordering
+     * put a baseline first: collect real efforts, confirm compaction is being
+     * reasoned at `high`, then decide. That baseline cannot be collected from
+     * this field, and the obstacle is one field down. {@link origin} folds
+     * threshold-triggered compaction into `"turn"` — the main loop AND its
+     * compaction, deliberately, so `runCount` keeps meaning "turns" — so an
+     * effort recorded for a `summarize` call is indistinguishable from one
+     * recorded for the turn that triggered it. Only a manual `/compact` is
+     * separable, and it is separable because it is NOT the case in question.
+     * A week of passive collection therefore yields efforts that cannot be
+     * attributed to the class the floor would target. That is a property of the
+     * record's shape, not of the sample size, and it is why #195 closed on the
+     * measurement rather than on the empty week that prompted the look.
+     *
+     * WHAT TO REACH FOR INSTEAD, when the goal is a cheaper compaction. Effort
+     * lives inside output, and output is a minority of the weighted unit —
+     * roughly 7.8% across the store's own history, which is the ceiling for
+     * eliminating ALL reasoning on ALL traffic, not the floor's share of it.
+     * `TIER_MULTIPLIERS` moves the whole unit instead: kavi 3.8 → vaani 3.25 is
+     * 14.5% off input and output together, on the most input-heavy request the
+     * CLI makes. `routing.map.summarize` already expresses that, in config, with
+     * no code. Reach for the multiplier before reaching for the effort.
      */
     reasoningEffort: z.string().optional(),
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cruxy/cli",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "an agentic coding CLI",
   "type": "module",
   "bin": {