autohand-cli 0.9.0 → 0.9.2

package/dist/{chunk-LQBONA55.cjs → chunk-7EEK7CRR.cjs}

@@ -229,6 +229,48 @@ var HookManager = (_class = class {
       case "subagent-stop":
         value = _nullishCoalesce(context.subagentType, () => ( ""));
         break;
+      case "automode:start":
+      case "automode:iteration":
+      case "automode:checkpoint":
+      case "automode:pause":
+      case "automode:resume":
+      case "automode:cancel":
+      case "automode:complete":
+      case "automode:error":
+        value = [
+          context.automodePrompt,
+          context.automodeCancelReason,
+          context.automodeCheckpointCommit,
+          context.automodeIteration
+        ].filter((part) => part !== void 0 && part !== null).join(" ");
+        break;
+      case "review:start":
+      case "review:end":
+      case "review:paused":
+      case "review:failed":
+      case "review:completed":
+        value = [
+          context.reviewPath,
+          context.reviewScope,
+          context.reviewInstructions,
+          context.reviewError
+        ].filter((part) => part !== void 0 && part !== null).join(" ");
+        break;
+      case "goal-written:completed":
+        value = [context.goalObjective, context.goalSource].filter((part) => part !== void 0 && part !== null).join(" ");
+        break;
+      case "team-created":
+      case "team-shutdown":
+        value = _nullishCoalesce(context.teamName, () => ( ""));
+        break;
+      case "teammate-spawned":
+      case "teammate-idle":
+        value = [context.teamName, context.teammateName, context.teammateAgentName].filter((part) => part !== void 0 && part !== null).join(" ");
+        break;
+      case "task-assigned":
+      case "task-completed":
+        value = [context.teamTaskId, context.teamTaskOwner, context.teamTaskResult].filter((part) => part !== void 0 && part !== null).join(" ");
+        break;
       default:
         return true;
     }
@@ -259,6 +301,7 @@ var HookManager = (_class = class {
     if (context.instruction) env.HOOK_INSTRUCTION = context.instruction;
     if (context.mentionedFiles) env.HOOK_MENTIONED_FILES = JSON.stringify(context.mentionedFiles);
     if (context.tokensUsed !== void 0) env.HOOK_TOKENS = String(context.tokensUsed);
+    if (context.tokensUsageStatus !== void 0) env.HOOK_TOKENS_USAGE_STATUS = context.tokensUsageStatus;
     if (context.toolCallsCount !== void 0) env.HOOK_TOOL_CALLS_COUNT = String(context.toolCallsCount);
     if (context.toolCallsInTurn !== void 0) env.HOOK_TURN_TOOL_CALLS = String(context.toolCallsInTurn);
     if (context.turnDuration !== void 0) env.HOOK_TURN_DURATION = String(context.turnDuration);
@@ -287,6 +330,19 @@ var HookManager = (_class = class {
       if (context.reviewError) env.HOOK_REVIEW_ERROR = context.reviewError;
       if (context.reviewInstructions) env.HOOK_REVIEW_INSTRUCTIONS = context.reviewInstructions;
     }
+    if (context.goalId) env.HOOK_GOAL_ID = context.goalId;
+    if (context.goalObjective) env.HOOK_GOAL_OBJECTIVE = context.goalObjective;
+    if (context.goalSource) env.HOOK_GOAL_SOURCE = context.goalSource;
+    if (context.teamName) env.HOOK_TEAM_NAME = context.teamName;
+    if (context.teammateName) env.HOOK_TEAMMATE_NAME = context.teammateName;
+    if (context.teammateAgentName) env.HOOK_TEAMMATE_AGENT = context.teammateAgentName;
+    if (context.teammatePid !== void 0) env.HOOK_TEAMMATE_PID = String(context.teammatePid);
+    if (context.teamTaskId) env.HOOK_TEAM_TASK_ID = context.teamTaskId;
+    if (context.teamTaskOwner) env.HOOK_TEAM_TASK_OWNER = context.teamTaskOwner;
+    if (context.teamTaskResult) env.HOOK_TEAM_TASK_RESULT = context.teamTaskResult;
+    if (context.teamMemberCount !== void 0) env.HOOK_TEAM_MEMBER_COUNT = String(context.teamMemberCount);
+    if (context.teamTasksCompleted !== void 0) env.HOOK_TEAM_TASKS_COMPLETED = String(context.teamTasksCompleted);
+    if (context.teamTasksTotal !== void 0) env.HOOK_TEAM_TASKS_TOTAL = String(context.teamTasksTotal);
     if (context.additionalWorkspaces && context.additionalWorkspaces.length > 0) {
       env.HOOK_ADDITIONAL_WORKSPACES = JSON.stringify(context.additionalWorkspaces);
     }
@@ -314,6 +370,7 @@ var HookManager = (_class = class {
       mentioned_files: context.mentionedFiles,
       // Stop/response context
       tokens_used: context.tokensUsed,
+      tokens_usage_status: context.tokensUsageStatus,
       tool_calls_count: context.toolCallsCount,
       turn_tool_calls: context.toolCallsInTurn,
       turn_duration: context.turnDuration,
@@ -352,6 +409,21 @@ var HookManager = (_class = class {
       review_scope: context.reviewScope,
       review_instructions: context.reviewInstructions,
       review_error: context.reviewError,
+      // Goal context
+      goal_id: context.goalId,
+      goal_objective: context.goalObjective,
+      goal_source: context.goalSource,
+      // Team context
+      team_name: context.teamName,
+      teammate_name: context.teammateName,
+      teammate_agent_name: context.teammateAgentName,
+      teammate_pid: context.teammatePid,
+      team_task_id: context.teamTaskId,
+      team_task_owner: context.teamTaskOwner,
+      team_task_result: context.teamTaskResult,
+      team_member_count: context.teamMemberCount,
+      team_tasks_completed: context.teamTasksCompleted,
+      team_tasks_total: context.teamTasksTotal,
       // Multi-directory support
       additional_workspaces: context.additionalWorkspaces
     });
@@ -542,6 +614,11 @@ var HookManager = (_class = class {
       "automode:cancel",
       "automode:complete",
       "automode:error",
+      // Learn events
+      "pre-learn",
+      "post-learn",
+      // Goal authoring events
+      "goal-written:completed",
       // Review events
       "review:start",
       "review:end",
@@ -554,7 +631,14 @@ var HookManager = (_class = class {
       "teammate-idle",
       "task-assigned",
       "task-completed",
-      "team-shutdown"
+      "team-shutdown",
+      // Mode events
+      "mode-change",
+      // Context lifecycle events
+      "context:compact",
+      "context:overflow",
+      "context:warning",
+      "context:critical"
     ];
     const summary = {};
     for (const event of events) {

package/dist/chunk-7TO3PDMV.cjs

@@ -0,0 +1,324 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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/features/featureRegistry.ts
+var AWS_BEDROCK_PROVIDER_FLAG = "aws_bedrock_provider";
+var FEATURE_REGISTRY = [
+  {
+    id: "mcp",
+    label: "MCP tools",
+    description: "Connect configured Model Context Protocol servers and expose their tools.",
+    stage: "stable",
+    configPath: "mcp.enabled",
+    defaultEnabled: true,
+    requiresRestart: true
+  },
+  {
+    id: "hooks",
+    label: "Lifecycle hooks",
+    description: "Run configured shell hooks around prompts, tools, sessions, and notifications.",
+    stage: "stable",
+    configPath: "hooks.enabled",
+    defaultEnabled: true
+  },
+  {
+    id: "teams",
+    label: "Agent teams",
+    description: "Enable multi-agent team coordination commands and teammate execution.",
+    stage: "experimental",
+    configPath: "teams.enabled",
+    defaultEnabled: true
+  },
+  {
+    id: "community_skills",
+    label: "Community skills",
+    description: "Enable discovery and use of community skill packs.",
+    stage: "stable",
+    configPath: "communitySkills.enabled",
+    defaultEnabled: true
+  },
+  {
+    id: "prompt_suggestions",
+    label: "Prompt suggestions",
+    description: "Show generated next-step suggestions in the interactive prompt placeholder.",
+    stage: "stable",
+    configPath: "ui.promptSuggestions",
+    defaultEnabled: true
+  },
+  {
+    id: "request_queue",
+    label: "Request queue",
+    description: "Allow typing follow-up requests while the agent is still working.",
+    stage: "stable",
+    configPath: "agent.enableRequestQueue",
+    defaultEnabled: true
+  },
+  {
+    id: "thinking_display",
+    label: "Thinking display",
+    description: "Show model thinking or reasoning blocks when the provider returns them.",
+    stage: "stable",
+    configPath: "ui.showThinking",
+    defaultEnabled: true
+  },
+  {
+    id: "completion_notifications",
+    label: "Completion notifications",
+    description: "Show desktop notifications when an agent turn completes.",
+    stage: "stable",
+    configPath: "ui.showCompletionNotification",
+    defaultEnabled: true
+  },
+  {
+    id: "terminal_bell",
+    label: "Terminal bell",
+    description: "Ring the terminal bell when work completes.",
+    stage: "stable",
+    configPath: "ui.terminalBell",
+    defaultEnabled: true
+  },
+  {
+    id: "tool_selection_cache",
+    label: "Tool selection cache",
+    description: "Cache local tool-schema selection for equivalent turns.",
+    stage: "stable",
+    configPath: "agent.toolSelectionCache",
+    defaultEnabled: true
+  },
+  {
+    id: "usage_v2",
+    label: "Usage v2",
+    description: "Show the v2 usage dashboard with model, provider, context, and limit details.",
+    stage: "experimental",
+    configPath: "features.usageV2",
+    defaultEnabled: false
+  },
+  {
+    id: AWS_BEDROCK_PROVIDER_FLAG,
+    label: "AWS Bedrock provider",
+    description: "Enable AWS Bedrock as a first-class model provider.",
+    stage: "experimental",
+    configPath: "features.awsBedrockProvider",
+    defaultEnabled: true,
+    requiresRestart: true
+  },
+  {
+    id: "slash_goal",
+    label: "Slash goal",
+    description: "Enable experimental persistent goals across /goal, --goal, tools, RPC, and ACP.",
+    stage: "experimental",
+    configPath: "features.slashGoal",
+    defaultEnabled: false
+  },
+  {
+    id: "token_usage_status",
+    label: "Token usage status",
+    description: "Show real-time token usage (tokens up/down and context window occupancy) in the status line.",
+    stage: "experimental",
+    configPath: "features.tokenUsageStatus",
+    defaultEnabled: false
+  },
+  {
+    id: "experimental_fork",
+    label: "Experimental fork",
+    description: "Enable branching a new session from the active session or an earlier user message.",
+    stage: "experimental",
+    configPath: "features.experimentalFork",
+    defaultEnabled: false
+  },
+  {
+    id: "experimental_clone",
+    label: "Experimental clone",
+    description: "Enable duplicating the active session branch into a new session.",
+    stage: "experimental",
+    configPath: "features.experimentalClone",
+    defaultEnabled: false
+  },
+  {
+    id: "experimental_handoff",
+    label: "Experimental handoff",
+    description: "Enable handoff session commands for continuing work from another Autohand surface.",
+    stage: "experimental",
+    configPath: "features.experimentalHandoff",
+    defaultEnabled: false
+  },
+  {
+    id: "chrome_integration",
+    label: "Chrome integration",
+    description: "Start the browser bridge by default for Chrome extension handoff.",
+    stage: "experimental",
+    configPath: "chrome.enabledByDefault",
+    defaultEnabled: false,
+    requiresRestart: true
+  },
+  {
+    id: "telemetry",
+    label: "Telemetry",
+    description: "Share anonymized product telemetry when explicitly enabled.",
+    stage: "stable",
+    configPath: "telemetry.enabled",
+    defaultEnabled: false
+  }
+];
+function isAwsBedrockProviderEnabled(config) {
+  const definition = FEATURE_REGISTRY.find((feature) => feature.id === AWS_BEDROCK_PROVIDER_FLAG);
+  return _nullishCoalesce(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _ => _.features, 'optionalAccess', _2 => _2.awsBedrockProvider]), () => ( _optionalChain([definition, 'optionalAccess', _3 => _3.defaultEnabled]))), () => ( true));
+}
+function isTokenUsageStatusEnabled(config) {
+  const definition = FEATURE_REGISTRY.find((feature) => feature.id === "token_usage_status");
+  return _nullishCoalesce(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _4 => _4.features, 'optionalAccess', _5 => _5.tokenUsageStatus]), () => ( _optionalChain([definition, 'optionalAccess', _6 => _6.defaultEnabled]))), () => ( false));
+}
+var LOCAL_FEATURE_IDS = new Set(FEATURE_REGISTRY.map((feature) => feature.id));
+function isLocalFeatureId(id) {
+  return LOCAL_FEATURE_IDS.has(id);
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getNestedValue(root, configPath) {
+  let current = root;
+  for (const part of configPath.split(".")) {
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function setNestedValue(root, configPath, value) {
+  const parts = configPath.split(".");
+  let current = root;
+  for (const part of parts.slice(0, -1)) {
+    const existing = current[part];
+    if (!isRecord(existing)) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function getRemoteFeatureStates(config, options = {}) {
+  const remoteOverrides = _optionalChain([config, 'access', _7 => _7.features, 'optionalAccess', _8 => _8.remoteOverrides]) || {};
+  const snapshot = options.remoteSnapshot;
+  if (!snapshot) return [];
+  return snapshot.flags.filter((flag) => !isLocalFeatureId(flag.key) && isVisibleRemoteExperiment(flag)).map((flag) => {
+    const localOverride = remoteOverrides[flag.key] === "off" ? "off" : void 0;
+    return {
+      id: flag.key,
+      label: flag.key,
+      description: `Remote feature flag (${flag.reason})`,
+      stage: "experimental",
+      defaultEnabled: false,
+      enabled: flag.enabled && localOverride !== "off",
+      source: "remote",
+      remoteEnabled: flag.enabled,
+      reason: flag.reason,
+      userOverridable: flag.userOverridable,
+      localOverride,
+      lastEvaluatedAt: snapshot.evaluatedAt
+    };
+  });
+}
+function isVisibleRemoteExperiment(flag) {
+  const reason = flag.reason.toLowerCase();
+  if (reason.includes("archived") || reason.includes("client_type mismatch") || reason.includes("client type mismatch")) {
+    return false;
+  }
+  return !flag.clientTypes || flag.clientTypes.length === 0 || flag.clientTypes.includes("cli");
+}
+function getFeatureState(config, id, options = {}) {
+  const definition = FEATURE_REGISTRY.find((feature) => feature.id === id);
+  if (definition) {
+    const rawValue = definition.configPath ? getNestedValue(config, definition.configPath) : void 0;
+    return {
+      ...definition,
+      source: "local",
+      enabled: typeof rawValue === "boolean" ? rawValue : definition.defaultEnabled
+    };
+  }
+  return getRemoteFeatureStates(config, options).find((feature) => feature.id === id);
+}
+function listFeatureStates(config, options = {}) {
+  const local = FEATURE_REGISTRY.map((feature) => ({
+    ...feature,
+    source: "local",
+    enabled: _nullishCoalesce(_optionalChain([getFeatureState, 'call', _9 => _9(config, feature.id, options), 'optionalAccess', _10 => _10.enabled]), () => ( feature.defaultEnabled))
+  }));
+  return [...local, ...getRemoteFeatureStates(config, options)];
+}
+function setFeatureState(config, id, enabled, options = {}) {
+  const definition = FEATURE_REGISTRY.find((feature) => feature.id === id);
+  if (definition) {
+    if (!definition.configPath) {
+      return { ok: false, error: `Feature "${id}" cannot be changed locally.` };
+    }
+    setNestedValue(config, definition.configPath, enabled);
+    return {
+      ok: true,
+      feature: getFeatureState(config, id, options)
+    };
+  }
+  const remoteFeature = getRemoteFeatureStates(config, options).find((feature) => feature.id === id);
+  if (!remoteFeature) {
+    return { ok: false, error: `Unknown feature "${id}".` };
+  }
+  config.features ||= {};
+  config.features.remoteOverrides ||= {};
+  if (enabled) {
+    delete config.features.remoteOverrides[id];
+    return { ok: true, feature: getFeatureState(config, id, options) };
+  }
+  if (!remoteFeature.userOverridable) {
+    return { ok: false, error: `Feature "${id}" is controlled remotely and cannot be changed locally.` };
+  }
+  config.features.remoteOverrides[id] = "off";
+  return { ok: true, feature: getFeatureState(config, id, options) };
+}
+function formatFeatureList(config, options = {}) {
+  const states = listFeatureStates(config, options);
+  const idWidth = Math.max(...states.map((feature) => feature.id.length), "feature".length);
+  const sourceWidth = Math.max(...states.map((feature) => feature.source.length), "source".length);
+  const stageWidth = Math.max(...states.map((feature) => feature.stage.length), "stage".length);
+  return states.map((feature) => `${feature.id.padEnd(idWidth + 2)}${feature.source.padEnd(sourceWidth + 2)}${feature.stage.padEnd(stageWidth + 2)}${String(feature.enabled)}`).join("\n");
+}
+function formatFeatureStatus(config, id, options = {}) {
+  const feature = getFeatureState(config, id, options);
+  if (!feature) {
+    return `Unknown feature "${id}".`;
+  }
+  const restart = feature.requiresRestart ? "yes" : "no";
+  const lines = [
+    `${feature.id}`,
+    `Label: ${feature.label}`,
+    `Source: ${feature.source}`,
+    `Stage: ${feature.stage}`,
+    `Enabled: ${String(feature.enabled)}`,
+    `Config: ${feature.configPath || "remote"}`,
+    `Default: ${String(feature.defaultEnabled)}`,
+    `Restart required: ${restart}`,
+    `Description: ${feature.description}`
+  ];
+  if (feature.source === "remote") {
+    lines.push(
+      `Remote enabled: ${String(feature.remoteEnabled)}`,
+      `Local override: ${feature.localOverride || "none"}`,
+      `Reason: ${feature.reason || "unknown"}`,
+      `User overridable: ${String(feature.userOverridable !== false)}`,
+      `Last evaluated: ${feature.lastEvaluatedAt || "never"}`
+    );
+  }
+  return lines.join("\n");
+}
+
+
+
+
+
+
+
+
+
+
+exports.isAwsBedrockProviderEnabled = isAwsBedrockProviderEnabled; exports.isTokenUsageStatusEnabled = isTokenUsageStatusEnabled; exports.isLocalFeatureId = isLocalFeatureId; exports.getFeatureState = getFeatureState; exports.listFeatureStates = listFeatureStates; exports.setFeatureState = setFeatureState; exports.formatFeatureList = formatFeatureList; exports.formatFeatureStatus = formatFeatureStatus;
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */