autohand-cli 0.9.0 → 0.9.2

package/dist/chunk-VLUIVJ3J.js

@@ -0,0 +1,235 @@
+import {
+  GoalManager
+} from "./chunk-UMJYX5KD.js";
+import {
+  GOAL_FEATURE_DISABLED_MESSAGE,
+  resolveGoalFeatureEnabled
+} from "./chunk-X53SHYCG.js";
+
+// src/commands/goal.ts
+import chalk from "chalk";
+var metadata = {
+  command: "/goal",
+  description: "Create, inspect, refine, pause, resume, complete, clear, and queue persistent goals",
+  implemented: true,
+  subcommands: [
+    { name: "writer", description: "Interview the user and draft a stronger goal before creating it" },
+    { name: "queue", description: "List queued goals or enqueue a goal" },
+    { name: "pause", description: "Pause the current goal" },
+    { name: "resume", description: "Resume a paused or queued goal" },
+    { name: "complete", description: "Mark the current goal complete" },
+    { name: "clear", description: "Clear the current goal" },
+    { name: "templates", description: "List reusable .pi-goals templates" }
+  ]
+};
+async function goal(ctx, args = []) {
+  if (!resolveGoalFeatureEnabled(ctx.config, ctx.isFeatureEnabled)) {
+    return GOAL_FEATURE_DISABLED_MESSAGE;
+  }
+  await ctx.trackFeatureActivation?.("slash_goal", { surface: "slash_command" });
+  const manager = new GoalManager(ctx.workspaceRoot);
+  const input = args.join(" ").trim();
+  if (!input) {
+    const snapshot = await manager.getSnapshot();
+    if (!snapshot.goal && snapshot.queue.length === 0) {
+      return startGoalWriter(ctx);
+    }
+    return formatSnapshot(snapshot);
+  }
+  const [subcommand, ...restArgs] = args;
+  const rest = restArgs.join(" ").trim();
+  switch (subcommand?.toLowerCase()) {
+    case "writer":
+    case "write":
+    case "refine":
+      return startGoalWriter(ctx, rest);
+    case "queue":
+      return handleQueue(manager, rest);
+    case "pause":
+      return formatMutation(await manager.updateGoal({ status: "paused" }));
+    case "resume": {
+      const snapshot = await manager.getSnapshot();
+      if (!snapshot.goal && snapshot.queue.length > 0) {
+        const started = await manager.startQueuedGoal();
+        if (started.ok && started.goal) {
+          queueGoalContinuation(ctx, started.goal.objective);
+        }
+        return formatMutation(started);
+      }
+      const resumed = await manager.updateGoal({ status: "active" });
+      if (resumed.ok && resumed.goal) {
+        queueGoalContinuation(ctx, resumed.goal.objective);
+      }
+      return formatMutation(resumed);
+    }
+    case "complete": {
+      const completed = await manager.updateGoal({ status: "complete" });
+      if (completed.ok && completed.started && completed.goal?.status === "active") {
+        queueGoalContinuation(ctx, completed.goal.objective);
+      }
+      return formatMutation(completed);
+    }
+    case "clear":
+      return formatMutation(await manager.clearGoal());
+    case "templates": {
+      const templates = await manager.listTemplates();
+      if (templates.length === 0) return "No goal templates found in .pi-goals/ or .ai/.pi-goals/.";
+      return [
+        `Goal templates (${templates.length}):`,
+        ...templates.map((template) => {
+          const aliases = template.aliases.length ? ` aliases: ${template.aliases.join(", ")}` : "";
+          return `- ${template.name}${aliases}${template.description ? ` - ${template.description}` : ""}`;
+        })
+      ].join("\n");
+    }
+    default: {
+      const resolved = await manager.resolveObjective(input);
+      if (!resolved.ok) return chalk.yellow(resolved.message);
+      const created = await manager.createGoal(resolved.input, { replace: false });
+      if (created.ok && created.goal) {
+        await emitGoalWrittenCompleted(ctx, created.goal, "slash");
+        queueGoalContinuation(ctx, created.goal.objective);
+      }
+      return formatMutation(created);
+    }
+  }
+}
+async function runGoalCli(workspaceRoot, rawInput, config) {
+  if (!resolveGoalFeatureEnabled(config)) {
+    return GOAL_FEATURE_DISABLED_MESSAGE;
+  }
+  const manager = new GoalManager(workspaceRoot);
+  const input = rawInput?.trim() ?? "";
+  if (!input) return formatSnapshot(await manager.getSnapshot());
+  const args = input.match(/"[^"]*"|'[^']*'|\S+/g)?.map(unquote) ?? [];
+  return goal({ workspaceRoot }, args);
+}
+function startGoalWriter(ctx, roughGoal) {
+  const activated = ctx.skillsRegistry?.activateSkill("goal-writer") ?? false;
+  const roughGoalText = roughGoal?.trim() || "No rough goal was provided yet.";
+  ctx.queueInstruction?.([
+    "Activate the built-in goal-writer skill and use it to help the user draft one or more stronger /goal objectives.",
+    "Interview the user with follow-up questions when the finish line, proof, boundaries, loop, or stop rule is unclear.",
+    "Show every full drafted objective and get explicit user approval before calling create_goal. If more than one goal is approved, call create_goal for each one in order so later goals are queued.",
+    `Rough goal request: ${roughGoalText}`
+  ].join("\n"));
+  return [
+    "Goal writer started.",
+    activated ? "The built-in $goal-writer skill is active for the next turn." : "The next turn will use the built-in $goal-writer skill instructions if available.",
+    "Answer the follow-up questions to create a completion contract with proof, boundaries, and a stop rule."
+  ].join("\n");
+}
+async function emitGoalWrittenCompleted(ctx, goalState, source) {
+  await ctx.hookManager?.executeHooks("goal-written:completed", {
+    goalId: goalState.goalId,
+    goalObjective: goalState.objective,
+    goalSource: source
+  });
+}
+async function handleQueue(manager, rest) {
+  if (!rest) {
+    const snapshot = await manager.getSnapshot();
+    if (snapshot.queue.length === 0) return "No queued goals.";
+    return formatQueue(snapshot);
+  }
+  return formatMutation(await manager.enqueueGoalBlock(rest, "command"));
+}
+function queueGoalContinuation(ctx, objective) {
+  ctx.queueInstruction?.([
+    `Active goal: ${objective}`,
+    "Continue working toward this persistent goal until it is complete, blocked, paused, cleared, or budget-limited.",
+    "Use get_goal or update_goal when you need to inspect or modify the goal state."
+  ].join("\n"));
+}
+function formatMutation(result) {
+  const lines = [result.ok ? chalk.green(result.message ?? "Goal updated.") : chalk.yellow(result.message ?? "Goal command failed.")];
+  if (result.goal) {
+    lines.push("");
+    lines.push(formatGoal(result.goal));
+  }
+  if (result.queued?.length) {
+    lines.push("");
+    lines.push(`Queued ${result.queued.length} goal${result.queued.length === 1 ? "" : "s"}:`);
+    for (const item of result.queued) {
+      lines.push(`- [${item.queueId}] ${item.objective}`);
+    }
+  }
+  if (result.started) {
+    lines.push(`Started queue item: ${result.started.queueId}`);
+  }
+  if (result.completedRun?.length && result.queue.length === 0) {
+    lines.push("");
+    lines.push(formatCompletedRun(result.completedRun));
+  }
+  if (result.queue.length > 0 && !result.queued?.length) {
+    lines.push("");
+    lines.push(formatQueue({ queue: result.queue }));
+  }
+  return lines.join("\n");
+}
+function formatSnapshot(snapshot) {
+  if (!snapshot.goal && snapshot.queue.length === 0 && snapshot.completed.length === 0) {
+    return [
+      "No goal is currently set.",
+      "Use /goal <objective> to create one, or /goal queue <objective> to queue later work."
+    ].join("\n");
+  }
+  const parts = [];
+  if (snapshot.goal) parts.push(formatGoal(snapshot.goal));
+  else parts.push("No active goal.");
+  if (snapshot.queue.length > 0) {
+    parts.push("");
+    parts.push(formatQueue(snapshot));
+  }
+  if (snapshot.completed.length > 0) {
+    parts.push("");
+    parts.push(formatCompletedRun(snapshot.completed));
+  }
+  return parts.join("\n");
+}
+function formatGoal(goalState) {
+  const lines = [
+    `Goal: ${goalState.objective}`,
+    `Status: ${goalState.status}`,
+    `ID: ${goalState.goalId}`,
+    `Elapsed: ${formatDuration(goalState.timeUsedSeconds)}`,
+    `Tokens: ${goalState.tokensUsed}${goalState.tokenBudget ? ` / ${goalState.tokenBudget}` : ""}`
+  ];
+  if (goalState.timeBudgetSeconds) lines.push(`Time budget: ${formatDuration(goalState.timeBudgetSeconds)}`);
+  if (goalState.minTokensBeforeWrapUp) lines.push(`Token floor: ${goalState.minTokensBeforeWrapUp}`);
+  if (goalState.minTimeSecondsBeforeWrapUp) lines.push(`Time floor: ${formatDuration(goalState.minTimeSecondsBeforeWrapUp)}`);
+  return lines.join("\n");
+}
+function formatQueue(snapshot) {
+  if (snapshot.queue.length === 0) return "No queued goals.";
+  return [
+    `Queued goals (${snapshot.queue.length}):`,
+    ...snapshot.queue.map((item, index) => `${index + 1}. [${item.queueId}] ${item.objective}`)
+  ].join("\n");
+}
+function formatCompletedRun(completed) {
+  return [
+    `Completed goals this session (${completed.length}):`,
+    ...completed.map((item, index) => `${index + 1}. ${item.objective}`)
+  ].join("\n");
+}
+function formatDuration(seconds) {
+  const whole = Math.max(0, Math.floor(seconds));
+  const minutes = Math.floor(whole / 60);
+  const secs = whole % 60;
+  return minutes > 0 ? `${minutes}m ${secs}s` : `${secs}s`;
+}
+function unquote(value) {
+  return value.replace(/^['"]|['"]$/g, "");
+}
+
+export {
+  metadata,
+  goal,
+  runGoalCli
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-VOBINVMV.cjs

@@ -0,0 +1,430 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkCSUGNNJYcjs = require('./chunk-CSUGNNJY.cjs');
+
+
+var _chunkDMM2BKSVcjs = require('./chunk-DMM2BKSV.cjs');
+
+
+var _chunkCNQKIWIScjs = require('./chunk-CNQKIWIS.cjs');
+
+
+
+
+
+
+
+var _chunk7TO3PDMVcjs = require('./chunk-7TO3PDMV.cjs');
+
+
+var _chunk3JURXAL6cjs = require('./chunk-3JURXAL6.cjs');
+
+// src/features/RemoteFeatureFlagManager.ts
+var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var FEATURE_FLAG_REQUEST_TIMEOUT_MS = 1500;
+var CLI_CLIENT_TYPE = "cli";
+function getApiBaseUrl(config) {
+  return (_optionalChain([config, 'access', _ => _.api, 'optionalAccess', _2 => _2.baseUrl]) || _optionalChain([config, 'access', _3 => _3.telemetry, 'optionalAccess', _4 => _4.apiBaseUrl]) || "https://api.autohand.ai").replace(/\/+$/, "");
+}
+function readDeviceId() {
+  try {
+    _fsextra2.default.ensureDirSync(_path2.default.dirname(_chunk3JURXAL6cjs.AUTOHAND_FILES.deviceId));
+    if (_fsextra2.default.existsSync(_chunk3JURXAL6cjs.AUTOHAND_FILES.deviceId)) {
+      const existing = _fsextra2.default.readFileSync(_chunk3JURXAL6cjs.AUTOHAND_FILES.deviceId, "utf8").trim();
+      if (existing) return existing;
+    }
+    const next = _crypto2.default.randomUUID();
+    _fsextra2.default.writeFileSync(_chunk3JURXAL6cjs.AUTOHAND_FILES.deviceId, next);
+    return next;
+  } catch (e) {
+    return _crypto2.default.randomUUID();
+  }
+}
+function parseSnapshot(value) {
+  if (value.success !== true || !Array.isArray(value.flags)) return null;
+  const flags = [];
+  for (const flag of value.flags) {
+    if (!flag || typeof flag !== "object") continue;
+    const candidate = flag;
+    if (typeof candidate.key !== "string" || typeof candidate.enabled !== "boolean") continue;
+    const clientTypes = parseClientTypes(candidate);
+    if (!isCliFeatureFlag(candidate, clientTypes)) continue;
+    flags.push({
+      key: candidate.key,
+      enabled: candidate.enabled,
+      reason: typeof candidate.reason === "string" ? candidate.reason : "unknown",
+      userOverridable: candidate.userOverridable !== false,
+      ...clientTypes.length > 0 ? { clientTypes } : {}
+    });
+  }
+  return {
+    success: true,
+    environment: typeof value.environment === "string" ? value.environment : "production",
+    flags,
+    evaluatedAt: typeof value.evaluatedAt === "string" ? value.evaluatedAt : (/* @__PURE__ */ new Date()).toISOString(),
+    ttlSeconds: typeof value.ttlSeconds === "number" ? value.ttlSeconds : 300
+  };
+}
+function parseClientTypes(candidate) {
+  const values = [
+    candidate.clientType,
+    candidate.clientTypes,
+    candidate.client_type,
+    candidate.client_types,
+    candidate.clients,
+    candidate.targetClients,
+    candidate.target_clients
+  ];
+  const clientTypes = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (typeof value === "string") {
+      for (const item of value.split(",")) {
+        const clientType = item.trim();
+        if (clientType) clientTypes.add(clientType);
+      }
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item === "string") {
+          clientTypes.add(item);
+        }
+      }
+    }
+  }
+  return [...clientTypes].map((clientType) => clientType.toLowerCase());
+}
+function isCliFeatureFlag(candidate, clientTypes) {
+  if (isArchivedFeatureFlag(candidate)) {
+    return false;
+  }
+  const reason = typeof candidate.reason === "string" ? candidate.reason.toLowerCase() : "";
+  if (reason.includes("client_type mismatch") || reason.includes("client type mismatch")) {
+    return false;
+  }
+  if (clientTypes.length > 0) {
+    return clientTypes.includes(CLI_CLIENT_TYPE);
+  }
+  const platforms = _nullishCoalesce(candidate.platforms, () => ( candidate.targetPlatforms));
+  if (Array.isArray(platforms)) {
+    const platformValues = platforms.filter((platform) => typeof platform === "string");
+    return platformValues.length === 0 || platformValues.includes(process.platform);
+  }
+  return true;
+}
+function isArchivedFeatureFlag(candidate) {
+  if (candidate.archived === true || candidate.deleted === true) {
+    return true;
+  }
+  const archivalFields = [
+    candidate.status,
+    candidate.state,
+    candidate.lifecycle,
+    candidate.reason
+  ];
+  return archivalFields.some((value) => typeof value === "string" && value.toLowerCase().includes("archived"));
+}
+function isSnapshotFresh(snapshot) {
+  const evaluatedAt = Date.parse(snapshot.evaluatedAt);
+  if (Number.isNaN(evaluatedAt)) return false;
+  const ttlMs = Math.max(0, snapshot.ttlSeconds) * 1e3;
+  return Date.now() - evaluatedAt < ttlMs;
+}
+function createEvaluationUrl(config, deviceId, clientVersion) {
+  const environment = _optionalChain([config, 'access', _5 => _5.features, 'optionalAccess', _6 => _6.environment]) || "production";
+  const url = new URL(`${getApiBaseUrl(config)}/v1/feature-flags/evaluate`);
+  url.searchParams.set("environment", environment);
+  url.searchParams.set("clientType", CLI_CLIENT_TYPE);
+  url.searchParams.set("deviceId", deviceId);
+  url.searchParams.set("cliVersion", clientVersion);
+  url.searchParams.set("platform", process.platform);
+  return url;
+}
+async function downloadRemoteFeatureFlags(config, deviceId, clientVersion) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FEATURE_FLAG_REQUEST_TIMEOUT_MS);
+  try {
+    const response = await fetch(createEvaluationUrl(config, deviceId, clientVersion), { signal: controller.signal });
+    if (!response.ok) return null;
+    return parseSnapshot(await response.json());
+  } catch (e2) {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function writeRemoteFeatureFlagCache(snapshot) {
+  await _fsextra2.default.ensureDir(_path2.default.dirname(_chunk3JURXAL6cjs.AUTOHAND_FILES.featureFlagsCache));
+  await _fsextra2.default.writeJson(_chunk3JURXAL6cjs.AUTOHAND_FILES.featureFlagsCache, snapshot, { spaces: 2 });
+}
+async function loadCachedRemoteFeatureFlags() {
+  try {
+    if (!await _fsextra2.default.pathExists(_chunk3JURXAL6cjs.AUTOHAND_FILES.featureFlagsCache)) {
+      return null;
+    }
+    const data = await _fsextra2.default.readJson(_chunk3JURXAL6cjs.AUTOHAND_FILES.featureFlagsCache);
+    return parseSnapshot(data);
+  } catch (e3) {
+    return null;
+  }
+}
+async function loadRemoteFeatureFlags(config, options = {}) {
+  const cached = await loadCachedRemoteFeatureFlags();
+  if (!options.forceRefresh && cached && isSnapshotFresh(cached)) {
+    return cached;
+  }
+  const downloaded = await downloadRemoteFeatureFlags(config, readDeviceId(), _chunkCSUGNNJYcjs.package_default.version);
+  if (downloaded) {
+    await writeRemoteFeatureFlagCache(downloaded);
+    return downloaded;
+  }
+  return options.allowCachedFallback === false ? null : cached;
+}
+var RemoteFeatureFlagManager = (_class = class {
+  constructor(config) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.config = config;
+    this.apiBaseUrl = getApiBaseUrl(config);
+    this.environment = _optionalChain([config, 'access', _7 => _7.features, 'optionalAccess', _8 => _8.environment]) || "production";
+    this.clientVersion = _chunkCSUGNNJYcjs.package_default.version;
+  }
+  
+  __init() {this.snapshot = null}
+  __init2() {this.deviceId = readDeviceId()}
+  
+  
+  
+  async refreshFeatureFlags() {
+    const downloaded = await downloadRemoteFeatureFlags(this.config, this.deviceId, this.clientVersion);
+    if (downloaded) {
+      this.snapshot = downloaded;
+      await writeRemoteFeatureFlagCache(downloaded);
+      return;
+    }
+    this.snapshot = await loadCachedRemoteFeatureFlags();
+  }
+  getSnapshot() {
+    return this.snapshot;
+  }
+  isFeatureEnabled(key, localDefault = false) {
+    if (_chunk7TO3PDMVcjs.isLocalFeatureId.call(void 0, key)) {
+      return localDefault;
+    }
+    const flag = _optionalChain([this, 'access', _9 => _9.snapshot, 'optionalAccess', _10 => _10.flags, 'access', _11 => _11.find, 'call', _12 => _12((item) => item.key === key)]);
+    if (!flag) return localDefault;
+    if (!flag.enabled) return false;
+    return _optionalChain([this, 'access', _13 => _13.config, 'access', _14 => _14.features, 'optionalAccess', _15 => _15.remoteOverrides, 'optionalAccess', _16 => _16[key]]) !== "off";
+  }
+  async trackFeatureActivation(key, metadata2) {
+    void metadata2;
+    const flag = _optionalChain([this, 'access', _17 => _17.snapshot, 'optionalAccess', _18 => _18.flags, 'access', _19 => _19.find, 'call', _20 => _20((item) => item.key === key)]);
+    if (!flag || !this.isFeatureEnabled(key)) return;
+    try {
+      await fetch(`${this.apiBaseUrl}/v1/feature-flags/events`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          events: [{
+            key,
+            environment: this.environment,
+            eventType: "activation",
+            enabled: true,
+            reason: flag.reason,
+            deviceId: this.deviceId,
+            clientType: "cli",
+            cliVersion: this.clientVersion,
+            platform: process.platform,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }]
+        })
+      });
+    } catch (e4) {
+    }
+  }
+  getStatus() {
+    return {
+      apiBaseUrl: this.apiBaseUrl,
+      environment: this.environment,
+      deviceId: this.deviceId,
+      platform: process.platform,
+      osVersion: _os2.default.release(),
+      evaluatedAt: _optionalChain([this, 'access', _21 => _21.snapshot, 'optionalAccess', _22 => _22.evaluatedAt]) || null
+    };
+  }
+}, _class);
+
+// src/commands/features.ts
+function renderUsage() {
+  return [
+    "Usage: /experiments [list|status|enable|disable|refresh]",
+    "",
+    "Commands:",
+    "  /experiments",
+    "  /experiments list",
+    "  /experiments status <feature>",
+    "  /experiments enable <feature>",
+    "  /experiments disable <feature>",
+    "  /experiments refresh"
+  ].join("\n");
+}
+function requireConfig(config) {
+  return _nullishCoalesce(config, () => ( "Config not available."));
+}
+async function setFeatureEnabled(config, featureId, enabled, remoteSnapshot) {
+  if (!featureId) {
+    return renderUsage();
+  }
+  const snapshot = remoteSnapshot === void 0 ? await loadRemoteFeatureFlags(config) : remoteSnapshot;
+  const result = _chunk7TO3PDMVcjs.setFeatureState.call(void 0, config, featureId, enabled, { remoteSnapshot: snapshot });
+  if (!result.ok || !result.feature) {
+    return _nullishCoalesce(result.error, () => ( `Unknown feature "${featureId}".`));
+  }
+  await _chunkCNQKIWIScjs.saveConfig.call(void 0, config);
+  if (result.feature.source === "remote") {
+    if (enabled) {
+      return `Following remote state for ${result.feature.id} (currently ${result.feature.enabled ? "on" : "off"}).`;
+    }
+    return `Disabled ${result.feature.id} locally. Remote state remains ${result.feature.remoteEnabled ? "on" : "off"}.`;
+  }
+  const action = enabled ? "Enabled" : "Disabled";
+  const restartNote = result.feature.requiresRestart ? " Restart Autohand for this to fully apply." : "";
+  return `${action} ${result.feature.id}.${restartNote}`;
+}
+async function showInteractiveFeatures(config, remoteSnapshot) {
+  let toggleCount = 0;
+  const pendingSaves = [];
+  const states = _chunk7TO3PDMVcjs.listFeatureStates.call(void 0, config, { remoteSnapshot });
+  const initialStates = new Map(states.map((feature) => [feature.id, feature.enabled]));
+  const finalStates = new Map(initialStates);
+  const restartRequired = new Set(states.filter((feature) => feature.requiresRestart).map((feature) => feature.id));
+  const options = states.map((feature) => ({
+    label: `${feature.id.padEnd(26)} ${feature.source.padEnd(8)} ${feature.stage.padEnd(12)} ${feature.enabled ? "on" : "off"}`,
+    value: feature.id,
+    checked: feature.enabled,
+    description: feature.description
+  }));
+  await _chunkDMM2BKSVcjs.showModal.call(void 0, {
+    title: "Experiments - space toggles, enter closes",
+    options,
+    multiSelect: true,
+    maxVisible: 12,
+    onToggle: (option, checked) => {
+      const result = _chunk7TO3PDMVcjs.setFeatureState.call(void 0, config, option.value, checked, { remoteSnapshot });
+      if (!result.ok) {
+        return;
+      }
+      toggleCount += 1;
+      finalStates.set(option.value, _nullishCoalesce(_optionalChain([result, 'access', _23 => _23.feature, 'optionalAccess', _24 => _24.enabled]), () => ( checked)));
+      pendingSaves.push(_chunkCNQKIWIScjs.saveConfig.call(void 0, config));
+    }
+  });
+  await Promise.all(pendingSaves);
+  if (toggleCount === 0) {
+    return null;
+  }
+  const enabled = [];
+  const disabled = [];
+  for (const [featureId, initiallyEnabled] of initialStates) {
+    const finallyEnabled = finalStates.get(featureId);
+    if (finallyEnabled === initiallyEnabled || typeof finallyEnabled !== "boolean") {
+      continue;
+    }
+    if (finallyEnabled) {
+      enabled.push(featureId);
+    } else {
+      disabled.push(featureId);
+    }
+  }
+  return formatInteractiveFeatureSummary({
+    enabled,
+    disabled,
+    restartRequired: [...new Set([...enabled, ...disabled].filter((featureId) => restartRequired.has(featureId)))]
+  });
+}
+function formatChangedFeatures(action, featureIds) {
+  if (featureIds.length === 0) {
+    return null;
+  }
+  if (featureIds.length === 1) {
+    return `${action} ${featureIds[0]}.`;
+  }
+  return `${action} ${featureIds.length} features: ${featureIds.join(", ")}.`;
+}
+function formatInteractiveFeatureSummary(changes) {
+  const parts = [
+    formatChangedFeatures("Enabled", changes.enabled),
+    formatChangedFeatures("Disabled", changes.disabled)
+  ].filter((part) => Boolean(part));
+  if (changes.restartRequired.length > 0) {
+    parts.push(`Restart required for: ${changes.restartRequired.join(", ")}.`);
+  }
+  return parts.length > 0 ? parts.join(" ") : null;
+}
+async function features(ctx, args = []) {
+  const required = requireConfig(ctx.config);
+  if (typeof required === "string") {
+    return required;
+  }
+  const subcommand = (_nullishCoalesce(args[0], () => ( ""))).toLowerCase();
+  const featureId = args[1];
+  const forceRefresh = subcommand === "refresh";
+  const remoteSnapshot = await loadRemoteFeatureFlags(required, {
+    forceRefresh,
+    allowCachedFallback: !forceRefresh
+  });
+  switch (subcommand) {
+    case "":
+      return showInteractiveFeatures(required, remoteSnapshot);
+    case "list":
+    case "ls":
+      if (ctx.interactive) {
+        return showInteractiveFeatures(required, remoteSnapshot);
+      }
+      return _chunk7TO3PDMVcjs.formatFeatureList.call(void 0, required, { remoteSnapshot });
+    case "status":
+    case "show":
+      return featureId ? _chunk7TO3PDMVcjs.formatFeatureStatus.call(void 0, required, featureId, { remoteSnapshot }) : renderUsage();
+    case "enable":
+    case "on":
+      return setFeatureEnabled(required, featureId, true, remoteSnapshot);
+    case "disable":
+    case "off":
+      return setFeatureEnabled(required, featureId, false, remoteSnapshot);
+    case "refresh":
+      if (!remoteSnapshot) {
+        return "No remote feature flags available. Using local feature switches only.";
+      }
+      return `Downloaded ${remoteSnapshot.flags.length} remote feature${remoteSnapshot.flags.length === 1 ? "" : "s"} from ${remoteSnapshot.environment}.`;
+    default:
+      if (_chunk7TO3PDMVcjs.getFeatureState.call(void 0, required, subcommand, { remoteSnapshot })) {
+        return _chunk7TO3PDMVcjs.formatFeatureStatus.call(void 0, required, subcommand, { remoteSnapshot });
+      }
+      return renderUsage();
+  }
+}
+var metadata = {
+  command: "/experiments",
+  description: "list and toggle Autohand experiments",
+  implemented: true,
+  subcommands: [
+    { name: "list", description: "List experiments and current state" },
+    { name: "status", description: "Show one experiment" },
+    { name: "enable", description: "Enable an experiment" },
+    { name: "disable", description: "Disable an experiment" },
+    { name: "refresh", description: "Download remote feature flags from the Autohand API" }
+  ]
+};
+
+
+
+
+
+
+exports.RemoteFeatureFlagManager = RemoteFeatureFlagManager; exports.setFeatureEnabled = setFeatureEnabled; exports.features = features; exports.metadata = metadata;
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */