@dzhechkov/harness-cli 0.3.199 → 0.3.200

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dzhechko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -376,7 +376,7 @@ dz vector import     <file.rvf> [--project <dir>] [--json]         # RVF import
 dz vector harmonize  [--apply] [--threshold <0..1>] [--json]       # SEMANTIC merge of near-dups (dry-run default; --apply after a restorable backup)
 dz teach --harmonize [--apply] [--threshold <0..1>]                # alias of `dz vector harmonize`
 dz statusline        [--json] [--install]   # compact Claude Code statusline: live self-learning pattern count + brain sources
-dz usage             [--json] [--project <dir>]   # ESTIMATE Claude session (5h-block) + weekly (7d) token usage from local transcripts; exit 0 ALWAYS; pct=null when limits unconfigured
+dz usage             [--json] [--project <dir>] | --calibrate --session <pct> --weekly <pct> [--model fable=<pct>]   # ESTIMATE Claude usage from fixed reset windows; optional per-model weekly binding; exit 0 ALWAYS
 dz brain list        [--json]                                        # the durable cross-project knowledge brain
 dz brain query       "<q>" [--source <slug>] [--limit <N>] [--any] [--rerank] [--json]  # cross-source recall (--any = OR match; --rerank reorders on-point first). Auto-broadens: if strict all-terms match yields 0 hits, it retries once as OR and labels the result "broadened" (text note + broadened:true in --json) instead of returning empty. Explicit --any is OR from the start (never labeled broadened).
 dz brain add         [--source <slug>] [--project <dir>] [--from-slice <f>|--from-pack <p>|--from-kus <f> --slug <s> --kind <k> --license <spdx> [--override]] [--json]  # grow the brain
