autohand-cli 0.9.0 → 0.9.2

package/dist/chunk-QDO4L2A7.cjs

@@ -0,0 +1,156 @@
+"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; }// src/commands/sessionBranching.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var FORK_FLAG = "experimental_fork";
+var CLONE_FLAG = "experimental_clone";
+var forkMetadata = {
+  command: "/fork",
+  description: "branch a new session from the active session or an earlier user message",
+  implemented: true
+};
+var cloneMetadata = {
+  command: "/clone",
+  description: "duplicate the active session branch into a new session",
+  implemented: true
+};
+var treeMetadata = {
+  command: "/tree",
+  description: "show the fork and clone tree for this project",
+  implemented: true
+};
+async function forkSession(ctx, args = []) {
+  if (!isEnabled(ctx, FORK_FLAG)) {
+    return `The /fork command is behind ${FORK_FLAG}. Run /features enable ${FORK_FLAG}, then /fork again. No restart required.`;
+  }
+  await _optionalChain([ctx, 'access', _ => _.trackFeatureActivation, 'optionalCall', _2 => _2(FORK_FLAG, { surface: "slash_command" })]);
+  const target = parseForkArgs(args);
+  const sourceSessionId = target.sourceReference ? await ctx.sessionManager.resolveSessionReference(target.sourceReference) : requireCurrentSessionId(ctx, "/fork");
+  const forked = await ctx.sessionManager.branchSession(sourceSessionId, {
+    type: "fork",
+    userMessageOrdinal: target.userMessageOrdinal
+  });
+  await _optionalChain([ctx, 'access', _3 => _3.restoreSession, 'optionalCall', _4 => _4(forked.metadata.sessionId)]);
+  const point = target.userMessageOrdinal ? ` at user message ${target.userMessageOrdinal}` : "";
+  return _chalk2.default.green(`Forked session ${forked.metadata.sessionId}${point}. Continue typing to explore this branch.`);
+}
+async function cloneSession(ctx, args = []) {
+  if (!isEnabled(ctx, CLONE_FLAG)) {
+    return `The /clone command is behind ${CLONE_FLAG}. Run /features enable ${CLONE_FLAG}, then /clone again. No restart required.`;
+  }
+  await _optionalChain([ctx, 'access', _5 => _5.trackFeatureActivation, 'optionalCall', _6 => _6(CLONE_FLAG, { surface: "slash_command" })]);
+  const sourceReference = args[0] ? await ctx.sessionManager.resolveSessionReference(args[0]) : requireCurrentSessionId(ctx, "/clone");
+  const cloned = await ctx.sessionManager.branchSession(sourceReference, { type: "clone" });
+  await _optionalChain([ctx, 'access', _7 => _7.restoreSession, 'optionalCall', _8 => _8(cloned.metadata.sessionId)]);
+  return _chalk2.default.green(`Cloned session ${cloned.metadata.sessionId}. Continue typing in the duplicate branch.`);
+}
+async function sessionTree(ctx) {
+  if (!isEnabled(ctx, FORK_FLAG) && !isEnabled(ctx, CLONE_FLAG)) {
+    return `The /tree command is behind ${FORK_FLAG} or ${CLONE_FLAG}. Enable one of those features first.`;
+  }
+  const sessions = await ctx.sessionManager.listSessions(
+    ctx.workspaceRoot ? { project: ctx.workspaceRoot } : void 0
+  );
+  if (sessions.length === 0) {
+    return "No sessions found for this project.";
+  }
+  return formatSessionTree(sessions, _optionalChain([ctx, 'access', _9 => _9.currentSession, 'optionalAccess', _10 => _10.metadata, 'access', _11 => _11.sessionId]));
+}
+async function forkSessionReference(ctx, sourceReference) {
+  if (!isEnabled(ctx, FORK_FLAG)) {
+    return `The --fork flag is behind ${FORK_FLAG}. Run /features enable ${FORK_FLAG}, then try again.`;
+  }
+  await _optionalChain([ctx, 'access', _12 => _12.trackFeatureActivation, 'optionalCall', _13 => _13(FORK_FLAG, { surface: "cli_flag" })]);
+  const sourceSessionId = await ctx.sessionManager.resolveSessionReference(sourceReference);
+  const forked = await ctx.sessionManager.branchSession(sourceSessionId, { type: "fork" });
+  await _optionalChain([ctx, 'access', _14 => _14.restoreSession, 'optionalCall', _15 => _15(forked.metadata.sessionId)]);
+  return forked.metadata.sessionId;
+}
+function isEnabled(ctx, flag) {
+  const localDefault = flag === FORK_FLAG ? _optionalChain([ctx, 'access', _16 => _16.config, 'optionalAccess', _17 => _17.features, 'optionalAccess', _18 => _18.experimentalFork]) === true : _optionalChain([ctx, 'access', _19 => _19.config, 'optionalAccess', _20 => _20.features, 'optionalAccess', _21 => _21.experimentalClone]) === true;
+  return _nullishCoalesce(_optionalChain([ctx, 'access', _22 => _22.isFeatureEnabled, 'optionalCall', _23 => _23(flag, localDefault)]), () => ( localDefault));
+}
+function requireCurrentSessionId(ctx, command) {
+  const sessionId = _nullishCoalesce(_optionalChain([ctx, 'access', _24 => _24.currentSession, 'optionalAccess', _25 => _25.metadata, 'access', _26 => _26.sessionId]), () => ( _optionalChain([ctx, 'access', _27 => _27.sessionManager, 'access', _28 => _28.getCurrentSession, 'call', _29 => _29(), 'optionalAccess', _30 => _30.metadata, 'access', _31 => _31.sessionId])));
+  if (!sessionId) {
+    throw new Error(`${command} requires an active session.`);
+  }
+  return sessionId;
+}
+function parseForkArgs(args) {
+  const rest = [...args];
+  let userMessageOrdinal;
+  const messageFlagIndex = rest.findIndex((arg) => arg === "--message" || arg === "-m");
+  if (messageFlagIndex >= 0) {
+    const rawValue = rest[messageFlagIndex + 1];
+    if (!rawValue) {
+      throw new Error("Missing message number after --message.");
+    }
+    userMessageOrdinal = parseUserMessageOrdinal(rawValue);
+    rest.splice(messageFlagIndex, 2);
+  }
+  if (rest.length === 1 && /^\d+$/.test(rest[0])) {
+    userMessageOrdinal = parseUserMessageOrdinal(rest[0]);
+    rest.length = 0;
+  }
+  return {
+    sourceReference: rest[0],
+    userMessageOrdinal
+  };
+}
+function parseUserMessageOrdinal(rawValue) {
+  const parsed = Number.parseInt(rawValue, 10);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new Error("Fork message must be a positive user-message number.");
+  }
+  return parsed;
+}
+function formatSessionTree(sessions, currentSessionId) {
+  const byParent = /* @__PURE__ */ new Map();
+  const roots = [];
+  const ids = new Set(sessions.map((session) => session.sessionId));
+  for (const session of sessions) {
+    const parentId = _optionalChain([session, 'access', _32 => _32.branch, 'optionalAccess', _33 => _33.sourceSessionId]);
+    if (parentId && ids.has(parentId)) {
+      const siblings = _nullishCoalesce(byParent.get(parentId), () => ( []));
+      siblings.push(session);
+      byParent.set(parentId, siblings);
+    } else {
+      roots.push(session);
+    }
+  }
+  const sortByCreated = (items) => [...items].sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+  const lines = ["Session tree:"];
+  const visit = (session, depth) => {
+    const marker = session.sessionId === currentSessionId ? " *" : "";
+    const branch = formatBranchLabel(session);
+    lines.push(`${"  ".repeat(depth)}- ${session.sessionId}${marker}${branch}`);
+    for (const child of sortByCreated(_nullishCoalesce(byParent.get(session.sessionId), () => ( [])))) {
+      visit(child, depth + 1);
+    }
+  };
+  for (const root of sortByCreated(roots)) {
+    visit(root, 0);
+  }
+  return lines.join("\n");
+}
+function formatBranchLabel(session) {
+  if (!session.branch) return "";
+  if (session.branch.type === "fork" && session.branch.sourceUserMessageOrdinal) {
+    return ` (${session.branch.type} at user message ${session.branch.sourceUserMessageOrdinal})`;
+  }
+  return ` (${session.branch.type})`;
+}
+
+
+
+
+
+
+
+
+
+exports.forkMetadata = forkMetadata; exports.cloneMetadata = cloneMetadata; exports.treeMetadata = treeMetadata; exports.forkSession = forkSession; exports.cloneSession = cloneSession; exports.sessionTree = sessionTree; exports.forkSessionReference = forkSessionReference;
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-LFDPTJYF.cjs → chunk-QDXRI5AM.cjs}

