@wrongstack/cli 1.0.24 → 1.0.27

package/dist/{sessions-config-IQUH2GXT.js → sessions-config-XHLXJ5C3.js}

@@ -1,6 +1,9 @@
 import {
   activeProfileConfigPath
 } from "./chunk-YMXXOOFN.js";
+import {
+  restoreFlags
+} from "./chunk-CSAPOCBP.js";
 import {
   backupCurrent,
   getHistoryEntry,
@@ -8,11 +11,9 @@ import {
   restoreFromHistory,
   restoreLast
 } from "./chunk-WSTVGC2C.js";
-import {
-  restoreFlags
-} from "./chunk-CSAPOCBP.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
@@ -32,6 +33,40 @@ function redactKeys(obj) {
 import * as fsp from "node:fs/promises";
 import * as path from "node:path";
 import { color } from "@wrongstack/core/utils";
+var STORE_SIDECAR_JSONL_NAMES = /* @__PURE__ */ new Set(["_index.jsonl", "_mailbox.jsonl"]);
+var SESSION_SIDECAR_JSONL_SUFFIXES = [".replay.jsonl", ".audit.jsonl", ".annotations.jsonl"];
+function isSubagentTranscriptFile(name) {
+  const lower = name.toLowerCase();
+  if (!lower.endsWith(".jsonl")) return false;
+  if (STORE_SIDECAR_JSONL_NAMES.has(lower)) return false;
+  return !SESSION_SIDECAR_JSONL_SUFFIXES.some((suffix) => lower.endsWith(suffix));
+}
+async function collectSubagentTranscripts(subagentsDir) {
+  let entries;
+  try {
+    entries = await fsp.readdir(subagentsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      if (isSubagentTranscriptFile(entry.name)) out.push(entry.name);
+      continue;
+    }
+    if (!entry.isDirectory() || entry.name === "transcripts" || entry.name === "shared") continue;
+    let nested;
+    try {
+      nested = await fsp.readdir(path.join(subagentsDir, entry.name));
+    } catch {
+      continue;
+    }
+    for (const name of nested) {
+      if (isSubagentTranscriptFile(name)) out.push(`${entry.name}/${name}`);
+    }
+  }
+  return out;
+}
 var sessionsFleetCmd = async (args, deps) => {
   const runId = args.find((a) => !a.startsWith("-"));
   if (runId) {
@@ -39,10 +74,46 @@ var sessionsFleetCmd = async (args, deps) => {
   }
   return listFleetRuns(deps);
 };
+async function hasFleetRunArtifacts(dir) {
+  const markers = await Promise.all(
+    ["fleet.json", "checkpoint.json", "subagents"].map(
+      (name) => fsp.access(path.join(dir, name)).then(
+        () => true,
+        () => false
+      )
+    )
+  );
+  return markers.some((found) => found);
+}
+async function discoverFleetRunIds(projectSessions) {
+  const entries = await fsp.readdir(projectSessions, { withFileTypes: true });
+  const ids = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const dir = path.join(projectSessions, entry.name);
+    if (await hasFleetRunArtifacts(dir)) {
+      ids.push(entry.name);
+      continue;
+    }
+    let children;
+    try {
+      children = await fsp.readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const child of children) {
+      if (!child.isDirectory()) continue;
+      if (await hasFleetRunArtifacts(path.join(dir, child.name))) {
+        ids.push(`${entry.name}/${child.name}`);
+      }
+    }
+  }
+  return ids;
+}
 async function listFleetRuns(deps) {
   let entries = [];
   try {
-    entries = await fsp.readdir(deps.paths.projectSessions);
+    entries = await discoverFleetRunIds(deps.paths.projectSessions);
   } catch {
     deps.renderer.writeError(`Cannot read projectSessions: ${deps.paths.projectSessions}
 `);
@@ -68,8 +139,8 @@ async function listFleetRuns(deps) {
             () => true,
             () => false
           ),
-          fsp.readdir(path.join(runDir, "subagents")).then(
-            (files) => files.filter((f) => f.endsWith(".jsonl")).length,
+          collectSubagentTranscripts(path.join(runDir, "subagents")).then(
+            (files) => files.length,
             () => 0
           )
         ]);
@@ -188,8 +259,7 @@ Fleet Run: ${runId}
   const subagentsDir = path.join(runDir, "subagents");
   let subagentFiles = [];
   try {
-    subagentFiles = await fsp.readdir(subagentsDir);
-    subagentFiles = subagentFiles.filter((f) => f.endsWith(".jsonl"));
+    subagentFiles = await collectSubagentTranscripts(subagentsDir);
   } catch {
   }
   if (subagentFiles.length > 0) {
@@ -296,6 +366,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;
@@ -308,7 +407,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;
@@ -426,4 +525,4 @@ export {
   configCmd,
   sessionsCmd
 };
-//# sourceMappingURL=sessions-config-IQUH2GXT.js.map
+//# sourceMappingURL=sessions-config-XHLXJ5C3.js.map

package/dist/short-circuit-flags-5TNTJPQR.js

@@ -0,0 +1,10 @@
+import {
+  handleHelpVersionShortCircuit
+} from "./chunk-HFZH2XJN.js";
+import "./chunk-5JYDKG5B.js";
+import "./chunk-F5DCFAKI.js";
+import "./chunk-Q4INH2DG.js";
+export {
+  handleHelpVersionShortCircuit
+};
+//# sourceMappingURL=short-circuit-flags-5TNTJPQR.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/goal-refiner.d.ts

@@ -1,14 +1,11 @@
 import type { OneShotOrchestrator } from '@wrongstack/core/execution';
-import type { Config, Provider } from '@wrongstack/core/types';
+import { type RefinedMission } from '@wrongstack/core/goal';
+import type { Provider } from '@wrongstack/core/types';
+export { refineGoalHeuristic, resolveRefinerTarget } from '@wrongstack/core/goal';
 /**
  * Result of refining a user's raw goal into a clear, actionable mission.
  */
-interface RefinedGoal {
-    /** Unambiguous, detailed goal statement. */
-    refinedGoal: string;
-    /** Concrete, verifiable deliverables (one per entry). */
-    deliverables: string[];
-}
+type RefinedGoal = RefinedMission;
 /**
  * Options for goal refinement with fallback tiers.
  */
@@ -31,42 +28,6 @@ interface GoalRefinerOptions {
      */
     oneShotOrchestrator?: OneShotOrchestrator | undefined;
 }
-/**
- * Resolved refiner target after validating against available providers,
- * favorite models, and the currently active session model.
- * Both `provider` and `model` are defined when a viable dedicated refiner
- * is found; otherwise the caller should use the primary session defaults.
- */
-interface ResolvedRefinerTarget {
-    /** Resolved provider instance, ready for `provider.complete()`. */
-    provider: Provider;
-    /** Resolved model id on that provider. */
-    model: string;
-}
-/**
- * Validate and resolve a dedicated refiner provider+model from the user
- * config. Returns undefined when:
- *   - refinerFallbackProfile resolves to a valid profile entry (tried first)
- *   - Neither refinerProvider nor refinerModel is configured
- *   - The configured provider is unavailable (createProvider returns
- *     undefined, meaning the provider doesn't exist or has no credentials)
- *   - The configured model is not a favorite model AND is not the
- *     currently active session model
- *
- * Precedence (first wins):
- *   1. refinerFallbackProfile → first valid entry from the named profile chain
- *   2. refinerProvider + refinerModel  (both set)
- *   3. refinerModel on the active session provider
- *
- * When only `refinerModel` is set (no provider), the model is used on
- * the active session provider — validated against the same constraints.
- *
- * @param cfg          — live Config from configStore
- * @param createProvider— factory: providerId → Provider | undefined
- * @param activeProviderId — the session's active provider id (config.provider)
- * @param activeModel  — the session's active model (config.model)
- */
-export declare function resolveRefinerTarget(cfg: Config, createProvider: ((providerId: string) => Provider | undefined) | undefined, activeProviderId: string, activeModel: string): ResolvedRefinerTarget | undefined;
 /**
  * Refine a raw goal using the best available model/provider, with a
  * four-tier fallback chain:
@@ -85,10 +46,4 @@ export declare function refineGoalWithFallback(rawGoal: string, opts: GoalRefine
  * or the call fails.
  */
 export declare function refineGoal(rawGoal: string, provider: Provider, model: string, oneShotOrchestrator?: OneShotOrchestrator | undefined): Promise<RefinedGoal | null>;
-/**
- * Heuristic-only refinement — used when no LLM is available.
- * Produces a basic structure from the raw goal.
- */
-export declare function refineGoalHeuristic(rawGoal: string): RefinedGoal;
-export {};
 //# sourceMappingURL=goal-refiner.d.ts.map

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

@@ -18,7 +18,8 @@ export { parseMcpArgs, runMcpManagementCommand } from '../services/mcp-managemen
  *   /mcp prompts <name> — discover cached/live prompts
  *   /mcp read <name> <uri> — explicitly insert a selected resource
  *   /mcp get <name> <prompt> [key=value...] — explicitly insert a selected prompt
- *   /mcp auth start <name> <client-id> <redirect-uri> [scopes...] — begin OAuth
+ *   /mcp auth login <name> [--client-id <id>] [--port <n>] [scopes...] — one-step OAuth
+ *   /mcp auth start <name> --redirect-uri <url> [--client-id <id>] [scopes...] — manual OAuth
  *   /mcp auth complete <name> <callback-url> — finish OAuth from a callback URL
  *   /mcp auth status <name> — show non-secret authorization state
  *   /mcp auth logout <name> — remove stored OAuth credentials

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

@@ -0,0 +1,4 @@
+import type { SlashCommand } from '@wrongstack/core/types';
+import type { SlashCommandContext } from './command-context.js';
+export declare function buildPermissionsCommand(opts: SlashCommandContext): SlashCommand;
+//# sourceMappingURL=permissions.d.ts.map

package/dist/slash-commands/settings-context-mutations.d.ts

@@ -0,0 +1,5 @@
+import { persistConfigSetting } from '../settings-menu.js';
+export declare function executeContextSettings(sub: string, rest: string[], persistDeps: Parameters<typeof persistConfigSetting>[0]): Promise<{
+    message: string;
+} | undefined>;
+//# sourceMappingURL=settings-context-mutations.d.ts.map

package/dist/slash-commands/settings-limits-mutations.d.ts

@@ -0,0 +1,12 @@
+import { type LimitsConfig } from '@wrongstack/core/types';
+import { persistConfigSetting } from '../settings-menu.js';
+/** Render `/settings limits` — every limit, whether the user set it, and its range. */
+export declare function renderLimitsView(limits: LimitsConfig | undefined): string;
+/**
+ * `/settings limits [<name> <n|off>]`. Limits are user config only (denied to
+ * in-project config), so writes always go to the active profile.
+ */
+export declare function executeLimitsSettings(sub: string, rest: string[], persistDeps: Parameters<typeof persistConfigSetting>[0], current: LimitsConfig | undefined): Promise<{
+    message: string;
+} | undefined>;
+//# sourceMappingURL=settings-limits-mutations.d.ts.map

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

@@ -1,5 +1,18 @@
-import type { InputReader, SlashCommand } from '@wrongstack/core/types';
+import type { InputReader, SlashCommand, ThemePresetId } from '@wrongstack/core/types';
 import type { SlashCommandContext } from './command-context.js';
+interface ThemeOption {
+    id: ThemePresetId;
+    name: string;
+    desc: string;
+}
+/**
+ * The CLI's picker rows, exported for the TUI↔CLI agreement test
+ * (`packages/cli/tests/theme-metadata-agreement.test.ts`). The TUI derives its
+ * own rows from the same `THEME_PRESET_META` record, so this export is the
+ * second side of that comparison — it must stay in step with `THEME_OPTIONS`
+ * above.
+ */
+export declare const cliThemePickerOptions: readonly ThemeOption[];
 /**
  * Windowed slice of the theme list for the raw-terminal picker — mirrors the
  * math in the TUI's `useWindowedPicker` (same centering + marker rules) so
@@ -35,4 +48,5 @@ export declare function truncateDesc(desc: string, columns: number, active: bool
 export declare function buildThemeCommand(opts: SlashCommandContext & {
     inputReader?: InputReader | undefined;
 }): SlashCommand;
+export {};
 //# sourceMappingURL=theme.d.ts.map

package/dist/standalone-auto-update-TOTRGCSA.js

@@ -0,0 +1,249 @@
+import {
+  MAX_BINARY_BYTES,
+  downloadReleaseAssetToFile,
+  findStandaloneRelease,
+  installExecutableFrom,
+  verifyStandaloneDigest
+} from "./chunk-X756ZS72.js";
+import {
+  isNewer
+} from "./chunk-RZ4ZDRYA.js";
+import {
+  CLI_VERSION,
+  STANDALONE_TARGET
+} from "./chunk-F5DCFAKI.js";
+
+// src/standalone-auto-update.ts
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isStandaloneBinary, wstackGlobalRoot } from "@wrongstack/core/utils";
+var PENDING_FILE = "pending.json";
+var APPLIED_FILE = "last-applied.json";
+var LOCK_FILE = "update.lock";
+var LOCK_STALE_MS = 45 * 6e4;
+var DOWNLOAD_TIMEOUT_MS = 30 * 6e4;
+function updatesDir(root = wstackGlobalRoot()) {
+  return path.join(root, "updates");
+}
+function autoUpdateEnabled(config, env = process.env) {
+  const off = env["WRONGSTACK_NO_AUTO_UPDATE"];
+  if (off !== void 0 && off !== "" && off !== "0") return false;
+  return config?.update?.autoDownload !== false;
+}
+function readPendingUpdate(dir = updatesDir()) {
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(path.join(dir, PENDING_FILE), "utf8"));
+  } catch {
+    return void 0;
+  }
+  const p = raw;
+  if (!p || typeof p.version !== "string" || typeof p.file !== "string" || typeof p.sha256 !== "string" || !/^[0-9a-f]{64}$/.test(p.sha256) || typeof p.target !== "string" || typeof p.executable !== "string" || // Only ever install from the staging directory itself.
+  path.dirname(path.resolve(p.file)) !== path.resolve(dir) || !fs.existsSync(p.file)) {
+    return void 0;
+  }
+  return {
+    version: p.version,
+    file: p.file,
+    sha256: p.sha256,
+    target: p.target,
+    executable: p.executable,
+    stagedAt: typeof p.stagedAt === "string" ? p.stagedAt : ""
+  };
+}
+function discardPending(dir, pending) {
+  fs.rmSync(path.join(dir, PENDING_FILE), { force: true });
+  if (pending) fs.rmSync(pending.file, { force: true });
+}
+function writeJsonAtomic(file, value) {
+  const tmp = `${file}.${randomBytes(6).toString("hex")}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384, flag: "wx" });
+  fs.renameSync(tmp, file);
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function acquireLock(dir) {
+  const lock = path.join(dir, LOCK_FILE);
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      fs.writeFileSync(lock, JSON.stringify({ pid: process.pid, at: Date.now() }), { flag: "wx" });
+      return () => fs.rmSync(lock, { force: true });
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      let owner = {};
+      try {
+        owner = JSON.parse(fs.readFileSync(lock, "utf8"));
+      } catch {
+      }
+      const fresh = typeof owner.pid === "number" && pidAlive(owner.pid) && typeof owner.at === "number" && Date.now() - owner.at < LOCK_STALE_MS;
+      if (fresh) return void 0;
+      fs.rmSync(lock, { force: true });
+    }
+  }
+  return void 0;
+}
+function applyPending(install, platform) {
+  const { dir, current, executable } = install;
+  const pending = readPendingUpdate(dir);
+  if (!pending) return void 0;
+  if (!isNewer(pending.version, current)) {
+    discardPending(dir, pending);
+    return void 0;
+  }
+  if (pending.executable !== executable) return void 0;
+  const release = acquireLock(dir);
+  if (!release) return void 0;
+  try {
+    try {
+      installExecutableFrom(executable, pending.file, pending.sha256, platform);
+    } catch (err) {
+      if (/does not match its digest/.test(String(err))) discardPending(dir, pending);
+      throw err;
+    }
+    discardPending(dir, pending);
+    writeJsonAtomic(path.join(dir, APPLIED_FILE), {
+      from: current,
+      to: pending.version,
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return pending.version;
+  } finally {
+    release();
+  }
+}
+function takeAppliedUpdate(dir = updatesDir()) {
+  const file = path.join(dir, APPLIED_FILE);
+  try {
+    const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+    fs.rmSync(file, { force: true });
+    if (typeof raw.from === "string" && typeof raw.to === "string") {
+      return { from: raw.from, to: raw.to };
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function stageLatest(install, signal) {
+  const { dir } = install;
+  const release = await findStandaloneRelease(install.target, signal);
+  if (!isNewer(release.version, install.current)) return void 0;
+  const already = readPendingUpdate(dir);
+  if (already?.version === release.version && already.target === install.target && already.executable === install.executable) {
+    return already;
+  }
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  const unlock = acquireLock(dir);
+  if (!unlock) return void 0;
+  const partial = path.join(dir, `.partial-${randomBytes(9).toString("hex")}`);
+  try {
+    const sha256 = await downloadReleaseAssetToFile(release.asset.browser_download_url, partial, {
+      timeoutMs: DOWNLOAD_TIMEOUT_MS,
+      maxBytes: MAX_BINARY_BYTES,
+      signal
+    });
+    await verifyStandaloneDigest(release, sha256, signal);
+    const file = path.join(dir, `${release.version}-${release.assetName}`);
+    fs.rmSync(file, { force: true });
+    fs.renameSync(partial, file);
+    const pending = {
+      version: release.version,
+      file,
+      sha256,
+      target: install.target,
+      executable: install.executable,
+      stagedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writeJsonAtomic(path.join(dir, PENDING_FILE), pending);
+    for (const name of fs.readdirSync(dir)) {
+      const keep = [PENDING_FILE, APPLIED_FILE, LOCK_FILE, path.basename(file)];
+      if (!keep.includes(name)) fs.rmSync(path.join(dir, name), { force: true, recursive: true });
+    }
+    return pending;
+  } finally {
+    fs.rmSync(partial, { force: true });
+    unlock();
+  }
+}
+function standaloneUpdater(install) {
+  const bound = { ...install, dir: install.dir ?? updatesDir() };
+  const pending = () => {
+    const found = readPendingUpdate(bound.dir);
+    return found?.executable === bound.executable ? found : void 0;
+  };
+  return {
+    pending,
+    stage: (signal) => stageLatest(bound, signal),
+    apply: (platform) => applyPending(bound, platform),
+    clear: () => {
+      const found = pending();
+      if (found) discardPending(bound.dir, found);
+    }
+  };
+}
+function startStandaloneAutoUpdate(options) {
+  if (!isStandaloneBinary() || !STANDALONE_TARGET) return void 0;
+  if (!autoUpdateEnabled(options.getConfig())) return void 0;
+  let updater;
+  try {
+    updater = standaloneUpdater({
+      executable: fs.realpathSync(process.execPath),
+      target: STANDALONE_TARGET,
+      current: CLI_VERSION
+    });
+  } catch {
+    return void 0;
+  }
+  const listeners = /* @__PURE__ */ new Set();
+  let ready;
+  const markReady = (version) => {
+    ready = version;
+    for (const listener of listeners) listener(version);
+  };
+  process.once("exit", () => {
+    if (!autoUpdateEnabled(options.getConfig())) return;
+    try {
+      updater.apply();
+    } catch {
+    }
+  });
+  const found = updater.pending();
+  const pending = found && isNewer(found.version, CLI_VERSION) ? found : void 0;
+  const latest = options.updateInfo?.outdated ? options.updateInfo.latest : void 0;
+  const controller = new AbortController();
+  if (pending && (latest === void 0 || !isNewer(latest, pending.version))) {
+    ready = pending.version;
+  } else if (latest !== void 0) {
+    void updater.stage(controller.signal).then((staged) => {
+      if (staged) markReady(staged.version);
+    }).catch((err) => {
+      if (controller.signal.aborted) return;
+      options.onError?.(err instanceof Error ? err.message : String(err));
+    });
+  }
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      if (ready) listener(ready);
+      return () => listeners.delete(listener);
+    },
+    dispose() {
+      controller.abort();
+      listeners.clear();
+    }
+  };
+}
+export {
+  autoUpdateEnabled,
+  standaloneUpdater,
+  startStandaloneAutoUpdate,
+  takeAppliedUpdate
+};
+//# sourceMappingURL=standalone-auto-update-TOTRGCSA.js.map