@sunasteriskrnd/takumi 1.0.0-dev.49 → 1.0.0-dev.50

package/dist/index.js

@@ -19815,7 +19815,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@sunasteriskrnd/takumi",
-    version: "1.0.0-dev.49",
+    version: "1.0.0-dev.50",
     description: "CLI tool for bootstrapping and managing Takumi projects",
     type: "module",
     repository: {
@@ -20011,7 +20011,7 @@ function getLegacyManifestPath(providerRoot) {
   return join4(providerRoot, LEGACY_MANIFEST_FILENAME);
 }
 function getCliVersion() {
-  return process.env.TAKUMI_CLI_VERSION?.trim() || process.env.npm_package_version?.trim() || "unknown";
+  return "1.0.0-dev.50"?.trim() || process.env.npm_package_version?.trim() || "unknown";
 }
 function getCliUserAgent() {
   return `${TAKUMI_CLI_NPM_PACKAGE_NAME}/${getCliVersion()}`;
@@ -22249,6 +22249,7 @@ var init_kit = __esm(() => {
     ".mcp.json",
     ".tkmignore",
     ".skignore",
+    "takumi.json",
     ".takumi.json"
   ];
   PROTECTED_PATTERNS = [...NEVER_COPY_PATTERNS, ...USER_CONFIG_PATTERNS];
@@ -22515,7 +22516,7 @@ function normalizeTakumiConfigInput(value) {
   }
   return normalized;
 }
-var PlanValidationModeSchema, PlanFocusAreaSchema, PlanResolutionOrderSchema, ProjectTypeSchema, PackageManagerSchema, FrameworkSchema, GEMINI_MODEL_VALUES, LEGACY_GEMINI_MODEL_ALIASES, GeminiModelSchema, StatuslineModeSchema, StatuslineSectionIdSchema, StatuslineSectionConfigSchema, StatuslineThemeSchema, StatuslineLayoutSchema, CodingLevelSchema, PlanResolutionSchema, PlanValidationSchema, SkPlanConfigSchema, SkDocsConfigSchema, SkPathsConfigSchema, SkLocaleConfigSchema, SkTrustConfigSchema, SkGraphifyConfigSchema, SkProjectConfigSchema, SkGeminiConfigSchema, SkSkillsConfigSchema, SkSkillExtensionsConfigSchema, UpdatePipelineSchema, ResolvedModelConfigSchema, ModelTierMapSchema, SkModelTaxonomySchema, SkAssertionSchema, SkHooksConfigSchema, TakumiConfigSchema, DEFAULT_TAKUMI_CONFIG, TAKUMI_HOOK_NAMES;
+var PlanValidationModeSchema, PlanFocusAreaSchema, PlanResolutionOrderSchema, ProjectTypeSchema, PackageManagerSchema, FrameworkSchema, GEMINI_MODEL_VALUES, LEGACY_GEMINI_MODEL_ALIASES, GeminiModelSchema, StatuslineModeSchema, StatuslineSectionIdSchema, StatuslineSectionConfigSchema, StatuslineThemeSchema, StatuslineLayoutSchema, StatuslineBarStyleSchema, StatuslineConfigSchema, CodingLevelSchema, PlanResolutionSchema, PlanValidationSchema, SkPlanConfigSchema, SkDocsConfigSchema, SkPathsConfigSchema, SkLocaleConfigSchema, SkTrustConfigSchema, SkGraphifyConfigSchema, SkProjectConfigSchema, SkGeminiConfigSchema, SkSkillsConfigSchema, SkSkillExtensionsConfigSchema, UpdatePipelineSchema, ResolvedModelConfigSchema, ModelTierMapSchema, SkModelTaxonomySchema, SkAssertionSchema, SkHooksConfigSchema, TakumiConfigSchema, DEFAULT_TAKUMI_CONFIG, TAKUMI_HOOK_NAMES;
 var init_takumi_config = __esm(() => {
   init_zod();
   PlanValidationModeSchema = exports_external.enum(["prompt", "auto", "strict", "none"]);
@@ -22603,6 +22604,50 @@ var init_takumi_config = __esm(() => {
     maxAgentRows: exports_external.number().int().min(1).max(10).default(4),
     todoTruncation: exports_external.number().int().min(20).max(100).default(50)
   });
+  StatuslineBarStyleSchema = exports_external.enum(["geometric", "block"]);
+  StatuslineConfigSchema = exports_external.object({
+    prompt: exports_external.string().optional(),
+    brand: exports_external.object({
+      icon: exports_external.string().optional(),
+      showCliVersion: exports_external.boolean().optional(),
+      showCoreVersion: exports_external.boolean().optional(),
+      color: exports_external.string().optional(),
+      versionColor: exports_external.string().optional()
+    }).passthrough().optional(),
+    model: exports_external.object({ color: exports_external.string().optional() }).passthrough().optional(),
+    context: exports_external.object({
+      barWidth: exports_external.number().int().optional(),
+      barStyle: StatuslineBarStyleSchema.optional(),
+      showPercent: exports_external.boolean().optional(),
+      colors: exports_external.object({ low: exports_external.string(), mid: exports_external.string(), high: exports_external.string() }).partial().passthrough().optional(),
+      thresholds: exports_external.object({ mid: exports_external.number(), high: exports_external.number() }).partial().passthrough().optional()
+    }).passthrough().optional(),
+    quotas: exports_external.object({
+      windows: exports_external.array(exports_external.string()).optional(),
+      barWidth: exports_external.number().int().optional(),
+      showCountdown: exports_external.boolean().optional(),
+      icon: exports_external.string().optional()
+    }).passthrough().optional(),
+    directory: exports_external.object({
+      icon: exports_external.string().optional(),
+      collapseHome: exports_external.boolean().optional(),
+      truncationLength: exports_external.number().int().optional(),
+      color: exports_external.string().optional()
+    }).passthrough().optional(),
+    git: exports_external.object({
+      icon: exports_external.string().optional(),
+      showDirty: exports_external.boolean().optional(),
+      dirtyInBrackets: exports_external.boolean().optional(),
+      showAheadBehind: exports_external.boolean().optional(),
+      countUntracked: exports_external.boolean().optional(),
+      branchColor: exports_external.string().optional()
+    }).passthrough().optional(),
+    activity: exports_external.object({
+      maxAgentRows: exports_external.number().int().optional(),
+      todoTruncation: exports_external.number().int().optional()
+    }).passthrough().optional(),
+    cost: exports_external.object({ icon: exports_external.string().optional(), hideZero: exports_external.boolean().optional() }).passthrough().optional()
+  }).passthrough();
   CodingLevelSchema = exports_external.number().int().min(-1).max(5);
   PlanResolutionSchema = exports_external.object({
     order: exports_external.array(PlanResolutionOrderSchema).optional(),
@@ -22689,7 +22734,7 @@ var init_takumi_config = __esm(() => {
   TakumiConfigSchema = exports_external.object({
     $schema: exports_external.string().optional(),
     codingLevel: CodingLevelSchema.optional(),
-    statusline: StatuslineModeSchema.optional(),
+    statusline: exports_external.union([StatuslineModeSchema, StatuslineConfigSchema]).optional(),
     statuslineColors: exports_external.boolean().optional(),
     statuslineQuota: exports_external.boolean().optional(),
     statuslineLayout: StatuslineLayoutSchema.optional(),
@@ -24713,6 +24758,22 @@ var init_manifest_tracker = __esm(() => {
 });
 
 // src/services/file-operations/manifest/index.ts
+var exports_manifest = {};
+__export(exports_manifest, {
+  writeManifest: () => writeManifest,
+  writeKitPending: () => writeKitPending,
+  trackFilesWithProgress: () => trackFilesWithProgress,
+  removeKitFromManifest: () => removeKitFromManifest,
+  readManifest: () => readManifest,
+  readKitManifest: () => readKitManifest,
+  getUninstallManifest: () => getUninstallManifest,
+  findPendingKits: () => findPendingKits,
+  findManifestPathSync: () => findManifestPathSync,
+  findManifestPath: () => findManifestPath,
+  findFileInInstalledKits: () => findFileInInstalledKits,
+  buildFileTrackingList: () => buildFileTrackingList,
+  ManifestTracker: () => ManifestTracker
+});
 var init_manifest = __esm(() => {
   init_manifest_reader();
   init_manifest_tracker();
@@ -45575,14 +45636,26 @@ class TakumiConfigManager {
   static getGlobalConfigDir() {
     return join62(homedir18(), ".claude");
   }
+  static resolveConfigPath(dir) {
+    const preferred = join62(dir, TAKUMI_CONFIG_FILE);
+    if (existsSync26(preferred))
+      return preferred;
+    const legacy = join62(dir, LEGACY_TAKUMI_CONFIG_FILE);
+    if (existsSync26(legacy))
+      return legacy;
+    return preferred;
+  }
+  static configFileExistsIn(dir) {
+    return existsSync26(join62(dir, TAKUMI_CONFIG_FILE)) || existsSync26(join62(dir, LEGACY_TAKUMI_CONFIG_FILE));
+  }
   static getGlobalConfigPath() {
-    return join62(TakumiConfigManager.getGlobalConfigDir(), TAKUMI_CONFIG_FILE);
+    return TakumiConfigManager.resolveConfigPath(TakumiConfigManager.getGlobalConfigDir());
   }
   static getProjectConfigDir(projectDir) {
     return join62(projectDir, ".claude");
   }
   static getProjectConfigPath(projectDir) {
-    return join62(TakumiConfigManager.getProjectConfigDir(projectDir), TAKUMI_CONFIG_FILE);
+    return TakumiConfigManager.resolveConfigPath(TakumiConfigManager.getProjectConfigDir(projectDir));
   }
   static async loadConfigFile(configPath) {
     try {
@@ -45676,8 +45749,8 @@ class TakumiConfigManager {
     return TakumiConfigManager.loadConfigFile(TakumiConfigManager.getProjectConfigPath(projectDir));
   }
   static projectConfigExists(dir, isGlobal) {
-    const configPath = isGlobal ? join62(dir, ".takumi.json") : TakumiConfigManager.getProjectConfigPath(dir);
-    return existsSync26(configPath);
+    const searchDir = isGlobal ? dir : TakumiConfigManager.getProjectConfigDir(dir);
+    return TakumiConfigManager.configFileExistsIn(searchDir);
   }
   static configExists(scope, projectDir) {
     if (scope === "global") {
@@ -45699,7 +45772,7 @@ class TakumiConfigManager {
     await TakumiConfigManager.saveFull(existing, scope, projectDir);
   }
 }
-var TAKUMI_CONFIG_FILE = ".takumi.json", DANGEROUS_KEYS;
+var TAKUMI_CONFIG_FILE = "takumi.json", LEGACY_TAKUMI_CONFIG_FILE = ".takumi.json", DANGEROUS_KEYS;
 var init_takumi_config_manager = __esm(() => {
   init_logger();
   init_types2();
@@ -49666,19 +49739,305 @@ var require_parse4 = __commonJS((exports, module) => {
   };
 });
 
+// src/domains/statusline/cache-dir.ts
+import {
+  closeSync as closeSync5,
+  constants as fsConstants3,
+  fstatSync,
+  mkdirSync as mkdirSync5,
+  openSync as openSync8,
+  readSync as readSync5,
+  renameSync as renameSync3,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync9
+} from "node:fs";
+import { join as join102 } from "node:path";
+function getStatuslineCacheDir() {
+  return join102(getConfigDir(), "cache", "statusline");
+}
+function getStatuslineCachePath(fileName) {
+  return join102(getStatuslineCacheDir(), fileName);
+}
+function ensureStatuslineCacheDir() {
+  try {
+    mkdirSync5(getStatuslineCacheDir(), { recursive: true, mode: 448 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readCacheFileSafe(path10) {
+  let fd;
+  try {
+    fd = openSync8(path10, fsConstants3.O_RDONLY | fsConstants3.O_NOFOLLOW);
+    const stat9 = fstatSync(fd);
+    if (!stat9.isFile())
+      return null;
+    const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
+    if (uid !== undefined && stat9.uid !== uid)
+      return null;
+    const size = stat9.size;
+    if (size <= 0)
+      return "";
+    const buf = Buffer.allocUnsafe(size);
+    let read = 0;
+    while (read < size) {
+      const n2 = readSync5(fd, buf, read, size - read, read);
+      if (n2 <= 0)
+        break;
+      read += n2;
+    }
+    return buf.toString("utf8", 0, read);
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) {
+      try {
+        closeSync5(fd);
+      } catch {}
+    }
+  }
+}
+function writeCacheFileSafe(path10, data) {
+  if (!ensureStatuslineCacheDir())
+    return false;
+  const tmpPath = `${path10}.tmp.${process.pid}.${++writeCounter2}`;
+  try {
+    writeFileSync9(tmpPath, data, { mode: 384 });
+    renameSync3(tmpPath, path10);
+    return true;
+  } catch {
+    try {
+      rmSync3(tmpPath, { force: true });
+    } catch {}
+    return false;
+  }
+}
+var writeCounter2 = 0;
+var init_cache_dir = __esm(() => {
+  init_paths2();
+});
+
+// src/domains/hooks/handlers/usage-cache/usage-credential.ts
+import { execFileSync as execFileSync6 } from "node:child_process";
+import { closeSync as closeSync6, constants as fsConstants4, fstatSync as fstatSync2, openSync as openSync9, readFileSync as readFileSync18 } from "node:fs";
+import { homedir as homedir28, platform as platform10 } from "node:os";
+import { join as join111 } from "node:path";
+function hasAnthropicRuntimeOverride(env2 = process.env) {
+  return OVERRIDE_ENV_KEYS.some((key) => {
+    const value = env2[key];
+    return typeof value === "string" && value.trim().length > 0;
+  });
+}
+function lowerTrimmed(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function parseOAuth(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const bag = raw.claudeAiOauth;
+  if (!bag || typeof bag !== "object")
+    return null;
+  const oauth = bag;
+  const token = typeof oauth.accessToken === "string" ? oauth.accessToken.trim() : "";
+  if (!token)
+    return null;
+  return {
+    accessToken: token,
+    subscriptionType: lowerTrimmed(oauth.subscriptionType),
+    rateLimitTier: lowerTrimmed(oauth.rateLimitTier)
+  };
+}
+function readTrustedFile(path10) {
+  let fd;
+  try {
+    fd = openSync9(path10, fsConstants4.O_RDONLY | fsConstants4.O_NOFOLLOW);
+    const stat9 = fstatSync2(fd);
+    if (!stat9.isFile())
+      return null;
+    const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
+    if (uid !== undefined && stat9.uid !== uid)
+      return null;
+    if ((stat9.mode & 18) !== 0)
+      return null;
+    return readFileSync18(fd, "utf8");
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) {
+      try {
+        closeSync6(fd);
+      } catch {}
+    }
+  }
+}
+function fromCredentialsFile() {
+  const raw = readTrustedFile(join111(homedir28(), ".claude", ".credentials.json"));
+  if (!raw)
+    return null;
+  try {
+    return parseOAuth(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function fromKeychain() {
+  if (platform10() !== "darwin")
+    return null;
+  try {
+    const out = execFileSync6("security", ["find-generic-password", "-s", KEYCHAIN_SERVICE, "-w"], {
+      timeout: 5000,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return parseOAuth(JSON.parse(out.trim()));
+  } catch {
+    return null;
+  }
+}
+function isPaidSubscription(oauth) {
+  const sub = oauth.subscriptionType;
+  const hasPaidPlan = sub.length > 0 && sub !== "free" && sub !== "none";
+  return hasPaidPlan || PAID_TIER_PATTERN.test(oauth.rateLimitTier);
+}
+function resolveUsageAccess() {
+  if (hasAnthropicRuntimeOverride()) {
+    return { eligible: false, note: "runtime-override", accessToken: null };
+  }
+  const oauth = fromKeychain() ?? fromCredentialsFile();
+  if (!oauth) {
+    return { eligible: false, note: "missing-credentials", accessToken: null };
+  }
+  if (!isPaidSubscription(oauth)) {
+    return { eligible: false, note: "non-subscription-auth", accessToken: null };
+  }
+  return { eligible: true, note: "eligible", accessToken: oauth.accessToken };
+}
+var OVERRIDE_ENV_KEYS, PAID_TIER_PATTERN, KEYCHAIN_SERVICE = "Claude Code-credentials";
+var init_usage_credential = __esm(() => {
+  OVERRIDE_ENV_KEYS = [
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_API_KEY"
+  ];
+  PAID_TIER_PATTERN = /claude|max|pro|team|enterprise/;
+});
+
+// src/domains/hooks/handlers/usage-cache/usage-limits-cache.ts
+var exports_usage_limits_cache = {};
+__export(exports_usage_limits_cache, {
+  refreshUsageCache: () => refreshUsageCache,
+  readUsageCache: () => readUsageCache,
+  normalizeUtilization: () => normalizeUtilization,
+  isUsageCacheFresh: () => isUsageCacheFresh,
+  getCacheAgeMs: () => getCacheAgeMs
+});
+function cachePath() {
+  return getStatuslineCachePath(USAGE_CACHE_FILE);
+}
+function readUsageCache() {
+  const raw = readCacheFileSafe(cachePath());
+  if (!raw)
+    return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function getCacheAgeMs(cache3, now = Date.now()) {
+  if (!cache3 || typeof cache3.timestamp !== "number")
+    return Number.POSITIVE_INFINITY;
+  return Math.max(0, now - cache3.timestamp);
+}
+function isUsageCacheFresh(cache3, maxAgeMs, now = Date.now()) {
+  return getCacheAgeMs(cache3, now) <= maxAgeMs;
+}
+function normalizeUtilization(utilization) {
+  if (typeof utilization !== "number" || !Number.isFinite(utilization))
+    return null;
+  if (utilization > 0 && utilization < 1)
+    return Math.round(utilization * 100);
+  return Math.max(0, Math.round(utilization));
+}
+function buildSnapshot(data, now) {
+  if (!data)
+    return null;
+  return {
+    sourceVersion: SNAPSHOT_VERSION,
+    fetchedAt: new Date(now).toISOString(),
+    fiveHourPercent: normalizeUtilization(data.five_hour?.utilization),
+    weekPercent: normalizeUtilization(data.seven_day?.utilization)
+  };
+}
+function persist(status2, data) {
+  const now = Date.now();
+  const cache3 = {
+    timestamp: now,
+    status: status2,
+    data,
+    snapshot: status2 === "available" ? buildSnapshot(data, now) : null
+  };
+  writeCacheFileSafe(cachePath(), JSON.stringify(cache3));
+}
+async function fetchUsage() {
+  const access3 = resolveUsageAccess();
+  if (!access3.eligible || !access3.accessToken) {
+    return { status: "unavailable", note: access3.note, data: null };
+  }
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const response = await fetch(USAGE_ENDPOINT, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${access3.accessToken}`,
+        "anthropic-beta": OAUTH_BETA_HEADER,
+        "User-Agent": USER_AGENT
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return { status: "unavailable", note: `http-${response.status}`, data: null };
+    }
+    const body = await response.json();
+    if (!body || typeof body !== "object") {
+      return { status: "unavailable", note: "invalid-body", data: null };
+    }
+    return { status: "available", note: "fetched", data: body };
+  } catch (err) {
+    const aborted = err instanceof Error && err.name === "AbortError";
+    return { status: "unavailable", note: aborted ? "timeout" : "fetch-failed", data: null };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function refreshUsageCache() {
+  const outcome = await fetchUsage();
+  persist(outcome.status, outcome.data);
+  return outcome.note;
+}
+var USAGE_ENDPOINT = "https://api.anthropic.com/api/oauth/usage", USER_AGENT = "takumi-agent-kit-engineer/usage-cache", FETCH_TIMEOUT_MS = 5000, USAGE_CACHE_FILE = "usage-limits.json", OAUTH_BETA_HEADER = "oauth-2025-04-20", SNAPSHOT_VERSION = 1;
+var init_usage_limits_cache = __esm(() => {
+  init_cache_dir();
+  init_usage_credential();
+});
+
 // src/shared/monorepo-resolver.ts
 var exports_monorepo_resolver = {};
 __export(exports_monorepo_resolver, {
   resolveMonorepoRoot: () => resolveMonorepoRoot
 });
-import { existsSync as existsSync56, readFileSync as readFileSync22 } from "node:fs";
-import { dirname as dirname33, join as join118, resolve as resolve26 } from "node:path";
+import { existsSync as existsSync58, readFileSync as readFileSync23 } from "node:fs";
+import { dirname as dirname33, join as join121, resolve as resolve26 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function parseMetadataAt(metadataPath) {
-  if (!existsSync56(metadataPath))
+  if (!existsSync58(metadataPath))
     return null;
   try {
-    const raw = readFileSync22(metadataPath, "utf-8");
+    const raw = readFileSync23(metadataPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.name !== "string" || typeof parsed.version !== "string" || !ACCEPTED_METADATA_NAMES.has(parsed.name)) {
       return null;
@@ -49689,11 +50048,11 @@ function parseMetadataAt(metadataPath) {
   }
 }
 function readSourceDirFromPackageJson(candidateRoot) {
-  const packageJsonPath = join118(candidateRoot, "package.json");
-  if (!existsSync56(packageJsonPath))
+  const packageJsonPath = join121(candidateRoot, "package.json");
+  if (!existsSync58(packageJsonPath))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync22(packageJsonPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync23(packageJsonPath, "utf-8"));
     const kitCfg = parsed.takumi;
     if (kitCfg && typeof kitCfg.sourceDir === "string" && kitCfg.sourceDir.length > 0) {
       return kitCfg.sourceDir;
@@ -49712,7 +50071,7 @@ function tryReadAtCandidate(candidateRoot) {
     };
   }
   const sourceDir = readSourceDirFromPackageJson(candidateRoot) ?? "claude";
-  const sourceRoot = join118(candidateRoot, sourceDir);
+  const sourceRoot = join121(candidateRoot, sourceDir);
   const nestedMetadata = parseMetadataAt(getManifestPath(sourceRoot)) ?? parseMetadataAt(getLegacyManifestPath(sourceRoot));
   if (nestedMetadata) {
     return {
@@ -50442,7 +50801,7 @@ var init_help_commands = __esm(() => {
 });
 
 // src/domains/help/help-interactive.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import * as readline from "node:readline";
 function getTerminalHeight() {
   return process.stdout.rows || 24;
@@ -50477,7 +50836,7 @@ async function trySystemPager(content) {
     const pagerCmd = process.env.PAGER || "less";
     const pagerArgs = getPagerArgs(pagerCmd);
     try {
-      const pager = spawn5(pagerCmd, pagerArgs, {
+      const pager = spawn6(pagerCmd, pagerArgs, {
         stdio: ["pipe", process.stdout, process.stderr],
         shell: false
       });
@@ -73292,13 +73651,538 @@ var metricsRecord = {
   }
 };
 
+// src/domains/statusline/activity-cache.ts
+import { readdirSync as readdirSync7, rmSync as rmSync4, statSync as statSync8 } from "node:fs";
+import { join as join103 } from "node:path";
+
+// src/domains/statusline/activity-snapshot.ts
+import { existsSync as existsSync49 } from "node:fs";
+
+// src/domains/statusline/transcript-parser.ts
+import { createReadStream as createReadStream4, existsSync as existsSync48 } from "node:fs";
+import { createInterface as createInterface2 } from "node:readline";
+var MAX_TOOLS = 20;
+var MAX_AGENTS = 10;
+var NATIVE_TASK = "native_task";
+var LEGACY_TODOWRITE = "legacy_todowrite";
+var BASH_TARGET_LIMIT = 30;
+var TASK_ID_PATTERN = /["']?task[_-]?id["']?\s*[:=]\s*["']([^"']+)["']/i;
+function asRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringOr(value, fallback2) {
+  return typeof value === "string" ? value : fallback2;
+}
+function stringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function extractTarget(toolName, input) {
+  switch (toolName) {
+    case "Read":
+    case "Write":
+    case "Edit":
+      return stringOrNull(input.file_path) ?? stringOrNull(input.path);
+    case "Glob":
+    case "Grep":
+      return stringOrNull(input.pattern);
+    case "Bash": {
+      const command = input.command;
+      if (typeof command !== "string")
+        return null;
+      return command.length > BASH_TARGET_LIMIT ? `${command.slice(0, BASH_TARGET_LIMIT)}...` : command;
+    }
+    default:
+      return null;
+  }
+}
+function findEmbeddedTaskId(node) {
+  if (node == null)
+    return null;
+  if (typeof node === "string") {
+    try {
+      const parsed = JSON.parse(node);
+      if (parsed && typeof parsed === "object")
+        return findEmbeddedTaskId(parsed);
+    } catch {}
+    const match = node.match(TASK_ID_PATTERN);
+    return match ? match[1] : null;
+  }
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      const found = findEmbeddedTaskId(item);
+      if (found)
+        return found;
+    }
+    return null;
+  }
+  if (typeof node === "object") {
+    const obj = node;
+    for (const key of ["taskId", "task_id"]) {
+      const direct = obj[key];
+      if (typeof direct === "string" || typeof direct === "number")
+        return String(direct);
+    }
+    for (const value of Object.values(obj)) {
+      const found = findEmbeddedTaskId(value);
+      if (found)
+        return found;
+    }
+  }
+  return null;
+}
+function normalizeTodo(todo) {
+  if (!todo || typeof todo !== "object")
+    return null;
+  const t = todo;
+  const out = {
+    content: typeof t.content === "string" ? t.content : "",
+    status: typeof t.status === "string" ? t.status : "pending",
+    activeForm: typeof t.activeForm === "string" ? t.activeForm : null
+  };
+  if (t.id != null)
+    out.id = t.id;
+  return out;
+}
+function emptyTranscript() {
+  return {
+    tools: [],
+    agents: [],
+    todos: [],
+    sessionStart: null,
+    statuslineActivityCount: 0,
+    invalidLineCount: 0,
+    lastValidEntryAt: null,
+    lastActivityAt: null
+  };
+}
+async function parseTranscript(transcriptPath) {
+  if (!transcriptPath || !existsSync48(transcriptPath))
+    return emptyTranscript();
+  const tools = new Map;
+  const agents = new Map;
+  let todos = [];
+  let sessionStart = null;
+  let activityCount = 0;
+  let invalidLines = 0;
+  let lastValidEntryAt = null;
+  let lastActivityAt = null;
+  const applyTaskUpdate = (input) => {
+    const { taskId, status: status2 } = input;
+    if (!taskId || !status2)
+      return;
+    const taskIdStr = String(taskId);
+    const natives = todos.filter((t) => t._source === NATIVE_TASK);
+    let target = natives.find((t) => String(t.id) === taskIdStr);
+    if (!target && /^\d+$/.test(taskIdStr)) {
+      target = natives[Number.parseInt(taskIdStr, 10) - 1];
+    }
+    if (!target)
+      return;
+    target.status = String(status2);
+    if ("activeForm" in input) {
+      target.activeForm = typeof input.activeForm === "string" ? input.activeForm : null;
+    }
+  };
+  const handleToolUse = (block, at) => {
+    const id = block.id;
+    const name2 = block.name;
+    if (typeof id !== "string" || typeof name2 !== "string")
+      return false;
+    const input = asRecord2(block.input);
+    switch (name2) {
+      case "Task":
+        agents.set(id, {
+          id,
+          type: stringOr(input.subagent_type, "unknown"),
+          model: stringOrNull(input.model),
+          description: stringOrNull(input.description),
+          status: "running",
+          startTime: at,
+          endTime: null
+        });
+        return true;
+      case "TodoWrite":
+        if (Array.isArray(input.todos)) {
+          todos = input.todos.map((raw) => ({ ...asRecord2(raw), _source: LEGACY_TODOWRITE }));
+        }
+        return true;
+      case "TaskCreate":
+        if (input.subject) {
+          todos.push({
+            id,
+            content: String(input.subject),
+            status: "pending",
+            activeForm: input.activeForm ? String(input.activeForm) : null,
+            _source: NATIVE_TASK,
+            _toolUseId: id
+          });
+        }
+        return true;
+      case "TaskUpdate":
+        applyTaskUpdate(input);
+        return true;
+      default:
+        tools.set(id, {
+          id,
+          name: name2,
+          target: extractTarget(name2, input),
+          status: "running",
+          startTime: at,
+          endTime: null
+        });
+        return false;
+    }
+  };
+  const handleToolResult = (block, at) => {
+    const id = block.tool_use_id;
+    if (typeof id !== "string")
+      return false;
+    const tool = tools.get(id);
+    if (tool) {
+      tool.status = block.is_error ? "error" : "completed";
+      tool.endTime = at;
+    }
+    let agentActivity = false;
+    const agent = agents.get(id);
+    if (agent) {
+      agent.status = "completed";
+      agent.endTime = at;
+      agentActivity = true;
+    }
+    const nativeTodo = todos.find((t) => t._source === NATIVE_TASK && t._toolUseId === id);
+    if (nativeTodo) {
+      const resolvedId = findEmbeddedTaskId(block.content);
+      if (resolvedId)
+        nativeTodo.id = resolvedId;
+    }
+    return agentActivity;
+  };
+  const processEntry = (entry) => {
+    const rawTs = entry.timestamp;
+    const parsed = rawTs == null ? new Date(Number.NaN) : new Date(rawTs);
+    const hasValidTime = !Number.isNaN(parsed.getTime());
+    const at = hasValidTime ? parsed : new Date;
+    lastValidEntryAt = at.toISOString();
+    if (sessionStart === null && hasValidTime)
+      sessionStart = at;
+    const content = asRecord2(entry.message).content;
+    if (!Array.isArray(content))
+      return;
+    let activity = false;
+    for (const rawBlock of content) {
+      const block = asRecord2(rawBlock);
+      if (block.type === "tool_use") {
+        if (handleToolUse(block, at)) {
+          activityCount++;
+          activity = true;
+        }
+      } else if (block.type === "tool_result") {
+        if (handleToolResult(block, at)) {
+          activityCount++;
+          activity = true;
+        }
+      }
+    }
+    if (activity)
+      lastActivityAt = at.toISOString();
+  };
+  await new Promise((resolve21) => {
+    let stream;
+    try {
+      stream = createReadStream4(transcriptPath, { encoding: "utf8" });
+    } catch {
+      resolve21();
+      return;
+    }
+    stream.on("error", () => resolve21());
+    const rl = createInterface2({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
+    rl.on("line", (line) => {
+      if (!line.trim())
+        return;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        invalidLines++;
+        return;
+      }
+      if (entry && typeof entry === "object")
+        processEntry(entry);
+    });
+    rl.on("error", () => resolve21());
+    rl.on("close", () => resolve21());
+  });
+  return {
+    tools: Array.from(tools.values()).slice(-MAX_TOOLS),
+    agents: Array.from(agents.values()).slice(-MAX_AGENTS),
+    todos: todos.map(normalizeTodo).filter((t) => t !== null),
+    sessionStart,
+    statuslineActivityCount: activityCount,
+    invalidLineCount: invalidLines,
+    lastValidEntryAt,
+    lastActivityAt
+  };
+}
+
+// src/domains/statusline/activity-snapshot.ts
+var MAX_AGENTS2 = 10;
+var WARM_SOURCES = new Set(["startup", "resume", "compact"]);
+function nowIso() {
+  return new Date().toISOString();
+}
+function asRecord3(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function stringOr2(value, fallback2) {
+  return typeof value === "string" && value ? value : fallback2;
+}
+function toIsoOrNull(value) {
+  if (!value)
+    return null;
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+function isoOr(value, fallback2) {
+  return toIsoOrNull(value) ?? fallback2;
+}
+function normalizeAgent(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const a3 = raw;
+  return {
+    id: a3.id != null ? String(a3.id) : null,
+    type: stringOr2(a3.type, "unknown"),
+    model: stringOr2(a3.model, null),
+    description: stringOr2(a3.description, null),
+    status: a3.status === "completed" ? "completed" : "running",
+    startTime: toIsoOrNull(a3.startTime),
+    endTime: toIsoOrNull(a3.endTime)
+  };
+}
+function normalizeTodo2(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const t = raw;
+  const todo = {
+    content: stringOr2(t.content, ""),
+    status: stringOr2(t.status, "pending"),
+    activeForm: stringOr2(t.activeForm, null)
+  };
+  if (t.id != null)
+    todo.id = String(t.id);
+  return todo;
+}
+function createEmptyActivitySnapshot(now = nowIso()) {
+  return { sessionStart: now, updatedAt: now, warmed: false, agents: [], todos: [] };
+}
+function sanitizeActivitySnapshot(snapshot) {
+  const now = nowIso();
+  if (!snapshot || typeof snapshot !== "object")
+    return createEmptyActivitySnapshot(now);
+  const s = snapshot;
+  const rawAgents = Array.isArray(s.agents) ? s.agents : [];
+  const rawTodos = Array.isArray(s.todos) ? s.todos : [];
+  return {
+    sessionStart: isoOr(s.sessionStart, now),
+    updatedAt: isoOr(s.updatedAt, now),
+    warmed: Boolean(s.warmed),
+    agents: rawAgents.map(normalizeAgent).filter((a3) => a3 !== null).slice(-MAX_AGENTS2),
+    todos: rawTodos.map(normalizeTodo2).filter((t) => t !== null)
+  };
+}
+function applyStatuslineEvent(snapshot, input, now) {
+  const base = sanitizeActivitySnapshot({ ...asRecord3(snapshot), updatedAt: now });
+  if (input.hook_event_name !== "SubagentStop")
+    return base;
+  const agentId = input.agent_id != null ? String(input.agent_id) : null;
+  const agentType = typeof input.agent_type === "string" ? input.agent_type : null;
+  if (!agentId && !agentType)
+    return base;
+  for (let i = base.agents.length - 1;i >= 0; i--) {
+    const agent = base.agents[i];
+    const matchesId = agentId != null && agent.id === agentId;
+    const matchesType = agentId == null && agentType != null && agent.status === "running" && agent.type === agentType;
+    if (matchesId || matchesType) {
+      agent.status = "completed";
+      agent.endTime = agent.endTime || now;
+      break;
+    }
+  }
+  return base;
+}
+function shouldPreserveExistingSnapshot(existing, parsed, transcript) {
+  if (!existing)
+    return false;
+  const existingHasActivity = existing.agents.length > 0 || existing.todos.length > 0;
+  if (!existingHasActivity || existing.warmed !== true)
+    return false;
+  const existingAt = Date.parse(existing.updatedAt);
+  const transcriptAt = Date.parse(transcript.lastActivityAt || transcript.lastValidEntryAt || "");
+  const bothDated = Number.isFinite(existingAt) && Number.isFinite(transcriptAt);
+  if (bothDated && existingAt >= transcriptAt)
+    return true;
+  if (transcript.invalidLineCount > 0) {
+    if (!bothDated)
+      return true;
+    return existingAt >= transcriptAt;
+  }
+  const parsedHasActivity = parsed.agents.length > 0 || parsed.todos.length > 0;
+  if (parsedHasActivity)
+    return false;
+  return transcript.statuslineActivityCount === 0;
+}
+function resolveTranscriptPath(input, cachedPath) {
+  const fromInput = input.transcript_path;
+  if (typeof fromInput === "string" && fromInput && existsSync49(fromInput))
+    return fromInput;
+  if (cachedPath && existsSync49(cachedPath))
+    return cachedPath;
+  return "";
+}
+function shouldWarmStatuslineCache(source, snapshot) {
+  if (!source || !WARM_SOURCES.has(source))
+    return false;
+  return snapshot?.warmed !== true;
+}
+async function refreshActivitySnapshot(input, sessionId) {
+  try {
+    if (!sessionId)
+      return;
+    const now = nowIso();
+    const existing = readActivity(sessionId);
+    const current = existing?.snapshot ?? createEmptyActivitySnapshot(now);
+    const existingPath = existing?.lastTranscriptPath ?? "";
+    const transcriptPath = resolveTranscriptPath(input, existingPath);
+    if (!transcriptPath) {
+      const next2 = sanitizeActivitySnapshot(applyStatuslineEvent(current, input, now));
+      writeActivity(sessionId, next2, existingPath);
+      return;
+    }
+    const transcript = await parseTranscript(transcriptPath);
+    const parsedSnapshot = applyStatuslineEvent({
+      sessionStart: transcript.sessionStart?.toISOString() || current.sessionStart || now,
+      updatedAt: now,
+      warmed: true,
+      agents: transcript.agents,
+      todos: transcript.todos
+    }, input, now);
+    const preserve = shouldPreserveExistingSnapshot(current, parsedSnapshot, transcript);
+    const next = sanitizeActivitySnapshot(preserve ? applyStatuslineEvent(current, input, now) : parsedSnapshot);
+    writeActivity(sessionId, next, preserve && existingPath ? existingPath : transcriptPath);
+  } catch {}
+}
+
+// src/domains/statusline/activity-cache.ts
+init_cache_dir();
+var ACTIVITY_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+var FILE_PREFIX = "statusline-activity-";
+var FILE_SUFFIX = ".json";
+var MAX_ID_LENGTH = 128;
+function fileNameFor(sessionId) {
+  const safe = sessionId.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, MAX_ID_LENGTH);
+  return `${FILE_PREFIX}${safe}${FILE_SUFFIX}`;
+}
+function readActivity(sessionId) {
+  if (!sessionId)
+    return null;
+  const raw = readCacheFileSafe(getStatuslineCachePath(fileNameFor(sessionId)));
+  if (!raw)
+    return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      snapshot: sanitizeActivitySnapshot(parsed.snapshot),
+      lastTranscriptPath: typeof parsed.lastTranscriptPath === "string" ? parsed.lastTranscriptPath : ""
+    };
+  } catch {
+    return null;
+  }
+}
+function writeActivity(sessionId, snapshot, lastTranscriptPath) {
+  if (!sessionId)
+    return false;
+  return writeCacheFileSafe(getStatuslineCachePath(fileNameFor(sessionId)), JSON.stringify({ snapshot, lastTranscriptPath }));
+}
+function cleanupStaleActivity(now = Date.now()) {
+  let entries;
+  try {
+    entries = readdirSync7(getStatuslineCacheDir());
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith(FILE_PREFIX) || !entry.endsWith(FILE_SUFFIX))
+      continue;
+    const full = join103(getStatuslineCacheDir(), entry);
+    try {
+      if (now - statSync8(full).mtimeMs > ACTIVITY_TTL_MS)
+        rmSync4(full, { force: true });
+    } catch {}
+  }
+}
+
+// src/domains/hooks/handlers/session-activity/handler.ts
+var ENABLE_GATE_KEY = "session-state";
+var TRACKED_TOOLS = new Set([
+  "Task",
+  "TaskCreate",
+  "TaskUpdate",
+  "TodoWrite"
+]);
+var RECORD_RESULT = { status: "record", timingMs: 0 };
+var NOOP_RESULT = { status: "no-op", timingMs: 0 };
+var sessionActivity = {
+  name: "session-activity",
+  category: "session",
+  policy: "record",
+  events: ["SessionStart", "PostToolUse", "Stop", "SubagentStop"],
+  matchers: {
+    SessionStart: "startup|resume|compact",
+    PostToolUse: "Task|TaskCreate|TaskUpdate|TodoWrite"
+  },
+  async run(input, ctx) {
+    try {
+      if (!isHandlerEnabled(ctx, ENABLE_GATE_KEY))
+        return NOOP_RESULT;
+      const sessionId = ctx.sessionId;
+      if (!sessionId)
+        return RECORD_RESULT;
+      switch (ctx.event) {
+        case "SessionStart": {
+          cleanupStaleActivity();
+          const source = typeof input.source === "string" ? input.source : "";
+          const existing = readActivity(sessionId)?.snapshot ?? null;
+          if (shouldWarmStatuslineCache(source, existing)) {
+            await refreshActivitySnapshot(input, sessionId);
+          }
+          return RECORD_RESULT;
+        }
+        case "PostToolUse": {
+          const tool = typeof input.tool_name === "string" ? input.tool_name : "";
+          if (TRACKED_TOOLS.has(tool))
+            await refreshActivitySnapshot(input, sessionId);
+          return RECORD_RESULT;
+        }
+        case "Stop":
+        case "SubagentStop":
+          await refreshActivitySnapshot(input, sessionId);
+          return RECORD_RESULT;
+        default:
+          return NOOP_RESULT;
+      }
+    } catch {
+      return NOOP_RESULT;
+    }
+  }
+};
+
 // src/domains/hooks/handlers/session-init/handler.ts
-import { mkdirSync as mkdirSync5 } from "node:fs";
-import { dirname as dirname28, join as join105 } from "node:path";
+import { mkdirSync as mkdirSync6 } from "node:fs";
+import { dirname as dirname28, join as join107 } from "node:path";
 
 // src/domains/hooks/handlers/_shared/project-detector.ts
-import { existsSync as existsSync48, readFileSync as readFileSync15 } from "node:fs";
-import { join as join102 } from "node:path";
+import { existsSync as existsSync50, readFileSync as readFileSync15 } from "node:fs";
+import { join as join104 } from "node:path";
 var LOCKFILE_PRIORITY = [
   { manager: "bun", files: ["bun.lockb", "bun.lock"] },
   { manager: "pnpm", files: ["pnpm-lock.yaml"] },
@@ -73333,14 +74217,14 @@ var APP_FRAMEWORKS = new Set([
 var WORKSPACE_MARKER_FILES = ["pnpm-workspace.yaml", "turbo.json", "lerna.json"];
 function fileExists(cwd2, name2) {
   try {
-    return existsSync48(join102(cwd2, name2));
+    return existsSync50(join104(cwd2, name2));
   } catch {
     return false;
   }
 }
 function readPackageJson(cwd2) {
   try {
-    const raw = readFileSync15(join102(cwd2, "package.json"), "utf8");
+    const raw = readFileSync15(join104(cwd2, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object")
       return parsed;
@@ -73424,26 +74308,26 @@ function detectProject(cwd2) {
 // src/domains/hooks/handlers/session-init/env-entries.ts
 import { createHash as createHash14 } from "node:crypto";
 import { platform as platform8, userInfo } from "node:os";
-import { join as join104 } from "node:path";
+import { join as join106 } from "node:path";
 
 // src/domains/hooks/handlers/session-init/plan-resolver.ts
-import { existsSync as existsSync49, readFileSync as readFileSync16, readdirSync as readdirSync7 } from "node:fs";
-import { join as join103 } from "node:path";
+import { existsSync as existsSync51, readFileSync as readFileSync16, readdirSync as readdirSync8 } from "node:fs";
+import { join as join105 } from "node:path";
 var MAX_PLAN_DIRS = 100;
 var MAX_PLAN_FILE_BYTES = 64 * 1024;
 function listPlanDirs(plansPath) {
   try {
-    if (!existsSync49(plansPath))
+    if (!existsSync51(plansPath))
       return [];
-    return readdirSync7(plansPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().slice(0, MAX_PLAN_DIRS);
+    return readdirSync8(plansPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().slice(0, MAX_PLAN_DIRS);
   } catch {
     return [];
   }
 }
 function planFileMentionsSession(planDir, sessionId) {
   try {
-    const planFile = join103(planDir, "plan.md");
-    if (!existsSync49(planFile))
+    const planFile = join105(planDir, "plan.md");
+    if (!existsSync51(planFile))
       return false;
     const body = readFileSync16(planFile, { encoding: "utf8" });
     if (body.length > MAX_PLAN_FILE_BYTES)
@@ -73457,7 +74341,7 @@ function resolveActivePlan(plansPath, sessionId) {
   if (!sessionId)
     return "";
   for (const name2 of listPlanDirs(plansPath)) {
-    const dir = join103(plansPath, name2);
+    const dir = join105(plansPath, name2);
     if (name2.includes(sessionId) || planFileMentionsSession(dir, sessionId)) {
       return dir;
     }
@@ -73478,7 +74362,7 @@ function resolveSuggestedPlan(plansPath, branch, branchPattern) {
     return "";
   for (const name2 of listPlanDirs(plansPath)) {
     if (name2.includes(slug))
-      return join103(plansPath, name2);
+      return join105(plansPath, name2);
   }
   return "";
 }
@@ -73532,11 +74416,11 @@ function buildEnvEntries(params) {
   const plan = config.plan ?? {};
   const locale = config.locale ?? {};
   const validation = plan.validation ?? {};
-  const settingsDir = join104(projectRoot, ".claude");
-  const docsPath = join104(projectRoot, paths.docs ?? "docs");
-  const plansPath = join104(projectRoot, paths.plans ?? "plans");
+  const settingsDir = join106(projectRoot, ".claude");
+  const docsPath = join106(projectRoot, paths.docs ?? "docs");
+  const plansPath = join106(projectRoot, paths.plans ?? "plans");
   const reportsDir = plan.reportsDir ?? "reports";
-  const reportsPath = join104(plansPath, reportsDir);
+  const reportsPath = join106(plansPath, reportsDir);
   const namingFormat = plan.namingFormat ?? "";
   const activePlan = resolveActivePlan(plansPath, ctx.sessionId);
   const suggestedPlan = resolveSuggestedPlan(plansPath, branch, plan.resolution?.branchPattern ?? "");
@@ -73585,11 +74469,12 @@ function numberString(value) {
 // src/domains/hooks/handlers/session-init/git-facts.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 var GIT_TIMEOUT_MS = 800;
-function runGit(cwd2, args) {
+var GIT_STATUS_TIMEOUT_MS = 500;
+function runGit(cwd2, args, timeoutMs = GIT_TIMEOUT_MS) {
   try {
     const out = execFileSync2("git", ["-C", cwd2, ...args], {
       encoding: "utf8",
-      timeout: GIT_TIMEOUT_MS,
+      timeout: timeoutMs,
       stdio: ["ignore", "pipe", "ignore"]
     });
     return out.trim();
@@ -73597,13 +74482,20 @@ function runGit(cwd2, args) {
     return "";
   }
 }
-function resolveGitRoot(cwd2) {
-  return runGit(cwd2, ["rev-parse", "--show-toplevel"]);
+function resolveGitRoot(cwd2, timeoutMs) {
+  return runGit(cwd2, ["rev-parse", "--show-toplevel"], timeoutMs);
 }
-function resolveGitBranch(cwd2) {
-  const branch = runGit(cwd2, ["rev-parse", "--abbrev-ref", "HEAD"]);
+function resolveGitBranch(cwd2, timeoutMs) {
+  const branch = runGit(cwd2, ["rev-parse", "--abbrev-ref", "HEAD"], timeoutMs);
   return branch === "HEAD" ? "" : branch;
 }
+var GIT_RENDER_TIMEOUT_MS = GIT_STATUS_TIMEOUT_MS;
+function resolveGitBranchOrCommit(cwd2, timeoutMs) {
+  const current = runGit(cwd2, ["branch", "--show-current"], timeoutMs);
+  if (current)
+    return current;
+  return runGit(cwd2, ["rev-parse", "--short", "HEAD"], timeoutMs);
+}
 
 // src/domains/hooks/handlers/session-init/handler.ts
 var KNOWN_SOURCES = new Set(["startup", "resume", "clear", "compact"]);
@@ -73617,11 +74509,11 @@ function resolveEnvFilePath(settingsDir) {
   const override = process.env.CLAUDE_ENV_FILE;
   if (override && override.trim().length > 0)
     return override;
-  return join105(settingsDir, DEFAULT_ENV_FILE);
+  return join107(settingsDir, DEFAULT_ENV_FILE);
 }
 function persistEntries(envFilePath, entries) {
   try {
-    mkdirSync5(dirname28(envFilePath), { recursive: true });
+    mkdirSync6(dirname28(envFilePath), { recursive: true });
     writeEnvFile(envFilePath, entries);
     return true;
   } catch {
@@ -73672,9 +74564,9 @@ var sessionInit = {
 // src/domains/hooks/handlers/_shared/context-assembler.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { createHash as createHash15 } from "node:crypto";
-import { existsSync as existsSync50, mkdirSync as mkdirSync6, readFileSync as readFileSync17, rmSync as rmSync3, statSync as statSync8, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync52, mkdirSync as mkdirSync7, readFileSync as readFileSync17, rmSync as rmSync5, statSync as statSync9, writeFileSync as writeFileSync10 } from "node:fs";
 import { homedir as homedir27, platform as platform9, tmpdir as tmpdir4 } from "node:os";
-import { basename as basename18, join as join106, resolve as resolve21 } from "node:path";
+import { basename as basename18, join as join108, resolve as resolve21 } from "node:path";
 var INJECTED_TTL_MS = 12 * 60 * 60 * 1000;
 var RESERVATION_TTL_MS = 60 * 1000;
 function gitBranch(dir) {
@@ -73751,16 +74643,16 @@ function scopeKey(baseDir) {
   return `${slug}-${hash}`;
 }
 function stateDir() {
-  return join106(tmpdir4(), "takumi-context-throttle");
+  return join108(tmpdir4(), "takumi-context-throttle");
 }
 function stateFile(sessionId, scope, transcriptPath) {
   const key = `${sessionId}\x00${scope}\x00${transcriptPath ?? ""}`;
   const hash = createHash15("sha256").update(key).digest("hex").slice(0, 32);
-  return join106(stateDir(), `${hash}.json`);
+  return join108(stateDir(), `${hash}.json`);
 }
 function readState(file) {
   try {
-    if (!existsSync50(file))
+    if (!existsSync52(file))
       return null;
     return JSON.parse(readFileSync17(file, "utf8"));
   } catch {
@@ -73768,14 +74660,14 @@ function readState(file) {
   }
 }
 function writeState(file, state) {
-  mkdirSync6(stateDir(), { recursive: true });
-  writeFileSync9(file, JSON.stringify(state), "utf8");
+  mkdirSync7(stateDir(), { recursive: true });
+  writeFileSync10(file, JSON.stringify(state), "utf8");
 }
 function transcriptSize(transcriptPath) {
   if (!transcriptPath)
     return 0;
   try {
-    return statSync8(transcriptPath).size;
+    return statSync9(transcriptPath).size;
   } catch {
     return 0;
   }
@@ -73820,14 +74712,14 @@ function clearPending(sessionId, scope, transcriptPath) {
     if (state.injectedAt) {
       writeState(file, { ...state, pending: false, reservedAt: undefined });
     } else {
-      rmSync3(file, { force: true });
+      rmSync5(file, { force: true });
     }
   } catch {}
 }
 function resolveSkillsVenv(_cwd) {
-  const base = join106(homedir27(), ".claude", "skills", ".venv");
-  const interpreter = platform9() === "win32" ? join106(base, "Scripts", "python.exe") : join106(base, "bin", "python3");
-  return existsSync50(interpreter) ? interpreter : null;
+  const base = join108(homedir27(), ".claude", "skills", ".venv");
+  const interpreter = platform9() === "win32" ? join108(base, "Scripts", "python.exe") : join108(base, "bin", "python3");
+  return existsSync52(interpreter) ? interpreter : null;
 }
 
 // src/domains/hooks/handlers/session-prompt-context/handler.ts
@@ -73865,12 +74757,12 @@ var sessionPromptContext = {
 };
 
 // src/domains/hooks/handlers/session-subagent-init/context-block.ts
-import { join as join108 } from "node:path";
+import { join as join110 } from "node:path";
 
 // src/domains/hooks/handlers/session-subagent-init/context-sources.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { readdirSync as readdirSync8, statSync as statSync9 } from "node:fs";
-import { isAbsolute as isAbsolute4, join as join107, resolve as resolve22 } from "node:path";
+import { readdirSync as readdirSync9, statSync as statSync10 } from "node:fs";
+import { isAbsolute as isAbsolute4, join as join109, resolve as resolve22 } from "node:path";
 var MAX_DOCS_FILES = 15;
 var MAX_DOCS_SUBDIRS = 5;
 function gitFacts(dir) {
@@ -73902,16 +74794,16 @@ function planDirTemplate(format, dateStr) {
 }
 function detectPlan(plansAbs) {
   try {
-    const entries = readdirSync8(plansAbs, { withFileTypes: true });
+    const entries = readdirSync9(plansAbs, { withFileTypes: true });
     let best = null;
     for (const e2 of entries) {
       if (!e2.isDirectory())
         continue;
-      const dir = join107(plansAbs, e2.name);
+      const dir = join109(plansAbs, e2.name);
       try {
-        if (!readdirSync8(dir).includes("plan.md"))
+        if (!readdirSync9(dir).includes("plan.md"))
           continue;
-        const mtime = statSync9(join107(dir, "plan.md")).mtimeMs;
+        const mtime = statSync10(join109(dir, "plan.md")).mtimeMs;
         if (!best || mtime > best.mtime)
           best = { name: e2.name, mtime };
       } catch {}
@@ -73923,7 +74815,7 @@ function detectPlan(plansAbs) {
 }
 function docsCatalogue(docsAbs) {
   try {
-    const entries = readdirSync8(docsAbs, { withFileTypes: true });
+    const entries = readdirSync9(docsAbs, { withFileTypes: true });
     const files = entries.filter((e2) => e2.isFile() && e2.name.toLowerCase().endsWith(".md")).map((e2) => e2.name).sort();
     const subdirs = entries.filter((e2) => e2.isDirectory()).map((e2) => e2.name).sort();
     const lines = [];
@@ -73934,7 +74826,7 @@ function docsCatalogue(docsAbs) {
     for (const d3 of subdirs.slice(0, MAX_DOCS_SUBDIRS)) {
       let count = 0;
       try {
-        count = readdirSync8(join107(docsAbs, d3)).length;
+        count = readdirSync9(join109(docsAbs, d3)).length;
       } catch {}
       lines.push(`- ${d3}/ (${count} entries)`);
     }
@@ -73978,11 +74870,11 @@ function buildSubagentContext(input, ctx) {
   const agentId = strField(input, "agent_id") || "unknown";
   const plansAbs = abs(base, cfg.paths?.plans?.trim() || "plans");
   const docsAbs = abs(base, cfg.paths?.docs?.trim() || "docs");
-  const reportsAbs = join108(plansAbs, cfg.plan?.reportsDir?.trim() || "reports");
+  const reportsAbs = join110(plansAbs, cfg.plan?.reportsDir?.trim() || "reports");
   const dateStr = stamp(cfg.plan?.dateFormat?.trim() || "YYMMDD-HHmm", new Date);
   const namingFormat = cfg.plan?.namingFormat?.trim() || "{date}-{slug}";
-  const planDir = join108(plansAbs, planDirTemplate(namingFormat, dateStr));
-  const reportFile = join108(reportsAbs, `${agentKey}-${dateStr}-{slug}-report.md`);
+  const planDir = join110(plansAbs, planDirTemplate(namingFormat, dateStr));
+  const reportFile = join110(reportsAbs, `${agentKey}-${dateStr}-{slug}-report.md`);
   const activePlan = detectPlan(plansAbs);
   const venv = resolveSkillsVenv(effectiveCwd);
   const respLang = cfg.locale?.responseLanguage?.trim() || null;
@@ -74060,12 +74952,12 @@ var sessionSubagentInit = {
 // src/domains/hooks/handlers/session-wip-checkpoint/handler.ts
 import { execFileSync as execFileSync5 } from "node:child_process";
 var CONFIG_KEY5 = "precompact-guard";
-var GIT_STATUS_TIMEOUT_MS = 800;
+var GIT_STATUS_TIMEOUT_MS2 = 800;
 function countUncommittedEntries(cwd2) {
   try {
     const stdout = execFileSync5("git", ["status", "--porcelain"], {
       cwd: cwd2,
-      timeout: GIT_STATUS_TIMEOUT_MS,
+      timeout: GIT_STATUS_TIMEOUT_MS2,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       windowsHide: true
@@ -74102,6 +74994,69 @@ var sessionWipCheckpoint = {
   }
 };
 
+// src/domains/hooks/handlers/usage-cache/handler.ts
+import { spawn as spawn4 } from "node:child_process";
+init_usage_credential();
+init_usage_limits_cache();
+var ENABLE_GATE_KEY2 = "usage-context-awareness";
+var REFRESH_INTERVAL_PROMPT_MS = 60000;
+var REFRESH_INTERVAL_TOOL_MS = 300000;
+var RECORD_RESULT2 = { status: "record", timingMs: 0 };
+var NOOP_RESULT2 = { status: "no-op", timingMs: 0 };
+function isPromptEvent(event) {
+  return event === "SessionStart" || event === "UserPromptSubmit";
+}
+function decideUsageRefresh(ctx, event) {
+  if (!isHandlerEnabled(ctx, ENABLE_GATE_KEY2))
+    return "disabled";
+  if (hasAnthropicRuntimeOverride())
+    return "override";
+  const interval = isPromptEvent(event) ? REFRESH_INTERVAL_PROMPT_MS : REFRESH_INTERVAL_TOOL_MS;
+  return getCacheAgeMs(readUsageCache()) >= interval ? "refresh" : "throttled";
+}
+function spawnRefresh(ctx) {
+  try {
+    const { command, prefixArgs } = resolveInvocationPrefix();
+    const args = [...prefixArgs, "statusline", "--refresh-usage-cache"];
+    if (ctx.runtimeFlags?.debug)
+      args.push("--debug");
+    const child = spawn4(command, args, {
+      detached: true,
+      stdio: "ignore",
+      env: buildChildEnv()
+    });
+    child.on("error", (err) => {
+      hookLog("usage_cache_refresh", { spawn_error: err.message });
+    });
+    child.unref();
+  } catch (err) {
+    hookLog("usage_cache_refresh", {
+      spawn_error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+var usageCache = {
+  name: "perf-usage-cache",
+  category: "perf",
+  policy: "record",
+  events: ["SessionStart", "UserPromptSubmit", "PostToolUse"],
+  installAgents: ["claude"],
+  run(_input, ctx) {
+    try {
+      if (ctx.agent !== "claude")
+        return NOOP_RESULT2;
+      const decision = decideUsageRefresh(ctx, ctx.event);
+      if (decision === "disabled")
+        return NOOP_RESULT2;
+      if (decision === "refresh")
+        spawnRefresh(ctx);
+      return RECORD_RESULT2;
+    } catch {
+      return NOOP_RESULT2;
+    }
+  }
+};
+
 // src/domains/hooks/handlers/registry.ts
 var HOOK_HANDLERS = [
   guardJailbreak,
@@ -74115,7 +75070,9 @@ var HOOK_HANDLERS = [
   conventionQualityGate,
   extensionSkill,
   metricsRecord,
-  metricsFlush
+  metricsFlush,
+  usageCache,
+  sessionActivity
 ];
 function shortHandlerName(handler) {
   const prefix = `${handler.category}-`;
@@ -74588,7 +75545,7 @@ init_hooks_settings_merger();
 
 // src/commands/portable/settings-write-with-confirm.ts
 init_safe_prompts();
-import { existsSync as existsSync51, mkdirSync as mkdirSync7, readFileSync as readFileSync18, renameSync as renameSync3, rmSync as rmSync4, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync53, mkdirSync as mkdirSync8, readFileSync as readFileSync19, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync11 } from "node:fs";
 import { dirname as dirname29 } from "node:path";
 
 // node_modules/diff/libesm/diff/base.js
@@ -75761,11 +76718,11 @@ var EMPTY_RESULT = (status2) => ({
   backupPath: null
 });
 function readCurrent(path10) {
-  if (!existsSync51(path10))
+  if (!existsSync53(path10))
     return { kind: "missing" };
   let raw = "";
   try {
-    raw = readFileSync18(path10, "utf8");
+    raw = readFileSync19(path10, "utf8");
     const parsed = JSON.parse(raw);
     return { kind: "ok", raw, parsed };
   } catch {
@@ -75792,13 +76749,13 @@ function diffStats(diff) {
   return { additions, deletions };
 }
 function atomicWrite2(path10, contents, backupPath) {
-  mkdirSync7(dirname29(path10), { recursive: true });
+  mkdirSync8(dirname29(path10), { recursive: true });
   const tmp = `${path10}.tmp`;
   try {
-    writeFileSync10(tmp, contents);
-    renameSync3(tmp, path10);
+    writeFileSync11(tmp, contents);
+    renameSync4(tmp, path10);
   } catch (err) {
-    rmSync4(tmp, { force: true });
+    rmSync6(tmp, { force: true });
     const trailer = backupPath ? `. Backup preserved at: ${backupPath}` : "";
     throw new Error(`Failed to write ${path10}: ${err instanceof Error ? err.message : String(err)}${trailer}`);
   }
@@ -75807,7 +76764,7 @@ function writeBackup(path10, raw) {
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const backupPath = `${path10}.${timestamp}.bak`;
   try {
-    writeFileSync10(backupPath, raw);
+    writeFileSync11(backupPath, raw);
     return backupPath;
   } catch {
     return null;
@@ -75878,18 +76835,18 @@ init_dist2();
 // src/commands/hooks/lib/agent-target-picker.ts
 init_safe_prompts();
 init_dist2();
-import { existsSync as existsSync52 } from "node:fs";
+import { existsSync as existsSync54 } from "node:fs";
 
 // src/commands/hooks/lib/settings-path-resolver.ts
 import { lstatSync as lstatSync3, realpathSync as realpathSync3 } from "node:fs";
-import { homedir as homedir28 } from "node:os";
-import { join as join109 } from "node:path";
+import { homedir as homedir29 } from "node:os";
+import { join as join112 } from "node:path";
 function rawPath(agent, global3) {
-  const root = global3 ? homedir28() : process.cwd();
+  const root = global3 ? homedir29() : process.cwd();
   if (agent === "claude") {
-    return join109(root, ".claude", "settings.json");
+    return join112(root, ".claude", "settings.json");
   }
-  return join109(root, ".codex", "hooks.json");
+  return join112(root, ".codex", "hooks.json");
 }
 function resolveSettingsPath(agent, options2 = {}) {
   const originalPath = rawPath(agent, Boolean(options2.global));
@@ -75917,7 +76874,7 @@ function probe(global3) {
     return {
       agent,
       path: location2.realPath,
-      exists: existsSync52(location2.realPath)
+      exists: existsSync54(location2.realPath)
     };
   });
 }
@@ -76020,6 +76977,8 @@ function planEntry(handler, event, agent, bin, flags) {
 function buildHookSection(agent, bin, flags = {}, handlers3 = HOOK_HANDLERS) {
   const section = {};
   for (const handler of handlers3) {
+    if (handler.installAgents && !handler.installAgents.includes(agent))
+      continue;
     for (const event of handler.events) {
       const planned = planEntry(handler, event, agent, bin, flags);
       if (!planned)
@@ -76038,9 +76997,82 @@ function buildHookSection(agent, bin, flags = {}, handlers3 = HOOK_HANDLERS) {
   return section;
 }
 
+// src/commands/hooks/lib/install-statusline.ts
+var USAGE_HANDLER = "perf-usage-cache";
+var ACTIVITY_HANDLER = "session-activity";
+var USAGE_PRODUCERS = ["usage-quota-cache-refresh.cjs", "usage-context-awareness.cjs"];
+var ACTIVITY_PRODUCER = "session-state.cjs";
+var ACTIVITY_PRODUCER_EVENT = "PostToolUse";
+function buildStatuslineCommand(bin, flags) {
+  const parts = [bin || DEFAULT_HOOK_BIN, "statusline"];
+  if (flags.debug)
+    parts.push("--debug");
+  return parts.join(" ");
+}
+function strippedBasenamesForEvent(event, installsUsage, installsActivity) {
+  const out = [];
+  if (installsUsage)
+    out.push(...USAGE_PRODUCERS);
+  if (installsActivity && event === ACTIVITY_PRODUCER_EVENT)
+    out.push(ACTIVITY_PRODUCER);
+  return out;
+}
+function commandReferences(command, basename19) {
+  return typeof command === "string" && command.includes(basename19);
+}
+function isCliStatuslineCommand(command) {
+  return /^\S+\s+statusline(\s|$)/.test(command);
+}
+function shouldSetStatusline(command) {
+  if (typeof command !== "string" || command.trim() === "")
+    return true;
+  return command.includes("statusline.cjs") || isCliStatuslineCommand(command);
+}
+function installStatusline(settings, opts) {
+  if (opts.agent !== "claude")
+    return settings;
+  const installsUsage = opts.handlerNames.has(USAGE_HANDLER);
+  const installsActivity = opts.handlerNames.has(ACTIVITY_HANDLER);
+  if (!installsUsage && !installsActivity)
+    return settings;
+  const next = { ...settings };
+  if (installsUsage && installsActivity) {
+    const existing = next.statusLine;
+    if (shouldSetStatusline(existing?.command)) {
+      const command = buildStatuslineCommand(opts.bin, opts.flags ?? {});
+      next.statusLine = { type: "command", ...existing ?? {}, command };
+    }
+  }
+  const hooks = next.hooks;
+  if (hooks && typeof hooks === "object") {
+    const rebuilt = {};
+    for (const [event, groups] of Object.entries(hooks)) {
+      if (!Array.isArray(groups)) {
+        rebuilt[event] = groups;
+        continue;
+      }
+      const strip = strippedBasenamesForEvent(event, installsUsage, installsActivity);
+      const keptGroups = [];
+      for (const group of groups) {
+        if (!Array.isArray(group.hooks)) {
+          keptGroups.push(group);
+          continue;
+        }
+        const keptHooks = group.hooks.filter((entry) => !strip.some((basename19) => commandReferences(entry.command, basename19)));
+        if (keptHooks.length > 0)
+          keptGroups.push({ ...group, hooks: keptHooks });
+      }
+      if (keptGroups.length > 0)
+        rebuilt[event] = keptGroups;
+    }
+    next.hooks = rebuilt;
+  }
+  return next;
+}
+
 // src/commands/hooks/uninstall-handler.ts
 init_logger();
-import { existsSync as existsSync53, mkdirSync as mkdirSync8, readFileSync as readFileSync19, renameSync as renameSync4, rmSync as rmSync5, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync55, mkdirSync as mkdirSync9, readFileSync as readFileSync20, renameSync as renameSync5, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "node:fs";
 import { dirname as dirname30 } from "node:path";
 var AGENT_DISPLAY2 = {
   claude: "Claude Code",
@@ -76082,13 +77114,13 @@ function pruneHooksSection(hooks, agent) {
   return { pruned, removed };
 }
 function writeAtomic(path10, contents) {
-  mkdirSync8(dirname30(path10), { recursive: true });
+  mkdirSync9(dirname30(path10), { recursive: true });
   const tmp = `${path10}.tmp`;
   try {
-    writeFileSync11(tmp, contents);
-    renameSync4(tmp, path10);
+    writeFileSync12(tmp, contents);
+    renameSync5(tmp, path10);
   } catch (err) {
-    rmSync5(tmp, { force: true });
+    rmSync7(tmp, { force: true });
     throw err;
   }
 }
@@ -76100,12 +77132,12 @@ async function uninstallForAgent(agent, options2) {
     removed: 0,
     dryRun: Boolean(options2.dryRun)
   };
-  if (!existsSync53(location2.realPath)) {
+  if (!existsSync55(location2.realPath)) {
     return result;
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync19(location2.realPath, "utf8"));
+    parsed = JSON.parse(readFileSync20(location2.realPath, "utf8"));
   } catch {
     logger.warning(`[hooks] could not parse ${location2.realPath}; uninstall skipped to avoid clobbering`);
     return result;
@@ -76169,11 +77201,13 @@ function eventsSummary(section) {
 }
 async function installForAgent(agent, options2, interactive, useStepUI) {
   const location2 = resolveSettingsPath(agent, { global: options2.global });
+  const handlers3 = selectHandlersForInstall(options2.categories);
   const section = buildHookSection(agent, options2.bin, {
     noDetach: options2.noDetach,
     debug: options2.debug
-  }, selectHandlersForInstall(options2.categories));
+  }, handlers3);
   const entriesPlanned = countEntries(section);
+  const handlerNames = new Set(handlers3.map((h2) => h2.name));
   const result = await writeSettingsWithConfirm({
     path: location2.realPath,
     label: `${AGENT_DISPLAY3[agent]} settings`,
@@ -76182,7 +77216,13 @@ async function installForAgent(agent, options2, interactive, useStepUI) {
       const existingHooks = safeCurrent.hooks ?? {};
       const { pruned } = pruneHooksSection(existingHooks, agent);
       const purged = { ...safeCurrent, hooks: pruned };
-      return mergeHooksObject(purged, section);
+      const merged = mergeHooksObject(purged, section);
+      return installStatusline(merged, {
+        agent,
+        handlerNames,
+        bin: options2.bin,
+        flags: { noDetach: options2.noDetach, debug: options2.debug }
+      });
     },
     missingFile: resolveMissingFileMode(options2, interactive),
     yes: options2.yes,
@@ -76319,7 +77359,7 @@ async function installHook(options2) {
 // src/commands/hooks/status.ts
 init_takumi_config_manager();
 init_logger();
-import { existsSync as existsSync54, readFileSync as readFileSync20 } from "node:fs";
+import { existsSync as existsSync56, readFileSync as readFileSync21 } from "node:fs";
 var AGENT_DISPLAY4 = { claude: "Claude Code", codex: "Codex" };
 var NEW_SHAPE = /\bhook-exec\b.*--hook\s+(guard|session|convention|extension|metrics|perf)\.(\S+).*-a\s+(claude|codex)(?![\w-])/;
 var LEGACY_SHAPE = /\bhooks\s+(?:session-start|user-prompt-submit|pre-tool-use|post-tool-use|stop|session-end)\s+-a\s+(claude|codex)(?![\w-])/;
@@ -76349,7 +77389,7 @@ async function statusForAgent(agent, options2, cwd2 = process.cwd()) {
   const result = {
     agent,
     settingsPath: location2.realPath,
-    exists: existsSync54(location2.realPath),
+    exists: existsSync56(location2.realPath),
     shape: "none",
     byCategory: {},
     newEntryCount: 0,
@@ -76360,7 +77400,7 @@ async function statusForAgent(agent, options2, cwd2 = process.cwd()) {
     return result;
   let hooks;
   try {
-    const parsed = JSON.parse(readFileSync20(location2.realPath, "utf8"));
+    const parsed = JSON.parse(readFileSync21(location2.realPath, "utf8"));
     hooks = parsed.hooks ?? {};
   } catch {
     return result;
@@ -77350,7 +78390,7 @@ async function promptFreshConfirmation(targetPath, analysis) {
 // src/domains/ui/prompts/confirmation-prompts.ts
 init_output_manager();
 init_safe_prompts();
-import { platform as platform10 } from "node:os";
+import { platform as platform11 } from "node:os";
 
 // src/types/skills-dependencies.ts
 var SKILLS_DEPENDENCIES = {
@@ -77412,7 +78452,7 @@ async function promptSkillsInstallation() {
   if (output.isJson()) {
     return false;
   }
-  const isWindows2 = platform10() === "win32";
+  const isWindows2 = platform11() === "win32";
   const pythonDeps = formatDependencyList(SKILLS_DEPENDENCIES.python);
   const systemDeps = formatDependencyList(SKILLS_DEPENDENCIES.system);
   const nodeDeps = formatDependencyList(SKILLS_DEPENDENCIES.node);
@@ -77590,7 +78630,7 @@ init_logger();
 init_takumi_constants();
 var import_fs_extra33 = __toESM(require_lib(), 1);
 var import_semver5 = __toESM(require_semver2(), 1);
-import { join as join110 } from "node:path";
+import { join as join113 } from "node:path";
 function evaluateCliVersionGate(input) {
   const min = typeof input.minCliVersion === "string" ? input.minCliVersion.trim() : undefined;
   if (!min)
@@ -77611,7 +78651,7 @@ function evaluateCliVersionGate(input) {
 }
 async function readKitMinCliVersion(extractDir) {
   try {
-    const resolved = await findManifestPath(join110(extractDir, ".claude"));
+    const resolved = await findManifestPath(join113(extractDir, ".claude"));
     if (!resolved)
       return;
     const raw = await import_fs_extra33.readFile(resolved.path, "utf-8");
@@ -77803,7 +78843,7 @@ init_logger();
 init_safe_spinner();
 import { mkdir as mkdir25, stat as stat11 } from "node:fs/promises";
 import { tmpdir as tmpdir5 } from "node:os";
-import { join as join116 } from "node:path";
+import { join as join119 } from "node:path";
 
 // src/shared/temp-cleanup.ts
 init_logger();
@@ -77820,9 +78860,9 @@ var import_ignore6 = __toESM(require_ignore(), 1);
 // src/domains/installation/download/file-downloader.ts
 init_logger();
 init_output_manager();
-import { createWriteStream as createWriteStream2, rmSync as rmSync6 } from "node:fs";
+import { createWriteStream as createWriteStream2, rmSync as rmSync8 } from "node:fs";
 import { mkdir as mkdir21 } from "node:fs/promises";
-import { join as join111 } from "node:path";
+import { join as join114 } from "node:path";
 
 // src/shared/progress-bar.ts
 init_output_manager();
@@ -78032,7 +79072,7 @@ var MAX_DOWNLOAD_SIZE = 500 * 1024 * 1024;
 class FileDownloader {
   async downloadAsset(asset, destDir) {
     try {
-      const destPath = join111(destDir, asset.name);
+      const destPath = join114(destDir, asset.name);
       await mkdir21(destDir, { recursive: true });
       output.info(`Downloading ${asset.name} (${formatBytes(asset.size)})...`);
       logger.verbose("Download details", {
@@ -78090,7 +79130,7 @@ class FileDownloader {
           fileStream.end();
           await new Promise((resolve24) => fileStream.once("close", resolve24));
           try {
-            rmSync6(destPath, { force: true });
+            rmSync8(destPath, { force: true });
           } catch (cleanupError) {
             const errorMsg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
             logger.debug(`Failed to clean up partial download ${destPath}: ${errorMsg}`);
@@ -78104,7 +79144,7 @@ class FileDownloader {
         fileStream.end();
         await new Promise((resolve24) => fileStream.once("close", resolve24));
         try {
-          rmSync6(destPath, { force: true });
+          rmSync8(destPath, { force: true });
         } catch (cleanupError) {
           const errorMsg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
           logger.debug(`Failed to clean up partial download ${destPath}: ${errorMsg}`);
@@ -78117,7 +79157,7 @@ class FileDownloader {
   }
   async downloadFile(params) {
     const { url, name: name2, size, destDir, token } = params;
-    const destPath = join111(destDir, name2);
+    const destPath = join114(destDir, name2);
     await mkdir21(destDir, { recursive: true });
     output.info(`Downloading ${name2}${size ? ` (${formatBytes(size)})` : ""}...`);
     const headers = {};
@@ -78187,7 +79227,7 @@ class FileDownloader {
         fileStream.end();
         await new Promise((resolve24) => fileStream.once("close", resolve24));
         try {
-          rmSync6(destPath, { force: true });
+          rmSync8(destPath, { force: true });
         } catch (cleanupError) {
           const errorMsg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
           logger.debug(`Failed to clean up partial download ${destPath}: ${errorMsg}`);
@@ -78205,7 +79245,7 @@ class FileDownloader {
       fileStream.end();
       await new Promise((resolve24) => fileStream.once("close", resolve24));
       try {
-        rmSync6(destPath, { force: true });
+        rmSync8(destPath, { force: true });
       } catch (cleanupError) {
         const errorMsg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
         logger.debug(`Failed to clean up partial download ${destPath}: ${errorMsg}`);
@@ -78220,7 +79260,7 @@ init_logger();
 init_types2();
 import { constants as constants3 } from "node:fs";
 import { access as access3, readdir as readdir26 } from "node:fs/promises";
-import { join as join112 } from "node:path";
+import { join as join115 } from "node:path";
 async function validateExtraction(extractDir) {
   try {
     const entries = await readdir26(extractDir, { encoding: "utf8" });
@@ -78232,7 +79272,7 @@ async function validateExtraction(extractDir) {
     const missingPaths = [];
     for (const path10 of criticalPaths) {
       try {
-        await access3(join112(extractDir, path10), constants3.F_OK);
+        await access3(join115(extractDir, path10), constants3.F_OK);
         logger.debug(`Found: ${path10}`);
       } catch {
         logger.warning(`Expected path not found: ${path10}`);
@@ -78254,7 +79294,7 @@ async function validateExtraction(extractDir) {
 // src/domains/installation/extraction/tar-extractor.ts
 init_logger();
 import { copyFile as copyFile5, mkdir as mkdir23, readdir as readdir28, rm as rm8, stat as stat9 } from "node:fs/promises";
-import { join as join114 } from "node:path";
+import { join as join117 } from "node:path";
 
 // node_modules/tar/dist/esm/index.min.js
 import Kr from "events";
@@ -81467,7 +82507,7 @@ function decodeFilePath(path10) {
 init_logger();
 init_types2();
 import { copyFile as copyFile4, lstat as lstat8, mkdir as mkdir22, readdir as readdir27 } from "node:fs/promises";
-import { join as join113, relative as relative17 } from "node:path";
+import { join as join116, relative as relative17 } from "node:path";
 async function withRetry2(fn2, retries = 3) {
   for (let i = 0;i < retries; i++) {
     try {
@@ -81489,8 +82529,8 @@ async function moveDirectoryContents(sourceDir, destDir, shouldExclude, sizeTrac
   await mkdir22(destDir, { recursive: true });
   const entries = await readdir27(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
-    const sourcePath = join113(sourceDir, entry);
-    const destPath = join113(destDir, entry);
+    const sourcePath = join116(sourceDir, entry);
+    const destPath = join116(destDir, entry);
     const relativePath = relative17(sourceDir, sourcePath);
     if (!isPathSafe(destDir, destPath)) {
       logger.warning(`Skipping unsafe path: ${relativePath}`);
@@ -81517,8 +82557,8 @@ async function copyDirectory(sourceDir, destDir, shouldExclude, sizeTracker) {
   await mkdir22(destDir, { recursive: true });
   const entries = await readdir27(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
-    const sourcePath = join113(sourceDir, entry);
-    const destPath = join113(destDir, entry);
+    const sourcePath = join116(sourceDir, entry);
+    const destPath = join116(destDir, entry);
     const relativePath = relative17(sourceDir, sourcePath);
     if (!isPathSafe(destDir, destPath)) {
       logger.warning(`Skipping unsafe path: ${relativePath}`);
@@ -81573,7 +82613,7 @@ class TarExtractor {
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
-        const rootPath = join114(tempExtractDir, rootEntry);
+        const rootPath = join117(tempExtractDir, rootEntry);
         const rootStat = await stat9(rootPath);
         if (rootStat.isDirectory()) {
           const rootContents = await readdir28(rootPath, { encoding: "utf8" });
@@ -81589,7 +82629,7 @@ class TarExtractor {
           }
         } else {
           await mkdir23(destDir, { recursive: true });
-          await copyFile5(rootPath, join114(destDir, rootEntry));
+          await copyFile5(rootPath, join117(destDir, rootEntry));
         }
       } else {
         logger.debug("Multiple root entries - moving all");
@@ -81610,7 +82650,7 @@ class TarExtractor {
 init_logger();
 import { createWriteStream as createWriteStream3 } from "node:fs";
 import { chmod as chmod4, copyFile as copyFile6, mkdir as mkdir24, readdir as readdir29, rm as rm9, stat as stat10 } from "node:fs/promises";
-import { dirname as dirname31, join as join115, resolve as resolve24 } from "node:path";
+import { dirname as dirname31, join as join118, resolve as resolve24 } from "node:path";
 import { pipeline } from "node:stream/promises";
 import yauzl from "yauzl-promise";
 class ZipExtractor {
@@ -81624,7 +82664,7 @@ class ZipExtractor {
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
-        const rootPath = join115(tempExtractDir, rootEntry);
+        const rootPath = join118(tempExtractDir, rootEntry);
         const rootStat = await stat10(rootPath);
         if (rootStat.isDirectory()) {
           const rootContents = await readdir29(rootPath, { encoding: "utf8" });
@@ -81640,7 +82680,7 @@ class ZipExtractor {
           }
         } else {
           await mkdir24(destDir, { recursive: true });
-          await copyFile6(rootPath, join115(destDir, rootEntry));
+          await copyFile6(rootPath, join118(destDir, rootEntry));
         }
       } else {
         logger.debug("Multiple root entries - moving all");
@@ -81769,7 +82809,7 @@ class DownloadManager {
   async createTempDir() {
     const timestamp = Date.now();
     const counter = DownloadManager.tempDirCounter++;
-    const primaryTempDir = join116(tmpdir5(), `takumi-${timestamp}-${counter}`);
+    const primaryTempDir = join119(tmpdir5(), `takumi-${timestamp}-${counter}`);
     try {
       await mkdir25(primaryTempDir, { recursive: true });
       logger.debug(`Created temp directory: ${primaryTempDir}`);
@@ -81786,7 +82826,7 @@ Solutions:
   2. Set HOME environment variable
   3. Try running from a different directory`);
       }
-      const fallbackTempDir = join116(homeDir, ".sunagentkit", "tmp", `takumi-${timestamp}-${counter}`);
+      const fallbackTempDir = join119(homeDir, ".sunagentkit", "tmp", `takumi-${timestamp}-${counter}`);
       try {
         await mkdir25(fallbackTempDir, { recursive: true });
         logger.debug(`Created temp directory (fallback): ${fallbackTempDir}`);
@@ -82493,7 +83533,7 @@ Re-run with explicit base kit, e.g. --kit ${BASE_KIT} --kit ${parsed2.join(" --k
 }
 // src/commands/init/phases/selection-handler.ts
 import { mkdir as mkdir26 } from "node:fs/promises";
-import { join as join120, resolve as resolve28 } from "node:path";
+import { join as join123, resolve as resolve28 } from "node:path";
 
 // src/commands/shared/agent-selector.ts
 init_registry();
@@ -82646,8 +83686,8 @@ init_logger();
 init_safe_spinner();
 init_takumi_constants();
 var import_fs_extra34 = __toESM(require_lib(), 1);
-import { existsSync as existsSync57, readdirSync as readdirSync9, rmSync as rmSync7, rmdirSync as rmdirSync2, unlinkSync as unlinkSync6 } from "node:fs";
-import { dirname as dirname34, join as join119, resolve as resolve27 } from "node:path";
+import { existsSync as existsSync59, readdirSync as readdirSync10, rmSync as rmSync9, rmdirSync as rmdirSync2, unlinkSync as unlinkSync6 } from "node:fs";
+import { dirname as dirname34, join as join122, resolve as resolve27 } from "node:path";
 var TAKUMI_SUBDIRECTORIES = ["commands", "agents", "skills", "rules", "hooks"];
 async function analyzeFreshInstallation(claudeDir) {
   const metadata = await readManifest(claudeDir);
@@ -82696,7 +83736,7 @@ function cleanupEmptyDirectories2(filePath, claudeDir) {
   let currentDir = resolve27(dirname34(filePath));
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir)) {
     try {
-      const entries = readdirSync9(currentDir);
+      const entries = readdirSync10(currentDir);
       if (entries.length === 0) {
         rmdirSync2(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
@@ -82717,9 +83757,9 @@ async function removeFilesByOwnership(claudeDir, analysis, includeModified) {
   const filesToRemove = includeModified ? [...analysis.ckFiles, ...analysis.ckModifiedFiles] : analysis.ckFiles;
   const filesToPreserve = includeModified ? analysis.userFiles : [...analysis.ckModifiedFiles, ...analysis.userFiles];
   for (const file of filesToRemove) {
-    const fullPath = join119(claudeDir, file.path);
+    const fullPath = join122(claudeDir, file.path);
     try {
-      if (existsSync57(fullPath)) {
+      if (existsSync59(fullPath)) {
         unlinkSync6(fullPath);
         removedFiles.push(file.path);
         logger.debug(`Removed: ${file.path}`);
@@ -82791,9 +83831,9 @@ async function removeSubdirectoriesFallback(claudeDir) {
   const removedFiles = [];
   let removedDirCount = 0;
   for (const subdir of TAKUMI_SUBDIRECTORIES) {
-    const subdirPath = join119(claudeDir, subdir);
+    const subdirPath = join122(claudeDir, subdir);
     if (await import_fs_extra34.pathExists(subdirPath)) {
-      rmSync7(subdirPath, { recursive: true, force: true });
+      rmSync9(subdirPath, { recursive: true, force: true });
       removedDirCount++;
       removedFiles.push(`${subdir}/ (entire directory)`);
       logger.debug(`Removed subdirectory: ${subdir}/`);
@@ -83016,7 +84056,7 @@ async function handleSelection(ctx) {
   }
   if (!ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir = prefix ? join120(resolvedDir, prefix) : resolvedDir;
+    const claudeDir = prefix ? join123(resolvedDir, prefix) : resolvedDir;
     try {
       const existingMetadata = await readManifest(claudeDir);
       if (existingMetadata?.kits) {
@@ -83049,7 +84089,7 @@ async function handleSelection(ctx) {
   }
   if (ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir = prefix ? join120(resolvedDir, prefix) : resolvedDir;
+    const claudeDir = prefix ? join123(resolvedDir, prefix) : resolvedDir;
     const canProceed = await handleFreshInstallation(claudeDir, ctx.prompts);
     if (!canProceed) {
       return { ...ctx, cancelled: true };
@@ -83069,7 +84109,7 @@ async function handleSelection(ctx) {
     let currentVersion = null;
     try {
       const prefix = PathResolver.getPathPrefix(ctx.options.global);
-      const claudeDir = prefix ? join120(resolvedDir, prefix) : resolvedDir;
+      const claudeDir = prefix ? join123(resolvedDir, prefix) : resolvedDir;
       const existingMetadata = await readManifest(claudeDir);
       currentVersion = existingMetadata?.kits?.[kitType]?.version || null;
       if (currentVersion) {
@@ -83157,7 +84197,7 @@ async function handleSelection(ctx) {
   if (ctx.options.yes && !ctx.options.fresh && !ctx.options.force && releaseTag && !isOfflineMode) {
     try {
       const prefix = PathResolver.getPathPrefix(ctx.options.global);
-      const claudeDir = prefix ? join120(resolvedDir, prefix) : resolvedDir;
+      const claudeDir = prefix ? join123(resolvedDir, prefix) : resolvedDir;
       const existingMetadata = await readManifest(claudeDir);
       const installedKitVersion = existingMetadata?.kits?.[kitType]?.version;
       if (installedKitVersion && versionsMatch(installedKitVersion, releaseTag)) {
@@ -83180,7 +84220,7 @@ async function handleSelection(ctx) {
       let currentSecondaryVersion = null;
       try {
         const prefix = PathResolver.getPathPrefix(ctx.options.global);
-        const claudeDir = prefix ? join120(resolvedDir, prefix) : resolvedDir;
+        const claudeDir = prefix ? join123(resolvedDir, prefix) : resolvedDir;
         const existingMetadata = await readManifest(claudeDir);
         currentSecondaryVersion = existingMetadata?.kits?.[secondaryKit]?.version || null;
       } catch {}
@@ -83264,12 +84304,12 @@ function resolveGlobalTargetDir(targetAgents2) {
 // src/commands/init/phases/sync-handler.ts
 init_paths();
 import { copyFile as copyFile7, mkdir as mkdir28, open as open3, readFile as readFile43, rename as rename8, stat as stat13, unlink as unlink11, writeFile as writeFile29 } from "node:fs/promises";
-import { dirname as dirname35, join as join123, resolve as resolve29 } from "node:path";
+import { dirname as dirname35, join as join126, resolve as resolve29 } from "node:path";
 
 // src/domains/sync/config-version-checker.ts
 init_auth_client();
 import { mkdir as mkdir27, readFile as readFile41, unlink as unlink10, writeFile as writeFile28 } from "node:fs/promises";
-import { join as join121 } from "node:path";
+import { join as join124 } from "node:path";
 init_version_utils();
 init_logger();
 init_path_resolver();
@@ -83305,12 +84345,12 @@ var CACHE_FILENAME = "config-update-cache.json";
 class ConfigVersionChecker {
   static getCacheFilePath(kitType, global3) {
     const cacheDir = PathResolver.getCacheDir(global3);
-    return join121(cacheDir, `${kitType}-${CACHE_FILENAME}`);
+    return join124(cacheDir, `${kitType}-${CACHE_FILENAME}`);
   }
   static async loadCache(kitType, global3) {
     try {
-      const cachePath = ConfigVersionChecker.getCacheFilePath(kitType, global3);
-      const data = await readFile41(cachePath, "utf8");
+      const cachePath2 = ConfigVersionChecker.getCacheFilePath(kitType, global3);
+      const data = await readFile41(cachePath2, "utf8");
       const parsed = JSON.parse(data);
       if (typeof parsed !== "object" || parsed === null || typeof parsed.lastCheck !== "number" || typeof parsed.latestVersion !== "string" || !parsed.latestVersion || parsed.lastCheck < 0 || parsed.lastCheck > Date.now() + 7 * 24 * 60 * 60 * 1000) {
         logger.debug("Invalid cache structure, ignoring");
@@ -83323,10 +84363,10 @@ class ConfigVersionChecker {
   }
   static async saveCache(kitType, global3, cache3) {
     try {
-      const cachePath = ConfigVersionChecker.getCacheFilePath(kitType, global3);
+      const cachePath2 = ConfigVersionChecker.getCacheFilePath(kitType, global3);
       const cacheDir = PathResolver.getCacheDir(global3);
       await mkdir27(cacheDir, { recursive: true });
-      await writeFile28(cachePath, JSON.stringify(cache3, null, 2));
+      await writeFile28(cachePath2, JSON.stringify(cache3, null, 2));
     } catch (error) {
       logger.debug(`Cache write failed: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
@@ -83410,9 +84450,9 @@ class ConfigVersionChecker {
     };
   }
   static async clearCache(kitType, global3 = false) {
-    const cachePath = ConfigVersionChecker.getCacheFilePath(kitType, global3);
+    const cachePath2 = ConfigVersionChecker.getCacheFilePath(kitType, global3);
     try {
-      await unlink10(cachePath);
+      await unlink10(cachePath2);
       logger.debug(`Cleared sync cache for ${kitType}`);
     } catch (error) {
       if (error.code !== "ENOENT") {
@@ -83425,7 +84465,7 @@ class ConfigVersionChecker {
 init_ownership_checker();
 init_logger();
 import { lstat as lstat9, readFile as readFile42, readlink, realpath as realpath3, stat as stat12 } from "node:fs/promises";
-import { isAbsolute as isAbsolute5, join as join122, normalize as normalize9, relative as relative18 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join125, normalize as normalize9, relative as relative18 } from "node:path";
 var MAX_SYNC_FILE_SIZE = 10 * 1024 * 1024;
 var MAX_SYMLINK_DEPTH = 20;
 async function validateSymlinkChain(path11, basePath, maxDepth = MAX_SYMLINK_DEPTH) {
@@ -83437,7 +84477,7 @@ async function validateSymlinkChain(path11, basePath, maxDepth = MAX_SYMLINK_DEP
       if (!stats.isSymbolicLink())
         break;
       const target = await readlink(current);
-      const resolvedTarget = isAbsolute5(target) ? target : join122(current, "..", target);
+      const resolvedTarget = isAbsolute5(target) ? target : join125(current, "..", target);
       const normalizedTarget = normalize9(resolvedTarget);
       const rel = relative18(basePath, normalizedTarget);
       if (rel.startsWith("..") || isAbsolute5(rel)) {
@@ -83473,7 +84513,7 @@ async function validateSyncPath(basePath, filePath) {
   if (normalized.startsWith("..") || normalized.includes("/../")) {
     throw new Error(`Path traversal not allowed: ${filePath}`);
   }
-  const fullPath = join122(basePath, normalized);
+  const fullPath = join125(basePath, normalized);
   const rel = relative18(basePath, fullPath);
   if (rel.startsWith("..") || isAbsolute5(rel)) {
     throw new Error(`Path escapes base directory: ${filePath}`);
@@ -83488,7 +84528,7 @@ async function validateSyncPath(basePath, filePath) {
     }
   } catch (error) {
     if (error.code === "ENOENT") {
-      const parentPath = join122(fullPath, "..");
+      const parentPath = join125(fullPath, "..");
       try {
         const resolvedBase = await realpath3(basePath);
         const resolvedParent = await realpath3(parentPath);
@@ -83979,7 +85019,7 @@ function getLockTimeout() {
 var STALE_LOCK_THRESHOLD_MS = 5 * 60 * 1000;
 async function acquireSyncLock(global3) {
   const cacheDir = PathResolver.getCacheDir(global3);
-  const lockPath2 = join123(cacheDir, ".sync-lock");
+  const lockPath2 = join126(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
   await mkdir28(dirname35(lockPath2), { recursive: true });
@@ -84060,7 +85100,7 @@ async function executeSyncMerge(ctx) {
         try {
           const sourcePath = await validateSyncPath(upstreamDir, file.path);
           const targetPath = await validateSyncPath(ctx.claudeDir, file.path);
-          const targetDir = join123(targetPath, "..");
+          const targetDir = join126(targetPath, "..");
           try {
             await mkdir28(targetDir, { recursive: true });
           } catch (mkdirError) {
@@ -84231,7 +85271,7 @@ async function createBackup(claudeDir, files, backupDir) {
       const sourcePath = await validateSyncPath(claudeDir, file.path);
       if (await import_fs_extra36.pathExists(sourcePath)) {
         const targetPath = await validateSyncPath(backupDir, file.path);
-        const targetDir = join123(targetPath, "..");
+        const targetDir = join126(targetPath, "..");
         await mkdir28(targetDir, { recursive: true });
         await copyFile7(sourcePath, targetPath);
       }
@@ -84257,38 +85297,38 @@ init_logger();
 init_types2();
 var import_fs_extra37 = __toESM(require_lib(), 1);
 import { rename as rename9, rm as rm10 } from "node:fs/promises";
-import { join as join124, relative as relative19 } from "node:path";
+import { join as join127, relative as relative19 } from "node:path";
 async function collectDirsToRename(extractDir, folders) {
   const dirsToRename = [];
   if (folders.docs !== DEFAULT_FOLDERS.docs) {
-    const docsPath = join124(extractDir, DEFAULT_FOLDERS.docs);
+    const docsPath = join127(extractDir, DEFAULT_FOLDERS.docs);
     if (await import_fs_extra37.pathExists(docsPath)) {
       dirsToRename.push({
         from: docsPath,
-        to: join124(extractDir, folders.docs)
+        to: join127(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join124(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    const claudeDocsPath = join127(extractDir, ".claude", DEFAULT_FOLDERS.docs);
     if (await import_fs_extra37.pathExists(claudeDocsPath)) {
       dirsToRename.push({
         from: claudeDocsPath,
-        to: join124(extractDir, ".claude", folders.docs)
+        to: join127(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join124(extractDir, DEFAULT_FOLDERS.plans);
+    const plansPath = join127(extractDir, DEFAULT_FOLDERS.plans);
     if (await import_fs_extra37.pathExists(plansPath)) {
       dirsToRename.push({
         from: plansPath,
-        to: join124(extractDir, folders.plans)
+        to: join127(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join124(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    const claudePlansPath = join127(extractDir, ".claude", DEFAULT_FOLDERS.plans);
     if (await import_fs_extra37.pathExists(claudePlansPath)) {
       dirsToRename.push({
         from: claudePlansPath,
-        to: join124(extractDir, ".claude", folders.plans)
+        to: join127(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -84329,7 +85369,7 @@ async function renameFolders(dirsToRename, extractDir, options2) {
 init_logger();
 init_types2();
 import { readFile as readFile44, readdir as readdir30, writeFile as writeFile30 } from "node:fs/promises";
-import { join as join125, relative as relative20 } from "node:path";
+import { join as join128, relative as relative20 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
   ".txt",
@@ -84382,7 +85422,7 @@ async function transformFileContents(dir, compiledReplacements, options2) {
   let replacementsCount = 0;
   const entries = await readdir30(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join125(dir, entry.name);
+    const fullPath = join128(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -84518,9 +85558,9 @@ async function transformFolderPaths(extractDir, folders, options2 = {}) {
 // src/services/transformers/global-path-transformer.ts
 init_logger();
 import { readFile as readFile45, readdir as readdir31, writeFile as writeFile31 } from "node:fs/promises";
-import { platform as platform11 } from "node:os";
-import { extname as extname8, join as join126 } from "node:path";
-var IS_WINDOWS3 = platform11() === "win32";
+import { platform as platform12 } from "node:os";
+import { extname as extname8, join as join129 } from "node:path";
+var IS_WINDOWS3 = platform12() === "win32";
 var HOME_PREFIX = "$HOME";
 function getHomeDirPrefix() {
   return HOME_PREFIX;
@@ -84619,7 +85659,7 @@ async function transformPathsForGlobalInstall(directory, options2 = {}) {
   async function processDirectory2(dir) {
     const entries = await readdir31(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join126(dir, entry.name);
+      const fullPath = join129(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -84912,8 +85952,8 @@ init_dist2();
 
 // src/domains/mcp/agent-detector.ts
 init_environment();
-import { existsSync as existsSync58 } from "node:fs";
-import { join as join127 } from "node:path";
+import { existsSync as existsSync60 } from "node:fs";
+import { join as join130 } from "node:path";
 
 // src/domains/mcp/shell-out.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
@@ -85003,9 +86043,9 @@ function getAgentConfigPath(agent) {
     return null;
   switch (agent) {
     case "claude-code":
-      return join127(home6, ".claude.json");
+      return join130(home6, ".claude.json");
     case "codex":
-      return join127(home6, ".codex", "config.toml");
+      return join130(home6, ".codex", "config.toml");
     default: {
       const _exhaustive = agent;
       return _exhaustive;
@@ -85014,7 +86054,7 @@ function getAgentConfigPath(agent) {
 }
 var defaultCheckers = {
   binaryOnPath: isBinaryOnPath,
-  configExists: existsSync58
+  configExists: existsSync60
 };
 function isAgentPresent(agent, checkers = defaultCheckers) {
   if (checkers.binaryOnPath(AGENT_BINARY[agent])) {
@@ -85030,8 +86070,8 @@ var PROJECT_MARKERS = {
   "claude-code": [".claude", "CLAUDE.md"],
   codex: [".codex", "AGENTS.md"]
 };
-function detectProjectAgents(cwd2 = process.cwd(), exists2 = existsSync58) {
-  return ALL_MCP_AGENTS.filter((agent) => PROJECT_MARKERS[agent].some((marker) => exists2(join127(cwd2, marker))));
+function detectProjectAgents(cwd2 = process.cwd(), exists2 = existsSync60) {
+  return ALL_MCP_AGENTS.filter((agent) => PROJECT_MARKERS[agent].some((marker) => exists2(join130(cwd2, marker))));
 }
 
 // src/domains/mcp/registry-client.ts
@@ -85043,12 +86083,12 @@ init_auth_client();
 init_logger();
 init_paths2();
 import { promises as fs33 } from "node:fs";
-import { join as join128 } from "node:path";
+import { join as join131 } from "node:path";
 function getCacheDir() {
-  return join128(getConfigDir(), "mcp");
+  return join131(getConfigDir(), "mcp");
 }
 function getCachePath2() {
-  return join128(getCacheDir(), "registry-cache.json");
+  return join131(getCacheDir(), "registry-cache.json");
 }
 async function readCachedRegistry() {
   try {
@@ -85177,16 +86217,16 @@ function resolveService(registry, name2) {
 }
 
 // src/domains/mcp/writers/claude-config-file.ts
-import { existsSync as existsSync59 } from "node:fs";
+import { existsSync as existsSync61 } from "node:fs";
 import { mkdir as mkdir29, writeFile as writeFile32 } from "node:fs/promises";
-import { dirname as dirname36, join as join129 } from "node:path";
+import { dirname as dirname36, join as join132 } from "node:path";
 var AGENT = "claude-code";
 var LOCAL_SCOPE_FALLBACK_WARNING = "claude CLI not found; local scope isn't representable via direct file write, wrote to user-level ~/.claude.json instead";
 function userConfigPath() {
   return getAgentConfigPath(AGENT);
 }
 function projectConfigPath() {
-  return join129(process.cwd(), ".mcp.json");
+  return join132(process.cwd(), ".mcp.json");
 }
 function configPathFor(scope) {
   return scope === "project" ? projectConfigPath() : userConfigPath();
@@ -85225,7 +86265,7 @@ async function fileAdd(entry, scope) {
 }
 async function fileRemove(name2, scope) {
   const path11 = configPathFor(scope);
-  if (!path11 || !existsSync59(path11)) {
+  if (!path11 || !existsSync61(path11)) {
     return { agent: AGENT, status: "skipped", detail: "No config file present" };
   }
   const existing = await readJsonConfigFile(path11);
@@ -85340,7 +86380,7 @@ var claudeWriter = {
 
 // src/domains/mcp/writers/codex-writer.ts
 init_path_safety();
-import { existsSync as existsSync60 } from "node:fs";
+import { existsSync as existsSync62 } from "node:fs";
 import { readFile as readFile47, writeFile as writeFile33 } from "node:fs/promises";
 
 // src/domains/mcp/writers/codex-config-file.ts
@@ -85431,7 +86471,7 @@ async function fileAdd2(entry, scope) {
 }
 async function fileRemove2(name2) {
   const path11 = configPath();
-  if (!path11 || !existsSync60(path11)) {
+  if (!path11 || !existsSync62(path11)) {
     return { agent: AGENT3, status: "skipped", detail: "No config file present" };
   }
   try {
@@ -85510,7 +86550,7 @@ async function remove13(name2, opts) {
 }
 async function listConfigured() {
   const path11 = configPath();
-  if (!path11 || !existsSync60(path11))
+  if (!path11 || !existsSync62(path11))
     return { has: () => false };
   try {
     const content = await readFile47(path11, "utf-8");
@@ -85866,19 +86906,19 @@ async function mcpCommand(action, service, options2 = {}) {
 }
 // src/commands/plan/plan-command.ts
 init_output_manager();
-import { existsSync as existsSync65, statSync as statSync11 } from "node:fs";
-import { dirname as dirname42, join as join133, parse as parse4, resolve as resolve33 } from "node:path";
+import { existsSync as existsSync67, statSync as statSync12 } from "node:fs";
+import { dirname as dirname42, join as join136, parse as parse4, resolve as resolve33 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
-import { existsSync as existsSync64, statSync as statSync10 } from "node:fs";
-import { basename as basename21, dirname as dirname41, join as join132, relative as relative21, resolve as resolve31 } from "node:path";
+import { existsSync as existsSync66, statSync as statSync11 } from "node:fs";
+import { basename as basename21, dirname as dirname41, join as join135, relative as relative21, resolve as resolve31 } from "node:path";
 
 // src/domains/plan-parser/index.ts
 import { dirname as dirname40 } from "node:path";
 
 // src/domains/plan-parser/plan-table-parser.ts
 var import_gray_matter6 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync23 } from "node:fs";
+import { readFileSync as readFileSync24 } from "node:fs";
 import { dirname as dirname37, resolve as resolve30 } from "node:path";
 function normalizeStatus(raw) {
   const s3 = raw.toLowerCase().trim();
@@ -86244,30 +87284,30 @@ function parsePhasesFromBody(body, dir, options2) {
   return parseFormat6(normalizedBody, dir, options2);
 }
 function parsePlanFile(planFilePath, options2) {
-  const content = readFileSync23(planFilePath, "utf8");
+  const content = readFileSync24(planFilePath, "utf8");
   const dir = dirname37(planFilePath);
   const { data: frontmatter, content: body } = import_gray_matter6.default(content);
   const phases = parsePhasesFromBody(body, dir, options2);
   return { frontmatter, phases };
 }
 // src/domains/plan-parser/plan-scanner.ts
-import { existsSync as existsSync61, readdirSync as readdirSync10 } from "node:fs";
-import { join as join130 } from "node:path";
+import { existsSync as existsSync63, readdirSync as readdirSync11 } from "node:fs";
+import { join as join133 } from "node:path";
 function scanPlanDir(dir) {
-  if (!existsSync61(dir))
+  if (!existsSync63(dir))
     return [];
   try {
-    return readdirSync10(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join130(dir, entry.name, "plan.md")).filter(existsSync61);
+    return readdirSync11(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join133(dir, entry.name, "plan.md")).filter(existsSync63);
   } catch {
     return [];
   }
 }
 // src/domains/plan-parser/plan-validator.ts
 var import_gray_matter7 = __toESM(require_gray_matter(), 1);
-import { existsSync as existsSync62, readFileSync as readFileSync24 } from "node:fs";
+import { existsSync as existsSync64, readFileSync as readFileSync25 } from "node:fs";
 import { basename as basename19, dirname as dirname38 } from "node:path";
 function validatePlanFile(filePath, strict = false) {
-  const content = readFileSync24(filePath, "utf8");
+  const content = readFileSync25(filePath, "utf8");
   const dir = dirname38(filePath);
   const issues = [];
   const lines = content.split(`
@@ -86304,7 +87344,7 @@ function validatePlanFile(filePath, strict = false) {
     });
   }
   for (const phase of phases) {
-    if (phase.file && !existsSync62(phase.file)) {
+    if (phase.file && !existsSync64(phase.file)) {
       const fileBasename = basename19(phase.file);
       const refLine = lines.findIndex((l2) => l2.includes(fileBasename));
       issues.push({
@@ -86324,9 +87364,9 @@ function validatePlanFile(filePath, strict = false) {
 }
 // src/domains/plan-parser/plan-writer.ts
 var import_gray_matter8 = __toESM(require_gray_matter(), 1);
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync25, writeFileSync as writeFileSync12 } from "node:fs";
-import { existsSync as existsSync63 } from "node:fs";
-import { basename as basename20, dirname as dirname39, join as join131 } from "node:path";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync26, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync65 } from "node:fs";
+import { basename as basename20, dirname as dirname39, join as join134 } from "node:path";
 function phaseNameToFilename(id, name2) {
   const numMatch = /^(\d+)([a-z]*)$/i.exec(id);
   const num4 = numMatch ? numMatch[1] : id;
@@ -86431,16 +87471,16 @@ function resolvePhaseIds(phases) {
 }
 function scaffoldPlan(options2) {
   const { dir } = options2;
-  mkdirSync9(dir, { recursive: true });
+  mkdirSync10(dir, { recursive: true });
   const resolvedPhases = resolvePhaseIds(options2.phases);
   const optionsWithResolved = { ...options2, phases: resolvedPhases };
-  const planFile = join131(dir, "plan.md");
-  writeFileSync12(planFile, generatePlanMd(optionsWithResolved), "utf8");
+  const planFile = join134(dir, "plan.md");
+  writeFileSync13(planFile, generatePlanMd(optionsWithResolved), "utf8");
   const phaseFiles = [];
   for (const phase of resolvedPhases) {
     const filename = phaseNameToFilename(phase.id, phase.name);
-    const phaseFile = join131(dir, filename);
-    writeFileSync12(phaseFile, generatePhaseTemplate(phase), "utf8");
+    const phaseFile = join134(dir, filename);
+    writeFileSync13(phaseFile, generatePhaseTemplate(phase), "utf8");
     phaseFiles.push(phaseFile);
   }
   return { planFile, phaseFiles };
@@ -86464,7 +87504,7 @@ function isCanonicalFormat(content) {
   return /^\|\s*phase\s*\|\s*name\s*\|\s*status\s*\|/im.test(content);
 }
 function updatePhaseStatus(planFile, phaseId, newStatus) {
-  const raw = readFileSync25(planFile, "utf8").replace(/\r\n/g, `
+  const raw = readFileSync26(planFile, "utf8").replace(/\r\n/g, `
 `);
   if (!isCanonicalFormat(raw)) {
     console.error("[!] plan.md is not in canonical format — skipping status update");
@@ -86504,10 +87544,10 @@ function updatePhaseStatus(planFile, phaseId, newStatus) {
   }
   const updatedFrontmatter = { ...frontmatter, status: planStatus };
   const updatedContent = import_gray_matter8.default.stringify(updatedBody, updatedFrontmatter);
-  writeFileSync12(planFile, updatedContent, "utf8");
+  writeFileSync13(planFile, updatedContent, "utf8");
   const planDir = dirname39(planFile);
   const phaseFilename = phaseNameFilenameFromTableRow(updatedBody, phaseId, planDir);
-  if (phaseFilename && existsSync63(phaseFilename)) {
+  if (phaseFilename && existsSync65(phaseFilename)) {
     updatePhaseFileFrontmatter(phaseFilename, newStatus);
   }
 }
@@ -86519,18 +87559,18 @@ function phaseNameFilenameFromTableRow(body, phaseId, planDir) {
       continue;
     const linkMatch = /\[([^\]]+)\]\(\.\/([^)]+)\)/.exec(row);
     if (linkMatch)
-      return join131(planDir, linkMatch[2]);
+      return join134(planDir, linkMatch[2]);
   }
   return null;
 }
 function updatePhaseFileFrontmatter(phaseFile, newStatus) {
-  const raw = readFileSync25(phaseFile, "utf8");
+  const raw = readFileSync26(phaseFile, "utf8");
   const { data: frontmatter, content: body } = import_gray_matter8.default(raw);
   const updated = { ...frontmatter, status: newStatus };
-  writeFileSync12(phaseFile, import_gray_matter8.default.stringify(body, updated), "utf8");
+  writeFileSync13(phaseFile, import_gray_matter8.default.stringify(body, updated), "utf8");
 }
 function addPhase(planFile, name2, afterId) {
-  const raw = readFileSync25(planFile, "utf8").replace(/\r\n/g, `
+  const raw = readFileSync26(planFile, "utf8").replace(/\r\n/g, `
 `);
   if (!isCanonicalFormat(raw)) {
     console.error("[!] plan.md is not in canonical format — cannot add phase");
@@ -86599,9 +87639,9 @@ function addPhase(planFile, name2, afterId) {
     updatedBody = lines.join(`
 `);
   }
-  writeFileSync12(planFile, import_gray_matter8.default.stringify(updatedBody, frontmatter), "utf8");
-  const phaseFilePath = join131(planDir, filename);
-  writeFileSync12(phaseFilePath, generatePhaseTemplate({ id: phaseId, name: name2 }), "utf8");
+  writeFileSync13(planFile, import_gray_matter8.default.stringify(updatedBody, frontmatter), "utf8");
+  const phaseFilePath = join134(planDir, filename);
+  writeFileSync13(phaseFilePath, generatePhaseTemplate({ id: phaseId, name: name2 }), "utf8");
   return { phaseId, phaseFile: phaseFilePath };
 }
 
@@ -86704,7 +87744,7 @@ async function handleValidate(target, options2) {
 }
 async function handleStatus(target, options2) {
   const t = target ? resolve31(target) : null;
-  const plansDir = t && existsSync64(t) && statSync10(t).isDirectory() && !existsSync64(join132(t, "plan.md")) ? t : null;
+  const plansDir = t && existsSync66(t) && statSync11(t).isDirectory() && !existsSync66(join135(t, "plan.md")) ? t : null;
   if (plansDir) {
     const planFiles = scanPlanDir(plansDir);
     if (planFiles.length === 0) {
@@ -86935,20 +87975,20 @@ async function handleAddPhase(target, options2) {
 // src/commands/plan/plan-command.ts
 function resolvePlanFile(target) {
   const t = target ? resolve33(target) : process.cwd();
-  if (existsSync65(t)) {
-    const stat14 = statSync11(t);
+  if (existsSync67(t)) {
+    const stat14 = statSync12(t);
     if (stat14.isFile())
       return t;
-    const candidate = join133(t, "plan.md");
-    if (existsSync65(candidate))
+    const candidate = join136(t, "plan.md");
+    if (existsSync67(candidate))
       return candidate;
   }
   if (!target) {
     let dir = process.cwd();
     const root = parse4(dir).root;
     while (dir !== root) {
-      const candidate = join133(dir, "plan.md");
-      if (existsSync65(candidate))
+      const candidate = join136(dir, "plan.md");
+      if (existsSync67(candidate))
         return candidate;
       dir = dirname42(dir);
     }
@@ -86998,7 +88038,7 @@ async function planCommand(action, target, options2) {
   let resolvedTarget = target;
   if (resolvedAction && !knownActions.has(resolvedAction)) {
     const looksLikePath = resolvedAction.includes("/") || resolvedAction.includes("\\") || resolvedAction.endsWith(".md") || resolvedAction === "." || resolvedAction === "..";
-    const existsOnDisk = !looksLikePath && existsSync65(resolve33(resolvedAction));
+    const existsOnDisk = !looksLikePath && existsSync67(resolve33(resolvedAction));
     if (looksLikePath || existsOnDisk) {
       resolvedTarget = resolvedAction;
       resolvedAction = undefined;
@@ -87035,6 +88075,791 @@ async function planCommand(action, target, options2) {
       process.exitCode = 1;
   }
 }
+// src/commands/statusline/statusline-command.ts
+import { appendFileSync as appendFileSync3 } from "node:fs";
+import { homedir as homedir31 } from "node:os";
+init_cache_dir();
+
+// src/domains/statusline/config-loader.ts
+init_takumi_config_manager();
+
+// src/domains/statusline/config.ts
+var PRESET_PROMPTS = {
+  full: "$brand  $model  $context  $quotas  $directory  $git  $activity",
+  compact: "$model  $context  $quotas  $directory  $git",
+  minimal: "$model  $context  $directory",
+  none: ""
+};
+var DEFAULT_STATUSLINE_SETTINGS = {
+  prompt: PRESET_PROMPTS.full,
+  brand: {
+    icon: "◆",
+    showCliVersion: true,
+    showCoreVersion: false,
+    color: "magenta",
+    versionColor: "dim"
+  },
+  model: { color: "brightCyan" },
+  context: {
+    barWidth: 10,
+    barStyle: "geometric",
+    showPercent: true,
+    colors: { low: "brightGreen", mid: "brightYellow", high: "brightRed" },
+    thresholds: { mid: 50, high: 80 }
+  },
+  quotas: { windows: ["5h", "week"], barWidth: 0, showCountdown: true, icon: "⏳" },
+  directory: { icon: "\uD83D\uDCC2", collapseHome: true, truncationLength: 3, color: "yellow" },
+  git: {
+    icon: "✦",
+    showDirty: true,
+    dirtyInBrackets: true,
+    showAheadBehind: true,
+    countUntracked: true,
+    branchColor: "magenta"
+  },
+  activity: { maxAgentRows: 4, todoTruncation: 50 },
+  cost: { icon: "\uD83D\uDCB0", hideZero: true }
+};
+function isPreset(value) {
+  return value === "full" || value === "compact" || value === "minimal" || value === "none";
+}
+function mergeSettings2(base, override) {
+  const o2 = override;
+  return {
+    prompt: o2.prompt ?? base.prompt,
+    brand: { ...base.brand, ...o2.brand },
+    model: { ...base.model, ...o2.model },
+    context: {
+      ...base.context,
+      ...o2.context,
+      colors: { ...base.context.colors, ...o2.context?.colors },
+      thresholds: { ...base.context.thresholds, ...o2.context?.thresholds }
+    },
+    quotas: { ...base.quotas, ...o2.quotas },
+    directory: { ...base.directory, ...o2.directory },
+    git: { ...base.git, ...o2.git },
+    activity: { ...base.activity, ...o2.activity },
+    cost: { ...base.cost, ...o2.cost }
+  };
+}
+function cloneDefaults() {
+  return mergeSettings2(DEFAULT_STATUSLINE_SETTINGS, {});
+}
+function resolveStatuslineSettings(raw) {
+  if (raw == null)
+    return cloneDefaults();
+  if (typeof raw === "string") {
+    const prompt = isPreset(raw) ? PRESET_PROMPTS[raw] : PRESET_PROMPTS.full;
+    return { ...cloneDefaults(), prompt };
+  }
+  return mergeSettings2(DEFAULT_STATUSLINE_SETTINGS, raw);
+}
+
+// src/domains/statusline/config-loader.ts
+async function loadStatuslineSettings(cwd2) {
+  try {
+    const { config } = await TakumiConfigManager.loadFull(cwd2);
+    return resolveStatuslineSettings(config.statusline);
+  } catch {
+    return resolveStatuslineSettings(undefined);
+  }
+}
+
+// src/domains/statusline/context-usage.ts
+var AUTOCOMPACT_BUFFER = 40000;
+function usedTokens(usage2) {
+  if (!usage2)
+    return 0;
+  const { input_tokens, cache_creation_input_tokens, cache_read_input_tokens } = usage2;
+  return (input_tokens ?? 0) + (cache_creation_input_tokens ?? 0) + (cache_read_input_tokens ?? 0);
+}
+function computeContextPercent(cw) {
+  const size = cw.context_window_size ?? 0;
+  if (size <= 0)
+    return 0;
+  const reported = cw.used_percentage;
+  if (typeof reported === "number" && reported >= 0)
+    return Math.round(reported);
+  if (size <= AUTOCOMPACT_BUFFER)
+    return 0;
+  const occupied = usedTokens(cw.current_usage) + AUTOCOMPACT_BUFFER;
+  return Math.min(100, Math.round(occupied / size * 100));
+}
+
+// src/domains/statusline/git-cache.ts
+import { createHash as createHash16 } from "node:crypto";
+import { readFileSync as readFileSync27 } from "node:fs";
+init_cache_dir();
+var GIT_CACHE_TTL_MS = 30000;
+var MAX_UNTRACKED_FILES = 200;
+var MAX_UNTRACKED_BYTES = 4 * 1024 * 1024;
+var NEWLINE = 10;
+function emptySnapshot(branch = "") {
+  return {
+    branch,
+    trackedInsertions: 0,
+    untrackedInsertions: 0,
+    deletions: 0,
+    ahead: 0,
+    behind: 0
+  };
+}
+function cachePathFor(cwd2) {
+  const key = createHash16("md5").update(cwd2).digest("hex").slice(0, 8);
+  return getStatuslineCachePath(`git-${key}.json`);
+}
+function readFreshCache(cwd2, now) {
+  const raw = readCacheFileSafe(cachePathFor(cwd2));
+  if (!raw)
+    return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.timestamp !== "number" || !parsed.data)
+      return null;
+    if (now - parsed.timestamp >= GIT_CACHE_TTL_MS)
+      return null;
+    return parsed.data;
+  } catch {
+    return null;
+  }
+}
+function toCount(field) {
+  const n2 = Number.parseInt(field ?? "", 10);
+  return Number.isNaN(n2) ? 0 : n2;
+}
+function sumNumstat(numstat) {
+  return numstat.split(`
+`).filter(Boolean).reduce((acc, row) => {
+    const [added, removed] = row.split("\t");
+    if (added === "-")
+      return acc;
+    acc.insertions += toCount(added);
+    acc.deletions += toCount(removed);
+    return acc;
+  }, { insertions: 0, deletions: 0 });
+}
+function trackedDiff(cwd2) {
+  const vsHead = runGit(cwd2, ["diff", "HEAD", "--numstat"], GIT_RENDER_TIMEOUT_MS);
+  if (vsHead)
+    return sumNumstat(vsHead);
+  const staged = runGit(cwd2, ["diff", "--cached", "--numstat"], GIT_RENDER_TIMEOUT_MS);
+  const unstaged = runGit(cwd2, ["diff", "--numstat"], GIT_RENDER_TIMEOUT_MS);
+  return sumNumstat([staged, unstaged].join(`
+`));
+}
+function countBufferLines(buf) {
+  if (buf.length === 0)
+    return 0;
+  let count = 0;
+  for (let idx = buf.indexOf(NEWLINE);idx !== -1; idx = buf.indexOf(NEWLINE, idx + 1)) {
+    count++;
+  }
+  return buf[buf.length - 1] === NEWLINE ? count : count + 1;
+}
+function untrackedInsertions(cwd2) {
+  const listing = runGit(cwd2, ["ls-files", "--others", "--exclude-standard"], GIT_RENDER_TIMEOUT_MS);
+  if (!listing)
+    return 0;
+  const files = listing.split(`
+`).filter(Boolean).slice(0, MAX_UNTRACKED_FILES);
+  let total = 0;
+  let byteBudget = MAX_UNTRACKED_BYTES;
+  for (const relative23 of files) {
+    if (byteBudget <= 0)
+      break;
+    let buf;
+    try {
+      buf = readFileSync27(`${cwd2}/${relative23}`);
+    } catch {
+      continue;
+    }
+    const slice = buf.length > byteBudget ? buf.subarray(0, byteBudget) : buf;
+    total += countBufferLines(slice);
+    byteBudget -= slice.length;
+  }
+  return total;
+}
+function aheadBehind(cwd2) {
+  const out = runGit(cwd2, ["rev-list", "--left-right", "--count", "@{u}...HEAD"], GIT_RENDER_TIMEOUT_MS);
+  if (!out)
+    return { ahead: 0, behind: 0 };
+  const [behind, ahead] = out.split(/\s+/);
+  return { ahead: Number.parseInt(ahead, 10) || 0, behind: Number.parseInt(behind, 10) || 0 };
+}
+function probe2(cwd2, branch) {
+  const tracked = trackedDiff(cwd2);
+  const { ahead, behind } = aheadBehind(cwd2);
+  return {
+    branch,
+    trackedInsertions: tracked.insertions,
+    untrackedInsertions: untrackedInsertions(cwd2),
+    deletions: tracked.deletions,
+    ahead,
+    behind
+  };
+}
+function getGitSnapshot(cwd2) {
+  try {
+    const now = Date.now();
+    const cached = readFreshCache(cwd2, now);
+    if (cached)
+      return cached;
+    const branch = resolveGitBranchOrCommit(cwd2, GIT_RENDER_TIMEOUT_MS);
+    const snapshot = branch ? probe2(cwd2, branch) : emptySnapshot("");
+    const envelope = { timestamp: now, data: snapshot };
+    writeCacheFileSafe(cachePathFor(cwd2), JSON.stringify(envelope));
+    return snapshot;
+  } catch {
+    return emptySnapshot("");
+  }
+}
+
+// src/domains/statusline/payload.ts
+function finiteOrUndefined(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function finiteOr0(value) {
+  return finiteOrUndefined(value) ?? 0;
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function text(value) {
+  return typeof value === "string" ? value : "";
+}
+var NUMERIC_STRING = /^\d+(\.\d+)?$/;
+function parseCost(value) {
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : null;
+  if (typeof value === "string" && NUMERIC_STRING.test(value))
+    return Number.parseFloat(value);
+  return null;
+}
+function parseContextWindow(value) {
+  const raw = record(value);
+  const usage2 = record(raw.current_usage);
+  return {
+    used_percentage: finiteOrUndefined(raw.used_percentage),
+    context_window_size: finiteOr0(raw.context_window_size),
+    remaining_percentage: finiteOrUndefined(raw.remaining_percentage),
+    current_usage: {
+      input_tokens: finiteOr0(usage2.input_tokens),
+      cache_creation_input_tokens: finiteOr0(usage2.cache_creation_input_tokens),
+      cache_read_input_tokens: finiteOr0(usage2.cache_read_input_tokens)
+    }
+  };
+}
+function parseStatusPayload(raw) {
+  const model = record(raw.model);
+  const workspace = record(raw.workspace);
+  const cost = record(raw.cost);
+  const workspaceDir = workspace.current_dir;
+  const cwd2 = typeof workspaceDir === "string" && workspaceDir.length > 0 ? workspaceDir : text(raw.cwd);
+  const displayName = model.display_name;
+  return {
+    sessionId: text(raw.session_id),
+    modelName: typeof displayName === "string" ? displayName : "Claude",
+    cwd: cwd2,
+    contextWindow: parseContextWindow(raw.context_window),
+    costUsd: parseCost(cost.total_cost_usd),
+    linesAdded: finiteOr0(cost.total_lines_added),
+    linesRemoved: finiteOr0(cost.total_lines_removed)
+  };
+}
+
+// src/domains/statusline/quota-windows.ts
+init_usage_limits_cache();
+
+// src/domains/statusline/time-format.ts
+function safeGetTime(value) {
+  if (!value)
+    return 0;
+  const ms2 = value instanceof Date ? value.getTime() : new Date(value).getTime();
+  return Number.isNaN(ms2) ? 0 : ms2;
+}
+function formatElapsed(start2, end) {
+  const from = safeGetTime(start2);
+  if (!from)
+    return "0s";
+  const to2 = end == null ? Date.now() : safeGetTime(end) || Date.now();
+  const span = to2 - from;
+  if (span < 1000)
+    return "<1s";
+  if (span < 60000)
+    return `${Math.round(span / 1000)}s`;
+  const minutes = Math.floor(span / 60000);
+  const seconds = Math.round(span % 60000 / 1000);
+  return `${minutes}m ${seconds}s`;
+}
+function formatCountdown(msLeft) {
+  if (!Number.isFinite(msLeft) || msLeft <= 0)
+    return "";
+  const totalMinutes = Math.floor(msLeft / 60000);
+  if (totalMinutes < 60)
+    return `${totalMinutes}m`;
+  if (totalMinutes < 1440) {
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    return minutes === 0 ? `${hours}h` : `${hours}h${minutes}m`;
+  }
+  return `${Math.floor(totalMinutes / 1440)}d`;
+}
+
+// src/domains/statusline/quota-windows.ts
+var RENDER_TTL_MS = 300000;
+var FIVE_HOUR_LABEL = "5h";
+var WEEK_LABEL = "wk";
+function pushSnapshotWindow(into, label, percent, resetsAt, now) {
+  if (percent == null)
+    return;
+  let text2 = `${label} ${percent}%`;
+  if (resetsAt) {
+    const countdown = formatCountdown(new Date(resetsAt).getTime() - now);
+    if (countdown)
+      text2 += ` (${countdown})`;
+  }
+  into.push(text2);
+}
+function fromSnapshot(snapshot, data, now) {
+  if (!snapshot)
+    return [];
+  const windows = [];
+  pushSnapshotWindow(windows, FIVE_HOUR_LABEL, snapshot.fiveHourPercent, data?.five_hour?.resets_at, now);
+  pushSnapshotWindow(windows, WEEK_LABEL, snapshot.weekPercent, data?.seven_day?.resets_at, now);
+  return windows;
+}
+function fromRawUtilization(data) {
+  if (!data)
+    return [];
+  const windows = [];
+  const fiveHour = normalizeUtilization(data.five_hour?.utilization);
+  if (fiveHour != null)
+    windows.push(`${FIVE_HOUR_LABEL} ${fiveHour}%`);
+  const week = normalizeUtilization(data.seven_day?.utilization);
+  if (week != null)
+    windows.push(`${WEEK_LABEL} ${week}%`);
+  return windows;
+}
+function quotaWindows(now = Date.now()) {
+  const cache3 = readUsageCache();
+  if (!cache3 || cache3.status !== "available")
+    return [];
+  if (!isUsageCacheFresh(cache3, RENDER_TTL_MS, now))
+    return [];
+  const snapshotWindows = fromSnapshot(cache3.snapshot, cache3.data, now);
+  return snapshotWindows.length > 0 ? snapshotWindows : fromRawUtilization(cache3.data);
+}
+
+// src/domains/statusline/components.ts
+import { homedir as homedir30 } from "node:os";
+
+// src/domains/statusline/colors.ts
+init_help_colors();
+var COLOR_ENABLED = process.env.NO_COLOR === undefined;
+var RESET = "\x1B[0m";
+var CLEAR_INTENSITY = "\x1B[22m";
+var CLEAR_FOREGROUND = "\x1B[39m";
+var STABLE_PREFIX = `${CLEAR_INTENSITY}${CLEAR_FOREGROUND}`;
+var STABLE_SUFFIX = `${RESET}${CLEAR_INTENSITY}${CLEAR_FOREGROUND}`;
+var CODES = {
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightMagenta: "\x1B[95m",
+  brightCyan: "\x1B[96m"
+};
+function paint(name2, text2) {
+  if (!COLOR_ENABLED)
+    return text2;
+  const code = CODES[name2];
+  return code ? `${STABLE_PREFIX}${code}${text2}${STABLE_SUFFIX}` : text2;
+}
+function percentColorName(percent) {
+  if (percent >= 80)
+    return "brightRed";
+  if (percent >= 50)
+    return "brightYellow";
+  return "brightGreen";
+}
+var BAR_GLYPHS = {
+  geometric: { filled: "▰", empty: "▱" },
+  block: { filled: "█", empty: "░" }
+};
+function progressBar2(percent, width = 10, style = "geometric", color) {
+  if (width <= 0)
+    return "";
+  const { filled: fg, empty: bg } = BAR_GLYPHS[style];
+  const clamped = Math.max(0, Math.min(100, percent));
+  const filled = Math.round(clamped / 100 * width);
+  const empty = width - filled;
+  if (!COLOR_ENABLED)
+    return fg.repeat(filled) + bg.repeat(empty);
+  const filledColor = color && CODES[color] || CODES[percentColorName(percent)];
+  return `${STABLE_PREFIX}${filledColor}${fg.repeat(filled)}${STABLE_PREFIX}${CODES.dim}${bg.repeat(empty)}${STABLE_SUFFIX}`;
+}
+
+// src/domains/statusline/sanitize.ts
+var ANSI_SEQUENCE = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_]/g;
+var CONTROL_CHARS = /[\x00-\x1f\x7f-\x9f]/g;
+function sanitizeField(value) {
+  if (typeof value !== "string")
+    return "";
+  return value.replace(ANSI_SEQUENCE, "").replace(CONTROL_CHARS, "");
+}
+
+// src/domains/statusline/activity-renderers.ts
+var MAX_AGENT_ROWS = 4;
+var TODO_TRUNCATION = 50;
+var DETAIL_LIMIT = 50;
+var NEXT_LIMIT = 40;
+function orderAgents(agents) {
+  const rank = (a3) => a3.status === "running" ? 0 : 1;
+  return [...agents].sort((a3, b4) => rank(a3) - rank(b4) || safeGetTime(a3.startTime) - safeGetTime(b4.startTime));
+}
+function collapseAgents(ordered) {
+  const groups = [];
+  for (const agent of ordered) {
+    const type = sanitizeField(agent.type) || "agent";
+    const previous = groups[groups.length - 1];
+    if (previous && previous.type === type && previous.status === agent.status) {
+      previous.count++;
+    } else {
+      groups.push({ type, status: agent.status, count: 1 });
+    }
+  }
+  return groups;
+}
+function renderDetailLine(ordered) {
+  const running = ordered.find((a3) => a3.status === "running");
+  const completed = ordered.filter((a3) => a3.status === "completed");
+  const agent = running ?? completed[completed.length - 1];
+  if (!agent || !agent.description)
+    return null;
+  let desc = sanitizeField(agent.description);
+  if (!desc)
+    return null;
+  if (desc.length > DETAIL_LIMIT)
+    desc = `${desc.slice(0, DETAIL_LIMIT - 3)}...`;
+  const tone = agent.status === "running" ? "yellow" : "dim";
+  const elapsed = formatElapsed(agent.startTime, agent.endTime);
+  return `   ${paint(tone, `▸ ${desc}`)} ${paint("dim", `(${elapsed})`)}`;
+}
+function renderAgentLines(agents, maxRows) {
+  if (agents.length === 0)
+    return [];
+  const ordered = orderAgents(agents);
+  const groups = collapseAgents(ordered).slice(-Math.max(1, maxRows));
+  const rendered = groups.map((g3) => {
+    const tone = g3.status === "running" ? "yellow" : "dim";
+    const icon = g3.status === "running" ? "●" : "○";
+    const suffix = g3.count > 1 ? `×${g3.count}` : "";
+    return paint(tone, `${icon} ${g3.type}${suffix}`);
+  });
+  let summary = rendered.join(" → ");
+  const completedCount = ordered.filter((a3) => a3.status === "completed").length;
+  if (completedCount > 2)
+    summary += paint("dim", ` (${completedCount} done)`);
+  const lines = [summary];
+  const detail = renderDetailLine(ordered);
+  if (detail)
+    lines.push(detail);
+  return lines;
+}
+function renderTodoLine(todos, truncation) {
+  if (todos.length === 0)
+    return null;
+  const limit = Math.max(10, truncation);
+  const done = todos.filter((t) => t.status === "completed").length;
+  const pending = todos.filter((t) => t.status === "pending").length;
+  const active = todos.find((t) => t.status === "in_progress");
+  if (active) {
+    let text2 = sanitizeField(active.activeForm || active.content);
+    if (!text2)
+      return null;
+    if (text2.length > limit)
+      text2 = `${text2.slice(0, limit - 3)}...`;
+    return paint("yellow", `▸ ${text2} (${done} done, ${pending} pending)`);
+  }
+  if (done === todos.length) {
+    return paint("green", `✓ All ${todos.length} todos complete`);
+  }
+  if (pending > 0) {
+    const next = todos.find((t) => t.status === "pending");
+    let text2 = sanitizeField(next?.content || "Next task");
+    if (text2.length > NEXT_LIMIT)
+      text2 = `${text2.slice(0, NEXT_LIMIT - 3)}...`;
+    return paint("dim", `○ Next: ${text2} (${done} done, ${pending} pending)`);
+  }
+  return null;
+}
+function renderActivityLines(snapshot, opts) {
+  if (!snapshot)
+    return [];
+  const lines = renderAgentLines(snapshot.agents, opts?.maxAgentRows ?? MAX_AGENT_ROWS);
+  const todoLine = renderTodoLine(snapshot.todos, opts?.todoTruncation ?? TODO_TRUNCATION);
+  if (todoLine)
+    lines.push(todoLine);
+  return lines;
+}
+
+// src/domains/statusline/components.ts
+function normalizeVersion2(raw) {
+  const v3 = sanitizeField(raw ?? "").trim();
+  if (!v3 || v3.toLowerCase() === "unknown")
+    return null;
+  return `v${v3.replace(/^v/i, "")}`;
+}
+function renderBrand(data, s3) {
+  const cli = s3.showCliVersion ? normalizeVersion2(data.versions.cli) : null;
+  let takumi = paint(s3.color, "Takumi");
+  if (cli)
+    takumi += ` ${paint(s3.versionColor, cli)}`;
+  const pieces = [takumi];
+  const core = s3.showCoreVersion ? normalizeVersion2(data.versions.core) : null;
+  if (core)
+    pieces.push(`${paint(s3.color, "core")} ${paint(s3.versionColor, core)}`);
+  const icon = s3.icon ? `${paint(s3.color, s3.icon)} ` : "";
+  return `${icon}${pieces.join(paint(s3.color, " · "))}`;
+}
+function renderModel(data, s3) {
+  return paint(s3.color, sanitizeField(data.modelName) || "Claude");
+}
+function renderContext(data, s3) {
+  const pct = data.contextPercent;
+  if (!(pct > 0))
+    return null;
+  const color = pct >= s3.thresholds.high ? s3.colors.high : pct >= s3.thresholds.mid ? s3.colors.mid : s3.colors.low;
+  const bar = progressBar2(pct, s3.barWidth, s3.barStyle, color);
+  const pctText = s3.showPercent ? paint(color, `${pct}%`) : "";
+  const parts = [bar, pctText].filter(Boolean);
+  return parts.length ? parts.join(" ") : null;
+}
+var WINDOW_ALIASES = {
+  "5h": "5h",
+  "5hour": "5h",
+  week: "wk",
+  weekly: "wk",
+  wk: "wk"
+};
+function renderQuotas(data, s3) {
+  if (data.usageWindows.length === 0)
+    return null;
+  const allow = new Set(s3.windows.map((w4) => WINDOW_ALIASES[w4.toLowerCase()] ?? w4.toLowerCase()));
+  const parts = [];
+  for (const windowText of data.usageWindows) {
+    const clean = sanitizeField(windowText);
+    const match = clean.match(/^(\w+)\s+(\d+)%(.*)$/);
+    if (!match) {
+      parts.push(paint("dim", clean));
+      continue;
+    }
+    const [, label, pctStr, rest] = match;
+    if (allow.size > 0 && !allow.has(label.toLowerCase()))
+      continue;
+    const pct = Number.parseInt(pctStr, 10);
+    const color = pct >= 85 ? "brightRed" : "brightGreen";
+    const value = paint(color, `${pct}%${s3.showCountdown ? rest : ""}`);
+    parts.push(s3.barWidth > 0 ? `${label} ${progressBar2(pct, s3.barWidth, "geometric", color)} ${value}` : `${paint("dim", label)} ${value}`);
+  }
+  return parts.length ? `${s3.icon} ${parts.join("  ")}` : null;
+}
+function shortenLeadingDirs(path11, keepFull) {
+  if (keepFull <= 0)
+    return path11;
+  const marker = path11.startsWith("~") ? "~" : "";
+  const body = marker ? path11.slice(marker.length) : path11;
+  const leadingSlash = body.startsWith("/");
+  const segments = body.split("/").filter(Boolean);
+  if (segments.length <= keepFull)
+    return path11;
+  const leadCount = segments.length - keepFull;
+  const shortened = segments.map((seg, i) => i < leadCount ? Array.from(seg)[0] ?? seg : seg);
+  const sep9 = marker || leadingSlash ? "/" : "";
+  return `${marker}${sep9}${shortened.join("/")}`;
+}
+function renderDirectory(data, s3) {
+  let path11 = data.cwd || process.cwd();
+  if (s3.collapseHome) {
+    const home6 = homedir30();
+    if (home6 && path11.startsWith(home6))
+      path11 = `~${path11.slice(home6.length)}`;
+  }
+  path11 = shortenLeadingDirs(path11, s3.truncationLength);
+  return `${s3.icon} ${paint(s3.color, sanitizeField(path11))}`;
+}
+function renderGit(data, s3) {
+  const git = data.git;
+  if (!git || !git.branch)
+    return null;
+  let part = `${s3.icon} ${paint(s3.branchColor, sanitizeField(git.branch))}`;
+  if (s3.showDirty) {
+    const insertions = git.trackedInsertions + (s3.countUntracked ? git.untrackedInsertions : 0);
+    const tokens = [];
+    if (insertions > 0)
+      tokens.push(paint("green", `+${insertions}`));
+    if (git.deletions > 0)
+      tokens.push(paint("red", `-${git.deletions}`));
+    if (tokens.length > 0) {
+      part += s3.dirtyInBrackets ? ` (${tokens.join(" ")})` : ` ${tokens.join(" ")}`;
+    }
+  }
+  if (s3.showAheadBehind) {
+    if (git.ahead > 0)
+      part += ` ${paint("dim", `⇡${git.ahead}`)}`;
+    if (git.behind > 0)
+      part += ` ${paint("dim", `⇣${git.behind}`)}`;
+  }
+  return part;
+}
+function renderCost(data, s3) {
+  const cost = data.costUsd;
+  if (cost == null)
+    return null;
+  if (s3.hideZero && !(cost > 0))
+    return null;
+  return `${s3.icon} ${paint("dim", `$${cost.toFixed(4)}`)}`;
+}
+function renderActivity(data, s3) {
+  return renderActivityLines(data.activity, {
+    maxAgentRows: s3.maxAgentRows,
+    todoTruncation: s3.todoTruncation
+  });
+}
+
+// src/domains/statusline/renderer.ts
+function renderInline(name2, data, settings) {
+  switch (name2) {
+    case "brand":
+      return renderBrand(data, settings.brand);
+    case "model":
+      return renderModel(data, settings.model);
+    case "context":
+      return renderContext(data, settings.context);
+    case "quotas":
+      return renderQuotas(data, settings.quotas);
+    case "directory":
+      return renderDirectory(data, settings.directory);
+    case "git":
+      return renderGit(data, settings.git);
+    case "cost":
+      return renderCost(data, settings.cost);
+    default:
+      return null;
+  }
+}
+function renderStatusline(data, settings) {
+  const prompt = settings.prompt ?? "";
+  const activityLines = prompt.includes("$activity") ? renderActivity(data, settings.activity) : [];
+  const inlinePrompt = prompt.replace(/\$activity/g, "");
+  const substituted = inlinePrompt.replace(/\$([a-z]+)/g, (_match, name2) => {
+    return renderInline(name2, data, settings) ?? "";
+  });
+  const mainLine = substituted.replace(/[ \t]{2,}/g, "  ").trim();
+  const lines = [];
+  if (mainLine)
+    lines.push(mainLine);
+  for (const line of activityLines) {
+    if (line)
+      lines.push(line);
+  }
+  return lines.join(`
+`);
+}
+
+// src/domains/statusline/versions.ts
+import { join as join137 } from "node:path";
+async function resolveCoreVersion(cwd2) {
+  try {
+    const { readManifest: readManifest3 } = await Promise.resolve().then(() => (init_manifest(), exports_manifest));
+    const meta = await readManifest3(join137(cwd2, ".claude"));
+    if (!meta)
+      return null;
+    const kits = meta.kits;
+    const version3 = kits?.core?.version ?? meta.version;
+    return typeof version3 === "string" && version3.length > 0 ? version3 : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/statusline/statusline-command.ts
+init_takumi_constants();
+function writeDebug(enabled, context, err) {
+  if (!enabled)
+    return;
+  try {
+    ensureStatuslineCacheDir();
+    const detail = err instanceof Error ? err.stack ?? err.message : String(err);
+    appendFileSync3(getStatuslineCachePath("debug.log"), `[${new Date().toISOString()}] ${context}: ${detail}
+`, {
+      mode: 384
+    });
+  } catch {}
+}
+function collapseHome(p2) {
+  const home6 = homedir31();
+  return home6 && p2.startsWith(home6) ? `~${p2.slice(home6.length)}` : p2;
+}
+function fallbackLine(cwd2) {
+  const safe = sanitizeField(collapseHome(cwd2 || process.cwd() || "unknown")) || "unknown";
+  return `\uD83D\uDCC1 ${safe}`;
+}
+async function runUsageCacheRefresh(debug) {
+  try {
+    const { refreshUsageCache: refreshUsageCache2 } = await Promise.resolve().then(() => (init_usage_limits_cache(), exports_usage_limits_cache));
+    await refreshUsageCache2();
+  } catch (err) {
+    writeDebug(debug, "refresh-usage-cache", err);
+  }
+  process.exitCode = 0;
+}
+async function statuslineCommand(options2 = {}) {
+  if (options2.refreshUsageCache) {
+    await runUsageCacheRefresh(options2.debug);
+    return;
+  }
+  let fallbackCwd = "";
+  try {
+    const raw = await readStdinJson();
+    if (Object.keys(raw).length === 0) {
+      process.stdout.write(`${fallbackLine(process.cwd())}
+`);
+      process.exitCode = 0;
+      return;
+    }
+    const payload = parseStatusPayload(raw);
+    fallbackCwd = payload.cwd;
+    const cwd2 = payload.cwd || process.cwd();
+    const settings = await loadStatuslineSettings(cwd2);
+    const billingMode = process.env.CLAUDE_BILLING_MODE || "api";
+    const costUsd = billingMode === "api" ? payload.costUsd : null;
+    const core = settings.brand.showCoreVersion ? await resolveCoreVersion(cwd2) : null;
+    const data = {
+      modelName: payload.modelName,
+      cwd: cwd2,
+      git: getGitSnapshot(cwd2),
+      contextPercent: computeContextPercent(payload.contextWindow),
+      costUsd,
+      usageWindows: quotaWindows(),
+      activity: readActivity(payload.sessionId)?.snapshot ?? null,
+      versions: { cli: getCliVersion(), core }
+    };
+    process.stdout.write(`${renderStatusline(data, settings)}
+`);
+    process.exitCode = 0;
+  } catch (err) {
+    writeDebug(options2.debug, "render", err);
+    process.stdout.write(`${fallbackLine(fallbackCwd)}
+`);
+    process.exitCode = 0;
+  }
+}
 // src/commands/telemetry/telemetry-command.ts
 init_logger();
 
@@ -87042,24 +88867,24 @@ init_logger();
 init_logger();
 
 // src/commands/telemetry/shared.ts
-import { existsSync as existsSync66, readFileSync as readFileSync26, readdirSync as readdirSync11 } from "node:fs";
-import { homedir as homedir29 } from "node:os";
-import { join as join134 } from "node:path";
+import { existsSync as existsSync68, readFileSync as readFileSync28, readdirSync as readdirSync12 } from "node:fs";
+import { homedir as homedir32 } from "node:os";
+import { join as join138 } from "node:path";
 init_token_store();
 init_manifest_path_resolver();
 init_takumi_constants();
-var USER_CACHE_PATH = join134(homedir29(), ".claude", "sk-user.json");
-var EVENT_BUFFER_DIR = join134(homedir29(), ".claude", "sk-events");
-var RATE_STATE_PATH = join134(homedir29(), ".claude", "sk-rate-state.json");
-var TAKUMI_MANIFEST_PATH = join134(homedir29(), ".claude", MANIFEST_FILENAME);
-var LEGACY_METADATA_PATH = join134(homedir29(), ".claude", LEGACY_MANIFEST_FILENAME);
+var USER_CACHE_PATH = join138(homedir32(), ".claude", "sk-user.json");
+var EVENT_BUFFER_DIR = join138(homedir32(), ".claude", "sk-events");
+var RATE_STATE_PATH = join138(homedir32(), ".claude", "sk-rate-state.json");
+var TAKUMI_MANIFEST_PATH = join138(homedir32(), ".claude", MANIFEST_FILENAME);
+var LEGACY_METADATA_PATH = join138(homedir32(), ".claude", LEGACY_MANIFEST_FILENAME);
 var TELEMETRY_HOOK_FIELD = "hooks.telemetry";
 var TOKEN_PLACEHOLDER = "__INJECT_AT_RELEASE__";
 function readUserCache() {
   try {
-    if (!existsSync66(USER_CACHE_PATH))
+    if (!existsSync68(USER_CACHE_PATH))
       return null;
-    const parsed = JSON.parse(readFileSync26(USER_CACHE_PATH, "utf8"));
+    const parsed = JSON.parse(readFileSync28(USER_CACHE_PATH, "utf8"));
     if (!parsed || typeof parsed !== "object")
       return null;
     return parsed;
@@ -87069,9 +88894,9 @@ function readUserCache() {
 }
 function countBufferFiles() {
   try {
-    if (!existsSync66(EVENT_BUFFER_DIR))
+    if (!existsSync68(EVENT_BUFFER_DIR))
       return 0;
-    return readdirSync11(EVENT_BUFFER_DIR).filter((f4) => f4.endsWith(".jsonl")).length;
+    return readdirSync12(EVENT_BUFFER_DIR).filter((f4) => f4.endsWith(".jsonl")).length;
   } catch {
     return 0;
   }
@@ -87081,9 +88906,9 @@ function readTelemetryConfig() {
   const envToken = process.env.TAKUMI_TELEMETRY_TOKEN;
   let metadata = null;
   try {
-    const resolved = findManifestPathSync(join134(homedir29(), ".claude"));
+    const resolved = findManifestPathSync(join138(homedir32(), ".claude"));
     if (resolved) {
-      metadata = JSON.parse(readFileSync26(resolved.path, "utf8"));
+      metadata = JSON.parse(readFileSync28(resolved.path, "utf8"));
     }
   } catch {
     metadata = null;
@@ -87107,8 +88932,8 @@ function collectRuntimeContext() {
     cacheSource: cache3?.source === "gh" || cache3?.source === "manual" ? cache3.source : null,
     bufferFileCount: countBufferFiles(),
     bufferDir: EVENT_BUFFER_DIR,
-    rateStateExists: existsSync66(RATE_STATE_PATH),
-    userCacheExists: existsSync66(USER_CACHE_PATH),
+    rateStateExists: existsSync68(RATE_STATE_PATH),
+    userCacheExists: existsSync68(USER_CACHE_PATH),
     endpoint,
     tokenConfigured: Boolean(token)
   };
@@ -87258,8 +89083,8 @@ init_logger();
 init_safe_prompts();
 init_safe_spinner();
 var import_fs_extra39 = __toESM(require_lib(), 1);
-import { readdirSync as readdirSync13, rmSync as rmSync9 } from "node:fs";
-import { join as join136, resolve as resolve34, sep as sep9 } from "node:path";
+import { readdirSync as readdirSync14, rmSync as rmSync11 } from "node:fs";
+import { join as join140, resolve as resolve34, sep as sep9 } from "node:path";
 
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
@@ -87269,13 +89094,13 @@ init_logger();
 init_safe_prompts();
 init_takumi_constants();
 var import_picocolors28 = __toESM(require_picocolors(), 1);
-import { existsSync as existsSync67, readdirSync as readdirSync12, rmSync as rmSync8 } from "node:fs";
-import { dirname as dirname43, join as join135 } from "node:path";
+import { existsSync as existsSync69, readdirSync as readdirSync13, rmSync as rmSync10 } from "node:fs";
+import { dirname as dirname43, join as join139 } from "node:path";
 function listPresentManifestNames(installPath) {
   const present = [];
-  if (existsSync67(getManifestPath(installPath)))
+  if (existsSync69(getManifestPath(installPath)))
     present.push(MANIFEST_FILENAME);
-  if (existsSync67(getLegacyManifestPath(installPath)))
+  if (existsSync69(getLegacyManifestPath(installPath)))
     present.push(LEGACY_MANIFEST_FILENAME);
   return present;
 }
@@ -87296,9 +89121,9 @@ async function cleanupEmptyDirectories3(filePath, installationRoot) {
   let currentDir = dirname43(filePath);
   while (currentDir !== installationRoot && currentDir.startsWith(installationRoot)) {
     try {
-      const entries = readdirSync12(currentDir);
+      const entries = readdirSync13(currentDir);
       if (entries.length === 0) {
-        rmSync8(currentDir, { recursive: true });
+        rmSync10(currentDir, { recursive: true });
         cleaned++;
         logger.debug(`Removed empty directory: ${currentDir}`);
         currentDir = dirname43(currentDir);
@@ -87323,7 +89148,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
   if (uninstallManifest.isMultiKit && kit && metadata?.kits?.[kit]) {
     const kitFiles = metadata.kits[kit].files || [];
     for (const trackedFile of kitFiles) {
-      const filePath = join135(installation.path, trackedFile.path);
+      const filePath = join139(installation.path, trackedFile.path);
       if (uninstallManifest.filesToPreserve.includes(trackedFile.path)) {
         result.toPreserve.push({ path: trackedFile.path, reason: "shared with other kit" });
         continue;
@@ -87355,7 +89180,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     return result;
   }
   for (const trackedFile of allTrackedFiles) {
-    const filePath = join135(installation.path, trackedFile.path);
+    const filePath = join139(installation.path, trackedFile.path);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -87454,7 +89279,7 @@ async function removeInstallations(installations, options2) {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join136(installation.path, item.path);
+        const filePath = join140(installation.path, item.path);
         if (!await import_fs_extra39.pathExists(filePath))
           continue;
         if (!await isPathSafeToRemove(filePath, installation.path)) {
@@ -87473,9 +89298,9 @@ async function removeInstallations(installations, options2) {
         await ManifestWriter.removeKitFromManifest(installation.path, options2.kit);
       }
       try {
-        const remaining = readdirSync13(installation.path);
+        const remaining = readdirSync14(installation.path);
         if (remaining.length === 0) {
-          rmSync9(installation.path, { recursive: true });
+          rmSync11(installation.path, { recursive: true });
           logger.debug(`Removed empty installation directory: ${installation.path}`);
         }
       } catch {}
@@ -87656,7 +89481,7 @@ ${import_picocolors29.default.yellow("User modifications will be permanently del
 // src/commands/update-cli.ts
 init_takumi_config_manager();
 init_npm_registry();
-import { exec as exec8, spawn as spawn4 } from "node:child_process";
+import { exec as exec8, spawn as spawn5 } from "node:child_process";
 import { promisify as promisify14 } from "node:util";
 init_metadata_migration();
 init_version_utils();
@@ -87885,7 +89710,7 @@ async function promptKitUpdate(beta, yes, deps) {
       const displayCmd = `tkm ${args.join(" ")}`;
       logger.info(`Running: ${displayCmd}`);
       const spawnFn = deps?.spawnInitFn ?? ((spawnArgs) => new Promise((resolve35) => {
-        const child = spawn4("tkm", spawnArgs, { stdio: "inherit", shell: true });
+        const child = spawn5("tkm", spawnArgs, { stdio: "inherit", shell: true });
         child.on("close", (code) => resolve35(code ?? 1));
         child.on("error", (err) => {
           logger.verbose(`Failed to spawn tkm init: ${err.message}`);
@@ -88274,6 +90099,12 @@ function registerCommands(cli) {
       debug: options2.debug
     });
   });
+  cli.command("statusline", "Render the Takumi statusline from a piped status JSON (agent-invoked)").option("--refresh-usage-cache", "Internal: run the detached usage-cache refresh").option("--debug", "Log swallowed errors to <cache>/statusline/debug.log").action(async (options2 = {}) => {
+    await statuslineCommand({
+      refreshUsageCache: options2.refreshUsageCache,
+      debug: options2.debug
+    });
+  });
   cli.command("plan [action] [target]", "Plan management: parse, validate, status, kanban, create, check, uncheck, add-phase").option("--json", "Output in JSON format").option("--strict", "Strict validation mode").option("--title <title>", "Plan title (for create)").option("--phases <phases>", "Comma-separated phase names (for create)").option("--dir <dir>", "Plan directory (for create)").option("--priority <priority>", "Priority: P1, P2, P3 (for create)").option("--issue <issue>", "GitHub issue number (for create)").option("--after <after>", "Insert after phase ID (for add-phase)").option("--start", "Mark as in-progress instead of completed (for check)").action(async (action, target, options2) => {
     await planCommand(action, target, options2);
   });
@@ -88325,8 +90156,8 @@ init_version_checker();
 init_manifest_path_resolver();
 init_logger();
 init_types2();
-import { readFileSync as readFileSync27 } from "node:fs";
-import { join as join137 } from "node:path";
+import { readFileSync as readFileSync29 } from "node:fs";
+import { join as join141 } from "node:path";
 var PROVIDER_LOCAL_SUBDIRS = {
   "claude-code": ".claude",
   codex: ".codex"
@@ -88381,7 +90212,7 @@ async function displayVersion() {
     const localSubdir = PROVIDER_LOCAL_SUBDIRS[provider];
     if (!localSubdir)
       continue;
-    const localRoot = join137(process.cwd(), localSubdir);
+    const localRoot = join141(process.cwd(), localSubdir);
     if (localRoot === inst.globalRoot())
       continue;
     const resolved = findManifestPathSync(localRoot);
@@ -88391,7 +90222,7 @@ async function displayVersion() {
   }
   for (const { provider, path: metaPath } of localChecks) {
     try {
-      const rawMetadata = JSON.parse(readFileSync27(metaPath, "utf-8"));
+      const rawMetadata = JSON.parse(readFileSync29(metaPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);
       const kitsDisplay = formatInstalledKits(metadata);
       if (kitsDisplay) {
@@ -88411,7 +90242,7 @@ async function displayVersion() {
     const resolved = findManifestPathSync(installPath);
     if (resolved) {
       try {
-        const rawMetadata = JSON.parse(readFileSync27(resolved.path, "utf-8"));
+        const rawMetadata = JSON.parse(readFileSync29(resolved.path, "utf-8"));
         const metadata = MetadataSchema.parse(rawMetadata);
         const kitsDisplay = formatInstalledKits(metadata);
         if (kitsDisplay) {
@@ -88566,8 +90397,8 @@ class Logger2 {
       process.exit(1);
     });
   }
-  sanitize(text) {
-    return text.replace(/ghp_[a-zA-Z0-9]{36}/g, "ghp_***").replace(/github_pat_[a-zA-Z0-9_]{82}/g, "github_pat_***").replace(/gho_[a-zA-Z0-9]{36}/g, "gho_***").replace(/ghu_[a-zA-Z0-9]{36}/g, "ghu_***").replace(/ghs_[a-zA-Z0-9]{36}/g, "ghs_***").replace(/ghr_[a-zA-Z0-9]{36}/g, "ghr_***").replace(/Bearer [a-zA-Z0-9_-]+/g, "Bearer ***").replace(/token=[a-zA-Z0-9_-]+/g, "token=***");
+  sanitize(text2) {
+    return text2.replace(/ghp_[a-zA-Z0-9]{36}/g, "ghp_***").replace(/github_pat_[a-zA-Z0-9_]{82}/g, "github_pat_***").replace(/gho_[a-zA-Z0-9]{36}/g, "gho_***").replace(/ghu_[a-zA-Z0-9]{36}/g, "ghu_***").replace(/ghs_[a-zA-Z0-9]{36}/g, "ghs_***").replace(/ghr_[a-zA-Z0-9]{36}/g, "ghr_***").replace(/Bearer [a-zA-Z0-9_-]+/g, "Bearer ***").replace(/token=[a-zA-Z0-9_-]+/g, "token=***");
   }
   getTimestamp() {
     return new Date().toISOString();
@@ -88793,7 +90624,7 @@ var output2 = new OutputManager2;
 // src/shared/temp-cleanup.ts
 init_logger();
 var import_fs_extra41 = __toESM(require_lib(), 1);
-import { rmSync as rmSync10 } from "node:fs";
+import { rmSync as rmSync12 } from "node:fs";
 var tempDirs2 = new Set;
 async function cleanup() {
   if (tempDirs2.size === 0)
@@ -88814,7 +90645,7 @@ function cleanupSync() {
     return;
   for (const dir of tempDirs2) {
     try {
-      rmSync10(dir, { recursive: true, force: true });
+      rmSync12(dir, { recursive: true, force: true });
     } catch {}
   }
   tempDirs2.clear();