howtofixcli 0.7.13 → 0.7.15

package/package.json

@@ -1,8 +1,20 @@
 {
   "name": "howtofixcli",
-  "version": "0.7.13",
-  "description": "HowToFix coding agent. Workbench TUI, sessions, background agents.",
+  "version": "0.7.15",
   "type": "module",
+  "description": "HowToFix coding agent. Workbench TUI, sessions, background agents.",
+  "license": "UNLICENSED",
+  "homepage": "https://howtofix.id",
+  "author": "HowToFix",
+  "keywords": [
+    "coding-agent",
+    "cli",
+    "tui",
+    "howtofix"
+  ],
+  "engines": {
+    "node": ">=22.19"
+  },
   "bin": {
     "howtofix": "dist/main.js"
   },
@@ -11,72 +23,13 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json && node --input-type=module -e \"import { rmSync, cpSync } from 'node:fs'; rmSync('dist/presets', { recursive: true, force: true }); cpSync('presets', 'dist/presets', { recursive: true });\" && node scripts/set-executable.mjs",
-    "start": "node dist/main.js",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "check": "node scripts/check-all.mjs",
-    "check:hub": "node scripts/check-hub-install.mjs",
-    "check:tar": "node scripts/check-tar.mjs --online",
-    "quality": "node scripts/quality.mjs",
-    "frame": "node scripts/render-frame.mjs",
-    "frame:workflow": "node scripts/render-workflow-frame.mjs",
-    "probe:commands": "python3 scripts/probe-slash-commands.py",
-    "build:release": "node scripts/build-release.mjs",
-    "version": "node scripts/sync-version.mjs",
-    "slop": "node scripts/slop.mjs",
-    "slop:commits": "node scripts/slop.mjs --commits",
-    "hooks:install": "git config core.hooksPath .githooks && echo 'hooks installed from .githooks'",
-    "check:sync": "node scripts/check-hub-sync.mjs --online",
-    "check:level-color": "python3 scripts/probe-level-color.py",
-    "check:skills-wire": "node scripts/check-skill-wire.mjs",
-    "check:agents-live": "node scripts/check-subagent-live.mjs",
-    "release:patch": "node scripts/release.mjs patch",
-    "release:minor": "node scripts/release.mjs minor",
-    "release:major": "node scripts/release.mjs major",
-    "release:dry": "node scripts/release.mjs patch --dry",
-    "test": "node --test test/*.test.mjs",
-    "format": "prettier --write \"src/**/*.ts\" \"scripts/**/*.mjs\" \"test/**/*.mjs\"",
-    "format:check": "prettier --check \"src/**/*.ts\" \"scripts/**/*.mjs\" \"test/**/*.mjs\""
-  },
-  "license": "UNLICENSED",
-  "engines": {
-    "node": ">=22.19"
-  },
   "dependencies": {
     "@netrodev/hxf-agent-core": "^1.0.22",
     "@netrodev/hxf-ai": "^1.0.22",
     "@netrodev/hxf-coding-agent": "^1.0.27",
     "@netrodev/hxf-tui": "^1.0.22",
-    "typebox": "1.3.27",
+    "typebox": "^1.4.3",
     "typescript": "7.0.2",
-    "undici": "^8.10.2"
-  },
-  "devDependencies": {
-    "@types/node": "^22.20.5",
-    "esbuild": "^0.28.2",
-    "prettier": "^3.9.10"
-  },
-  "homepage": "https://howtofix.id",
-  "author": "HowToFix",
-  "keywords": [
-    "coding-agent",
-    "cli",
-    "tui",
-    "howtofix"
-  ],
-  "contributors": [
-    {
-      "name": "hshinosa",
-      "url": "https://github.com/hshinosa"
-    },
-    {
-      "name": "yhagus",
-      "url": "https://github.com/yhagus"
-    },
-    {
-      "name": "mmatttttt",
-      "url": "https://github.com/mmatttttt"
-    }
-  ]
+    "undici": "^8.12.3"
+  }
 }

package/dist/account-credential.js

