autohand-cli 0.9.0 → 0.9.1

package/dist/chunk-HTU4W3GB.js

@@ -0,0 +1,183 @@
+// src/goals/templates.ts
+import { execFileSync } from "child_process";
+import fs from "fs-extra";
+import path from "path";
+var TEMPLATE_DIR = ".pi-goals";
+var DEFAULT_COMMAND_TIMEOUT_MS = 1e4;
+var DEFAULT_COMMAND_OUTPUT_LIMIT = 2e4;
+async function listGoalTemplateMetadata(root) {
+  const templates = await discoverGoalTemplates(root);
+  return templates.map((template) => {
+    const requiredPlaceholders = findRequiredPlaceholders(template.body);
+    return {
+      name: template.name,
+      path: template.path,
+      description: template.description,
+      aliases: template.aliases,
+      allowCommands: template.allowCommands,
+      requiredPlaceholders,
+      requiredFlags: requiredPlaceholders.filter((placeholder) => placeholder !== "args"),
+      requiresArgs: requiredPlaceholders.includes("args")
+    };
+  });
+}
+async function resolveGoalTemplateInvocation(input, root) {
+  const parsed = parseInvocation(input);
+  if (!parsed) return { ok: false, notTemplate: true };
+  return resolveGoalTemplateByName(root, parsed.name, parsed.flags, parsed.args);
+}
+async function resolveGoalTemplateByName(root, nameOrAlias, flags = {}, args = "") {
+  const templates = await discoverGoalTemplates(root);
+  const matches = templates.filter((template2) => template2.name === nameOrAlias || template2.aliases.includes(nameOrAlias));
+  if (matches.length === 0) return { ok: false, notTemplate: true };
+  if (matches.length > 1) {
+    return { ok: false, error: `Ambiguous goal template '${nameOrAlias}' matches: ${matches.map((template2) => template2.name).join(", ")}.` };
+  }
+  const template = matches[0];
+  try {
+    const objective = resolveInlineCommands(interpolate(template.body, { ...flags, args }), template, root).trim();
+    return { ok: true, template: { name: template.name, path: template.path, objective, flags: { ...flags }, args } };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function discoverGoalTemplates(root) {
+  const templates = [];
+  for (const dir of templateDirs(root)) {
+    if (!await fs.pathExists(dir)) continue;
+    await collectTemplates(root, dir, templates);
+  }
+  templates.sort((a, b) => a.name.localeCompare(b.name));
+  return templates;
+}
+function templateDirs(root) {
+  return [path.join(root, TEMPLATE_DIR), path.join(root, ".ai", TEMPLATE_DIR)];
+}
+async function collectTemplates(root, templateDir, templates) {
+  const entries = await fs.readdir(templateDir).catch(() => []);
+  for (const entry of entries) {
+    const fullPath = path.join(templateDir, entry);
+    const stats = await fs.stat(fullPath).catch(() => null);
+    if (!stats) continue;
+    if (stats.isDirectory()) {
+      await collectTemplates(root, fullPath, templates);
+      continue;
+    }
+    if (![".md", ".markdown", ".txt"].includes(path.extname(entry).toLowerCase())) continue;
+    const raw = await fs.readFile(fullPath, "utf8");
+    const parsed = parseFrontmatter(raw);
+    const name = stripMarkdownExt(path.relative(templateDir, fullPath).split(path.sep).join("/"));
+    templates.push({
+      name,
+      path: path.relative(root, fullPath),
+      description: parsed.frontmatter.description || firstContentLine(parsed.body),
+      aliases: parseList(parsed.frontmatter.aliases),
+      allowCommands: parseBoolean(parsed.frontmatter.allow_commands),
+      commandTimeoutMs: parsePositiveInt(parsed.frontmatter.command_timeout_ms, DEFAULT_COMMAND_TIMEOUT_MS),
+      commandOutputLimit: parsePositiveInt(parsed.frontmatter.command_output_limit, DEFAULT_COMMAND_OUTPUT_LIMIT),
+      body: parsed.body
+    });
+  }
+}
+function parseFrontmatter(raw) {
+  if (!raw.startsWith("---\n")) return { frontmatter: {}, body: raw };
+  const end = raw.indexOf("\n---", 4);
+  if (end < 0) return { frontmatter: {}, body: raw };
+  const frontmatter = {};
+  for (const line of raw.slice(4, end).split(/\r?\n/)) {
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (match) frontmatter[match[1]] = stripQuotes(match[2].trim());
+  }
+  return { frontmatter, body: raw.slice(end + 4).replace(/^\r?\n/, "") };
+}
+function parseInvocation(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  const match = trimmed.match(/^(\S+)(?:\s+([\s\S]*))?$/);
+  if (!match) return null;
+  let rest = match[2] ?? "";
+  let args = "";
+  if (rest.startsWith("-- ")) {
+    args = rest.slice(3).trim();
+    rest = "";
+  } else {
+    const delimiter = rest.indexOf(" -- ");
+    if (delimiter >= 0) {
+      args = rest.slice(delimiter + 4).trim();
+      rest = rest.slice(0, delimiter).trim();
+    }
+  }
+  return { name: match[1], flags: parseFlags(rest), args };
+}
+function parseFlags(input) {
+  const values = {};
+  const tokens = input.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = unquote(tokens[i]);
+    if (!token.startsWith("--")) continue;
+    const eq = token.indexOf("=");
+    if (eq > 2) {
+      values[token.slice(2, eq)] = token.slice(eq + 1);
+      continue;
+    }
+    const next = tokens[i + 1] && !tokens[i + 1].startsWith("--") ? unquote(tokens[++i]) : "true";
+    values[token.slice(2)] = next;
+  }
+  return values;
+}
+function interpolate(text, values) {
+  return text.replace(/\{\{\s*([A-Za-z0-9_-]+)\s*\}\}/g, (_match, key) => {
+    if (values[key] === void 0) throw new Error(`Missing template value for {{${key}}}.`);
+    return values[key];
+  });
+}
+function resolveInlineCommands(text, template, cwd) {
+  return text.replace(/!`([^`]+)`/g, (_match, command) => {
+    if (!template.allowCommands) throw new Error(`Template ${template.name} uses inline commands but allow_commands is not true.`);
+    const output = execFileSync("/bin/bash", ["-lc", command], {
+      cwd,
+      encoding: "utf8",
+      timeout: template.commandTimeoutMs,
+      maxBuffer: template.commandOutputLimit + 1024
+    });
+    return output.length > template.commandOutputLimit ? `${output.slice(0, template.commandOutputLimit)}
+[output truncated]` : output;
+  });
+}
+function findRequiredPlaceholders(text) {
+  return Array.from(text.matchAll(/\{\{\s*([A-Za-z0-9_-]+)\s*\}\}/g), (match) => match[1]).filter((placeholder, index, all) => all.indexOf(placeholder) === index).sort();
+}
+function parseList(value) {
+  if (!value) return [];
+  return value.replace(/^\[|\]$/g, "").split(",").map((item) => stripQuotes(item.trim())).filter(Boolean);
+}
+function parseBoolean(value) {
+  return value === "true" || value === "yes" || value === "1";
+}
+function parsePositiveInt(value, fallback) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function stripMarkdownExt(filePath) {
+  return filePath.replace(/\.(md|markdown|txt)$/i, "");
+}
+function firstContentLine(body) {
+  return body.split(/\r?\n/).map((line) => line.replace(/^#+\s*/, "").trim()).find(Boolean);
+}
+function stripQuotes(value) {
+  return value.replace(/^['"]|['"]$/g, "");
+}
+function unquote(value) {
+  return stripQuotes(value);
+}
+
+export {
+  listGoalTemplateMetadata,
+  resolveGoalTemplateInvocation,
+  resolveGoalTemplateByName
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-5CMYEM3R.cjs → chunk-HVCIB4SW.cjs}

@@ -3,7 +3,7 @@
 var _chunkJHGIWNHLcjs = require('./chunk-JHGIWNHL.cjs');
 
 
-var _chunkE26KKI46cjs = require('./chunk-E26KKI46.cjs');
+var _chunkKASXKDF2cjs = require('./chunk-KASXKDF2.cjs');
 
 // src/skills/SkillsRegistry.ts
 var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
@@ -234,7 +234,7 @@ var SkillsRegistry = (_class = class {
     this.workspaceRoot = workspaceRoot;
     const claudeProjectSkillsDir = _path2.default.join(workspaceRoot, ".claude", "skills");
     await this.loadFromDirectory(claudeProjectSkillsDir, "claude-project", false);
-    const autohandProjectSkillsDir = _path2.default.join(workspaceRoot, _chunkE26KKI46cjs.PROJECT_DIR_NAME, "skills");
+    const autohandProjectSkillsDir = _path2.default.join(workspaceRoot, _chunkKASXKDF2cjs.PROJECT_DIR_NAME, "skills");
     await this.loadFromDirectory(autohandProjectSkillsDir, "autohand-project", true);
   }
   /**
@@ -293,7 +293,7 @@ var SkillsRegistry = (_class = class {
   async setWorkspaceWithAutoCopy(workspaceRoot) {
     this.workspaceRoot = workspaceRoot;
     const claudeProjectSkillsDir = _path2.default.join(workspaceRoot, ".claude", "skills");
-    const autohandProjectSkillsDir = _path2.default.join(workspaceRoot, _chunkE26KKI46cjs.PROJECT_DIR_NAME, "skills");
+    const autohandProjectSkillsDir = _path2.default.join(workspaceRoot, _chunkKASXKDF2cjs.PROJECT_DIR_NAME, "skills");
     await this.addLocationWithAutoCopy(
       claudeProjectSkillsDir,
       "claude-project",

package/dist/chunk-HXHE2KAO.js

@@ -0,0 +1,385 @@
+import {
+  formatAccount
+} from "./chunk-ZUYYHKQA.js";
+import {
+  createCommandTheme
+} from "./chunk-46MTALKD.js";
+import {
+  getProviderConfig
+} from "./chunk-IEPLQ47J.js";
+import {
+  getFeatureState
+} from "./chunk-LANGD5CO.js";
+
+// src/commands/usage.ts
+import fs from "fs";
+import os from "os";
+import path from "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(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 = text.match(/[{}[\]":\\]/g)?.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 = (baseRatio[modelFamily ?? "default"] ?? 3.5) * codeLikeRatio;
+  return Math.ceil(text.length / ratio);
+}
+function estimateMessageTokens(message, modelFamily) {
+  const structureOverhead = 10;
+  let tokens = structureOverhead;
+  tokens += estimateTokens(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 = os.homedir();
+  if (value === home) {
+    return "~";
+  }
+  if (value.startsWith(`${home}${path.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 (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 getProviderConfig(config, provider) ?? void 0;
+}
+function resolveActiveProvider(ctx) {
+  return ctx.config?.provider ?? ctx.provider ?? "openrouter";
+}
+function resolveActiveModel(ctx, provider) {
+  const settings = resolveProviderSettings(ctx.config, provider);
+  return settings?.model ?? ctx.model;
+}
+function resolveReasoningEffort(config, provider) {
+  return resolveProviderSettings(config, provider)?.reasoningEffort;
+}
+function resolveContextWindow(ctx, provider, model) {
+  const settings = resolveProviderSettings(ctx.config, provider);
+  return ctx.getContextWindow?.() ?? settings?.contextWindow ?? getContextWindow(model, settings?.contextWindow);
+}
+function resolveContextTokensUsed(ctx, contextWindow, percentLeft) {
+  const reported = ctx.getTotalTokensUsed?.();
+  if (typeof reported === "number" && Number.isFinite(reported) && reported > 0) {
+    return Math.round(reported);
+  }
+  return Math.round(contextWindow * ((100 - percentLeft) / 100));
+}
+function resolveAgentsFile(workspaceRoot) {
+  return fs.existsSync(path.join(workspaceRoot, "AGENTS.md")) ? "AGENTS.md" : "none";
+}
+function resolveAccount(config) {
+  const account = formatAccount(config, "");
+  if (account) {
+    return account;
+  }
+  if (config?.openai?.authMode === "chatgpt" && config.openai.chatgptAuth?.accountId) {
+    return `ChatGPT account ${config.openai.chatgptAuth.accountId}`;
+  }
+  return "not signed in";
+}
+function isUsageV2Enabled(ctx) {
+  const localDefault = ctx.config ? getFeatureState(ctx.config, USAGE_V2_FLAG)?.enabled ?? false : false;
+  return ctx.isFeatureEnabled?.(USAGE_V2_FLAG, localDefault) ?? localDefault;
+}
+function gatherUsageDashboardData(ctx) {
+  const provider = resolveActiveProvider(ctx);
+  const model = resolveActiveModel(ctx, provider);
+  const contextPercentLeft = clampPercent(ctx.getContextPercentLeft?.() ?? 100);
+  const contextWindow = resolveContextWindow(ctx, provider, model);
+  const currentSession = ctx.sessionManager.getCurrentSession();
+  const usageLimits = ctx.getUsageLimits?.() ?? [];
+  return {
+    model,
+    provider,
+    directory: formatPath(ctx.workspaceRoot),
+    permissions: formatPermissionMode(ctx.config?.permissions?.mode),
+    agentsFile: resolveAgentsFile(ctx.workspaceRoot),
+    account: resolveAccount(ctx.config),
+    sessionId: currentSession?.metadata.sessionId ?? "none",
+    contextPercentLeft,
+    contextWindow,
+    contextTokensUsed: resolveContextTokensUsed(ctx, contextWindow, contextPercentLeft),
+    tokenUsageStatus: ctx.getTokenUsageStatus?.() ?? "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 = createCommandTheme();
+  return `${theme.muted(label.padEnd(labelWidth))} ${value}`;
+}
+function formatModel(data) {
+  if (!data.reasoningEffort) {
+    return data.model;
+  }
+  return `${data.model} ${createCommandTheme().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 ${createCommandTheme().muted(`(${used} used / ${window}${suffix})`)}`;
+}
+function formatUsageLimitRow(row, labelWidth) {
+  if (row.unavailableReason) {
+    return formatInfoRow(`${row.label}:`, row.unavailableReason, labelWidth);
+  }
+  const percent = clampPercent(row.percentLeft ?? 100);
+  const reset = row.resetLabel ? createCommandTheme().muted(` (${row.resetLabel})`) : "";
+  const usage2 = typeof row.used === "number" && typeof row.limit === "number" ? createCommandTheme().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 ctx.trackFeatureActivation?.(USAGE_V2_FLAG, {
+    provider: ctx.provider,
+    model: ctx.model
+  });
+  return formatUsageDashboard(gatherUsageDashboardData(ctx));
+}
+
+export {
+  CONTEXT_ENV_VARS,
+  getContextWindow,
+  estimateMessageTokens,
+  estimateMessagesTokens,
+  calculateContextUsage,
+  USAGE_V2_FLAG,
+  metadata,
+  gatherUsageDashboardData,
+  formatUsageDashboard,
+  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-NMQ47RCG.js → chunk-HZWU6IO3.js}

@@ -2,7 +2,7 @@ import {
   getCurrentLocale,
   onLanguageChange,
   t
-} from "./chunk-CBFH2J3O.js";
+} from "./chunk-LEZEWKPA.js";
 
 // src/ui/i18n/I18nContext.tsx
 import { createContext, useContext, useState, useEffect, useMemo } from "react";
@@ -36,7 +36,10 @@ function useTranslation() {
 
 // src/ui/inkRenderOptions.ts
 function inkRenderOptions(options) {
-  return options;
+  return {
+    maxFps: 60,
+    ...options
+  };
 }
 
 export {

package/dist/{chunk-ZPD2AO3U.js → chunk-I2ZK3AOD.js}

@@ -3,10 +3,10 @@ import {
   addToLocalDenyList,
   loadLocalProjectSettings,
   mergePermissions
-} from "./chunk-HJIXWGQZ.js";
+} from "./chunk-5A7ZL64N.js";
 import {
   PROJECT_DIR_NAME
-} from "./chunk-TWQDAUZU.js";
+} from "./chunk-SHRLFX6F.js";
 
 // src/permissions/PermissionManager.ts
 import path2 from "path";