@bli-cockpit/cli 0.2.119 → 0.2.121

package/dist/commands/memory-hook-performance.js

@@ -15,130 +15,163 @@ export async function readMemoryHookPerformance(options) {
     const directory = memoryHookSamplesDirectory(options.homeDir);
     const start = now.getTime() - 24 * HOUR_MS;
     const reasons = new Set();
-    const result = {
-        schema_version: "memory-hook-performance.v1",
-        window_start: new Date(start).toISOString(),
-        window_end: now.toISOString(),
-        sampling_since: null,
-        samples: 0,
-        outcomes: { printed: 0, empty: 0, timeouts: 0, failed: 0, skipped: 0 },
-        duration_by_cache: {
-            hit: blankHistogram(), miss: blankHistogram(), shared: blankHistogram(), unknown: blankHistogram(),
-        },
-        producer_versions: [],
-        invalid_samples: 0,
-        incomplete_samples: 0,
-        unreadable_samples: 0,
-        capped: false,
-        reasons: [],
-    };
-    const versions = new Map();
-    const started = performance.now();
-    let filesRead = 0;
+    const state = createSamplingState(now, start);
     try {
         const lease = await renewLease(directory, now, reasons);
-        result.sampling_since = lease.continuous_since;
+        state.result.sampling_since = lease.continuous_since;
         if (Date.parse(lease.continuous_since) > start)
             reasons.add("partial_window");
-        // Exactly the 25 hour directories touching this rolling 24-hour window.
-        // Timestamp filtering below trims both partial boundary hours.
-        hours: for (let offset = 0; offset <= 24; offset += 1) {
-            const hour = new Date(now.getTime() - offset * HOUR_MS).toISOString().slice(0, 13);
-            let entries;
-            try {
-                entries = await fs.opendir(path.join(directory, hour));
-            }
-            catch (error) {
-                if (error.code !== "ENOENT")
-                    reasons.add("read_failed");
+        await collectHourlySamples(directory, now, start, options, reasons, state);
+        await pruneExpiredHours(directory, now, reasons);
+    }
+    catch {
+        reasons.add("read_failed");
+    }
+    return finishSampling(state, reasons);
+}
+function createSamplingState(now, start) {
+    return {
+        result: {
+            schema_version: "memory-hook-performance.v1",
+            window_start: new Date(start).toISOString(),
+            window_end: now.toISOString(),
+            sampling_since: null,
+            samples: 0,
+            outcomes: { printed: 0, empty: 0, timeouts: 0, failed: 0, skipped: 0 },
+            duration_by_cache: {
+                hit: blankHistogram(),
+                miss: blankHistogram(),
+                shared: blankHistogram(),
+                unknown: blankHistogram(),
+            },
+            producer_versions: [],
+            invalid_samples: 0,
+            incomplete_samples: 0,
+            unreadable_samples: 0,
+            capped: false,
+            reasons: [],
+        },
+        versions: new Map(),
+        started: performance.now(),
+        filesRead: 0,
+    };
+}
+async function collectHourlySamples(directory, now, start, options, reasons, state) {
+    // Exactly the 25 hour directories touching this rolling 24-hour window.
+    // Timestamp filtering below trims both partial boundary hours.
+    hours: for (let offset = 0; offset <= 24; offset += 1) {
+        const hour = new Date(now.getTime() - offset * HOUR_MS).toISOString().slice(0, 13);
+        const entries = await openHourDirectory(directory, hour, reasons);
+        if (!entries)
+            continue;
+        for await (const entry of entries) {
+            if (!entry.isFile() || !SAMPLE_FILE.test(entry.name))
                 continue;
+            if (hasReachedReadLimit(options, state)) {
+                state.result.capped = true;
+                reasons.add("read_limit");
+                break hours;
             }
-            for await (const entry of entries) {
-                if (!entry.isFile() || !SAMPLE_FILE.test(entry.name))
-                    continue;
-                if (filesRead >= (options.maxFiles ?? HOOK_SAMPLE_READ_LIMIT) ||
-                    performance.now() - started >= (options.readBudgetMs ?? READ_BUDGET_MS)) {
-                    result.capped = true;
-                    reasons.add("read_limit");
-                    break hours;
-                }
-                filesRead += 1;
-                const file = path.join(directory, hour, entry.name);
-                let raw;
-                try {
-                    const stat = await fs.stat(file);
-                    if (stat.size > MAX_SAMPLE_BYTES) {
-                        result.invalid_samples += 1;
-                        continue;
-                    }
-                    raw = await fs.readFile(file, "utf8");
-                }
-                catch {
-                    result.unreadable_samples += 1;
-                    continue;
-                }
-                if (!raw.endsWith("\n")) {
-                    // Could be a live writer or one killed by the host. Leave it for the
-                    // next tick, and keep the incomplete observation out of every rate.
-                    result.incomplete_samples += 1;
-                    continue;
-                }
-                let parsed;
-                try {
-                    parsed = JSON.parse(raw);
-                }
-                catch {
-                    result.invalid_samples += 1;
-                    continue;
-                }
-                const sample = MemoryHookSampleSchema.safeParse(parsed);
-                if (!sample.success || sample.data.recorded_at.slice(0, 13) !== hour) {
-                    result.invalid_samples += 1;
-                    continue;
-                }
-                const at = Date.parse(sample.data.recorded_at);
-                if (at < start || at > now.getTime())
-                    continue;
-                const version = sample.data.producer_version;
-                if (!versions.has(version) && versions.size >= 16) {
-                    result.capped = true;
-                    reasons.add("read_limit");
-                    break hours;
-                }
-                result.samples += 1;
-                result.outcomes[sample.data.outcome] += 1;
-                addDuration(result.duration_by_cache[sample.data.embed_cache], sample.data.elapsed_ms);
-                versions.set(version, (versions.get(version) ?? 0) + 1);
+            state.filesRead += 1;
+            const shouldContinue = await readSample(path.join(directory, hour, entry.name), hour, now, start, reasons, state);
+            if (!shouldContinue) {
+                break hours;
             }
         }
-        await pruneExpiredHours(directory, now, reasons);
+    }
+}
+async function openHourDirectory(directory, hour, reasons) {
+    try {
+        return await fs.opendir(path.join(directory, hour));
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            reasons.add("read_failed");
+        return null;
+    }
+}
+function hasReachedReadLimit(options, state) {
+    return state.filesRead >= (options.maxFiles ?? HOOK_SAMPLE_READ_LIMIT) ||
+        performance.now() - state.started >= (options.readBudgetMs ?? READ_BUDGET_MS);
+}
+async function readSample(file, hour, now, start, reasons, state) {
+    let raw;
+    try {
+        const stat = await fs.stat(file);
+        if (stat.size > MAX_SAMPLE_BYTES) {
+            state.result.invalid_samples += 1;
+            return true;
+        }
+        raw = await fs.readFile(file, "utf8");
     }
     catch {
-        reasons.add("read_failed");
+        state.result.unreadable_samples += 1;
+        return true;
+    }
+    if (!raw.endsWith("\n")) {
+        // Could be a live writer or one killed by the host. Leave it for the
+        // next tick, and keep the incomplete observation out of every rate.
+        state.result.incomplete_samples += 1;
+        return true;
+    }
+    return recordSample(raw, hour, now, start, reasons, state);
+}
+function recordSample(raw, hour, now, start, reasons, state) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
     }
-    if (!result.samples)
+    catch {
+        state.result.invalid_samples += 1;
+        return true;
+    }
+    const sample = MemoryHookSampleSchema.safeParse(parsed);
+    if (!sample.success || sample.data.recorded_at.slice(0, 13) !== hour) {
+        state.result.invalid_samples += 1;
+        return true;
+    }
+    const at = Date.parse(sample.data.recorded_at);
+    if (at < start || at > now.getTime())
+        return true;
+    const version = sample.data.producer_version;
+    if (!state.versions.has(version) && state.versions.size >= 16) {
+        state.result.capped = true;
+        reasons.add("read_limit");
+        return false;
+    }
+    state.result.samples += 1;
+    state.result.outcomes[sample.data.outcome] += 1;
+    addDuration(state.result.duration_by_cache[sample.data.embed_cache], sample.data.elapsed_ms);
+    state.versions.set(version, (state.versions.get(version) ?? 0) + 1);
+    return true;
+}
+function finishSampling(state, reasons) {
+    if (!state.result.samples)
         reasons.add("no_samples");
-    if (result.invalid_samples)
+    if (state.result.invalid_samples)
         reasons.add("invalid_samples");
-    if (result.incomplete_samples)
+    if (state.result.incomplete_samples)
         reasons.add("incomplete_samples");
-    if (result.unreadable_samples)
+    if (state.result.unreadable_samples)
         reasons.add("unreadable_samples");
-    result.producer_versions = [...versions].sort(([a], [b]) => a.localeCompare(b))
+    state.result.producer_versions = [...state.versions].sort(([a], [b]) => a.localeCompare(b))
         .map(([version, samples]) => ({ version, samples }));
-    result.reasons = [...reasons];
-    return result;
+    state.result.reasons = [...reasons];
+    return state.result;
 }
 async function renewLease(directory, now, reasons) {
     let continuousSince = now.toISOString();
     try {
         const previous = MemoryHookSamplingLeaseSchema.safeParse(JSON.parse(await fs.readFile(path.join(directory, "lease.json"), "utf8")));
-        if (!previous.success || Date.parse(previous.data.continuous_since) > now.getTime())
+        if (!previous.success || Date.parse(previous.data.continuous_since) > now.getTime()) {
             reasons.add("lease_invalid");
-        else if (Date.parse(previous.data.expires_at) <= now.getTime())
+        }
+        else if (Date.parse(previous.data.expires_at) <= now.getTime()) {
             reasons.add("lease_expired");
-        else
+        }
+        else {
             continuousSince = previous.data.continuous_since;
+        }
     }
     catch (error) {
         reasons.add(error.code === "ENOENT" ? "lease_absent" : "lease_invalid");
@@ -160,8 +193,9 @@ async function pruneExpiredHours(directory, now, reasons) {
         const entries = await fs.opendir(directory);
         let pruned = 0;
         for await (const entry of entries) {
-            if (!entry.isDirectory() || !HOUR_DIRECTORY.test(entry.name) || entry.name >= oldest)
+            if (!entry.isDirectory() || !HOUR_DIRECTORY.test(entry.name) || entry.name >= oldest) {
                 continue;
+            }
             // Cleanup belongs to the collector and cannot delay a prompt. A bounded
             // number of expired hours is enough to catch up over successive ticks.
             await fs.rm(path.join(directory, entry.name), { recursive: true, force: true });

package/dist/commands/memory-install-claude.js

@@ -84,21 +84,11 @@ export async function inspectClaudeMemoryIntegration(options) {
  * `matches` pair runs differs, both already parameters here.
  */
 export async function applyJsonTarget(input) {
+    const prepared = await readJsonTargetRoot(input);
+    if ("target" in prepared)
+        return prepared;
     const { file, options } = input;
-    const raw = await input.options.io.readText(file);
-    let root;
-    if (raw === null || !raw.trim()) {
-        root = {};
-    }
-    else {
-        const parsed = parseJsonRecord(raw);
-        if (!parsed) {
-            // Refuse rather than replace. A `~/.claude.json` that will not parse
-            // still holds the person's project history and their other servers.
-            return failure(input.target, file, "config_unreadable", "the file is not valid JSON; fix it and re-run");
-        }
-        root = parsed;
-    }
+    const { raw, root } = prepared;
     if (input.matches(root)) {
         return { target: input.target, status: "already", reason: "already_current", path: file };
     }
@@ -126,6 +116,17 @@ export async function applyJsonTarget(input) {
     }
     return { target: input.target, status: "installed", reason: "wrote_entry", path: file };
 }
+async function readJsonTargetRoot(input) {
+    const raw = await input.options.io.readText(input.file);
+    if (raw === null || !raw.trim())
+        return { raw, root: {} };
+    const root = parseJsonRecord(raw);
+    if (root)
+        return { raw, root };
+    // Refuse rather than replace. A `~/.claude.json` that will not parse
+    // still holds the person's project history and their other servers.
+    return failure(input.target, input.file, "config_unreadable", "the file is not valid JSON; fix it and re-run");
+}
 /** Exported for `tower-mcp-claude.ts` (BLI-3706) — see `applyJsonTarget`'s note. */
 export async function inspectJsonTarget(input) {
     const raw = await input.io.readText(input.file);

package/dist/commands/memory-install-codex.js

@@ -123,12 +123,7 @@ async function applyCodexMcpTable(options) {
 async function applyCodexSkills(options) {
     const directory = codexSkillDirectory(options.homeDir);
     const files = memoryCodexSkillFiles();
-    const stale = [];
-    for (const [relative, contents] of Object.entries(files)) {
-        const stored = await options.io.readText(path.join(directory, relative));
-        if (stored !== contents)
-            stale.push(relative);
-    }
+    const stale = await findStaleCodexSkillFiles(directory, files, options.io);
     if (stale.length === 0) {
         return {
             target: "codex_skills",
@@ -181,6 +176,15 @@ async function applyCodexSkills(options) {
         detail: `${stale.length} skill file(s) written`,
     };
 }
+async function findStaleCodexSkillFiles(directory, files, io) {
+    const stale = [];
+    for (const [relative, contents] of Object.entries(files)) {
+        const stored = await io.readText(path.join(directory, relative));
+        if (stored !== contents)
+            stale.push(relative);
+    }
+    return stale;
+}
 export function renderMemoryTable(config) {
     const entries = [
         ["command", config.mcp_server.command],

package/dist/commands/memory-install-config.js

@@ -51,9 +51,10 @@ export async function resolveMemoryConfig(command, io, platform, deps) {
     }
     if (isUnsafeBinPath(found.path)) {
         // A hook command is a shell string by the platform's design. A path that
-        // cannot be quoted safely is not escaped cleverly, and it is not swapped
-        // for a bare name that may resolve to something else either — the install
-        // refuses and says why.
+        // cannot be expressed safely in one is not escaped cleverly, and it is not
+        // swapped for a bare name that may resolve to something else either — the
+        // install refuses and says why. See `shellSafeBinPath` for what CAN be
+        // expressed, including the Windows separator normalisation of BLI-4136.
         return {
             config: null,
             source: "none",
@@ -61,7 +62,7 @@ export async function resolveMemoryConfig(command, io, platform, deps) {
                 target: "bin",
                 status: "failed",
                 reason: "bin_path_unsafe",
-                detail: "the resolved bin path contains characters that cannot appear in a hook command; nothing was written",
+                detail: "the resolved bin path cannot be expressed safely in a hook command; nothing was written",
             },
             bin_source: found.source,
         };

package/dist/commands/memory-install-contract.js

@@ -49,6 +49,12 @@
  * machine resolved before anything is written. Skipping that step registered
  * three hooks that answered `command not found` on every turn.
  *
+ * **And the path it is re-pointed at is written for a SHELL, not for the
+ * filesystem** — `shellSafeBinPath`. A hook command is a shell string, Windows
+ * runs it through bash, and a native path's backslashes are eaten as escapes:
+ * the same three hooks, the same `command not found`, arrived at from the other
+ * direction (BLI-4136).
+ *
  * Nothing here touches the filesystem. The halves that do are
  * `memory-install-claude.ts` and `memory-install-codex.ts`.
  */
@@ -96,16 +102,56 @@ export const MEMORY_AUTO_APPROVE_TOOLS = [
 ];
 /** Characters that would let a resolved path change the meaning of a hook command string. */
 const UNSAFE_PATH_CHARACTERS = /["'`$;&|<>\r\n]/u;
+/**
+ * Windows device paths — `\\?\C:\…` (extended length) and `\\.\…` (device
+ * namespace). Both prefixes are DEFINED in terms of backslashes and stop being
+ * that prefix the moment `shellSafeBinPath` turns them into forward slashes, so
+ * a hook command cannot carry one without silently naming a different file.
+ * Refused with a name rather than rewritten into something plausible.
+ */
+const WINDOWS_DEVICE_PATH = /^\\\\[?.]\\/u;
 export function isUnsafeBinPath(binPath) {
-    return UNSAFE_PATH_CHARACTERS.test(binPath);
+    return UNSAFE_PATH_CHARACTERS.test(binPath) || WINDOWS_DEVICE_PATH.test(binPath);
 }
 /**
- * A Claude Code hook `command` is a shell string by the platform's design, so
- * the only defence is quoting — and a path that could not be quoted safely is
- * refused upstream (see `resolveMemoryMcpBin`) rather than escaped cleverly.
+ * A path that no shell gives a meaning to, so it needs no quoting. Deliberately
+ * a tight allow-list rather than a list of known-bad characters: `(` and `)` in
+ * `C:/Program Files (x86)/…` are a bash syntax error, and the earlier
+ * whitespace-only trigger caught them only by the accident of the space.
+ */
+const PLAINLY_SAFE_PATH = /^[A-Za-z0-9_@:./+,-]+$/u;
+/**
+ * The resolved bin path, as it must appear INSIDE a hook command string.
+ *
+ * A Claude Code hook `command` is a shell string by the platform's design, and
+ * on Windows the host runs it through **bash** — which eats every backslash as
+ * an escape. So the native path this installer resolved,
+ * `C:\Users\…\.bin\bli-memory-mcp.cmd`, reaches the shell as
+ * `C:Users….binbli-memory-mcp.cmd` and answers `command not found` on every
+ * SessionStart, every prompt and every Stop. Non-blocking and therefore silent:
+ * memory recall simply degrades, and nothing says so (BLI-4136, fixed by hand
+ * twice on the same machine before the installer was the thing that changed).
+ *
+ * Two independent defences, because either one alone is a thin edge:
+ *
+ *  1. **Separators are normalised to `/` on Windows.** Win32 accepts forward
+ *     slashes in every path it resolves, and after this there is no escape
+ *     character left in the string for a shell to consume. This is also what
+ *     survives a `\\`: double-quoting ALONE would collapse the UNC prefix of
+ *     `\\server\share\…` back to one backslash and name the wrong path.
+ *  2. **Anything not plainly safe is double-quoted**, which covers spaces and
+ *     the bracket characters in `Program Files (x86)`.
+ *
+ * A path that still could not be expressed safely is refused upstream
+ * (`isUnsafeBinPath`, checked in `resolveMemoryConfig`) rather than escaped
+ * cleverly.
+ *
+ * POSIX keeps its separators untouched — a backslash there is a legal
+ * character in a filename, and rewriting it would name a different file.
  */
-export function shellQuoteBinPath(binPath) {
-    return /\s/u.test(binPath) ? `"${binPath}"` : binPath;
+export function shellSafeBinPath(binPath, platform) {
+    const forShell = platform === "win32" ? binPath.replace(/\\/gu, "/") : binPath;
+    return PLAINLY_SAFE_PATH.test(forShell) ? forShell : `"${forShell}"`;
 }
 /**
  * Windows cannot spawn an npm `.cmd` shim directly — Node refuses it without a
@@ -125,13 +171,13 @@ export function memoryMcpServerEntry(options) {
     return { command: options.binPath, args: [], env };
 }
 export function builtinMemoryInstallConfig(options) {
-    const quoted = shellQuoteBinPath(options.binPath);
+    const binPath = shellSafeBinPath(options.binPath, options.platform);
     return {
         server_id: MEMORY_MCP_SERVER_ID,
         mcp_server: memoryMcpServerEntry(options),
         hooks: MEMORY_HOOK_EVENTS.map((event) => ({
             event,
-            command: `${quoted} ${MEMORY_HOOK_SUBCOMMAND[event]}`,
+            command: `${binPath} ${MEMORY_HOOK_SUBCOMMAND[event]}`,
             timeout_seconds: MEMORY_HOOK_TIMEOUT_SECONDS[event],
         })),
         permissions_allow: [...MEMORY_AUTO_APPROVE_TOOLS],
@@ -237,13 +283,13 @@ export function parsePrintedMemoryInstallConfig(stdout) {
  * hook that runs something else.
  */
 export function withResolvedBinPath(config, options) {
-    const quoted = shellQuoteBinPath(options.binPath);
+    const binPath = shellSafeBinPath(options.binPath, options.platform);
     const hooks = [];
     for (const hook of config.hooks) {
         const tail = hookSubcommandTail(hook.command);
         if (!tail)
             return null;
-        hooks.push({ ...hook, command: `${quoted} ${tail}` });
+        hooks.push({ ...hook, command: `${binPath} ${tail}` });
     }
     const entry = memoryMcpServerEntry(options);
     return {

package/dist/commands/memory-install-report.js

@@ -83,17 +83,7 @@ export function logMemoryOutcome(outcome, platform) {
         : "[memory-install] BLI Memory registration converged", JSON.stringify(fields));
 }
 export function memoryOutcomeLines(outcome) {
-    const headline = outcome.status === "installed"
-        ? "BLI Memory registered on this machine."
-        : outcome.status === "already"
-            ? "BLI Memory is already registered on this machine."
-            : outcome.status === "would_install"
-                ? "BLI Memory would be registered (dry run; nothing was written)."
-                : outcome.status === "missing"
-                    ? "BLI Memory is not registered on this machine."
-                    : outcome.status === "skipped"
-                        ? "BLI Memory was not registered and nothing was written: the bli-memory-mcp server is not on this machine yet."
-                        : `BLI Memory is not fully registered: ${outcome.reason}.`;
+    const headline = memoryOutcomeHeadline(outcome);
     const lines = [headline, `  ${memoryReceiptLine(outcome.receipt)}`];
     // BLI-3884. Only `status` asks; an absent reading is not printed as "no
     // daemon", because nothing looked.
@@ -115,4 +105,19 @@ export function memoryOutcomeLines(outcome) {
         lines.push(`  ${target.target}: ${target.status} (${target.reason})${where}${detail}`);
     }
     return lines;
+}
+function memoryOutcomeHeadline(outcome) {
+    if (outcome.status === "installed")
+        return "BLI Memory registered on this machine.";
+    if (outcome.status === "already")
+        return "BLI Memory is already registered on this machine.";
+    if (outcome.status === "would_install") {
+        return "BLI Memory would be registered (dry run; nothing was written).";
+    }
+    if (outcome.status === "missing")
+        return "BLI Memory is not registered on this machine.";
+    if (outcome.status === "skipped") {
+        return "BLI Memory was not registered and nothing was written: the bli-memory-mcp server is not on this machine yet.";
+    }
+    return `BLI Memory is not fully registered: ${outcome.reason}.`;
 }

package/dist/commands/memory-install-skills.js

@@ -13,16 +13,6 @@
  * install is idempotent to the byte and a drifted copy is replaced rather than
  * merged — the same deal `cockpit agent-rules` offers for its managed block.
  */
-/** Relative path → exact file contents. The map IS the install. */
-export function memoryCodexSkillFiles() {
-    return {
-        "SKILL.md": SKILL_MD,
-        "references/search.md": SEARCH_MD,
-        "references/save.md": SAVE_MD,
-        "references/update.md": UPDATE_MD,
-        "references/forget.md": FORGET_MD,
-    };
-}
 const SKILL_MD = `---
 name: bli-memory
 description: BLI Memory — durable memory for this machine. Use when you need to recall what was decided before, or when a session produced a durable decision, preference or correction worth keeping.
@@ -118,4 +108,14 @@ again. Matching by content is exact after whitespace normalisation — never
 fuzzy, and never widened to every container.
 
 It returns what it removed. A bare "done" is not an answer.
-`;
+`;
+/** Relative path → exact file contents. The map IS the install. */
+export function memoryCodexSkillFiles() {
+    return {
+        "SKILL.md": SKILL_MD,
+        "references/search.md": SEARCH_MD,
+        "references/save.md": SAVE_MD,
+        "references/update.md": UPDATE_MD,
+        "references/forget.md": FORGET_MD,
+    };
+}

package/dist/commands/memory-log.js

@@ -5,20 +5,37 @@ import { callTower, openTower } from "./tower-command.js";
 function sender(command, io) {
     return async (entry) => {
         const tower = await openTower("memory log", command, io);
-        const result = await callTower(tower, { path: "/api/memory/experience", method: "POST", body: entry, label: "memory experience", timeoutMs: 5000 });
-        return result.ok ? { ok: result.body?.ok === true, reason: "experience_not_acknowledged" } : result;
+        const result = await callTower(tower, {
+            path: "/api/memory/experience",
+            method: "POST",
+            body: entry,
+            label: "memory experience",
+            timeoutMs: 5000,
+        });
+        return result.ok
+            ? {
+                ok: result.body?.ok === true,
+                reason: "experience_not_acknowledged",
+            }
+            : result;
     };
 }
 export async function runMemoryLog(command, io) {
-    const reason = command.reasonStdin ? (await readPipedText(io.stdin, { maxChars: 1002 })).trim() : command.reason;
+    const reason = command.reasonStdin
+        ? (await readPipedText(io.stdin, { maxChars: 1002 })).trim()
+        : command.reason;
     validateExperience(command.store, command.verdict, reason);
     const entry = await appendExperience({ store: command.store, verdict: command.verdict, reason }, {
-        homeDir: command.homeDir, agent: "cockpit", project: path.basename(process.cwd()),
+        homeDir: command.homeDir,
+        agent: "cockpit",
+        project: path.basename(process.cwd()),
     });
     const delivery = await shipExperience(entry, sender(command, io), command.homeDir);
     const receipt = { ok: true, id: entry.id, local: true, ...delivery };
     writeLine(io.stderr, `[memory experience] recorded ${JSON.stringify(receipt)}`);
-    writeLine(io.stdout, command.json ? JSON.stringify(receipt) : `Experience appended; shipped: ${delivery.shipped} (${delivery.reason}).`);
+    writeLine(io.stdout, command.json
+        ? JSON.stringify(receipt)
+        : `Experience appended; shipped: ${delivery.shipped} (${delivery.reason}).`);
     return 0;
 }
 export async function runMemoryExperienceAfterSync(command, io) {

package/dist/commands/msg.js

@@ -220,16 +220,23 @@ async function createChannel(command, door) {
     const membersAdded = body.members_added ?? [];
     const membersFailed = body.members_failed ?? [];
     const requestedMembers = command.memberEmails?.length ?? 0;
+    logChannelCreation(door, channel, command.isPrivate, requestedMembers, membersAdded, membersFailed);
+    if (door.json) {
+        return emitAgentDoor(door, { ok: true, channel, membersAdded, membersFailed });
+    }
+    reportChannelCreationToHuman(door, channel, name, requestedMembers, membersAdded, membersFailed);
+    return 0;
+}
+function logChannelCreation(door, channel, isPrivate, requestedMembers, membersAdded, membersFailed) {
     writeLine(door.io.stderr, `${TAG} created ${JSON.stringify({
         channel_id: channel?.id ?? null,
-        is_private: command.isPrivate,
+        is_private: isPrivate,
         members_requested: requestedMembers,
         members_added: membersAdded.length,
         members_failed: membersFailed.length,
     })}`);
-    if (door.json) {
-        return emitAgentDoor(door, { ok: true, channel, membersAdded, membersFailed });
-    }
+}
+function reportChannelCreationToHuman(door, channel, name, requestedMembers, membersAdded, membersFailed) {
     writeLine(door.io.stdout, `Created #${channel?.name ?? name} (${channel?.id ?? "?"}).`);
     if (membersAdded.length > 0) {
         writeLine(door.io.stdout, `${membersAdded.length} member(s) added.`);
@@ -246,7 +253,6 @@ async function createChannel(command, door) {
     for (const failure of membersFailed) {
         writeLine(door.io.stdout, `Not added (${failure.reason}): ${failure.userId}`);
     }
-    return 0;
 }
 async function openDm(command, door) {
     const email = command.dmEmail ?? "";