@@ -467,29 +467,66 @@ Modeled on the Agentic QE statusline pattern (e.g. AQE's `🎓 12 patterns`).
 
 ### Usage estimate (`dz usage`)
 
-`dz usage` prints a READONLY, never-throw ESTIMATE of Claude SESSION (active 5h-block) and WEEKLY
-(rolling 7d) token usage, aggregated from your local `~/.claude/projects/**/*.jsonl` transcripts:
+`dz usage` prints a READONLY, never-throw ESTIMATE of Claude SESSION and WEEKLY token usage,
+aggregated from your local `~/.claude/projects/**/*.jsonl` transcripts. Weekly counts start at the
+configured fixed local anchor (`memory.usage.weeklyResetAnchor`, for example `Wed 08:59`). Session
+counts use the active fixed-length transcript block (`memory.usage.sessionBlockHours`, normally `5`).
 
 ```bash
-dz usage           # session ~74% (resets 19:00) · week ~52% (resets Sat) · estimated
-dz usage --json    # {"sessionPct":74,"weeklyPct":52,"sessionTokens":…,"resetsAt":{…},"limits":{…},"estimated":true}
+dz usage           # session ~74% (resets 19:00) · week ~76% fable-bound (resets 08:59) · estimated
+dz usage --json    # {"sessionPct":74,"weeklyPct":76,"sessionTokens":...,"weeklyTokens":...,"resetsAt":{...},"limits":{...},"estimated":true}
 ```
 
 **Exit code is 0 ALWAYS** (even unconfigured/error → all-null JSON) — a probe must never distinguish
-"usage unknown" from "command failed" via a non-zero exit. Percentages are **ESTIMATES** (there is no
-official usage API); they are `null` until you configure the plan-dependent limits in `.dz/config.json`:
+"usage unknown" from "command failed" via a non-zero exit. Percentages are **ESTIMATES** from local
+transcripts; claude.ai/settings/usage is authoritative. They are `null` until you configure the
+plan-dependent limits in `.dz/config.json`:
 
 ```json
-{ "memory": { "usage": { "sessionTokenLimit": 200000000, "weeklyTokenLimit": 1000000000 } } }
+{
+  "memory": {
+    "usage": {
+      "sessionTokenLimit": 200000000,
+      "weeklyTokenLimit": 1000000000,
+      "weeklyResetAnchor": "Wed 08:59",
+      "sessionBlockHours": 5,
+      "weeklyTokenLimitByModel": { "fable": 500000000 }
+    }
+  }
+}
+```
+
+`sessionTokenLimit` and `weeklyTokenLimit` are optional; absent means that pct is `null` (unknown,
+never `0`). `weeklyTokenLimit` is the all-model weekly limit. `weeklyTokenLimitByModel` is optional;
+when it has at least one valid model limit (`fable`, `opus`, `sonnet`, or `haiku`), `weeklyPct` is the
+binding per-model percentage and `--json` adds:
+
+```json
+{
+  "weeklyByModel": { "fable": { "tokens": 380, "pct": 76 } },
+  "limits": { "session": 200000000, "weekly": 1000000000, "weeklyByModel": { "fable": 500 } }
+}
+```
+
+When no per-model limits are configured, the JSON shape stays at the legacy fields:
+`sessionPct`, `weeklyPct`, `sessionTokens`, `weeklyTokens`, `resetsAt`, `limits`, `estimated`.
+
+Calibrate from human-transcribed claude.ai percentages with one command:
+
+```bash
+dz usage --calibrate --session 20 --weekly 50 --model fable=76 --project .
 ```
 
-Both keys are OPTIONAL — absent ⇒ that `pct` is `null` (unknown, never `0`). **Calibrate** by scaling a
-limit by `X/100` when a real limit-hit lands at an estimated `X%` (observed-exhaustion calibration).
+It computes each limit as `currentTokens / (pct / 100)`, writes only `memory.usage` in
+`.dz/config.json`, and records `calibratedAt` plus `source: "claude.ai/settings/usage"`. Invalid
+percentages, unknown models, missing transcripts, and zero-token calibration requests are skipped with
+exit code `0`.
+
 This feeds `/feature-adr`'s **usage-adaptive routing** — the pipeline probes `dz usage --json` at each
-phase boundary and pre-emptively routes the remaining stages to Codex when usage crosses the threshold
-(default 70%). **Honest caveat:** at TRUE exhaustion even the Codex dispatch dies (`codex:codex-rescue`
-is a Claude wrapper), so the switch must happen BEFORE — the pre-emptive probe, not reactive detection,
-is the real defense.
+phase boundary and pre-emptively routes the remaining stages to Codex when `sessionPct` or the binding
+`weeklyPct` crosses the threshold (default 70%). **Honest caveat:** at TRUE exhaustion even the Codex
+dispatch dies (`codex:codex-rescue` is a Claude wrapper), so the switch must happen BEFORE — the
+pre-emptive probe, not reactive detection, is the real defense.
 
 ### Targets (10 platforms — 5 lossless + Copilot + AGENTS.md + Cursor + Gemini + Windsurf)
 

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAyJH,2EAA2E;AAC3E,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAitGD,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,KAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAgH5E"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA2JH,2EAA2E;AAC3E,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAq5GD,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,KAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAgH5E"}

package/dist/cli.js

