@moxxy/cli 0.14.1 → 0.14.3

package/dist/bin.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { z as z$1, createMutex, defineTunnelProvider, definePlugin, defineProvider, defineTool, MoxxyError, asTurnId, defineMode, asPluginId, defineCommand, defineChannel, defineWorkflowExecutor, toFriendlyError, estimateTextTokens, classifyHttpStatus, createStuckLoopDetector, runCompactionIfNeeded, runElisionIfNeeded, collectProviderStream, usageEventFields, isContextOverflowError, emitRequestsAndDetectStuck, executeToolUses, buildSystemPromptWithSkills, projectMessages, defineCompactor, defineCacheStrategy, denyByDefaultResolver, createAllowListResolver, zodToJsonSchema, fileDiffSummary, runSingleShotTurn, defineSurface, runManualCompaction, isFileDiffDisplay, renderFrontmatter, defineEmbedder, migrateModeName, skillFrontmatterSchema, asSkillId, getInstallHint, parseFrontmatterFile, createDeferredPermissionResolver, encodeLoginPrompt, defineTranscriber, summarizeTokensByModel, countNodes, moxxyPackageSchema, classifyNetworkError, addModelTotals, createJsonFileStore, ISOLATION_RANK, MOXXY_PCM16_24KHZ_MIME, fileDiffVerb, parseFrontmatter, createCallbackResolver, autoAllowResolver, asSessionId, asToolCallId, defineViewRenderer, DEFAULT_VIEW_TAGS, isSafeViewUrl, evaluateToolRule, summarizeSessionTokensFromEvents, toDiffRows, diffGutterNo, computeElisionState, toolResultStubbed, toolResultStub, toolResultBytes, conversationalStubbed, conversationalStub, asEventId } from '@moxxy/sdk';
+import { z as z$1, createMutex, defineTunnelProvider, definePlugin, defineProvider, defineTool, MoxxyError, asTurnId, defineMode, asPluginId, defineCommand, defineChannel, defineWorkflowExecutor, toFriendlyError, estimateTextTokens, classifyHttpStatus, createStuckLoopDetector, runCompactionIfNeeded, runElisionIfNeeded, collectProviderStream, usageEventFields, isContextOverflowError, emitRequestsAndDetectStuck, executeToolUses, buildSystemPromptWithSkills, projectMessages, defineCompactor, defineCacheStrategy, denyByDefaultResolver, createAllowListResolver, zodToJsonSchema, fileDiffSummary, runSingleShotTurn, defineSurface, runManualCompaction, isFileDiffDisplay, renderFrontmatter, defineEmbedder, migrateModeName, skillFrontmatterSchema, asSkillId, startChannelWith, parseFrontmatterFile, createDeferredPermissionResolver, getInstallHint, defineTranscriber, summarizeTokensByModel, countNodes, moxxyPackageSchema, encodeLoginPrompt, classifyNetworkError, addModelTotals, createJsonFileStore, ISOLATION_RANK, MOXXY_PCM16_24KHZ_MIME, fileDiffVerb, parseFrontmatter, createCallbackResolver, autoAllowResolver, asSessionId, asToolCallId, defineViewRenderer, DEFAULT_VIEW_TAGS, isSafeViewUrl, evaluateToolRule, summarizeSessionTokensFromEvents, toDiffRows, diffGutterNo, computeElisionState, toolResultStubbed, toolResultStub, toolResultBytes, conversationalStubbed, conversationalStub, asEventId } from '@moxxy/sdk';
 import * as fs32 from 'fs';
 import fs32__default, { existsSync, promises, ReadStream, mkdirSync, statSync, readdirSync, writeFileSync, readFileSync, unlinkSync, chmodSync, watch, createReadStream } from 'fs';
 import * as path3 from 'path';
@@ -3666,6 +3666,107 @@ var init_session = __esm({
     };
   }
 });
+
+// ../core/dist/setup-agent.js
+function resolvePermissions(p3) {
+  if (p3 === "deny")
+    return denyByDefaultResolver;
+  if (p3 === void 0 || p3 === "auto")
+    return autoAllowResolver;
+  return p3;
+}
+function finalText(events) {
+  for (let i2 = events.length - 1; i2 >= 0; i2 -= 1) {
+    const e3 = events[i2];
+    if (e3.type === "assistant_message")
+      return e3.content;
+  }
+  return "";
+}
+function mergePresets(presets) {
+  const plugins = [];
+  const seen = /* @__PURE__ */ new Set();
+  const tools = [];
+  let provider;
+  let cwd2;
+  let permissions;
+  let session;
+  for (const p3 of presets) {
+    for (const pl of p3.plugins ?? []) {
+      if (seen.has(pl.name))
+        continue;
+      seen.add(pl.name);
+      plugins.push(pl);
+    }
+    if (p3.tools)
+      tools.push(...p3.tools);
+    if (!provider && p3.provider)
+      provider = p3.provider;
+    cwd2 ??= p3.cwd;
+    permissions ??= p3.permissions;
+    if (p3.session)
+      session = { ...session, ...p3.session };
+  }
+  return { plugins, tools, provider, cwd: cwd2, permissions, session };
+}
+function setupAgent(input = {}) {
+  const opts = Array.isArray(input) ? mergePresets(input) : input;
+  const session = new Session({
+    cwd: opts.cwd ?? process.cwd(),
+    permissionResolver: resolvePermissions(opts.permissions),
+    ...opts.session
+  });
+  for (const plugin5 of opts.plugins ?? [])
+    session.pluginHost.registerStatic(plugin5);
+  for (const tool of opts.tools ?? [])
+    session.tools.register(tool);
+  if (opts.provider)
+    session.providers.setActive(opts.provider.name, opts.provider.config);
+  const agent = {
+    session,
+    async *stream(prompt, runOpts) {
+      yield* runTurn(session, prompt, runOpts);
+    },
+    async ask(prompt, runOpts) {
+      return finalText(await collectTurn(session, prompt, runOpts));
+    },
+    collect(prompt, runOpts) {
+      return collectTurn(session, prompt, runOpts);
+    },
+    async discover() {
+      await session.pluginHost.discoverAndLoad();
+      return agent;
+    },
+    use(plugin5) {
+      session.pluginHost.registerStatic(plugin5);
+      return agent;
+    },
+    addTool(tool) {
+      session.tools.register(tool);
+      return agent;
+    },
+    removeTool(name) {
+      session.tools.unregister(name);
+      return agent;
+    },
+    setProvider(name, config) {
+      session.providers.setActive(name, config);
+      return agent;
+    },
+    setMode(name) {
+      session.modes.setActive(name);
+      return agent;
+    }
+  };
+  return agent;
+}
+var init_setup_agent = __esm({
+  "../core/dist/setup-agent.js"() {
+    init_session();
+    init_run_turn();
+    init_resolvers();
+  }
+});
 function preferencesPath() {
   return path3.join(os5.homedir(), ".moxxy", "preferences.json");
 }
@@ -4149,6 +4250,45 @@ async function restoreEvents(sessionId, dir = defaultSessionsDir(), logger = cre
   }
   return events;
 }
+async function readEventPage(sessionId, opts, dir = defaultSessionsDir()) {
+  const logPath = path3.join(dir, `${sessionId}.jsonl`);
+  let raw;
+  try {
+    raw = await promises.readFile(logPath, "utf8");
+  } catch {
+    return { events: [], prevCursor: null };
+  }
+  const all = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim())
+      continue;
+    try {
+      all.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return pageEvents(all, opts.before, opts.limit);
+}
+function pageEvents(events, before, limit2) {
+  const cap = Math.max(0, Math.floor(limit2));
+  if (cap === 0 || events.length === 0) {
+    return { events: [], prevCursor: events.length === 0 ? null : before };
+  }
+  let end = events.length;
+  if (before !== null) {
+    end = 0;
+    for (let i2 = 0; i2 < events.length; i2 += 1) {
+      if (events[i2].seq < before)
+        end = i2 + 1;
+      else
+        break;
+    }
+  }
+  const start = Math.max(0, end - cap);
+  const page = events.slice(start, end);
+  const prevCursor = start <= 0 ? null : page[0].seq;
+  return { events: page, prevCursor };
+}
 async function deleteSession(sessionId, dir = defaultSessionsDir()) {
   await promises.rm(path3.join(dir, `${sessionId}.jsonl`), { force: true });
   await promises.rm(metaPath(dir, sessionId), { force: true });
@@ -8414,16 +8554,19 @@ __export(dist_exports, {
   mergeUsageStats: () => mergeUsageStats,
   newSessionId: () => newSessionId,
   newTurnId: () => newTurnId,
+  pageEvents: () => pageEvents,
   parseFrontmatter: () => parseFrontmatter,
   parseSkillFile: () => parseSkillFile,
   parseView: () => parseView,
   permissionPolicySchema: () => permissionPolicySchema,
   preferencesPath: () => preferencesPath,
   readPackageMoxxyRequirements: () => readPackageMoxxyRequirements,
+  readSessionEventPage: () => readEventPage,
   readSessionIndex: () => readIndex,
   restoreSessionEvents: () => restoreEvents,
   runTurn: () => runTurn,
   savePreferences: () => savePreferences,
+  setupAgent: () => setupAgent,
   silentLogger: () => silentLogger,
   synthesizeSkill: () => synthesizeSkill,
   toposortPluginManifests: () => toposortPluginManifests,
@@ -8434,6 +8577,7 @@ var init_dist = __esm({
   "../core/dist/index.js"() {
     init_session();
     init_run_turn();
+    init_setup_agent();
     init_subagents();
     init_preferences();
     init_usage_stats();
@@ -136266,7 +136410,7 @@ async function reclaimStaleSocket(socketPath) {
 
 // ../runner/dist/server.js
 init_dist();
-var RUNNER_PROTOCOL_VERSION = 9;
+var RUNNER_PROTOCOL_VERSION = 10;
 var MIN_COMPATIBLE_PROTOCOL_VERSION = 1;
 var RunnerMethod = {
   /** client->server: handshake; returns the initial info snapshot. */
@@ -136285,6 +136429,13 @@ var RunnerMethod = {
    * attached clients so every mirror clears in lockstep.
    */
   SessionReset: "session.reset",
+  /**
+   * client->server: page the runner's authoritative event history (v10).
+   * `{ before, limit }` → `{ events, prevCursor }`, newest-first. Backs the
+   * desktop dual-history retirement; a v10 client gates it on the server's
+   * reported version and falls back to its NDJSON store against an older runner.
+   */
+  SessionLoadHistory: "session.loadHistory",
   /** client->server: declare which resolvers this client will answer. */
   SetResolver: "setResolver",
   /** client->server: switch the active mode. */
@@ -136410,6 +136561,11 @@ var modeSetActiveParamsSchema = z.object({ name: z.string() });
 var sessionSetReasoningParamsSchema = z.object({
   effort: z.enum(["off", "low", "medium", "high"])
 });
+var MAX_HISTORY_PAGE_LIMIT = 2e3;
+var sessionLoadHistoryParamsSchema = z.object({
+  before: z.number().int().nonnegative().nullable(),
+  limit: z.number().int().positive().max(MAX_HISTORY_PAGE_LIMIT)
+});
 var providerSetActiveParamsSchema = z.object({
   name: z.string(),
   config: z.record(z.unknown()).optional()
@@ -136734,6 +136890,7 @@ async function handleSurfaceClose(ctx, raw) {
 }
 
 // ../runner/dist/handlers/session-handlers.js
+init_dist();
 function handleModeSetActive(ctx, raw) {
   const { name } = modeSetActiveParamsSchema.parse(raw);
   ctx.session.modes.setActive(name);
@@ -136745,6 +136902,14 @@ function handleSessionSetReasoning(ctx, raw) {
   ctx.broadcastInfo();
   return {};
 }
+async function handleSessionLoadHistory(ctx, raw) {
+  const { before, limit: limit2 } = sessionLoadHistoryParamsSchema.parse(raw);
+  const log = ctx.session.log;
+  if (log.baseSeq === 0) {
+    return pageEvents(log.toJSON(), before, limit2);
+  }
+  return readEventPage(String(ctx.session.id), { before, limit: limit2 }, ctx.sessionsDir);
+}
 async function handlePermissionAddAllow(ctx, raw) {
   const { name, reason } = permissionAddAllowParamsSchema.parse(raw);
   await ctx.session.permissions.addAllow({ name, ...reason ? { reason } : {} });
@@ -136863,6 +137028,7 @@ var RunnerServer = class {
     peer.handle(RunnerMethod.RunTurn, (raw) => this.handleRunTurn(client, raw));
     peer.handle(RunnerMethod.Abort, (raw) => this.handleAbort(client, raw));
     peer.handle(RunnerMethod.SessionReset, () => this.handleSessionReset());
+    peer.handle(RunnerMethod.SessionLoadHistory, (raw) => handleSessionLoadHistory(ctx, raw));
     peer.handle(RunnerMethod.SetResolver, (raw) => this.handleSetResolver(client, raw));
     peer.handle(RunnerMethod.ModeSetActive, (raw) => handleModeSetActive(ctx, raw));
     peer.handle(RunnerMethod.SessionSetReasoning, (raw) => handleSessionSetReasoning(ctx, raw));
@@ -136946,6 +137112,7 @@ var RunnerServer = class {
       } finally {
         this.turnControllers.delete(turnId);
         client.turns.delete(turnId);
+        await this.sealUnsealedStreamedText(turnId);
         this.broadcast(RunnerNotification.TurnComplete, {
           turnId,
           ...error2 ? { error: error2 } : {}
@@ -136990,6 +137157,59 @@ var RunnerServer = class {
     this.session.log.clear();
     return {};
   }
+  /**
+   * If this turn streamed assistant text (`assistant_chunk`) that no
+   * `assistant_message` ever sealed, append a REAL `assistant_message` to the
+   * authoritative log so it persists + replays like any other reply. It
+   * accumulates chunk deltas and seals whatever text remains at turn end — so a
+   * cleanly sealed reply (the normal path) leaves an empty remainder and this is
+   * a no-op.
+   *
+   * The accumulator resets on BOTH per-iteration boundaries — an
+   * `assistant_message` (a reply was sealed) AND a `provider_request` (a fresh
+   * provider iteration begins). Resetting on `provider_request` is what scopes
+   * the seal to the FINAL iteration: a retryable provider error can abandon a
+   * partially-streamed iteration WITHOUT sealing it (the mode loop emits the
+   * error and `continue`s), and a later iteration then streams fresh text and
+   * may itself end unsealed (a fatal error / abort / max-iterations). Without
+   * the `provider_request` reset, the abandoned attempt's chunks would be
+   * concatenated INTO the sealed reply ("ABANDONED-final" instead of "final"),
+   * durably corrupting authoritative/replayed history. (This is a deliberate
+   * improvement over the desktop renderer's old turn-complete synthesis, which
+   * accumulated across iterations and had exactly that defect — and which this
+   * seal retires.)
+   *
+   * The append flows through `session.log` → persistence + the broadcast stream,
+   * so mirrors ingest it as a normal event and never need to synthesize their
+   * own.
+   */
+  async sealUnsealedStreamedText(turnId) {
+    const events = this.session.log.byTurn(turnId);
+    if (events.length === 0)
+      return;
+    let unsealed = "";
+    for (const event of events) {
+      if (event.type === "assistant_message" || event.type === "provider_request")
+        unsealed = "";
+      else if (event.type === "assistant_chunk")
+        unsealed += event.delta;
+    }
+    if (!unsealed.trim())
+      return;
+    try {
+      await this.session.log.append({
+        type: "assistant_message",
+        sessionId: this.session.id,
+        turnId,
+        source: "model",
+        content: unsealed,
+        // The turn ended without the provider sealing the message (error/abort
+        // after partial text); record it as a normal completed reply.
+        stopReason: "end_turn"
+      });
+    } catch {
+    }
+  }
   handleSetResolver(client, raw) {
     const params = setResolverParamsSchema.parse(raw);
     if (params.permission !== void 0)
@@ -137602,6 +137822,26 @@ var RemoteSession = class {
   async reset() {
     await this.peer.request(RunnerMethod.SessionReset, {});
   }
+  /**
+   * Page the runner's AUTHORITATIVE event history (protocol v10). Backs the
+   * desktop's dual-history retirement — the renderer reads transcript history
+   * from the runner instead of its own NDJSON chat store. Newest-first paging:
+   * pass `before: null` for the newest page, then feed each result's
+   * `prevCursor` back as `before` to walk older pages until `prevCursor` is
+   * `null` (start of history).
+   *
+   * GATED on the server reporting protocol v10+. Against an OLDER runner this
+   * throws a clear, actionable error (not a raw method-not-found) — the desktop
+   * CATCHES it and falls back to its existing NDJSON path, so no transcript
+   * ever goes blank when the runner predates this method.
+   */
+  async loadHistory(before, limit2) {
+    this.requireServerProtocol(10, "Loading session history from the runner");
+    return this.peer.request(RunnerMethod.SessionLoadHistory, {
+      before,
+      limit: limit2
+    });
+  }
   getInfo() {
     return this.requireInfo();
   }
@@ -145703,8 +145943,8 @@ function runProcess(cmd, args, opts) {
 }
 
 // ../plugin-browser/dist/browser-surface.js
-var FRAME_INTERVAL_MS = 450;
-var FAIL_GRACE = 4;
+var FRAME_INTERVAL_MS = 300;
+var FAIL_GRACE = 6;
 function buildBrowserSurface(deps) {
   return defineSurface({
     kind: "browser",
@@ -145831,6 +146071,13 @@ function buildBrowserSurface(deps) {
           } else if (msg.type === "move" && typeof msg.fx === "number" && typeof msg.fy === "number") {
             await browserSidecarCall("mousemove", { x: msg.fx * vw, y: msg.fy * vh }, deps).catch(() => void 0);
             void tick();
+          } else if (msg.type === "capture" && typeof msg.fx === "number" && typeof msg.fy === "number" && typeof msg.fw === "number" && typeof msg.fh === "number") {
+            const shot = await browserSidecarCall("capture", { x: msg.fx * vw, y: msg.fy * vh, width: msg.fw * vw, height: msg.fh * vh }, deps).catch(() => null);
+            if (shot)
+              emit2({ type: "captured", base64: shot.base64, mediaType: shot.mediaType });
+          } else if (msg.type === "zoom" && typeof msg.factor === "number") {
+            await browserSidecarCall("zoom", { factor: msg.factor }, deps).catch(() => void 0);
+            bump();
           } else if (msg.type === "key" && typeof msg.key === "string") {
             await browserSidecarCall("key", { key: msg.key }, deps).catch(() => void 0);
             bump();
@@ -151228,6 +151475,15 @@ async function probeSession(opts, read, boot = setupSessionWithConfig) {
   }
 }
 
+// src/setup/close-session.ts
+async function closeSession(session, persistence) {
+  if (persistence) {
+    await persistence.flush().catch(() => void 0);
+    await persistence.settleWrites().catch(() => void 0);
+  }
+  await session.close("cli-exit").catch(() => void 0);
+}
+
 // src/argv-helpers.ts
 function argvToSetupOptions(argv, overrides = {}) {
   return {
@@ -151310,7 +151566,7 @@ ${stdinBuf}` : prompt;
   }
   const model = stringFlag(argv, "model");
   const resolver2 = allowAll ? denyByDefaultResolver : allowTools.length > 0 ? createAllowListResolver(allowTools) : denyByDefaultResolver;
-  const session = await setupSession({
+  const { session, persistence } = await setupSessionWithConfig({
     ...argvToSetupOptions(argv),
     resolver: resolver2
   });
@@ -151345,7 +151601,9 @@ ${stdinBuf}` : prompt;
     }
   } catch (err) {
     printError(`fatal: ${err instanceof Error ? err.message : String(err)}`);
-    return 1;
+    exitCode = 1;
+  } finally {
+    await closeSession(session, persistence);
   }
   return exitCode;
 }
@@ -151370,8 +151628,6 @@ async function readStdinIfPiped() {
 await init_dist9();
 await init_build2();
 var import_react70 = __toESM(require_react());
-
-// src/commands/web-surface.ts
 var REMOTE_CHANNELS = /* @__PURE__ */ new Set(["telegram"]);
 async function coAttachWebSurface(opts) {
   const { primary, session, vault, config } = opts;
@@ -151385,7 +151641,7 @@ async function coAttachWebSurface(opts) {
   await resolveTunnel(primary, session, webCfg, write);
   try {
     const web = def.create({ cwd: process.cwd(), vault, logger: session.logger, options: webCfg });
-    const handle2 = await web.start({ session });
+    const handle2 = await startChannelWith(web, { session });
     const url2 = web.shareUrl;
     if (url2) write(`  web surface  ${url2}
 `);
@@ -151824,14 +152080,21 @@ function renderLogo(width = process.stdout.columns ?? 80, opts = {}) {
 }
 async function runInitCommand(argv) {
   const interactive = Boolean(process.stdin.isTTY);
-  const { session, vault } = await bootSessionWithConfig(argv, {
+  const { session, vault, persistence } = await bootSessionWithConfig(argv, {
     skipKeyPrompt: true,
     skipProviderActivation: true,
     ...interactive ? { passphrasePrompt: promptVaultPassphrase } : {}
   });
-  if (!interactive) {
-    return await runHeadlessInit(session, vault);
+  try {
+    if (!interactive) {
+      return await runHeadlessInit(session, vault);
+    }
+    return await runInteractiveInit(session, vault);
+  } finally {
+    await closeSession(session, persistence);
   }
+}
+async function runInteractiveInit(session, vault) {
   process.stdout.write(renderLogo());
   await vault.open();
   const providerDefs = session.providers.list();
@@ -152798,8 +153061,6 @@ function stringFlag2(argv, name) {
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
-
-// src/commands/start-registered-channel.ts
 async function startRegisteredChannel(name, argv) {
   const standalone = hasBoolFlag(argv, "standalone");
   const mode = chooseClientMode({ standalone, runnerUp: standalone ? false : await isRunnerUp() });
@@ -152835,7 +153096,7 @@ async function runAttachedChannel(name, argv) {
     options: { ...configOpts, ...argv.flags }
   });
   remote.setPermissionResolver(channel.permissionResolver);
-  const handle2 = await channel.start({
+  const handle2 = await startChannelWith(channel, {
     session: remote,
     model: stringFlag(argv, "model"),
     ...collectExtraFlags(argv)
@@ -152881,7 +153142,7 @@ async function runSelfHostedChannel(name, argv, standalone) {
       runnerServer = null;
     }
   }
-  const handle2 = await channel.start({
+  const handle2 = await startChannelWith(channel, {
     session,
     model: stringFlag(argv, "model"),
     ...collectExtraFlags(argv)
@@ -154222,7 +154483,7 @@ async function runScheduleNow(argv) {
     process.stderr.write(colors.red("missing id") + "\n  usage: moxxy schedule run <id>\n");
     return 2;
   }
-  const { session, scheduler: full } = await setupSessionWithConfig({
+  const { session, scheduler: full, persistence } = await setupSessionWithConfig({
     cwd: process.cwd(),
     skipInitHooks: true
   });
@@ -154253,7 +154514,7 @@ async function runScheduleNow(argv) {
     );
     return outcome.ok ? 0 : 1;
   } finally {
-    await session.close("schedule-run").catch(() => void 0);
+    await closeSession(session, persistence);
   }
 }
 
@@ -154334,7 +154595,25 @@ async function runDoctorCommand(argv) {
     });
     return emit(checks, asJson);
   }
-  const { session, config, configSources, vault, memory, pluginRegistration } = setupResult.value;
+  const { session, config, configSources, vault, memory, pluginRegistration, persistence } = setupResult.value;
+  try {
+    return await runDoctorChecks({
+      session,
+      config,
+      configSources,
+      vault,
+      memory,
+      pluginRegistration,
+      checks,
+      checkKeys,
+      asJson
+    });
+  } finally {
+    await closeSession(session, persistence);
+  }
+}
+async function runDoctorChecks(deps) {
+  const { session, config, configSources, vault, memory, pluginRegistration, checks, checkKeys, asJson } = deps;
   if (configSources.length > 0) {
     const summary = configSources.map((s2) => `${s2.scope}:${s2.path}`).join(", ");
     checks.push({ id: "config", status: "ok", message: `loaded from ${summary}` });
@@ -154407,8 +154686,8 @@ async function runDoctorCommand(argv) {
       checks.push({ id: `provider:${name}`, status: "ok", message: "key resolved" });
     }
   }
-  const deps = { cwd: process.cwd(), vault, logger: session.logger, options: {} };
-  const channelEntries = await session.channels.listWithAvailability(deps);
+  const channelDeps = { cwd: process.cwd(), vault, logger: session.logger, options: {} };
+  const channelEntries = await session.channels.listWithAvailability(channelDeps);
   for (const { def, availability } of channelEntries) {
     if (availability.ok) {
       checks.push({ id: `channel:${def.name}`, status: "ok", message: "available" });
@@ -154620,12 +154899,18 @@ async function runLoginCommand(argv) {
   if (!sub || sub === "help" || sub === "--help" || sub === "-h") {
     let session = null;
     try {
-      const { session: s2 } = await bootSessionWithConfig(argv, {
+      const { session: s2, persistence } = await bootSessionWithConfig(argv, {
         skipKeyPrompt: true,
         skipProviderActivation: true,
         tolerateNoProvider: true
       });
       session = s2;
+      try {
+        process.stdout.write(buildHelp(session));
+      } finally {
+        await closeSession(s2, persistence);
+      }
+      return sub ? 0 : 2;
     } catch {
     }
     process.stdout.write(buildHelp(session));
@@ -154636,11 +154921,18 @@ async function runLoginCommand(argv) {
   return await loginProvider(argv, sub);
 }
 async function loginProvider(argv, providerName2) {
-  const { session, vault } = await bootSessionWithConfig(argv, {
+  const { session, vault, persistence } = await bootSessionWithConfig(argv, {
     skipKeyPrompt: true,
     skipProviderActivation: true,
     tolerateNoProvider: true
   });
+  try {
+    return await runLoginProvider(argv, providerName2, session, vault);
+  } finally {
+    await closeSession(session, persistence);
+  }
+}
+async function runLoginProvider(argv, providerName2, session, vault) {
   const def = session.providers.list().find((d2) => d2.name === providerName2);
   if (!def) {
     process.stderr.write(
@@ -154691,11 +154983,18 @@ Run \`moxxy init\` to store its key in the vault.
   }
 }
 async function loginStatus(argv) {
-  const { session, vault } = await bootSessionWithConfig(argv, {
+  const { session, vault, persistence } = await bootSessionWithConfig(argv, {
     skipKeyPrompt: true,
     skipProviderActivation: true,
     tolerateNoProvider: true
   });
+  try {
+    return await runLoginStatus(argv, session, vault);
+  } finally {
+    await closeSession(session, persistence);
+  }
+}
+async function runLoginStatus(argv, session, vault) {
   await vault.open();
   const ctx = buildProviderAuthContext(vault, { headless: true });
   const filter = argv.positional[1];
@@ -154762,11 +155061,18 @@ async function loginLogout(argv) {
     );
     return 2;
   }
-  const { session, vault } = await bootSessionWithConfig(argv, {
+  const { session, vault, persistence } = await bootSessionWithConfig(argv, {
     skipKeyPrompt: true,
     skipProviderActivation: true,
     tolerateNoProvider: true
   });
+  try {
+    return await runLoginLogout(providerName2, session, vault);
+  } finally {
+    await closeSession(session, persistence);
+  }
+}
+async function runLoginLogout(providerName2, session, vault) {
   await vault.open();
   const def = session.providers.list().find((d2) => d2.name === providerName2);
   if (!def || def.auth?.kind !== "oauth") {
@@ -155202,8 +155508,6 @@ async function runPath(spec) {
   process.stdout.write(s2.unitPath + "\n");
   return 0;
 }
-
-// src/commands/serve.ts
 var BACKGROUND_UNITS = [
   {
     id: "scheduler",
@@ -155452,7 +155756,7 @@ async function startChannel(def, setup, installResolver) {
   if (installResolver) {
     session.setPermissionResolver(channel.permissionResolver);
   }
-  return channel.start({ session, ...channelOpts });
+  return startChannelWith(channel, { session, ...channelOpts });
 }
 function failureHint(_name, error2) {
   const e3 = error2.toLowerCase();