@@ -1,136 +0,0 @@
-/**
- * Signing in with the account itself, not with a key made for the occasion.
- *
- * ## The problem this replaces
- *
- * `/connect` ended in a browser flow whose approval minted a fresh `sk-` key
- * every time. A user who reconnected a few times found a panel full of
- * near-identical rows, could not tell which one the CLI was using, and had to
- * revoke them one by one. The account was already the thing being proven; the
- * key was only a side effect of proving it.
- *
- * ## What happens instead
- *
- * The credential — `email:password`, base64-encoded — is stored once in the agent
- * directory, mode 600, and sent to `POST /api/auth/cli/credential`. The panel
- * verifies it and answers with the CLI key this account already owns; only an
- * account with no CLI key gets a new one. A headless install therefore needs no
- * second device and no pasted key.
- *
- * ## Why base64
- *
- * It is what people paste: one opaque string, no shell quoting, no `@` or `:` to
- * trip over. It is not encryption and is not presented as such — the file is
- * protected by its permissions, and the value is never printed.
- */
-import { chmodSync, existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { writeFileAtomicSync } from "./fs-atomic.js";
-/** Where the stored credential lives. */
-export function accountCredentialPath(agentDir) {
-    return join(agentDir, "account-credential.json");
-}
-/** base64 of `username:password`. */
-export function encodeCredential(username, password) {
-    return Buffer.from(`${username}:${password}`, "utf8").toString("base64");
-}
-/**
- * Read either a base64 blob or a plain `user:pass` line.
- *
- * A pasted credential is almost always one of the two, and refusing the plain
- * form only makes the user encode it by hand to satisfy the parser.
- */
-export function parseCredentialInput(raw) {
-    const trimmed = raw.trim();
-    if (!trimmed)
-        return null;
-    const fromPlain = (value) => {
-        const at = value.indexOf(":");
-        if (at <= 0 || at === value.length - 1)
-            return null;
-        return { username: value.slice(0, at), password: value.slice(at + 1) };
-    };
-    const plain = fromPlain(trimmed);
-    if (plain)
-        return plain;
-    // Not `user:pass`, so try base64 and re-read the decoded text.
-    try {
-        const decoded = Buffer.from(trimmed, "base64").toString("utf8");
-        if (!decoded.includes(":"))
-            return null;
-        return fromPlain(decoded);
-    }
-    catch {
-        return null;
-    }
-}
-/** Store the credential so a later `/connect` needs nothing typed. */
-export function saveAccountCredential(agentDir, username, password) {
-    try {
-        const payload = {
-            credential: encodeCredential(username, password),
-            username,
-            savedAt: Math.floor(Date.now() / 1000),
-        };
-        const target = accountCredentialPath(agentDir);
-        writeFileAtomicSync(target, JSON.stringify(payload, null, 2));
-        chmodSync(target, 0o600);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/** The stored credential, if one was saved and is still readable. */
-export function loadAccountCredential(agentDir) {
-    try {
-        const target = accountCredentialPath(agentDir);
-        if (!existsSync(target))
-            return null;
-        const parsed = JSON.parse(readFileSync(target, "utf8"));
-        if (!parsed?.credential || !parsed?.username)
-            return null;
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-/** A JSON POST against the panel. */
-async function panelPost(url, body) {
-    const response = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(20_000),
-    });
-    const text = await response.text();
-    let parsed;
-    try {
-        parsed = JSON.parse(text);
-    }
-    catch {
-        throw new Error(`the panel answered ${response.status} with something that is not JSON`);
-    }
-    const envelope = parsed;
-    if (!response.ok || envelope.success === false) {
-        throw new Error(envelope.message || `the panel answered ${response.status}`);
-    }
-    return envelope.data;
-}
-/**
- * Exchange the account credential for the CLI key this account owns.
- *
- * The panel decides whether that key already existed; the CLI never creates a
- * token of its own, so a reconnect cannot add a row to the panel.
- */
-export async function loginWithCredential(panelUrl, username, password, clientInfo) {
-    const data = await panelPost(`${panelUrl}/api/auth/cli/credential`, {
-        credential: encodeCredential(username, password),
-        client_info: clientInfo,
-    });
-    if (!data?.token) {
-        throw new Error("the panel accepted the credential but returned no key");
-    }
-    return { token: data.token };
-}

package/dist/account-credential.test.js

@@ -1,38 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-import { encodeCredential, parseCredentialInput } from "./account-credential.js";
-test("reads a plain email:password credential", () => {
-    assert.deepEqual(parseCredentialInput("netro@example.com:secret123"), {
-        username: "netro@example.com",
-        password: "secret123",
-    });
-});
-test("reads the base64 form of the same credential", () => {
-    const encoded = encodeCredential("netro@example.com", "secret123");
-    assert.deepEqual(parseCredentialInput(encoded), {
-        username: "netro@example.com",
-        password: "secret123",
-    });
-});
-test("keeps a password that contains a colon", () => {
-    assert.deepEqual(parseCredentialInput("user:p:a:ss"), {
-        username: "user",
-        password: "p:a:ss",
-    });
-});
-test("refuses a relay key", () => {
-    assert.equal(parseCredentialInput("sk-abcdef0123456789"), null);
-});
-test("refuses text with no separator", () => {
-    assert.equal(parseCredentialInput("just-a-word"), null);
-    assert.equal(parseCredentialInput(""), null);
-});
-test("refuses an empty username or password", () => {
-    assert.equal(parseCredentialInput(":secret"), null);
-    assert.equal(parseCredentialInput("user:"), null);
-});
-test("encodeCredential is what parseCredentialInput decodes", () => {
-    const encoded = encodeCredential("a@b.co", "p:w");
-    assert.equal(Buffer.from(encoded, "base64").toString("utf8"), "a@b.co:p:w");
-    assert.deepEqual(parseCredentialInput(encoded), { username: "a@b.co", password: "p:w" });
-});

package/dist/activity.js

@@ -1,124 +0,0 @@
-/**
- * The one line under the input box, made consistent.
- *
- * That line used to be a single `hud.activity` string written from twenty-three
- * places, each with its own idea of what it looked like:
- *
- *   `⠋ thinking 12s`          — spinner and a word
- *   `✓ Read ×1 | Workflow ×1` — a tool tally
- *   `* shell 4096 bytes`      — a bullet
- *   `API key for nrimo. Paste it, then press enter.` — a sentence
- *   `""`                      — blank, from eight different places
- *
- * The result flickered between shapes and erased itself whenever an unrelated
- * event landed, which is what "the text keeps changing and is not consistent"
- * describes. The cause is not the number of writers; it is that each writer
- * owned the *whole* line.
- *
- * So writers now own a **layer**, and the line renders the highest-priority
- * non-empty one:
- *
- *   prompt > retry > note > run > tally
- *
- * A prompt waiting for you outranks a transient note, a note outranks the live
- * run, and the tool tally is a floor that survives the run ending. Clearing a
- * layer only clears that layer: a finished run no longer wipes a message that
- * was waiting for the user.
- *
- * The retry sits above the note because the two describe the same silence — a
- * provider that did not answer — and the retry is the one that says what is
- * being done about it. A note that is still pinned while a retry counts down is
- * the older, vaguer half of the same story.
- *
- * Time-varying text is produced here, not stored, so the label stays put while
- * only the elapsed seconds tick.
- */
-export function emptyActivity() {
-    return {};
-}
-/** Set or clear one layer. Returns a new state; the caller assigns it. */
-export function withLayer(state, layer, text, now = Date.now()) {
-    const next = { ...state };
-    if (layer === "run") {
-        if (text === undefined || text === "")
-            delete next.run;
-        // Keep the original start when only the label changes, so a run that moves
-        // from "thinking" to "running agents" does not reset its own clock.
-        else
-            next.run = { label: text, since: state.run?.since ?? now };
-        return next;
-    }
-    if (text === undefined || text === "")
-        delete next[layer];
-    else
-        next[layer] = text;
-    return next;
-}
-/**
- * Set or clear the retry layer.
- *
- * Separate from `withLayer` because the value is a deadline rather than a
- * string: the caller hands over when the next attempt fires and what went
- * wrong, and the text is derived from the clock on every draw.
- */
-export function withRetry(state, retry) {
-    const next = { ...state };
-    if (retry === undefined)
-        delete next.retry;
-    else
-        next.retry = retry;
-    return next;
-}
-/** `42s` / `1m 05s`, the same shape the rest of the UI uses. */
-function formatElapsed(ms) {
-    const seconds = Math.max(0, Math.round(ms / 1000));
-    const minutes = Math.floor(seconds / 60);
-    return minutes > 0 ? `${minutes}m ${String(seconds % 60).padStart(2, "0")}s` : `${seconds}s`;
-}
-/**
- * The provider's message, cut to what one line can hold.
- *
- * A failed request reports itself in a paragraph, sometimes several — a status
- * line, a JSON body, a stack. The activity line is one row wide, so the first
- * non-empty line is the part that says what happened.
- */
-export function firstLine(text, limit = 72) {
-    const line = text.split("\n").map((part) => part.trim()).find((part) => part !== "") ?? "";
-    return line.length > limit ? `${line.slice(0, limit - 1)}…` : line;
-}
-/**
- * `retry 1/3 in 2s · upstream 502` — the wait counts down as the clock moves.
- *
- * The countdown is the point: a bare `retry 1/3` says something is happening
- * but not whether to wait or to reach for ctrl+c, and a retry that has already
- * fired must not keep reading like a countdown. Past the deadline the text says
- * so and stays there until the attempt reports back.
- */
-function retryText(retry, now) {
-    const left = Math.max(0, Math.ceil((retry.until - now) / 1000));
-    const when = left > 0 ? `in ${left}s` : "now";
-    const head = `retry ${retry.attempt}/${retry.maxAttempts} ${when}`;
-    const reason = firstLine(retry.error);
-    return reason === "" ? head : `${head} · ${reason}`;
-}
-/**
- * The line to draw, or `""` when nothing is happening.
- *
- * One marker per layer, one separator (` · `), and the text never carries its
- * own prefix — so two different states can never look like two different tools.
- */
-export function activityText(state, spinner, now = Date.now()) {
-    if (state.prompt)
-        return `? ${state.prompt}`;
-    if (state.retry)
-        return `* ${retryText(state.retry, now)}`;
-    if (state.note)
-        return `* ${state.note}`;
-    if (state.run)
-        return `${spinner} ${state.run.label} · ${formatElapsed(now - state.run.since)}`;
-    // No marker of its own: the tally is already a list of per-tool markers
-    // (`✓ Read ×1 | ! Workflow ×1`), so prefixing it drew `✓ ✓ Read ×1`.
-    if (state.tally)
-        return state.tally;
-    return "";
-}

package/dist/agent-defs.js

@@ -1,237 +0,0 @@
-import { readFileSync, readdirSync, statSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { getAgentDir, parseFrontmatter } from "@netrodev/hxf-coding-agent";
-import { BUILTIN_AGENT_NAMES } from "./agents.js";
-/**
- * Subagent definitions written by the user, as markdown.
- *
- * One file is one agent. The frontmatter carries what the model needs to choose
- * it and what the run needs to be set up, and the body becomes the child's
- * standing system prompt:
- *
- *     ---
- *     name: migration
- *     description: moves one module at a time and tests after each
- *     tools: read, bash, edit, write
- *     model: gemini-3-flash
- *     effort: medium
- *     ---
- *     Migrate exactly one module per turn. Run its tests before moving on, and
- *     report the file you changed and the test result.
- *
- * The parser is the harness's own, so a file means the same thing here and in
- * the harness. The locations follow this CLI's rule: everything a user writes
- * for a project lives under one directory, `.howtofix`, the same one that holds
- * project skills and presets.
- *
- *     <project>/.howtofix/agents/*.md  nearest ancestor, found by walking up
- *     ~/.howtofix/agent/agents/*.md    the CLI's own user scope
- *
- * `parseFrontmatter` is the SDK's YAML parser, which means quoted values,
- * arrays, comments and anything else YAML allows are read the same way the
- * harness reads them. The user-scope directory is the one the run store also
- * uses (`AGENTS_STORE_DIR`); the two do not collide because the store reads only
- * `*.json` and this reads only `*.md`.
- *
- * A definition replaces a built-in of the same name. That is the point of having
- * them: `scout`, `architect`, `task` and `reviewer` are a starting set, not a
- * fixed menu, and an agent whose prompt is wrong for a project should be fixable
- * without patching this package.
- */
-/** The effort levels a definition may declare. Ours, not the harness's. */
-const EFFORTS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-/** Frontmatter keys this loader reads; anything else is reported and ignored. */
-const KEYS = ["name", "description", "tools", "model", "effort"];
-/**
- * Tools a definition may name.
- *
- * Not a permission list — the permission extension still decides what a child
- * may actually do — but a spelling list, so a typo is reported at load instead of
- * silently resolving to nothing at call time. `mcp__<server>__<tool>` names are
- * accepted as written because they cannot be known in advance.
- */
-export const KNOWN_AGENT_TOOLS = ["read", "bash", "edit", "write", "grep", "find", "ls", "bash_output", "kill_shell", "todo", "context", "goal", "task", "workflow", "web_search", "web_fetch", "lsp", "quality", "claim", "repo_map"];
-/**
- * What a definition gets when it names no tools: the same set the built-in `task`
- * agent has.
- *
- * The harness leaves an absent `tools` meaning "no restriction". Here the field
- * is the child's allowlist, so absent has to mean something concrete, and a
- * working set is the useful reading: the permission extension already refuses
- * anything above the parent's approval mode inside a child, and a spawned agent
- * has no interactive UI, so the gate fails closed. Narrowing is what `tools` is
- * for.
- */
-export const DEFAULT_AGENT_TOOLS = ["read", "bash", "edit", "write", "grep", "find", "ls", "context", "todo", "web_search", "web_fetch", "lsp", "claim"];
-/** `a, b` and `[a, b]` both mean two tools; anything else means none declared. */
-function asToolList(value) {
-    const raw = typeof value === "string" ? value.split(",") : Array.isArray(value) ? value : [];
-    const tools = raw
-        .map((item) => String(item)
-        .trim()
-        .replace(/^["']|["']$/g, ""))
-        .filter(Boolean);
-    return tools.length > 0 ? tools : undefined;
-}
-function isDirectory(path) {
-    try {
-        return statSync(path).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * The nearest project agent directory, walking up from `cwd`.
- *
- * Walking up is the harness's rule and the useful one: a definition written for a
- * monorepo root applies to every package under it.
- */
-export function findProjectAgentDir(cwd) {
-    let current = cwd;
-    for (;;) {
-        // Beside project skills and presets: one project directory, .howtofix, so a
-        // repository does not end up with two dot-directories holding the same kind
-        // of file.
-        const candidate = join(current, ".howtofix", "agents");
-        if (isDirectory(candidate))
-            return candidate;
-        const parent = dirname(current);
-        if (parent === current)
-            return undefined;
-        current = parent;
-    }
-}
-/**
- * The directories definitions are read from, in load order.
- *
- * User first, project last, and a later definition replaces an earlier one — so a
- * project agent wins a name collision, the precedence the harness's own subagent
- * discovery uses.
- */
-export function subagentDirs(cwd) {
-    // One user location, the one this CLI owns. The harness default, ~/.hxf/agent,
-    // is not read: two folders holding the same kind of file is how a definition
-    // ends up in the place nothing looks at.
-    const dirs = [{ scope: "user", dir: join(getAgentDir(), "agents") }];
-    const project = findProjectAgentDir(cwd);
-    if (project)
-        dirs.push({ scope: "project", dir: project });
-    return dirs;
-}
-/**
- * Parse one definition file. Pure apart from the SDK's YAML parser, so the rules
- * can be tested without touching a filesystem.
- */
-export function parseAgentDef(text, file) {
-    const notes = [];
-    const problems = [];
-    const source = text.replace(/^\uFEFF/, "");
-    if (!/^---\r?\n/.test(source)) {
-        return { notes, problems: [`${file}: no frontmatter — the file must start with --- and end the block with ---`] };
-    }
-    let frontmatter = {};
-    let body = "";
-    try {
-        const parsed = parseFrontmatter(source);
-        frontmatter = parsed.frontmatter ?? {};
-        body = (parsed.body ?? "").trim();
-    }
-    catch (error) {
-        return { notes, problems: [`${file}: the frontmatter is not readable YAML — ${error instanceof Error ? error.message : String(error)}`] };
-    }
-    for (const key of Object.keys(frontmatter)) {
-        if (!KEYS.includes(key))
-            notes.push(`${file}: ignoring the unknown frontmatter key '${key}'`);
-    }
-    // A file's own name is the natural default, so `reviewer.md` needs no `name:`.
-    const stem = (file.split(/[\\/]/).pop() ?? file).replace(/\.md$/i, "");
-    const rawName = frontmatter.name;
-    const name = (typeof rawName === "string" && rawName.trim() ? rawName : stem).trim();
-    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name)) {
-        problems.push(`${file}: '${name}' is not a usable agent name — letters, digits, dot, dash and underscore only`);
-    }
-    const rawDescription = frontmatter.description;
-    const description = typeof rawDescription === "string" ? rawDescription.trim() : "";
-    if (!description)
-        problems.push(`${file}: a description is required — it is how the model decides to use this agent`);
-    if (!body)
-        problems.push(`${file}: no prompt body — the text below the frontmatter is the agent's standing instruction`);
-    const rawEffort = frontmatter.effort;
-    const effort = typeof rawEffort === "string" ? rawEffort.trim().toLowerCase() : "";
-    if (effort && !EFFORTS.includes(effort)) {
-        problems.push(`${file}: effort '${effort}' is not one of ${EFFORTS.join(", ")}`);
-    }
-    const declared = asToolList(frontmatter.tools);
-    const tools = declared ?? [...DEFAULT_AGENT_TOOLS];
-    if (declared) {
-        const unknown = declared.filter((tool) => !KNOWN_AGENT_TOOLS.includes(tool) && !tool.startsWith("mcp__"));
-        if (unknown.length > 0) {
-            notes.push(`${file}: unknown tool${unknown.length === 1 ? "" : "s"} ${unknown.join(", ")} — kept, but nothing registers them yet`);
-        }
-    }
-    const rawModel = frontmatter.model;
-    const model = typeof rawModel === "string" && rawModel.trim() ? rawModel.trim() : undefined;
-    if (problems.length > 0)
-        return { notes, problems };
-    return {
-        def: { name, description, tools, prompt: body, effort: (effort || "medium"), model, source: file },
-        notes,
-        problems,
-    };
-}
-/**
- * Load every definition into `into`.
- *
- * Re-running cannot shuffle which definition a session runs with: the same files
- * produce the same map, and a definition only ever replaces one that loaded
- * before it.
- */
-export function loadAgentDefs(cwd, into) {
-    const loaded = [];
-    const notes = [];
-    const problems = [];
-    const scopes = [];
-    for (const { scope, dir } of subagentDirs(cwd)) {
-        let entries;
-        try {
-            entries = readdirSync(dir);
-        }
-        catch {
-            // No directory is the normal case, not a problem to report.
-            continue;
-        }
-        for (const entry of entries.filter((name) => name.toLowerCase().endsWith(".md")).sort()) {
-            const file = join(dir, entry);
-            let text;
-            try {
-                text = readFileSync(file, "utf8");
-            }
-            catch (error) {
-                problems.push(`${file}: ${error instanceof Error ? error.message : String(error)}`);
-                continue;
-            }
-            const parsed = parseAgentDef(text, file);
-            notes.push(...parsed.notes);
-            problems.push(...parsed.problems);
-            const def = parsed.def;
-            if (!def)
-                continue;
-            if (into.has(def.name)) {
-                notes.push(`${file}: replaces ${BUILTIN_AGENT_NAMES.has(def.name) ? "the built-in" : "an earlier"} '${def.name}'`);
-            }
-            into.set(def.name, def);
-            loaded.push(def);
-            if (!scopes.includes(scope))
-                scopes.push(scope);
-        }
-    }
-    if (loaded.length > 0) {
-        // The effective set, not every file read: a definition that a later one
-        // replaced is not what a session will run with, and naming it twice would
-        // read as two agents.
-        const effective = loaded.filter((def) => into.get(def.name) === def);
-        notes.unshift(`loaded ${effective.length} subagent definition${effective.length === 1 ? "" : "s"} (${scopes.join(" and ")}): ${effective.map((def) => def.name).join(", ")}`);
-    }
-    return { loaded, notes, problems };
-}