olakai-cli 0.12.0 → 0.13.0

package/dist/index.js

@@ -14,8 +14,10 @@ import {
   reconcileCurrentWorkspace,
   removeEntry,
   runMonitorInstall
-} from "./chunk-ULJXILXR.js";
+} from "./chunk-HDP2NYQI.js";
 import {
+  RateLimitError,
+  bulkProvisionAgents,
   createAgent,
   createCustomDataConfig,
   createKpi,
@@ -46,12 +48,19 @@ import {
   updateKpi,
   updateWorkflow,
   validateKpiFormula
-} from "./chunk-KNGRF4XU.js";
+} from "./chunk-X25PWFMN.js";
 import {
+  CLAUDE_DIR,
+  HOOK_DEFINITIONS,
+  OLAKAI_DIR,
+  SETTINGS_FILE,
   findConfiguredWorkspace,
   getLegacyClaudeMonitorConfigPath,
-  getMonitorConfigPath
-} from "./chunk-KY6OHQZW.js";
+  getMonitorConfigFileName,
+  getMonitorConfigPath,
+  mergeHooksSettings,
+  writeJsonFile
+} from "./chunk-KMQAGJWN.js";
 import {
   HOSTS,
   clearToken,
@@ -75,7 +84,6 @@ import {
 } from "./chunk-AVB4N2UN.js";
 
 // src/index.ts
-import { createRequire } from "module";
 import { Command } from "commander";
 
 // src/commands/login.ts
@@ -160,7 +168,7 @@ Login failed: ${error.message}`);
   }
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
 // src/commands/logout.ts
@@ -2324,19 +2332,446 @@ function registerActivityCommand(program2) {
   activity.command("sessions").description("Inspect chat/session decoration status for troubleshooting").requiredOption("--agent-id <id>", "Agent ID (required)").option("--since <date>", "Start date (ISO format)").option("--until <date>", "End date (ISO format)").option("--limit <n>", "Results per page", "20").option("--offset <n>", "Skip first N results", "0").option("--json", "Output as JSON").action(sessionsCommand);
 }
 
-// src/commands/monitor.ts
+// src/commands/admin.ts
 import * as fs2 from "fs";
+import * as path2 from "path";
+var TOOL_AGENT_SOURCE = {
+  "claude-code": "CLAUDE_CODE"
+};
+var UNSUPPORTED_TOOL_HINTS = {
+  codex: "~/.codex/config.toml",
+  cursor: "~/.cursor/hooks.json",
+  "gemini-cli": "~/.gemini/settings.json",
+  antigravity: "~/.antigravity/hooks.json"
+};
+var MAX_EMAILS = 500;
+var CHUNK_SIZE = 100;
+var RATE_LIMIT_FALLBACK_WAIT_SECONDS = 30;
+var EMAIL_REGEX2 = /^[^\s@,]+@[^\s@,]+\.[^\s@,]+$/;
+function parseEmailsFile(content) {
+  const lines = content.split(/\r?\n/);
+  const emails = [];
+  const seen = /* @__PURE__ */ new Set();
+  const invalidLines = [];
+  let firstDataLineSeen = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.length === 0 || line.startsWith("#")) continue;
+    const firstCell = line.split(",")[0].trim().replace(/^["']|["']$/g, "");
+    if (!firstDataLineSeen) {
+      firstDataLineSeen = true;
+      if (!firstCell.includes("@") && (line.includes(",") || /^["']?email\b/i.test(line))) {
+        continue;
+      }
+    }
+    if (firstCell.length === 0 || !EMAIL_REGEX2.test(firstCell)) {
+      invalidLines.push({ lineNumber: i + 1, content: line });
+      continue;
+    }
+    const key = firstCell.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    emails.push(firstCell);
+  }
+  return { emails, invalidLines };
+}
+function bundleDirName(email, taken) {
+  const localPart = email.split("@")[0];
+  const sanitized = localPart.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/^\.+/, "") || "developer";
+  let candidate = sanitized;
+  let suffix = 2;
+  while (taken.has(candidate.toLowerCase())) {
+    candidate = `${sanitized}-${suffix}`;
+    suffix++;
+  }
+  taken.add(candidate.toLowerCase());
+  return candidate;
+}
+function chunkEmails(emails, size = CHUNK_SIZE) {
+  const chunks = [];
+  for (let i = 0; i < emails.length; i += size) {
+    chunks.push(emails.slice(i, i + size));
+  }
+  return chunks;
+}
+function mergeBulkProvisionResponses(responses) {
+  const merged = {
+    results: [],
+    summary: { requested: 0, created: 0, reused: 0, rotated: 0, errors: 0 }
+  };
+  for (const response of responses) {
+    merged.results.push(...response.results);
+    merged.summary.requested += response.summary.requested;
+    merged.summary.created += response.summary.created;
+    merged.summary.reused += response.summary.reused;
+    merged.summary.rotated += response.summary.rotated;
+    merged.summary.errors += response.summary.errors;
+  }
+  return merged;
+}
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function provisionChunkWithRetry(payload) {
+  try {
+    return await bulkProvisionAgents(payload);
+  } catch (error) {
+    if (!(error instanceof RateLimitError)) throw error;
+    const waitSeconds = error.retryAfterSeconds ?? RATE_LIMIT_FALLBACK_WAIT_SECONDS;
+    console.error(
+      `Rate limited by the backend \u2014 waiting ${waitSeconds}s before retrying this batch\u2026`
+    );
+    await sleep2(waitSeconds * 1e3);
+    return await bulkProvisionAgents(payload);
+  }
+}
+function csvEscape(value) {
+  let cell = value;
+  if (/^[=+\-@\t\r]/.test(cell)) {
+    cell = `'${cell}`;
+  }
+  if (/[",\r\n]/.test(cell)) {
+    return `"${cell.replace(/"/g, '""')}"`;
+  }
+  return cell;
+}
+function chmod600(filePath) {
+  try {
+    fs2.chmodSync(filePath, 384);
+  } catch {
+  }
+}
+function writeSecretFile(filePath, content) {
+  const dir = path2.dirname(filePath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  fs2.writeFileSync(filePath, content, { encoding: "utf-8", mode: 384 });
+  chmod600(filePath);
+}
+function writeDeveloperBundle(outDir, dirName, result, monitoringEndpoint) {
+  const bundleRoot = path2.join(outDir, dirName);
+  const settingsPath = path2.join(bundleRoot, CLAUDE_DIR, SETTINGS_FILE);
+  writeJsonFile(settingsPath, {
+    hooks: mergeHooksSettings(void 0, HOOK_DEFINITIONS)
+  });
+  const monitorConfig = {
+    agentId: result.agentId ?? "",
+    apiKey: result.apiKey ?? "",
+    agentName: result.agentName ?? "",
+    source: "claude-code",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    monitoringEndpoint
+  };
+  const configPath = path2.join(
+    bundleRoot,
+    OLAKAI_DIR,
+    getMonitorConfigFileName("claude-code")
+  );
+  writeSecretFile(configPath, JSON.stringify(monitorConfig, null, 2) + "\n");
+  return [settingsPath, configPath];
+}
+function writeKeymaps(outDir, results) {
+  const jsonPath = path2.join(outDir, "keymap.json");
+  const csvPath = path2.join(outDir, "keymap.csv");
+  const rows = results.map((r) => ({
+    email: r.email,
+    agentId: r.agentId ?? "",
+    agentName: r.agentName ?? "",
+    status: r.status,
+    apiKey: r.apiKey ?? ""
+  }));
+  writeSecretFile(jsonPath, JSON.stringify(rows, null, 2) + "\n");
+  const csvLines = ["email,agentId,agentName,status,apiKey"];
+  for (const row of rows) {
+    csvLines.push(
+      [row.email, row.agentId, row.agentName, row.status, row.apiKey].map(csvEscape).join(",")
+    );
+  }
+  writeSecretFile(csvPath, csvLines.join("\n") + "\n");
+  return [jsonPath, csvPath];
+}
+async function bulkProvisionCommand(options) {
+  try {
+    const tool = options.tool;
+    if (!isToolId(tool)) {
+      console.error(
+        `Unknown tool: "${tool}". Bulk provisioning currently supports: claude-code`
+      );
+      process.exit(1);
+    }
+    const source = TOOL_AGENT_SOURCE[tool];
+    if (!source) {
+      const hint = UNSUPPORTED_TOOL_HINTS[tool];
+      console.error(
+        `Bulk provisioning does not support "${tool}" yet.
+
+${tool} keeps its hooks in a global per-machine file${hint ? ` (${hint})` : ""}, not in per-repo config, so an Intune-pushable per-developer bundle isn't possible for it yet. Only claude-code is supported in v1.`
+      );
+      process.exit(1);
+    }
+    const token = getValidToken();
+    if (!token) {
+      console.error("Not logged in. Run 'olakai login' first.");
+      process.exit(1);
+    }
+    const emailsPath = path2.resolve(options.emails);
+    if (!fs2.existsSync(emailsPath)) {
+      console.error(`Emails file not found: ${emailsPath}`);
+      process.exit(1);
+    }
+    const { emails, invalidLines } = parseEmailsFile(
+      fs2.readFileSync(emailsPath, "utf-8")
+    );
+    if (invalidLines.length > 0) {
+      console.error(
+        `Invalid email lines in ${emailsPath} (fix or remove them, '#' comments are allowed):`
+      );
+      for (const { lineNumber, content } of invalidLines) {
+        console.error(`  line ${lineNumber}: ${content}`);
+      }
+      process.exit(1);
+    }
+    if (emails.length === 0) {
+      console.error(`No valid emails found in ${emailsPath}.`);
+      process.exit(1);
+    }
+    if (emails.length > MAX_EMAILS) {
+      console.error(
+        `Too many emails: ${emails.length} (max ${MAX_EMAILS} per run). Split the file and run again.`
+      );
+      process.exit(1);
+    }
+    const outDir = path2.resolve(options.out);
+    fs2.mkdirSync(outDir, { recursive: true });
+    const takenDirs = /* @__PURE__ */ new Set();
+    const dirNameByEmail = /* @__PURE__ */ new Map();
+    for (const email of emails) {
+      dirNameByEmail.set(email.toLowerCase(), bundleDirName(email, takenDirs));
+    }
+    if (!options.yes) {
+      const conflicts = [];
+      for (const name of ["keymap.json", "keymap.csv"]) {
+        const p = path2.join(outDir, name);
+        if (fs2.existsSync(p) && fs2.statSync(p).size > 0) conflicts.push(p);
+      }
+      for (const dirName of dirNameByEmail.values()) {
+        const bundleDir = path2.join(outDir, dirName);
+        if (fs2.existsSync(bundleDir)) conflicts.push(bundleDir);
+      }
+      if (conflicts.length > 0) {
+        console.error(
+          "Refusing to overwrite existing output from a previous run (it may hold API keys / already-deployed configs):"
+        );
+        for (const conflict of conflicts) {
+          console.error(`  ${conflict}`);
+        }
+        console.error(
+          "Pass --yes to overwrite, or use a fresh --out directory."
+        );
+        process.exit(1);
+      }
+    }
+    const payloadBase = {
+      source,
+      ...options.namePrefix ? { namePrefix: options.namePrefix } : {},
+      rotateExistingKeys: Boolean(options.rotateExistingKeys),
+      setVcsEmailHint: true
+    };
+    const chunks = chunkEmails(emails);
+    const chunkResponses = [];
+    let abort = null;
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      if (chunks.length > 1) {
+        console.error(
+          `Provisioning batch ${i + 1}/${chunks.length} (${chunk.length} email${chunk.length === 1 ? "" : "s"})\u2026`
+        );
+      }
+      try {
+        chunkResponses.push(
+          await provisionChunkWithRetry({ ...payloadBase, emails: chunk })
+        );
+      } catch (error) {
+        abort = {
+          message: error instanceof Error ? error.message : "Unknown error",
+          unattempted: chunks.slice(i).flat()
+        };
+        break;
+      }
+    }
+    const response = mergeBulkProvisionResponses(chunkResponses);
+    const monitoringEndpoint = `${getBaseUrl()}/api/monitoring/prompt`;
+    const bundlePaths = [];
+    let bundleCount = 0;
+    for (const result of response.results) {
+      if (!result.apiKey) continue;
+      const dirName = dirNameByEmail.get(result.email.toLowerCase()) ?? bundleDirName(result.email, takenDirs);
+      bundlePaths.push(
+        ...writeDeveloperBundle(outDir, dirName, result, monitoringEndpoint)
+      );
+      bundleCount++;
+    }
+    const keymapPaths = response.results.length > 0 ? writeKeymaps(outDir, response.results) : [];
+    let unprocessedPath = null;
+    if (abort && abort.unattempted.length > 0) {
+      unprocessedPath = path2.join(outDir, "unprocessed.txt");
+      fs2.writeFileSync(
+        unprocessedPath,
+        abort.unattempted.join("\n") + "\n",
+        "utf-8"
+      );
+    }
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            ...response,
+            bundles: [...bundlePaths, ...keymapPaths],
+            ...abort ? {
+              aborted: {
+                error: abort.message,
+                unattemptedEmails: abort.unattempted,
+                unprocessedPath
+              }
+            } : {}
+          },
+          null,
+          2
+        )
+      );
+      if (abort || response.summary.errors > 0) {
+        process.exit(1);
+      }
+      return;
+    }
+    const { summary } = response;
+    console.log("");
+    console.log(
+      `Provisioned ${summary.requested} developer${summary.requested === 1 ? "" : "s"} for ${tool}:`
+    );
+    console.log(`  created: ${summary.created}`);
+    console.log(`  reused:  ${summary.reused}`);
+    console.log(`  rotated: ${summary.rotated}`);
+    console.log(`  errors:  ${summary.errors}`);
+    const errorRows = response.results.filter((r) => r.status === "error");
+    if (errorRows.length > 0) {
+      console.log("");
+      console.log("Failed rows:");
+      for (const row of errorRows) {
+        console.log(`  ${row.email}: ${row.error ?? "unknown error"}`);
+      }
+    }
+    console.log("");
+    console.log(`\u2713 ${bundleCount} config bundle(s) written to ${outDir}`);
+    if (response.results.length > 0) {
+      console.log(`\u2713 Keymap written to keymap.json / keymap.csv (0600)`);
+    }
+    if (abort) {
+      console.log("");
+      console.log(`\u2717 Provisioning stopped early: ${abort.message}`);
+      console.log(
+        `  ${abort.unattempted.length} email(s) were NOT attempted${unprocessedPath ? ` \u2014 written to ${unprocessedPath}` : ""}.`
+      );
+      if (unprocessedPath) {
+        console.log(
+          `  Re-run with --emails ${unprocessedPath} --out <fresh-dir> to finish the rollout`
+        );
+        console.log(
+          "  (use a fresh --out so this run's keymaps aren't overwritten)."
+        );
+      }
+    }
+    if (summary.reused > 0) {
+      console.log("");
+      console.log(
+        `${summary.reused} developer(s) already had an agent, so no bundle was written for them`
+      );
+      console.log(
+        "(plaintext API keys are only returned at creation). Re-run with"
+      );
+      console.log(
+        "--rotate-existing-keys to regenerate their keys and bundles \u2014 but note"
+      );
+      console.log(
+        "rotation INVALIDATES any configs already deployed to their machines."
+      );
+    }
+    if (response.results.length > 0) {
+      console.log("");
+      console.log(
+        "\u26A0 These files contain live API credentials. Package the per-developer"
+      );
+      console.log(
+        "  directories into your device-management tool (e.g. Intune) so each"
+      );
+      console.log(
+        `  developer's repo gets its ${CLAUDE_DIR}/${SETTINGS_FILE} and ${OLAKAI_DIR}/${getMonitorConfigFileName("claude-code")},`
+      );
+      console.log(
+        "  then DELETE the local copies (including the keymap files)."
+      );
+    }
+    if (abort || summary.errors > 0) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(
+      `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+    process.exit(1);
+  }
+}
+function registerAdminCommand(program2) {
+  const admin = program2.command("admin").description("Admin operations (require the ADMIN role)");
+  const adminMonitor = admin.command("monitor").description("Admin operations for local coding-agent monitoring");
+  adminMonitor.command("bulk-provision").description(
+    "Bulk-provision developer monitoring agents from an email roster and write Intune-ready per-developer config bundles. Large rosters are provisioned in sequential batches of 100 emails. Exits non-zero when any roster row fails to provision or a batch cannot be completed (bundles/keymaps for provisioned rows are still written; unattempted emails go to <out>/unprocessed.txt)."
+  ).requiredOption(
+    "--emails <file>",
+    "Roster file (.txt or .csv): one email per line, or the first CSV column. '#' comments and a header row are skipped."
+  ).requiredOption(
+    "--out <dir>",
+    "Output directory for per-developer bundles + keymap.json/keymap.csv"
+  ).option(
+    "--tool <tool>",
+    "Tool to provision for (v1: claude-code only)",
+    "claude-code"
+  ).option(
+    "--rotate-existing-keys",
+    "Regenerate API keys for developers that already have an agent (invalidates already-deployed configs)"
+  ).option(
+    "--name-prefix <prefix>",
+    "Agent name prefix (backend default applies when omitted)"
+  ).option("--json", "Output the raw response JSON plus written bundle paths").option(
+    "--yes",
+    "Overwrite existing output in --out (non-empty keymap files and/or per-developer bundle directories from a previous run)"
+  ).action(bulkProvisionCommand);
+}
+
+// src/commands/monitor.ts
+import * as fs3 from "fs";
+
+// src/version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var packageJson = require2("../package.json");
+function getCliVersion() {
+  return packageJson.version;
+}
+
+// src/commands/monitor.ts
 function readStdin(timeoutMs = 3e3) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     if (process.stdin.isTTY) {
-      resolve("");
+      resolve2("");
       return;
     }
     let data = "";
     const timer = setTimeout(() => {
       process.stdin.removeAllListeners();
       process.stdin.destroy();
-      resolve(data);
+      resolve2(data);
     }, timeoutMs);
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
@@ -2344,11 +2779,11 @@ function readStdin(timeoutMs = 3e3) {
     });
     process.stdin.on("end", () => {
       clearTimeout(timer);
-      resolve(data);
+      resolve2(data);
     });
     process.stdin.on("error", () => {
       clearTimeout(timer);
-      resolve(data);
+      resolve2(data);
     });
   });
 }
@@ -2413,7 +2848,7 @@ async function statusCommand(options) {
     return;
   }
   if (plugin.id === "claude-code") {
-    const { printClaudeCodeStatus } = await import("./status-IZCIMES2.js");
+    const { printClaudeCodeStatus } = await import("./status-FTC6XEQH.js");
     await printClaudeCodeStatus({ projectRoot: process.cwd() });
     return;
   }
@@ -2462,7 +2897,7 @@ async function disableCommand(options) {
     }
   }
   if (agentIdToDelete) {
-    const { deleteAgent: deleteAgent2 } = await import("./api-JBVSHCKY.js");
+    const { deleteAgent: deleteAgent2 } = await import("./api-VIUUUQNR.js");
     try {
       await deleteAgent2(agentIdToDelete);
       console.log(`\u2713 Remote agent ${agentIdToDelete} deleted.`);
@@ -2491,7 +2926,7 @@ async function listCommand6(options) {
   console.log(formatRegistryTable(registry));
 }
 async function doctorCommand(options) {
-  const { runDoctor, printDoctorResult, exitCodeForStatus } = await import("./doctor-7Q7SPMVD.js");
+  const { runDoctor, printDoctorResult, exitCodeForStatus } = await import("./doctor-CE634QRJ.js");
   let tool;
   if (!options.all) {
     tool = await resolveToolFromOptions(options.tool, "status");
@@ -2509,7 +2944,7 @@ async function doctorCommand(options) {
 }
 async function repairCommand(options) {
   const tool = await resolveToolFromOptions(options.tool, "init");
-  const { runRepair, formatRepairResult, exitCodeForRepair } = await import("./repair-NIKAW7NS.js");
+  const { runRepair, formatRepairResult, exitCodeForRepair } = await import("./repair-ILYFGYX5.js");
   const result = await runRepair({
     tool,
     interactive: isInteractive()
@@ -2569,7 +3004,7 @@ function debugInvalidToolFlag(value, event) {
       { event, tool: value ?? null }
     )}
 `;
-    fs2.appendFileSync(logPath, line, "utf-8");
+    fs3.appendFileSync(logPath, line, "utf-8");
   } catch {
   }
 }
@@ -2581,7 +3016,7 @@ async function postMonitoringPayload(result) {
   const log = (event, data) => {
     if (!debug) return;
     try {
-      fs2.appendFileSync(
+      fs3.appendFileSync(
         logPath,
         `[${(/* @__PURE__ */ new Date()).toISOString()}] dispatcher/${event}: ${JSON.stringify(data)}
 `,
@@ -2597,11 +3032,13 @@ async function postMonitoringPayload(result) {
       apiKeyPrefix: result.transport.apiKey ? result.transport.apiKey.slice(0, 8) + "..." : null,
       bodyBytes: JSON.stringify([result.payload]).length
     });
+    result.payload.cliVersion = getCliVersion();
     const response = await fetch(result.transport.endpoint, {
       method: "POST",
       headers: {
         "x-api-key": result.transport.apiKey,
-        "Content-Type": "application/json"
+        "Content-Type": "application/json",
+        "User-Agent": `olakai-cli/${getCliVersion()}`
       },
       body: JSON.stringify([result.payload]),
       signal: controller.signal
@@ -2893,19 +3330,19 @@ function sectionHeader(title) {
 }
 function noProfileMessage(backend, backendError) {
   if (backendError === "not logged in") {
-    return "Run `olakai login` to see your Builder Profile.";
+    return "Run `olakai login` to see your AI Fluency.";
   }
   if (backendError === "session expired") {
     return "Session expired. Run `olakai login` to refresh your credentials.";
   }
   if (backendError === "unreachable") {
-    return "Could not reach Olakai. Your Builder Profile will be here once you're back online.";
+    return "Could not reach Olakai. Your AI Fluency will be here once you're back online.";
   }
   if (!backend || !backend.found || !backend.profile) {
     if (backend?.reason === "opted_out") {
-      return "Your Builder Profile is turned off. Re-enable it from your Olakai settings to start seeing your digest.";
+      return "Your AI Fluency is turned off. Re-enable it from your Olakai settings to start seeing your digest.";
     }
-    return "Not enough coding sessions yet to build your profile. Keep working with monitoring on \u2014 your Builder Profile appears after your first few sessions are analyzed.";
+    return "Not enough coding sessions yet to build your profile. Keep working with monitoring on \u2014 your AI Fluency appears after your first few sessions are analyzed.";
   }
   return null;
 }
@@ -2916,7 +3353,7 @@ function renderHuman(backend, backendError, reportUrl) {
     return;
   }
   const profile = backend.profile;
-  console.log(sectionHeader("BUILDER PROFILE"));
+  console.log(sectionHeader("AI FLUENCY"));
   if (profile.identity.displayName) {
     console.log(`  ${profile.identity.displayName}`);
   }
@@ -3010,7 +3447,7 @@ async function profileCommand(options) {
   } else {
     backend = result.data;
   }
-  const reportUrl = `${getBaseUrl()}/dashboard/coding-iq/builder-profile`;
+  const reportUrl = `${getBaseUrl()}/dashboard/coding-iq/my-ai-fluency`;
   if (options.json) {
     const output = {
       backend,
@@ -3024,7 +3461,7 @@ async function profileCommand(options) {
 }
 
 // src/commands/status.ts
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 function formatDollars2(cents) {
   return `$${(cents / 100).toFixed(2)}`;
 }
@@ -3058,7 +3495,7 @@ function collectLocalState() {
     tool: entry.tool,
     agentId: entry.agentId,
     workspacePath: entry.path,
-    configured: fs3.existsSync(entry.configPath)
+    configured: fs4.existsSync(entry.configPath)
   }));
 }
 async function fetchBackendStatus() {
@@ -3208,10 +3645,8 @@ async function statusCommand2(options) {
 }
 
 // src/index.ts
-var require2 = createRequire(import.meta.url);
-var packageJson = require2("../package.json");
 var program = new Command();
-program.name("olakai").description("Olakai CLI tool").version(packageJson.version).option(
+program.name("olakai").description("Olakai CLI tool").version(getCliVersion()).option(
   "-e, --env <environment>",
   `Environment to use (${getValidEnvironments().join(", ")})`,
   "production"
@@ -3257,11 +3692,12 @@ registerKpisCommand(program);
 registerCustomDataCommand(program);
 registerActivityCommand(program);
 registerMonitorCommand(program);
+registerAdminCommand(program);
 program.command("status").description("Show your Olakai monitoring state and personal Coding IQ status").option("--json", "Output as JSON (for machine consumption)").option("--workspace-only", "Show local monitor state only (no backend call)").action(
   (opts) => statusCommand2(opts)
 );
 program.command("profile").description(
-  "Show your Olakai Builder Profile \u2014 archetype, dimension scores, and personal ROI"
+  "Show your Olakai AI Fluency \u2014 archetype, dimension scores, and personal ROI"
 ).option("--json", "Output as JSON (for machine consumption)").action((opts) => profileCommand(opts));
 registerProfilesCommand(program);
 program.parse();