@wrongstack/cli 1.0.19 → 1.0.26

package/dist/{replay-Z3FTJEMM.js → replay-DEI566CW.js}

@@ -25,9 +25,9 @@ function bindReplayToContainer(opts) {
       warn: (m) => logger.warn?.(m)
     } : void 0
   });
-  container.bind(TOKENS.ProviderRunner, () => wrapped);
+  container.override(TOKENS.ProviderRunner, () => wrapped);
 }
 export {
   bindReplayToContainer
 };
-//# sourceMappingURL=replay-Z3FTJEMM.js.map
+//# sourceMappingURL=replay-DEI566CW.js.map

package/dist/services/commit-message.d.ts

@@ -16,7 +16,8 @@ export interface CommitLLMProvider {
                 text: string;
             }[];
         }[];
-        maxTokens: number;
+        /** Unset = the model's own output ceiling. */
+        maxTokens?: number | undefined;
         temperature?: number | undefined;
     }, opts: {
         signal: AbortSignal;

package/dist/services/dispatch-classifier.d.ts

@@ -1,12 +1,46 @@
 /**
- * LLM-backed classifier for the smart agent dispatcher.
+ * Classifier for the smart agent dispatcher.
  *
- * Wraps the session provider in the `complete(prompt) => text` shape that
- * `makeLLMClassifier` expects, so `/fleet dispatch` can fall back to the model
- * when the heuristic router is ambiguous. Mirrors the one-shot completion
- * pattern used by `generateCommitMessageWithLLM`.
+ * Two implementations behind one seam:
+ *
+ *   - `makeTypeSafeDispatchClassifier` — one typed `Choice` over the candidate
+ *     roles plus a `Noul` that can decline. Used when `fleet.dispatch
+ *     .typesafeClassifier` is on and a `typesafe` account resolves.
+ *   - `makeLLMClassifier` — the historical path: render a prompt, ask the
+ *     session provider for prose, regex out the first `{...}`. Still the
+ *     default, and still the fallback when TypeSafe is unconfigured.
+ *
+ * Either way the dispatcher only reaches a classifier when its keyword
+ * heuristic is ambiguous, so this runs on a minority of dispatches.
  */
 import type { DispatchClassifier } from '@wrongstack/core/coordination';
+import type { Config } from '@wrongstack/core/types';
+import { type WarnSink } from '@wrongstack/core/typesafe';
 import type { CommitLLMProvider } from './commit-message.js';
+/**
+ * Wrap the session provider in the `complete(prompt) => text` shape
+ * `makeLLMClassifier` expects. Mirrors `generateCommitMessageWithLLM`.
+ */
 export declare function makeProviderClassifier(provider: CommitLLMProvider, model: string): DispatchClassifier;
+/**
+ * Pick the classifier this config asks for.
+ *
+ * Falls back to the provider classifier — never to nothing — when TypeSafe is
+ * requested but unconfigured. A missing API key is a setup problem, not a
+ * reason to lose the routing the user already had.
+ */
+export declare function makeDispatchClassifier(deps: {
+    config: Config;
+    provider: CommitLLMProvider;
+    model: string;
+    env?: NodeJS.ProcessEnv | undefined;
+    /**
+     * Where the one-time "you asked for this and it is not running" line goes.
+     * Only `warn` is required; `debug` carries per-request token accounting when
+     * the host has somewhere to put it.
+     */
+    logger?: (WarnSink & {
+        debug?(message: string): void;
+    }) | undefined;
+}): DispatchClassifier;
 //# sourceMappingURL=dispatch-classifier.d.ts.map

package/dist/session-move-P2EC2COA.js

@@ -0,0 +1,44 @@
+
+// src/session-move.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { DefaultSessionStore } from "@wrongstack/core/storage";
+import { resolveWstackPaths } from "@wrongstack/core/utils";
+async function moveSessionTo(opts) {
+  const { store } = opts;
+  if (!store.move || store.sessionsDir === void 0) {
+    throw new Error("This session store cannot move sessions.");
+  }
+  const checkout = path.resolve(opts.targetPath);
+  const stat2 = await fs.stat(checkout).catch(() => null);
+  if (!stat2?.isDirectory()) throw new Error(`Not a directory: ${checkout}`);
+  const targetDir = resolveWstackPaths({
+    projectRoot: checkout,
+    ...opts.globalRoot ? { globalRoot: opts.globalRoot } : {}
+  }).projectSessions;
+  const adopt = store.adoptMovedSession?.bind(store);
+  if (path.resolve(targetDir) === path.resolve(store.sessionsDir) && adopt) {
+    return store.move(opts.sessionId, {
+      store: { sessionsDir: store.sessionsDir, adoptMovedSession: adopt },
+      checkout
+    });
+  }
+  await fs.mkdir(targetDir, { recursive: true });
+  const targetStore = new DefaultSessionStore({ dir: targetDir, projectRoot: checkout });
+  try {
+    return await store.move(opts.sessionId, { store: targetStore, checkout });
+  } finally {
+    await targetStore.dispose().catch(() => void 0);
+  }
+}
+function describeSessionMove(result) {
+  if (result.kind === "worktree") {
+    return `Moved ${result.id} to the worktree at ${result.checkout}; /resume lists it there.`;
+  }
+  return `Moved ${result.id} to the project at ${result.checkout}${result.fromProject ? ` (from ${result.fromProject})` : ""}. Open it there with: cd "${result.checkout}" && wstack resume ${result.id}`;
+}
+export {
+  describeSessionMove,
+  moveSessionTo
+};
+//# sourceMappingURL=session-move-P2EC2COA.js.map

package/dist/session-move.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `sessions move` for the CLI subcommand and the `/sessions move` slash
+ * command: resolve where a session goes and hand both stores to
+ * `SessionStore.move`.
+ *
+ * A path inside another git worktree of this repository resolves to this
+ * store (all worktrees share one), so the move only re-stamps the session's
+ * checkout. Any other path is a project of its own: its store is opened here,
+ * which connects to that project's session catalog.
+ */
+import type { SessionMoveResult, SessionStore } from '@wrongstack/core/types';
+export declare function moveSessionTo(opts: {
+    store: SessionStore;
+    sessionId: string;
+    targetPath: string;
+    globalRoot?: string | undefined;
+}): Promise<SessionMoveResult>;
+/** One line for the user: where the session went and how to open it there. */
+export declare function describeSessionMove(result: SessionMoveResult): string;
+//# sourceMappingURL=session-move.d.ts.map

package/dist/session-stats.d.ts

@@ -21,6 +21,16 @@ export declare class SessionStats {
     private bytesWritten;
     private bashCommands;
     private fetches;
+    /**
+     * First token after submit: from a leader turn's start to its first
+     * streamed text, thinking or tool call — what the user actually waits for,
+     * the provider's latency plus everything the agent does before the request.
+     * The leader is the context of the first run; subagent runs are not turns
+     * anyone typed.
+     */
+    private leaderCtx;
+    private turnStartedAt;
+    private readonly firstTokenMs;
     private readonly _handlers;
     constructor(events: EventBus, tokenCounter: TokenCounter);
     /** Remove all event listeners. Call this when the session ends. */

package/dist/{sessions-config-UL45XKX7.js → sessions-config-SXTTLNXA.js}

@@ -1,17 +1,19 @@
 import {
-  getHistoryEntry,
-  listHistory,
-  restoreFromHistory,
-  restoreLast
-} from "./chunk-B4JLSXZB.js";
+  activeProfileConfigPath
+} from "./chunk-YMXXOOFN.js";
 import {
   restoreFlags
 } from "./chunk-CSAPOCBP.js";
 import {
-  activeProfileConfigPath
-} from "./chunk-YMXXOOFN.js";
+  backupCurrent,
+  getHistoryEntry,
+  listHistory,
+  restoreFromHistory,
+  restoreLast
+} from "./chunk-WSTVGC2C.js";
 
 // src/subcommands/handlers/sessions-config.ts
+import * as path2 from "node:path";
 import { color as color2, expectDefined } from "@wrongstack/core/utils";
 
 // src/subcommands/handlers/helpers.ts
@@ -295,6 +297,35 @@ var sessionsCmd = async (args, deps) => {
     } catch (err) {
       deps.renderer.writeError(
         `Fork failed: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      return 1;
+    }
+  }
+  if (sub === "move") {
+    const moveArgs = args.slice(1);
+    const sessionId = moveArgs[0] && !moveArgs[0].startsWith("-") ? moveArgs[0] : void 0;
+    const targetPath = extractArg(moveArgs, "--to");
+    if (!sessionId || !targetPath) {
+      deps.renderer.writeError(
+        "Usage: wstack sessions move <id> --to <project or worktree path>\n"
+      );
+      return 1;
+    }
+    try {
+      const { moveSessionTo, describeSessionMove } = await import("./session-move-P2EC2COA.js");
+      const result = await moveSessionTo({
+        store: deps.sessionStore,
+        sessionId,
+        targetPath: path2.resolve(deps.cwd, targetPath),
+        globalRoot: deps.paths.globalRoot
+      });
+      deps.renderer.write(`${describeSessionMove(result)}
+`);
+      return 0;
+    } catch (err) {
+      deps.renderer.writeError(
+        `Move failed: ${err instanceof Error ? err.message : String(err)}
 `
       );
       return 1;
@@ -307,7 +338,7 @@ var sessionsCmd = async (args, deps) => {
   }
   for (const s of list)
     deps.renderer.write(
-      `  ${s.id}  ${color2.dim(s.startedAt)}  ${color2.dim(`${s.tokenTotal} tok`)}  ${s.title}
+      `  ${s.id}  ${color2.dim(s.startedAt)}  ${color2.dim(`${s.tokenTotal} tok`)}  ${s.name ? `${color2.cyan(s.name)}  ${color2.dim(s.title)}` : s.title}
 `
     );
   return 0;
@@ -322,6 +353,13 @@ var configCmd = async (args, deps) => {
   if (sub === "edit") {
     const editor = process.env["EDITOR"] ?? "vi";
     deps.renderer.write(`Run: ${editor} ${activeProfileConfigPath(deps.paths, deps.config)}
+`);
+    return 0;
+  }
+  if (sub === "backup") {
+    const profileConfigPath = activeProfileConfigPath(deps.paths, deps.config);
+    await backupCurrent(void 0, profileConfigPath);
+    deps.renderer.write(`Backed up active profile config: ${profileConfigPath}.last
 `);
     return 0;
   }
@@ -418,4 +456,4 @@ export {
   configCmd,
   sessionsCmd
 };
-//# sourceMappingURL=sessions-config-UL45XKX7.js.map
+//# sourceMappingURL=sessions-config-SXTTLNXA.js.map

package/dist/settings-menu.d.ts

@@ -22,6 +22,8 @@ interface PersistSettingDeps {
      * from landing in the wrong profile when the mutator changes activeProfile.
      */
     resolveProfilePath?: ((profileName: string) => string) | undefined;
+    /** Skip the live ConfigStore mirror when a caller is persisting a secondary split target. */
+    updateStore?: boolean | undefined;
 }
 export declare function resolvePersistPath(deps: PersistSettingDeps): string;
 /**

package/dist/short-circuit-flags-74Y5N6CF.js

@@ -0,0 +1,10 @@
+import {
+  handleHelpVersionShortCircuit
+} from "./chunk-WQV2NP57.js";
+import "./chunk-5JYDKG5B.js";
+import "./chunk-F5DCFAKI.js";
+import "./chunk-Q4INH2DG.js";
+export {
+  handleHelpVersionShortCircuit
+};
+//# sourceMappingURL=short-circuit-flags-74Y5N6CF.js.map

package/dist/{simpleui-dist-CXSIDAXZ.js → simpleui-dist-7BQISSEP.js}

@@ -4,9 +4,13 @@ import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import * as path from "node:path";
+import { wrongstackPackageJsonPath } from "@wrongstack/core/utils";
+function resolveSimpleUiPackageJson(id, req) {
+  return wrongstackPackageJsonPath(id.replace(/\/package\.json$/u, ""), (x) => req.resolve(x));
+}
 function resolveSimpleUiDistDir(deps = {}) {
   const requireFromHere = createRequire(import.meta.url);
-  const resolvePackageJson = deps.resolvePackageJson ?? ((id) => requireFromHere.resolve(id));
+  const resolvePackageJson = deps.resolvePackageJson ?? ((id) => resolveSimpleUiPackageJson(id, requireFromHere));
   const exists = deps.exists ?? existsSync;
   let packageJson;
   try {
@@ -30,7 +34,7 @@ async function ensureSimpleUiDistDir(deps = {}) {
   } catch {
   }
   const requireFromHere = createRequire(import.meta.url);
-  const resolvePackageJson = deps.resolvePackageJson ?? ((id) => requireFromHere.resolve(id));
+  const resolvePackageJson = deps.resolvePackageJson ?? ((id) => resolveSimpleUiPackageJson(id, requireFromHere));
   let packageDir;
   try {
     packageDir = path.dirname(resolvePackageJson("@wrongstack/simpleui/package.json"));
@@ -96,4 +100,4 @@ export {
   ensureSimpleUiDistDir,
   resolveSimpleUiDistDir
 };
-//# sourceMappingURL=simpleui-dist-CXSIDAXZ.js.map
+//# sourceMappingURL=simpleui-dist-7BQISSEP.js.map

package/dist/skill-suggest-L2EVWB6R.js

@@ -0,0 +1,290 @@
+
+// src/subcommands/handlers/skill-suggest.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import {
+  buildSuggesterFromConfig,
+  parseEvalJsonl,
+  scoreSuggestions,
+  sweepThresholds,
+  unknownGoldLabels
+} from "@wrongstack/core/skills";
+import { estimateTypeSafeCostUsd } from "@wrongstack/core/typesafe";
+import { color } from "@wrongstack/core/utils";
+var SWEEP_STEPS = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6];
+var EVAL_WORKERS = 4;
+var USAGE = [
+  "Usage:",
+  '  wstack skill-suggest "<request>"              preview one request',
+  "  wstack skill-suggest --eval <file.jsonl>      score a labeled set",
+  "  wstack skill-suggest --eval <file.jsonl> --sweep   \u2026and sweep thresholds",
+  "",
+  "Eval file: one JSON object per line.",
+  '  {"text": "cut a release branch for 1.2.0", "gold": "git-flow"}',
+  '  {"text": "explain what a monad is"}            // nothing covers it',
+  "",
+  "Both modes send request text to the configured TypeSafe/OpenRouter route.",
+  "Configure its key with `wstack typesafe login` and verify with `wstack typesafe test`."
+].join("\n");
+var skillSuggestCmd = async (args, deps) => {
+  const write = (line) => deps.renderer.write(`${line}
+`);
+  const flags = deps.flags ?? {};
+  const evalFile = typeof flags["eval"] === "string" ? flags["eval"] : void 0;
+  const sweep = flags["sweep"] === true || flags["sweep"] === "true";
+  const positional = args.filter((a) => !a.startsWith("-"));
+  if (flags["help"] === true || flags["h"] === true) {
+    write(USAGE);
+    return 0;
+  }
+  if (!evalFile && positional.length === 0) {
+    write(USAGE);
+    return 1;
+  }
+  const built = buildSuggesterFromConfig({
+    config: deps.config,
+    skillLoader: deps.skillLoader
+  });
+  if ("error" in built) {
+    write(color.red(`skill-suggest: ${built.error}`));
+    return 1;
+  }
+  const { suggester } = built;
+  if (evalFile) {
+    return runEval({
+      file: path.resolve(deps.cwd, evalFile),
+      sweep,
+      suggester,
+      rosterNames: (await deps.skillLoader?.list())?.map((s) => s.name) ?? [],
+      write
+    });
+  }
+  const request = positional.join(" ").trim();
+  if (!request) {
+    write(color.red("skill-suggest: give a request to preview, or --eval <file>"));
+    return 1;
+  }
+  return runPreview({ request, suggester, write, config: deps.config });
+};
+async function runPreview(input) {
+  const { write } = input;
+  const gateThreshold = input.config.skills?.suggest?.gateThreshold ?? 0.3;
+  const fitsThreshold = input.config.skills?.suggest?.fitsThreshold ?? 0.3;
+  const started = Date.now();
+  const trace = await input.suggester.explain(input.request);
+  const elapsed = Date.now() - started;
+  write("");
+  write(color.dim(`  "${truncate(input.request, 72)}"`));
+  write("");
+  if (trace.stop === "error") {
+    write(color.red("  the suggester failed \u2014 no answer to show"));
+    write(color.dim("  check the API key, the endpoint, and network reachability"));
+    return 1;
+  }
+  if (trace.stop === "roster-too-small") {
+    write(color.yellow("  roster has fewer than 2 visible skills \u2014 nothing to choose between"));
+    return 0;
+  }
+  write(
+    `  ${label("gate")} ${bar(trace.gate)} ${pct(trace.gate)} ${verdictWord(trace.gate >= gateThreshold, gateThreshold)}`
+  );
+  for (const [key, value] of Object.entries(trace.gateValues)) {
+    const inverted = key === "prose_suffices";
+    write(
+      color.dim(`      ${key.padEnd(34)} ${pct(value)}${inverted ? " (counts inverted)" : ""}`)
+    );
+  }
+  write("");
+  if (trace.ranked.length > 0) {
+    write(`  ${label("pass 1 \u2014 ranked")}`);
+    for (const entry of trace.ranked.slice(0, 5)) {
+      const shortlisted = trace.shortlist.includes(entry.name);
+      const line = `      ${pct(entry.probability).padStart(4)}  ${entry.name}`;
+      write(shortlisted ? line : color.dim(line));
+    }
+    write("");
+  }
+  if (trace.shortlist.length > 0 && Object.keys(trace.fits).length > 0) {
+    write(`  ${label("pass 2 \u2014 fits")}`);
+    for (const name of trace.shortlist) {
+      const value = trace.fits[name];
+      const marker = name === trace.winner ? color.cyan(" \u2190 choice") : "";
+      write(`      ${(value === void 0 ? "\u2014" : pct(value)).padStart(4)}  ${name}${marker}`);
+    }
+    write("");
+  }
+  const suggestion = trace.suggestion;
+  if (suggestion) {
+    write(`  ${color.green("suggests")} ${suggestion.name}`);
+  } else {
+    write(
+      `  ${color.yellow("suggests nothing")} ${color.dim(`(${stopReason(trace, gateThreshold, fitsThreshold)})`)}`
+    );
+  }
+  write(
+    color.dim(
+      `  ${trace.requests} request(s), ${elapsed}ms, ${trace.inputTokens} input tokens (~$${estimateTypeSafeCostUsd(trace.inputTokens).toFixed(6)})` + (trace.models.length > 0 ? ` \xB7 answered by ${trace.models.join(", ")}` : "")
+    )
+  );
+  write("");
+  return 0;
+}
+function stopReason(trace, gateThreshold, fitsThreshold) {
+  switch (trace.stop) {
+    case "gate":
+      return `gate ${pct(trace.gate)} below ${pct(gateThreshold)}`;
+    case "fits": {
+      const best = Math.max(...Object.values(trace.fits), 0);
+      return `best fit ${pct(best)} below ${pct(fitsThreshold)}`;
+    }
+    case "wide-failed":
+    case "rerank-failed":
+      return "the model returned no usable answer for that pass";
+    default:
+      return trace.stop;
+  }
+}
+async function runEval(input) {
+  const { write } = input;
+  let source;
+  try {
+    source = await fs.readFile(input.file, "utf8");
+  } catch {
+    write(color.red(`skill-suggest: cannot read ${input.file}`));
+    return 1;
+  }
+  const { requests, errors } = parseEvalJsonl(source);
+  for (const error of errors) {
+    write(color.yellow(`  line ${error.line}: ${error.reason}`));
+  }
+  if (requests.length === 0) {
+    write(color.red("skill-suggest: no usable cases in that file"));
+    return 1;
+  }
+  const unknown = unknownGoldLabels(requests, input.rosterNames);
+  if (unknown.length > 0) {
+    write(color.yellow(`  gold labels not in this roster: ${unknown.join(", ")}`));
+    write(color.yellow("  those cases can never be scored correct \u2014 fix or remove them"));
+    write("");
+  }
+  const covered = requests.filter((r) => r.gold).length;
+  write(
+    color.dim(
+      `  ${requests.length} cases (${covered} covered, ${requests.length - covered} uncovered) \u2192 up to ${requests.length * 2} TypeSafe requests`
+    )
+  );
+  write("");
+  const traces = await mapWithConcurrency(requests, EVAL_WORKERS, async (request) => ({
+    request,
+    // A sweep has to know what pass 2 WOULD have said below the configured
+    // gate, and a trace that stopped at the gate cannot answer that.
+    trace: await input.suggester.explain(request.text, void 0, { alwaysRerank: input.sweep })
+  }));
+  const inputTokens = traces.reduce((sum, row) => sum + row.trace.inputTokens, 0);
+  const models = [...new Set(traces.flatMap((row) => row.trace.models))];
+  write(
+    color.dim(
+      `  spent ${inputTokens} input tokens (~$${estimateTypeSafeCostUsd(inputTokens).toFixed(4)})` + (models.length > 0 ? ` \xB7 answered by ${models.join(", ")}` : "")
+    )
+  );
+  if (models.length > 1) {
+    write(
+      color.yellow(
+        "  Two model versions answered this run \u2014 the alias moved mid-run; re-run before trusting the sweep."
+      )
+    );
+  }
+  write("");
+  const failed = traces.filter((row) => row.trace.stop === "error").length;
+  if (failed > 0) {
+    write(color.yellow(`  ${failed} case(s) failed outright and count as "suggested nothing"`));
+    write("");
+  }
+  const byText = new Map(traces.map((row) => [row.request.text, row.trace]));
+  const { score, cases } = scoreSuggestions(
+    requests,
+    (request) => byText.get(request.text)?.suggestion?.name
+  );
+  writeScore(write, score);
+  const misses = cases.filter((c) => c.outcome === "wrong" || c.outcome === "needless");
+  if (misses.length > 0) {
+    write("");
+    write(`  ${label("worst cases")}`);
+    for (const miss of misses.slice(0, 10)) {
+      const wanted = miss.request.gold ?? "(nothing)";
+      write(color.dim(`      "${truncate(miss.request.text, 52)}"`));
+      write(`        wanted ${wanted}, got ${color.red(miss.suggested ?? "(nothing)")}`);
+    }
+    if (misses.length > 10) write(color.dim(`      \u2026and ${misses.length - 10} more`));
+  }
+  if (input.sweep) {
+    write("");
+    write(`  ${label("threshold sweep")}`);
+    write(
+      color.dim("      gate  fits  correct   wrong  missed  needless    (of covered / uncovered)")
+    );
+    const rows = sweepThresholds(traces, SWEEP_STEPS, SWEEP_STEPS);
+    for (const row of rows) {
+      const s = row.score;
+      write(
+        `      ${row.gateThreshold.toFixed(1)}   ${row.fitsThreshold.toFixed(1)}   ${pct(s.correct).padStart(6)}  ${pct(s.wrongSuggestion).padStart(6)}  ${pct(s.missed).padStart(6)}  ${pct(s.needless).padStart(8)}`
+      );
+    }
+    write("");
+    write(
+      color.dim(
+        "      These score the SUGGESTER against your labels, not what the agent then loads."
+      )
+    );
+    write(
+      color.dim(
+        "      Raising gate cuts needless suggestions and adds misses. Pick the one that costs you more."
+      )
+    );
+  }
+  write("");
+  return 0;
+}
+function writeScore(write, score) {
+  write(`  ${label("covered")} ${color.dim(`(${score.covered} cases)`)}`);
+  write(`      correct            ${pct(score.correct)}`);
+  write(`      wrong suggestion   ${pct(score.wrongSuggestion)}`);
+  write(`      suggested nothing  ${pct(score.missed)}`);
+  write(`  ${label("uncovered")} ${color.dim(`(${score.uncovered} cases)`)}`);
+  write(`      needless           ${pct(score.needless)}`);
+}
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    for (; ; ) {
+      const index = cursor++;
+      const item = items[index];
+      if (item === void 0) return;
+      results[index] = await fn(item);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+function pct(value) {
+  return `${(value * 100).toFixed(0)}%`;
+}
+function bar(value) {
+  const filled = Math.round(value * 10);
+  return color.dim(`[${"#".repeat(filled)}${".".repeat(10 - filled)}]`);
+}
+function label(text) {
+  return color.bold(text);
+}
+function verdictWord(passed, threshold) {
+  return passed ? color.green(`\u2265 ${pct(threshold)} \u2014 continue`) : color.yellow(`< ${pct(threshold)} \u2014 stop here`);
+}
+function truncate(text, max) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length <= max ? flat : `${flat.slice(0, max - 1)}\u2026`;
+}
+export {
+  skillSuggestCmd
+};
+//# sourceMappingURL=skill-suggest-L2EVWB6R.js.map

package/dist/slash-commands/command-context.d.ts

@@ -1,7 +1,7 @@
 import type { Context } from '@wrongstack/core/agent';
 import type { EventBus } from '@wrongstack/core/kernel';
 import type { SlashCommandRegistry, ToolRegistry } from '@wrongstack/core/registry';
-import type { CompactReport, HealthRegistry, MemoryPort, MetricsRuntimeStatus, MetricsSink, ModeStore, Renderer, SessionStore, SkillLoader, TokenCounter } from '@wrongstack/core/types';
+import type { CompactOptions, CompactReport, HealthRegistry, MemoryPort, MetricsRuntimeStatus, MetricsSink, ModeStore, PermissionPolicy, Renderer, SessionStore, SkillLoader, TokenCounter } from '@wrongstack/core/types';
 import type { WstackPaths } from '@wrongstack/core/utils';
 import type { SummarizerPort } from '@wrongstack/tools';
 import type { VectorMemoryStore } from '@wrongstack/vector-memory';
@@ -9,6 +9,12 @@ import type { VectorMemoryStore } from '@wrongstack/vector-memory';
 export interface SlashCommandContext {
     registry: SlashCommandRegistry;
     toolRegistry: ToolRegistry;
+    /**
+     * The agent's permission policy: `/permissions rules|explain` read it, and
+     * it reads each session's `/permissions allow|deny` rules from that
+     * session's context.
+     */
+    permissionPolicy?: PermissionPolicy | undefined;
     /** Run one tool through the active ToolExecutor and its permission policy. */
     executeTool?: ((name: string, input: Record<string, unknown>, ctx: Context) => Promise<{
         detail: string;
@@ -19,9 +25,7 @@ export interface SlashCommandContext {
     /** Explicit legacy SDD session codec for compatibility tests/old hosts. */
     sddSessionTransport?: 'kanban' | 'legacy-file' | undefined;
     compactor?: {
-        compact(ctx: Context, opts?: {
-            aggressive?: boolean | undefined;
-        }): Promise<CompactReport>;
+        compact(ctx: Context, opts?: CompactOptions): Promise<CompactReport>;
     };
     sessionStore?: SessionStore | undefined;
     skillLoader?: SkillLoader | undefined;
@@ -536,7 +540,13 @@ export interface SlashCommandContext {
      * Resume a persisted PhaseGraph. The host creates a new orchestrator for
      * the loaded graph and starts executing pending tasks.
      */
-    onGoalResumeFromGraph?: ((graph: import('@wrongstack/core/goal').PhaseGraph) => Promise<void>) | undefined;
+    onGoalResumeFromGraph?: ((graph: import('@wrongstack/core/goal').PhaseGraph) => Promise<{
+        ok: true;
+        graph: import('@wrongstack/core/goal').PhaseGraph;
+    } | {
+        ok: false;
+        error: string;
+    }>) | undefined;
     /** Live, read-only view of the running Goal (null when idle). */
     getGoalRunner?: () => {
         graph: import('@wrongstack/core/goal').PhaseGraph;

package/dist/slash-commands/effort.d.ts

@@ -1,6 +1,6 @@
 import { type ReasoningEffort, type SlashCommand } from '@wrongstack/core/types';
-import type { SlashCommandContext } from './command-context.js';
 import type { WstackPaths } from '@wrongstack/core/utils';
+import type { SlashCommandContext } from './command-context.js';
 /**
  * `/effort` — view or set the SESSION-WIDE reasoning effort applied to the
  * active leader model. This is the quick, discoverable front-end for

package/dist/slash-commands/fallback.d.ts

@@ -1,4 +1,4 @@
-import { type SlashCommand } from '@wrongstack/core/types';
+import type { SlashCommand } from '@wrongstack/core/types';
 import type { SlashCommandContext } from './command-context.js';
 /**
  * `/fallback` — view or change the cross-provider fallback chain that the

package/dist/slash-commands/gitid.d.ts

@@ -1,4 +1,4 @@
-import { type SlashCommand } from '@wrongstack/core/types';
+import type { SlashCommand } from '@wrongstack/core/types';
 import type { SlashCommandContext } from './command-context.js';
 /**
  * `/gitid` — view or change the commit identity (author/committer name +