@@ -9,7 +9,7 @@ import { execSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
-import { createSkill, getSkillInfo, getWorkflow, isTargetName, listSkills, runDoctor, runInit, benchmarkSkill, benchmarkSkills, scanMcp, reconcileCapabilities, RECONCILE_BANNER, buildRegistry, discoverSkillPackDirs, checkUpstream, compareSkills, checkAllUpstream, sweepSkillDrift, syncCanonicalSkill, checkUpgrades, discoverPackages, discoverSourcePackages, fetchAllDownloads, filterByCategory, pretrain, recommend, generatePlugin, publishPackages, runSetup, runMigrate, searchRegistry, runSync, runVerify, runInitAgentsMd, runInitGeminiMd, TARGET_NAMES, WORKFLOW_NAMES, importEcc, recordPattern, resolveLearningBackend, storeStats, consolidateSessions, pruneNoisePatterns, recallHybrid, teachGuard, mirrorPatternsToVector, vectorMirrorEnabled, vectorTierStatus, resolveVectorEngine, reindexVectorStore, harmonizeVectorStore, importRvfCheckpoint, statuslineData, writeFeatureAdrState, computeUsage, readUsageLimits, queryBookKnowledge, loadStorePatternsSync, bundleSkills, brainHome, listBrain, promoteProjectToBrain, updateBrainSource, queryBrain, groundPrompt, expandKu, reindexBrainVectors, buildPrimer, exportBrainSlice, importBrainSlice, registerKusToBrain, } from '@dzhechkov/harness-core';
+import { createSkill, getSkillInfo, getWorkflow, isTargetName, listSkills, runDoctor, runInit, benchmarkSkill, benchmarkSkills, scanMcp, reconcileCapabilities, RECONCILE_BANNER, buildRegistry, discoverSkillPackDirs, checkUpstream, compareSkills, checkAllUpstream, sweepSkillDrift, syncCanonicalSkill, checkUpgrades, discoverPackages, discoverSourcePackages, fetchAllDownloads, filterByCategory, pretrain, recommend, generatePlugin, publishPackages, runSetup, runMigrate, searchRegistry, runSync, runVerify, runInitAgentsMd, runInitGeminiMd, TARGET_NAMES, WORKFLOW_NAMES, importEcc, recordPattern, resolveLearningBackend, storeStats, consolidateSessions, pruneNoisePatterns, recallHybrid, teachGuard, mirrorPatternsToVector, vectorMirrorEnabled, vectorTierStatus, resolveVectorEngine, reindexVectorStore, harmonizeVectorStore, importRvfCheckpoint, statuslineData, writeFeatureAdrState, computeUsage, deriveUsageCalibration, normalizeClaudeUsageModelKey, readUsageLimits, queryBookKnowledge, loadStorePatternsSync, bundleSkills, brainHome, listBrain, promoteProjectToBrain, updateBrainSource, queryBrain, groundPrompt, expandKu, reindexBrainVectors, buildPrimer, exportBrainSlice, importBrainSlice, registerKusToBrain, } from '@dzhechkov/harness-core';
 import { getPreset, PRESET_NAMES } from '@dzhechkov/harness-presets';
 import { scanGitHub, analyzeRepo, generateReport, deepAnalyze, scanAllSources, ScoutMemory } from '@dzhechkov/scout';
 const USAGE = `dz - DZ cross-platform harness CLI
@@ -51,7 +51,7 @@ Usage:
   dz brain init  [--project <dir>] [--k <N>]                           (wire the grounding hook into .claude/settings.json — opt-in)
   dz statusline [--json] [--install] [--project <dir>]                 (live self-learning panel for Claude Code's status bar; reads the CC JSON payload from STDIN)
   dz statusline --fa-record --slug <s> --step "<label>" [--recalled <n>] [--stored <n>] [--mode <m>]   (feature-adr: record live per-run learning state → 📐 panel segment)
-  dz usage [--json] [--project <dir>]                                  (ESTIMATE Claude session (5h-block) + weekly (7d) token usage from local transcripts; exit 0 ALWAYS; pct=null when memory.usage.{sessionTokenLimit,weeklyTokenLimit} unconfigured in .dz/config.json)
+  dz usage [--json] [--project <dir>] | dz usage --calibrate --session <pct> --weekly <pct> [--model fable=<pct>] [--project <dir>]  (ESTIMATE Claude usage from fixed reset windows; optional per-model weekly binding; exit 0 ALWAYS; pct=null when limits unconfigured)
   dz pretrain [--project <dir>]
   dz recommend "<task description>"
   dz compose <preset1+preset2+...> [--target <name>]
@@ -81,6 +81,7 @@ Presets: ${PRESET_NAMES.join(', ')}`;
 /** Parse `<command> [--key value] [--flag]` argv. */
 function parseArgs(argv) {
     const options = new Map();
+    const optionLists = new Map();
     const flags = new Set();
     const positional = [];
     for (let index = 0; index < argv.length; index += 1) {
@@ -90,6 +91,9 @@ function parseArgs(argv) {
             const next = argv[index + 1];
             if (next !== undefined && !next.startsWith('--')) {
                 options.set(key, next);
+                const list = optionLists.get(key) ?? [];
+                list.push(next);
+                optionLists.set(key, list);
                 index += 1;
             }
             else {
@@ -104,7 +108,7 @@ function parseArgs(argv) {
     for (let pi = 1; pi < positional.length; pi += 1) {
         options.set(`_positional_${pi - 1}`, positional[pi] ?? '');
     }
-    return { command: positional[0] ?? '', options, flags };
+    return { command: positional[0] ?? '', options, optionLists, flags };
 }
 /**
  * Discover skill source directories: explicit `--skills-dir` if given, else
@@ -947,18 +951,165 @@ function cmdStatusline(options, flags, cwd, write, readStdin) {
         return 0;
     }
 }
+function isJsonRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function usageConfigPath(projectRoot) {
+    return join(projectRoot, '.dz', 'config.json');
+}
+function readProjectConfigForUsage(projectRoot) {
+    const path = usageConfigPath(projectRoot);
+    try {
+        if (!existsSync(path))
+            return { config: {} };
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        if (isJsonRecord(parsed))
+            return { config: parsed };
+        return { config: {}, warning: 'existing config is not a JSON object; writing a minimal config' };
+    }
+    catch {
+        return { config: {}, warning: 'existing config could not be parsed; writing a minimal config' };
+    }
+}
+function applyUsageCalibrationToConfig(config, plan) {
+    const next = { ...config };
+    const memory = isJsonRecord(next['memory']) ? { ...next['memory'] } : {};
+    const usage = isJsonRecord(memory['usage']) ? { ...memory['usage'] } : {};
+    for (const change of plan.changes) {
+        if (change.key === 'session') {
+            usage['sessionTokenLimit'] = change.after;
+        }
+        else if (change.key === 'weekly') {
+            usage['weeklyTokenLimit'] = change.after;
+        }
+        else {
+            const model = normalizeClaudeUsageModelKey(change.key);
+            if (model) {
+                const existingByModel = isJsonRecord(usage['weeklyTokenLimitByModel']) ? { ...usage['weeklyTokenLimitByModel'] } : {};
+                existingByModel[model] = change.after;
+                usage['weeklyTokenLimitByModel'] = existingByModel;
+            }
+        }
+    }
+    if (plan.changes.length > 0) {
+        usage['calibratedAt'] = plan.after.calibratedAt;
+        usage['source'] = plan.after.source;
+    }
+    memory['usage'] = usage;
+    next['memory'] = memory;
+    return next;
+}
+function parseUsageModelArgs(modelArgs) {
+    const modelPct = {};
+    const skipped = [];
+    for (const raw of modelArgs) {
+        const eq = raw.indexOf('=');
+        if (eq <= 0 || eq === raw.length - 1) {
+            skipped.push(`model ${raw}: skipped malformed model=pct argument`);
+            continue;
+        }
+        const modelName = raw.slice(0, eq).trim();
+        const model = normalizeClaudeUsageModelKey(modelName);
+        if (!model) {
+            skipped.push(`model ${modelName}: skipped unknown model`);
+            continue;
+        }
+        modelPct[model] = raw.slice(eq + 1).trim();
+    }
+    return { modelPct, skipped };
+}
+function writeUsageCalibrationSummary(opts) {
+    opts.write('usage calibrate: estimated local transcript counts; claude.ai/settings/usage is authoritative');
+    opts.write(`usage calibrate: project ${opts.projectRoot}`);
+    if (opts.configWarning)
+        opts.write(`usage calibrate: ${opts.configWarning}`);
+    for (const change of opts.plan.changes) {
+        opts.write(`usage calibrate: ${change.key} tokens=${change.tokens} pct=${change.pct}% limit ${change.before ?? 'null'} -> ${change.after}`);
+    }
+    const skipped = [...opts.preSkipped, ...opts.plan.skipped];
+    for (const item of skipped)
+        opts.write(`usage calibrate: skipped ${item}`);
+    if (opts.wrote) {
+        opts.write('usage calibrate: wrote .dz/config.json with source claude.ai/settings/usage');
+    }
+    else {
+        opts.write('usage calibrate: no config changes written');
+    }
+}
+function cmdUsageCalibrate(options, optionLists, cwd, write) {
+    const projectRoot = resolve(cwd, options.get('project') ?? '.');
+    const suppliedModels = optionLists.get('model') ?? [];
+    const parsedModels = parseUsageModelArgs(suppliedModels);
+    const modelPct = parsedModels.modelPct;
+    const hasModelPct = Object.keys(modelPct).length > 0;
+    const input = {
+        ...(options.has('session') ? { sessionPct: options.get('session') } : {}),
+        ...(options.has('weekly') ? { weeklyPct: options.get('weekly') } : {}),
+        ...(hasModelPct ? { modelPct } : {}),
+        calibratedAt: new Date().toISOString(),
+        source: 'claude.ai/settings/usage',
+    };
+    const missingInputs = [];
+    if (!options.has('session') && !options.has('weekly') && !hasModelPct) {
+        missingInputs.push('no calibration percentages supplied');
+    }
+    try {
+        const current = computeUsage(projectRoot);
+        const before = readUsageLimits(projectRoot);
+        const plan = deriveUsageCalibration(current, before, input);
+        if (plan.changes.length === 0) {
+            writeUsageCalibrationSummary({
+                projectRoot,
+                plan,
+                preSkipped: [...parsedModels.skipped, ...missingInputs],
+                wrote: false,
+                write,
+            });
+            return 0;
+        }
+        const existing = readProjectConfigForUsage(projectRoot);
+        const nextConfig = applyUsageCalibrationToConfig(existing.config, plan);
+        try {
+            mkdirSync(join(projectRoot, '.dz'), { recursive: true });
+            writeFileSync(usageConfigPath(projectRoot), JSON.stringify(nextConfig, null, 2) + '\n');
+            writeUsageCalibrationSummary({
+                projectRoot,
+                plan,
+                preSkipped: [...parsedModels.skipped, ...missingInputs],
+                configWarning: existing.warning,
+                wrote: true,
+                write,
+            });
+        }
+        catch {
+            writeUsageCalibrationSummary({
+                projectRoot,
+                plan,
+                preSkipped: [...parsedModels.skipped, ...missingInputs, 'write failed'],
+                configWarning: existing.warning,
+                wrote: false,
+                write,
+            });
+        }
+        return 0;
+    }
+    catch {
+        write('usage calibrate: skipped internal error; no config changes written');
+        return 0;
+    }
+}
 /**
- * `dz usage` — print an ESTIMATE of Claude session (active 5h-block) + weekly (rolling 7d) token
- * usage, aggregated READONLY from the local transcript store (see {@link computeUsage}). `--json`
- * emits the single-line contract the feature-adr usage-probe agent parses; the human path prints a
- * compact `session ~74% (resets 19:00) · week ~52% (resets Sat)` or an unconfigured hint.
+ * `dz usage` — print an ESTIMATE of Claude session + weekly usage from fixed reset windows,
+ * aggregated READONLY from the local transcript store (see {@link computeUsage}). `--json` emits
+ * the single-line contract the feature-adr usage-probe agent parses; `--calibrate` is the only
+ * write path and records human-transcribed claude.ai percentages in `.dz/config.json`.
  *
  * **Exit code is 0 ALWAYS** — including on internal error the whole body is guarded and prints the
  * all-null JSON, so a probe can NEVER distinguish "usage unknown" from "command failed" via a
- * non-zero exit (unknown is a first-class value, INV-3). `--project <dir>` scopes ONLY the
- * `.dz/config.json` limits read; the measurement is account-wide (all projects, FR-1.6).
+ * non-zero exit. `--project <dir>` scopes ONLY the `.dz/config.json` read/write; measurement is
+ * account-wide (all projects).
  */
-function cmdUsage(options, flags, cwd, write) {
+function cmdUsage(options, optionLists, flags, cwd, write) {
     const projectRoot = resolve(cwd, options.get('project') ?? '.');
     const nullContract = () => JSON.stringify({
         sessionPct: null,
@@ -970,18 +1121,28 @@ function cmdUsage(options, flags, cwd, write) {
         estimated: true,
     });
     try {
+        if (flags.has('calibrate'))
+            return cmdUsageCalibrate(options, optionLists, cwd, write);
         const u = computeUsage(projectRoot);
         const lim = readUsageLimits(projectRoot);
+        const modelLimits = lim.weeklyTokenLimitByModel;
+        const hasModelLimits = modelLimits !== undefined && Object.keys(modelLimits).length > 0;
         if (flags.has('json')) {
-            write(JSON.stringify({
+            const limitsPayload = { session: lim.sessionTokenLimit ?? null, weekly: lim.weeklyTokenLimit ?? null };
+            if (hasModelLimits)
+                limitsPayload.weeklyByModel = { ...modelLimits };
+            const payload = {
                 sessionPct: u.sessionPct,
                 weeklyPct: u.weeklyPct,
                 sessionTokens: u.sessionTokens,
                 weeklyTokens: u.weeklyTokens,
                 resetsAt: { session: u.sessionResetsAt, weekly: u.weeklyResetsAt },
-                limits: { session: lim.sessionTokenLimit ?? null, weekly: lim.weeklyTokenLimit ?? null },
+                limits: limitsPayload,
                 estimated: true,
-            }));
+            };
+            if (hasModelLimits && u.weeklyByModel !== undefined)
+                payload.weeklyByModel = u.weeklyByModel;
+            write(JSON.stringify(payload));
             return 0;
         }
         if (u.sessionPct === null && u.weeklyPct === null) {
@@ -1000,7 +1161,8 @@ function cmdUsage(options, flags, cwd, write) {
             }
         };
         const s = u.sessionPct === null ? 'n/a' : '~' + u.sessionPct + '%';
-        const w = u.weeklyPct === null ? 'n/a' : '~' + u.weeklyPct + '%';
+        const binding = hasModelLimits && u.weeklyBindingModel !== undefined ? ' ' + u.weeklyBindingModel + '-bound' : '';
+        const w = u.weeklyPct === null ? 'n/a' : '~' + u.weeklyPct + '%' + binding;
         write('usage: session ' + s + ' (resets ' + clock(u.sessionResetsAt) + ') · week ' + w + ' (resets ' + clock(u.weeklyResetsAt) + ') · estimated');
         return 0;
     }
@@ -3202,7 +3364,7 @@ export async function runCli(argv, io = {}) {
             return '';
         }
     };
-    const { command, options, flags } = parseArgs(argv);
+    const { command, options, optionLists, flags } = parseArgs(argv);
     if (command === '' || command === 'help' || flags.has('help')) {
         write(USAGE);
         return 0;
@@ -3221,7 +3383,7 @@ export async function runCli(argv, io = {}) {
             case 'create-skill':
                 return cmdCreateSkill(options, flags, cwd, write);
             case 'info':
-                return cmdInfo(options, { command, options, flags }, cwd, write);
+                return cmdInfo(options, { command, options, optionLists, flags }, cwd, write);
             case 'scout':
                 return await cmdScout(options, flags, cwd, write);
             case 'workflow':
@@ -3247,7 +3409,7 @@ export async function runCli(argv, io = {}) {
             case 'statusline':
                 return cmdStatusline(options, flags, cwd, write, readStdin);
             case 'usage':
-                return cmdUsage(options, flags, cwd, write);
+                return cmdUsage(options, optionLists, flags, cwd, write);
             case 'setup':
                 return await cmdSetup(options, flags, cwd, write);
             case 'pretrain':