autohand-cli 0.8.3 → 0.9.1

package/dist/chunk-KM7R5YPS.cjs

@@ -0,0 +1,385 @@
+"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 _chunkNVATU4V6cjs = require('./chunk-NVATU4V6.cjs');
+
+
+var _chunkLJD7KR3Lcjs = require('./chunk-LJD7KR3L.cjs');
+
+
+var _chunkX5P6QQOBcjs = require('./chunk-X5P6QQOB.cjs');
+
+
+var _chunkHK5A54AVcjs = require('./chunk-HK5A54AV.cjs');
+
+// src/commands/usage.ts
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+
+// src/core/context/types.ts
+var CONTEXT_ENV_VARS = {
+  /** Enable/disable context compaction ('true' | 'false'). */
+  CONTEXT_COMPACT: "AUTOHAND_CONTEXT_COMPACT",
+  /** Override context window size (number). */
+  CONTEXT_WINDOW: "AUTOHAND_CONTEXT_WINDOW",
+  /** Tokens to reserve for model output (number). */
+  RESERVE_TOKENS: "AUTOHAND_RESERVE_TOKENS"
+};
+
+// src/core/context/tokenizer.ts
+var MODEL_CONTEXT = {
+  "anthropic/claude-4-sonnet": 2e5,
+  "anthropic/claude-3-opus": 2e5,
+  "anthropic/claude-3-haiku": 2e5,
+  "anthropic/claude-opus-4": 2e5,
+  "anthropic/claude-opus-4-7": 1e6,
+  "openai/gpt-4o-mini": 128e3,
+  "openai/gpt-4o": 128e3,
+  "openai/gpt-4.1": 2e5,
+  "openai/o1": 2e5,
+  "openai/o1-mini": 128e3,
+  "tencent/hy3-preview:free": 262144,
+  "tencent/hy3-preview-20260421:free": 262144,
+  "deepseek/deepseek-r1": 64e3,
+  "deepseek/deepseek-r1-0528-qwen3-8b:free": 8e3,
+  "deepseek/deepseek-coder": 16e3
+};
+var SAFETY_MARGIN = 0.9;
+var CONTEXT_WARNING_THRESHOLD = 0.8;
+var CONTEXT_CRITICAL_THRESHOLD = 0.9;
+function parseContextWindowOverride(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return void 0;
+  }
+  return Math.floor(value);
+}
+function normalizeModelId(model) {
+  return model.trim().toLowerCase().replace(/^openai\//, "").replace(/^google\//, "").replace(/^deepseek\//, "");
+}
+function inferContextWindow(model) {
+  const normalized = normalizeModelId(model);
+  if (normalized.startsWith("gpt-5.5")) return 105e4;
+  if (normalized.startsWith("gpt-5.4") && !normalized.includes("mini") && !normalized.includes("nano")) return 105e4;
+  if (normalized.startsWith("gpt-5.4-mini") || normalized.startsWith("gpt-5.4-nano") || normalized.startsWith("gpt-5.3-codex") || normalized === "gpt-5" || normalized.startsWith("gpt-5-mini") || normalized.startsWith("gpt-5-nano")) {
+    return 4e5;
+  }
+  if (normalized.startsWith("gpt-5.3-chat")) return 128e3;
+  if (normalized.startsWith("gemini-3.1-flash-image")) return 128e3;
+  if (normalized.startsWith("gemini-3-pro-image")) return 65e3;
+  if (normalized.startsWith("gemini-3.1-pro") || normalized.startsWith("gemini-3.1-flash-lite") || normalized.startsWith("gemini-3-flash")) {
+    return 1e6;
+  }
+  if (normalized.startsWith("deepseek-v4")) return 1e6;
+  return void 0;
+}
+function getContextWindow(model, configuredContextWindow) {
+  const envOverride = process.env[CONTEXT_ENV_VARS.CONTEXT_WINDOW];
+  if (envOverride) {
+    const parsed = parseInt(envOverride, 10);
+    if (!isNaN(parsed) && parsed > 0) return parsed;
+  }
+  const configured = parseContextWindowOverride(configuredContextWindow);
+  if (configured) return configured;
+  const normalized = model.toLowerCase();
+  if (MODEL_CONTEXT[normalized]) {
+    return MODEL_CONTEXT[normalized];
+  }
+  const inferred = inferContextWindow(model);
+  if (inferred) return inferred;
+  const fuzzy = Object.entries(MODEL_CONTEXT).find(
+    ([name]) => normalized.includes(name) || name.includes(_nullishCoalesce(normalized.split("/").pop(), () => ( "")))
+  );
+  return fuzzy ? fuzzy[1] : 128e3;
+}
+function getModelFamily(model) {
+  const normalized = model.toLowerCase();
+  if (normalized.includes("claude")) return "claude";
+  if (normalized.includes("gpt-4") || normalized.includes("gpt-5") || normalized.includes("o1") || normalized.includes("o3")) return "openai";
+  if (normalized.includes("gemini")) return "gemini";
+  if (normalized.includes("deepseek")) return "deepseek";
+  return "default";
+}
+function estimateTokens(text, modelFamily) {
+  if (!text) return 0;
+  const codeLikeChars = _nullishCoalesce(_optionalChain([text, 'access', _ => _.match, 'call', _2 => _2(/[{}[\]":\\]/g), 'optionalAccess', _3 => _3.length]), () => ( 0));
+  const codeLikeRatio = text.length > 200 && codeLikeChars >= 4 ? 0.65 : 1;
+  const baseRatio = {
+    openai: 4,
+    claude: 3.5,
+    gemini: 4,
+    deepseek: 3,
+    default: 3.5
+  };
+  const ratio = (_nullishCoalesce(baseRatio[_nullishCoalesce(modelFamily, () => ( "default"))], () => ( 3.5))) * codeLikeRatio;
+  return Math.ceil(text.length / ratio);
+}
+function estimateMessageTokens(message, modelFamily) {
+  const structureOverhead = 10;
+  let tokens = structureOverhead;
+  tokens += estimateTokens(_nullishCoalesce(message.content, () => ( "")), modelFamily);
+  if (message.tool_calls) {
+    for (const call of message.tool_calls) {
+      tokens += 5;
+      tokens += estimateTokens(call.function.name, modelFamily);
+      tokens += estimateTokens(call.function.arguments, modelFamily);
+    }
+  }
+  return tokens;
+}
+function estimateMessagesTokens(messages, modelFamily) {
+  return messages.reduce(
+    (acc, message) => acc + estimateMessageTokens(message, modelFamily),
+    0
+  );
+}
+function estimateToolsTokens(tools, modelFamily) {
+  if (!tools || tools.length === 0) return 0;
+  let tokens = 0;
+  for (const tool of tools) {
+    tokens += estimateTokens(tool.name, modelFamily);
+    tokens += estimateTokens(tool.description, modelFamily);
+    if (tool.parameters) {
+      const paramJson = JSON.stringify(tool.parameters);
+      tokens += estimateTokens(paramJson, modelFamily);
+    }
+    tokens += 35;
+  }
+  return tokens;
+}
+function calculateContextUsage(messages, tools, model, outputBudget = 16e3, configuredContextWindow) {
+  const envReserve = process.env[CONTEXT_ENV_VARS.RESERVE_TOKENS];
+  if (envReserve) {
+    const parsed = parseInt(envReserve, 10);
+    if (!isNaN(parsed) && parsed > 0) outputBudget = parsed;
+  }
+  const modelFamily = getModelFamily(model);
+  const messagesTokens = estimateMessagesTokens(messages, modelFamily);
+  const toolsTokens = estimateToolsTokens(tools, modelFamily);
+  const totalTokens = messagesTokens + toolsTokens;
+  const contextWindow = getContextWindow(model, configuredContextWindow);
+  const cappedOutputBudget = Math.min(outputBudget, Math.floor(contextWindow * 0.25));
+  const effectiveWindow = contextWindow - cappedOutputBudget;
+  const safeWindow = Math.floor(effectiveWindow * SAFETY_MARGIN);
+  const usagePercent = totalTokens / effectiveWindow;
+  return {
+    totalTokens,
+    messagesTokens,
+    toolsTokens,
+    contextWindow,
+    safeWindow,
+    usagePercent,
+    isWarning: usagePercent >= CONTEXT_WARNING_THRESHOLD,
+    isCritical: usagePercent >= CONTEXT_CRITICAL_THRESHOLD,
+    isExceeded: totalTokens >= safeWindow,
+    remainingTokens: Math.max(0, safeWindow - totalTokens)
+  };
+}
+
+// src/commands/usage.ts
+var USAGE_V2_FLAG = "usage_v2";
+var metadata = {
+  command: "/usage",
+  description: "Show model, provider, context, and usage limits",
+  implemented: true
+};
+function clampPercent(value) {
+  if (!Number.isFinite(value)) return 100;
+  return Math.max(0, Math.min(100, Math.round(value)));
+}
+function formatPath(value) {
+  const home = _os2.default.homedir();
+  if (value === home) {
+    return "~";
+  }
+  if (value.startsWith(`${home}${_path2.default.sep}`)) {
+    return `~${value.slice(home.length)}`;
+  }
+  return value;
+}
+function formatCompactNumber(value) {
+  if (!Number.isFinite(value) || value < 0) {
+    return "0";
+  }
+  if (value >= 1e6) {
+    const millions = value / 1e6;
+    return `${Number.isInteger(millions) ? millions.toFixed(0) : millions.toFixed(1)}M`;
+  }
+  if (value >= 1e3) {
+    const thousands = value / 1e3;
+    return `${Number.isInteger(thousands) ? thousands.toFixed(0) : thousands.toFixed(1)}K`;
+  }
+  return String(Math.round(value));
+}
+function formatPermissionMode(mode) {
+  switch (_nullishCoalesce(mode, () => ( "interactive"))) {
+    case "interactive":
+      return "Workspace (on-request)";
+    case "unrestricted":
+      return "Workspace (full access)";
+    case "restricted":
+      return "Read-only (restricted)";
+    case "external":
+      return "External approval";
+  }
+}
+function resolveProviderSettings(config, provider) {
+  if (!config || !provider) {
+    return void 0;
+  }
+  return _nullishCoalesce(_chunkX5P6QQOBcjs.getProviderConfig.call(void 0, config, provider), () => ( void 0));
+}
+function resolveActiveProvider(ctx) {
+  return _nullishCoalesce(_nullishCoalesce(_optionalChain([ctx, 'access', _4 => _4.config, 'optionalAccess', _5 => _5.provider]), () => ( ctx.provider)), () => ( "openrouter"));
+}
+function resolveActiveModel(ctx, provider) {
+  const settings = resolveProviderSettings(ctx.config, provider);
+  return _nullishCoalesce(_optionalChain([settings, 'optionalAccess', _6 => _6.model]), () => ( ctx.model));
+}
+function resolveReasoningEffort(config, provider) {
+  return _optionalChain([resolveProviderSettings, 'call', _7 => _7(config, provider), 'optionalAccess', _8 => _8.reasoningEffort]);
+}
+function resolveContextWindow(ctx, provider, model) {
+  const settings = resolveProviderSettings(ctx.config, provider);
+  return _nullishCoalesce(_nullishCoalesce(_optionalChain([ctx, 'access', _9 => _9.getContextWindow, 'optionalCall', _10 => _10()]), () => ( _optionalChain([settings, 'optionalAccess', _11 => _11.contextWindow]))), () => ( getContextWindow(model, _optionalChain([settings, 'optionalAccess', _12 => _12.contextWindow]))));
+}
+function resolveContextTokensUsed(ctx, contextWindow, percentLeft) {
+  const reported = _optionalChain([ctx, 'access', _13 => _13.getTotalTokensUsed, 'optionalCall', _14 => _14()]);
+  if (typeof reported === "number" && Number.isFinite(reported) && reported > 0) {
+    return Math.round(reported);
+  }
+  return Math.round(contextWindow * ((100 - percentLeft) / 100));
+}
+function resolveAgentsFile(workspaceRoot) {
+  return _fs2.default.existsSync(_path2.default.join(workspaceRoot, "AGENTS.md")) ? "AGENTS.md" : "none";
+}
+function resolveAccount(config) {
+  const account = _chunkNVATU4V6cjs.formatAccount.call(void 0, config, "");
+  if (account) {
+    return account;
+  }
+  if (_optionalChain([config, 'optionalAccess', _15 => _15.openai, 'optionalAccess', _16 => _16.authMode]) === "chatgpt" && _optionalChain([config, 'access', _17 => _17.openai, 'access', _18 => _18.chatgptAuth, 'optionalAccess', _19 => _19.accountId])) {
+    return `ChatGPT account ${config.openai.chatgptAuth.accountId}`;
+  }
+  return "not signed in";
+}
+function isUsageV2Enabled(ctx) {
+  const localDefault = ctx.config ? _nullishCoalesce(_optionalChain([_chunkHK5A54AVcjs.getFeatureState.call(void 0, ctx.config, USAGE_V2_FLAG), 'optionalAccess', _20 => _20.enabled]), () => ( false)) : false;
+  return _nullishCoalesce(_optionalChain([ctx, 'access', _21 => _21.isFeatureEnabled, 'optionalCall', _22 => _22(USAGE_V2_FLAG, localDefault)]), () => ( localDefault));
+}
+function gatherUsageDashboardData(ctx) {
+  const provider = resolveActiveProvider(ctx);
+  const model = resolveActiveModel(ctx, provider);
+  const contextPercentLeft = clampPercent(_nullishCoalesce(_optionalChain([ctx, 'access', _23 => _23.getContextPercentLeft, 'optionalCall', _24 => _24()]), () => ( 100)));
+  const contextWindow = resolveContextWindow(ctx, provider, model);
+  const currentSession = ctx.sessionManager.getCurrentSession();
+  const usageLimits = _nullishCoalesce(_optionalChain([ctx, 'access', _25 => _25.getUsageLimits, 'optionalCall', _26 => _26()]), () => ( []));
+  return {
+    model,
+    provider,
+    directory: formatPath(ctx.workspaceRoot),
+    permissions: formatPermissionMode(_optionalChain([ctx, 'access', _27 => _27.config, 'optionalAccess', _28 => _28.permissions, 'optionalAccess', _29 => _29.mode])),
+    agentsFile: resolveAgentsFile(ctx.workspaceRoot),
+    account: resolveAccount(ctx.config),
+    sessionId: _nullishCoalesce(_optionalChain([currentSession, 'optionalAccess', _30 => _30.metadata, 'access', _31 => _31.sessionId]), () => ( "none")),
+    contextPercentLeft,
+    contextWindow,
+    contextTokensUsed: resolveContextTokensUsed(ctx, contextWindow, contextPercentLeft),
+    tokenUsageStatus: _nullishCoalesce(_optionalChain([ctx, 'access', _32 => _32.getTokenUsageStatus, 'optionalCall', _33 => _33()]), () => ( "actual")),
+    reasoningEffort: resolveReasoningEffort(ctx.config, provider),
+    usageLimits
+  };
+}
+function formatProgressBar(percentLeft, width = 24) {
+  const emptySlots = Math.round(percentLeft / 100 * width);
+  const usedSlots = width - emptySlots;
+  return `[${"\u2588".repeat(emptySlots)}${"\u2591".repeat(usedSlots)}]`;
+}
+function formatInfoRow(label, value, labelWidth) {
+  const theme = _chunkLJD7KR3Lcjs.createCommandTheme.call(void 0, );
+  return `${theme.muted(label.padEnd(labelWidth))} ${value}`;
+}
+function formatModel(data) {
+  if (!data.reasoningEffort) {
+    return data.model;
+  }
+  return `${data.model} ${_chunkLJD7KR3Lcjs.createCommandTheme.call(void 0, ).muted(`(reasoning ${data.reasoningEffort})`)}`;
+}
+function formatContextSummary(data) {
+  const used = formatCompactNumber(data.contextTokensUsed);
+  const window = formatCompactNumber(data.contextWindow);
+  const suffix = data.tokenUsageStatus === "unavailable" ? " estimated" : "";
+  return `${data.contextPercentLeft}% left ${_chunkLJD7KR3Lcjs.createCommandTheme.call(void 0, ).muted(`(${used} used / ${window}${suffix})`)}`;
+}
+function formatUsageLimitRow(row, labelWidth) {
+  if (row.unavailableReason) {
+    return formatInfoRow(`${row.label}:`, row.unavailableReason, labelWidth);
+  }
+  const percent = clampPercent(_nullishCoalesce(row.percentLeft, () => ( 100)));
+  const reset = row.resetLabel ? _chunkLJD7KR3Lcjs.createCommandTheme.call(void 0, ).muted(` (${row.resetLabel})`) : "";
+  const usage2 = typeof row.used === "number" && typeof row.limit === "number" ? _chunkLJD7KR3Lcjs.createCommandTheme.call(void 0, ).muted(` (${formatCompactNumber(row.used)} used / ${formatCompactNumber(row.limit)})`) : "";
+  return formatInfoRow(`${row.label}:`, `${formatProgressBar(percent)} ${percent}% left${reset}${usage2}`, labelWidth);
+}
+function formatUsageDashboard(data) {
+  const labelWidth = 24;
+  const providerLimitRows = data.usageLimits.length > 0 ? data.usageLimits : [{ label: String(data.provider), unavailableReason: "not reported by provider" }];
+  const lines = [
+    formatInfoRow("Model:", formatModel(data), labelWidth),
+    formatInfoRow("Provider:", String(data.provider), labelWidth),
+    formatInfoRow("Directory:", data.directory, labelWidth),
+    formatInfoRow("Permissions:", data.permissions, labelWidth),
+    formatInfoRow("Agents.md:", data.agentsFile, labelWidth),
+    formatInfoRow("Account:", data.account, labelWidth),
+    formatInfoRow("Session:", data.sessionId, labelWidth),
+    "",
+    formatInfoRow("Context window:", formatContextSummary(data), labelWidth),
+    formatInfoRow("", formatProgressBar(data.contextPercentLeft), labelWidth),
+    "",
+    formatInfoRow("Provider limits:", "", labelWidth).trimEnd(),
+    ...providerLimitRows.map((row) => formatUsageLimitRow(row, labelWidth))
+  ];
+  return lines.join("\n");
+}
+async function usage(ctx) {
+  if (!isUsageV2Enabled(ctx)) {
+    return "The /usage dashboard is behind usage_v2. Run /features enable usage_v2, then /usage again. No restart required.";
+  }
+  await _optionalChain([ctx, 'access', _34 => _34.trackFeatureActivation, 'optionalCall', _35 => _35(USAGE_V2_FLAG, {
+    provider: ctx.provider,
+    model: ctx.model
+  })]);
+  return formatUsageDashboard(gatherUsageDashboardData(ctx));
+}
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CONTEXT_ENV_VARS = CONTEXT_ENV_VARS; exports.getContextWindow = getContextWindow; exports.estimateMessageTokens = estimateMessageTokens; exports.estimateMessagesTokens = estimateMessagesTokens; exports.calculateContextUsage = calculateContextUsage; exports.USAGE_V2_FLAG = USAGE_V2_FLAG; exports.metadata = metadata; exports.gatherUsageDashboardData = gatherUsageDashboardData; exports.formatUsageDashboard = formatUsageDashboard; exports.usage = usage;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Domain types for the context-compaction module.
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Token estimation, context window lookup, and usage calculation.
+ * Moved from src/utils/context.ts — this is the canonical location.
+ * The old barrel re-exports for backward compatibility.
+ */
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-MBBY4ZIK.js → chunk-KMP6Y3LJ.js}

@@ -1,6 +1,6 @@
 import {
   AUTOHAND_HOME
-} from "./chunk-EGFT4PGW.js";
+} from "./chunk-SHRLFX6F.js";
 
 // src/skills/CommunitySkillsCache.ts
 import fs from "fs-extra";
@@ -8,6 +8,9 @@ import path from "path";
 var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_MAX_SKILLS_CACHE = 50;
 var CommunitySkillsCache = class {
+  cacheDir;
+  ttlMs;
+  maxSkillsCache;
   constructor(config = {}) {
     this.cacheDir = config.cacheDir || path.join(AUTOHAND_HOME, "community-skills", "cache");
     this.ttlMs = config.ttlMs ?? DEFAULT_TTL_MS;

package/dist/chunk-KWXGDSYT.js

@@ -0,0 +1,184 @@
+import {
+  GoalManager
+} from "./chunk-SZD45IDG.js";
+import {
+  GOAL_FEATURE_DISABLED_MESSAGE,
+  resolveGoalFeatureEnabled
+} from "./chunk-7MY4JHER.js";
+
+// src/commands/goal.ts
+import chalk from "chalk";
+var metadata = {
+  command: "/goal",
+  description: "Create, inspect, pause, resume, complete, clear, and queue persistent goals",
+  implemented: true,
+  subcommands: [
+    { 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) {
+    return formatSnapshot(await manager.getSnapshot());
+  }
+  const [subcommand, ...restArgs] = args;
+  const rest = restArgs.join(" ").trim();
+  switch (subcommand?.toLowerCase()) {
+    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":
+      return formatMutation(await manager.updateGoal({ status: "complete" }));
+    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) {
+        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);
+}
+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.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) {
+    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));
+  }
+  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 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
+ */