@@ -219,7 +219,7 @@ var PlanModeManager = class extends _events.EventEmitter {
 // src/commands/plan.ts
 var metadata = {
   command: "/plan",
-  description: "toggle plan mode for safe code exploration",
+  description: "plan and break down a complex task",
   implemented: true
 };
 var planModeManager = null;

package/dist/{chunk-3LJJG5YY.cjs → chunk-QLZOMZO5.cjs}

@@ -9,6 +9,7 @@ var _os = require('os'); var _os2 = _interopRequireDefault(_os);
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
 var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
 var GIT_COMMAND_TIMEOUT_MS = 5e3;
+var GIT_INIT_TIMEOUT_MS = 15e3;
 var toolCheckResultsPromise;
 function getCurrentBunVersion() {
   return process.versions.bun;
@@ -200,7 +201,7 @@ function isEmptyDirectory(dir) {
     return false;
   }
 }
-function runGitCommand(args, cwd) {
+function runGitCommand(args, cwd, timeoutMs = GIT_COMMAND_TIMEOUT_MS) {
   return new Promise((resolve) => {
     try {
       const proc = _child_process.spawn.call(void 0, "git", args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
@@ -208,7 +209,7 @@ function runGitCommand(args, cwd) {
       const timeout = setTimeout(() => {
         proc.kill();
         resolve(void 0);
-      }, GIT_COMMAND_TIMEOUT_MS);
+      }, timeoutMs);
       _optionalChain([proc, 'access', _7 => _7.stdout, 'optionalAccess', _8 => _8.on, 'call', _9 => _9("data", (chunk) => {
         stdout += chunk.toString();
       })]);
@@ -258,7 +259,7 @@ async function checkGitRepo(workspaceRoot) {
     };
   }
   if (isEmptyDirectory(workspaceRoot)) {
-    const initResult = await runGitCommand(["init"], workspaceRoot);
+    const initResult = await runGitCommand(["init"], workspaceRoot, GIT_INIT_TIMEOUT_MS);
     if (initResult !== void 0 || _fsextra2.default.existsSync(`${workspaceRoot}/.git/HEAD`)) {
       if (_os2.default.platform() === "darwin") {
         try {

package/dist/chunk-QVXMSQOG.js

@@ -0,0 +1,430 @@
+import {
+  package_default
+} from "./chunk-NOWCRKP2.js";
+import {
+  showModal
+} from "./chunk-LOSXLH7P.js";
+import {
+  saveConfig
+} from "./chunk-CM24K6ZT.js";
+import {
+  formatFeatureList,
+  formatFeatureStatus,
+  getFeatureState,
+  isLocalFeatureId,
+  listFeatureStates,
+  setFeatureState
+} from "./chunk-H7HXRRHK.js";
+import {
+  AUTOHAND_FILES
+} from "./chunk-PG2JIU5M.js";
+
+// src/features/RemoteFeatureFlagManager.ts
+import crypto from "crypto";
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
+var FEATURE_FLAG_REQUEST_TIMEOUT_MS = 1500;
+var CLI_CLIENT_TYPE = "cli";
+function getApiBaseUrl(config) {
+  return (config.api?.baseUrl || config.telemetry?.apiBaseUrl || "https://api.autohand.ai").replace(/\/+$/, "");
+}
+function readDeviceId() {
+  try {
+    fs.ensureDirSync(path.dirname(AUTOHAND_FILES.deviceId));
+    if (fs.existsSync(AUTOHAND_FILES.deviceId)) {
+      const existing = fs.readFileSync(AUTOHAND_FILES.deviceId, "utf8").trim();
+      if (existing) return existing;
+    }
+    const next = crypto.randomUUID();
+    fs.writeFileSync(AUTOHAND_FILES.deviceId, next);
+    return next;
+  } catch {
+    return crypto.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 = 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 = config.features?.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 {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function writeRemoteFeatureFlagCache(snapshot) {
+  await fs.ensureDir(path.dirname(AUTOHAND_FILES.featureFlagsCache));
+  await fs.writeJson(AUTOHAND_FILES.featureFlagsCache, snapshot, { spaces: 2 });
+}
+async function loadCachedRemoteFeatureFlags() {
+  try {
+    if (!await fs.pathExists(AUTOHAND_FILES.featureFlagsCache)) {
+      return null;
+    }
+    const data = await fs.readJson(AUTOHAND_FILES.featureFlagsCache);
+    return parseSnapshot(data);
+  } catch {
+    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(), package_default.version);
+  if (downloaded) {
+    await writeRemoteFeatureFlagCache(downloaded);
+    return downloaded;
+  }
+  return options.allowCachedFallback === false ? null : cached;
+}
+var RemoteFeatureFlagManager = class {
+  constructor(config) {
+    this.config = config;
+    this.apiBaseUrl = getApiBaseUrl(config);
+    this.environment = config.features?.environment || "production";
+    this.clientVersion = package_default.version;
+  }
+  config;
+  snapshot = null;
+  deviceId = readDeviceId();
+  apiBaseUrl;
+  environment;
+  clientVersion;
+  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 (isLocalFeatureId(key)) {
+      return localDefault;
+    }
+    const flag = this.snapshot?.flags.find((item) => item.key === key);
+    if (!flag) return localDefault;
+    if (!flag.enabled) return false;
+    return this.config.features?.remoteOverrides?.[key] !== "off";
+  }
+  async trackFeatureActivation(key, metadata2) {
+    void metadata2;
+    const flag = this.snapshot?.flags.find((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 {
+    }
+  }
+  getStatus() {
+    return {
+      apiBaseUrl: this.apiBaseUrl,
+      environment: this.environment,
+      deviceId: this.deviceId,
+      platform: process.platform,
+      osVersion: os.release(),
+      evaluatedAt: this.snapshot?.evaluatedAt || null
+    };
+  }
+};
+
+// 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 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 = setFeatureState(config, featureId, enabled, { remoteSnapshot: snapshot });
+  if (!result.ok || !result.feature) {
+    return result.error ?? `Unknown feature "${featureId}".`;
+  }
+  await saveConfig(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 = listFeatureStates(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 showModal({
+    title: "Experiments - space toggles, enter closes",
+    options,
+    multiSelect: true,
+    maxVisible: 12,
+    onToggle: (option, checked) => {
+      const result = setFeatureState(config, option.value, checked, { remoteSnapshot });
+      if (!result.ok) {
+        return;
+      }
+      toggleCount += 1;
+      finalStates.set(option.value, result.feature?.enabled ?? checked);
+      pendingSaves.push(saveConfig(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 = (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 formatFeatureList(required, { remoteSnapshot });
+    case "status":
+    case "show":
+      return featureId ? formatFeatureStatus(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 (getFeatureState(required, subcommand, { remoteSnapshot })) {
+        return formatFeatureStatus(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" }
+  ]
+};
+
+export {
+  RemoteFeatureFlagManager,
+  setFeatureEnabled,
+  features,
+  metadata
+};
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */