@wayai/cli 0.3.51 → 0.3.53

package/dist/index.js

@@ -7994,13 +7994,19 @@ function isNewerVersion(latest, current) {
   }
   return false;
 }
-var UUID_RE, slugify;
+var UUID_RE, slugify, OWN_HELP_COMMANDS;
 var init_utils = __esm({
   "src/lib/utils.ts"() {
     "use strict";
     init_dist();
     UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
     slugify = slugifySkillName;
+    OWN_HELP_COMMANDS = /* @__PURE__ */ new Set([
+      "eval",
+      "admin",
+      "report",
+      "conversations"
+    ]);
   }
 });
 
@@ -8867,111 +8873,132 @@ var init_logout = __esm({
   }
 });
 
-// src/lib/hub-lock.ts
+// src/lib/hub-binding.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import * as fs7 from "fs";
 import * as path7 from "path";
-function getLockPath() {
+function resolveGitDir() {
   const cwd = process.cwd();
-  if (_lockPathCache && _lockPathCache.cwd === cwd) return _lockPathCache.lockPath;
+  if (_gitDirCache && _gitDirCache.cwd === cwd) return _gitDirCache.gitDir;
   let gitDir;
   try {
-    gitDir = execFileSync2("git", ["rev-parse", "--git-dir"], {
+    const raw = execFileSync2("git", ["rev-parse", "--git-dir"], {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
+    gitDir = raw ? path7.resolve(cwd, raw) : null;
   } catch {
-    _lockPathCache = { cwd, lockPath: null };
-    return null;
+    gitDir = null;
   }
-  const lockPath = gitDir ? path7.resolve(cwd, gitDir, LOCK_FILENAME) : null;
-  _lockPathCache = { cwd, lockPath };
-  return lockPath;
+  _gitDirCache = { cwd, gitDir };
+  return gitDir;
 }
-function readLock() {
-  const lockPath = getLockPath();
-  if (!lockPath) return null;
-  let raw;
-  try {
-    raw = fs7.readFileSync(lockPath, "utf-8");
-  } catch (err) {
-    if (err.code === "ENOENT") return null;
-    throw err;
+function getBindingPath() {
+  const gitDir = resolveGitDir();
+  return gitDir ? path7.join(gitDir, BINDING_FILENAME) : null;
+}
+function getLegacyBindingPath() {
+  const gitDir = resolveGitDir();
+  return gitDir ? path7.join(gitDir, LEGACY_BINDING_FILENAME) : null;
+}
+function readBinding() {
+  for (const bindingPath of [getBindingPath(), getLegacyBindingPath()]) {
+    if (!bindingPath) continue;
+    let raw;
+    try {
+      raw = fs7.readFileSync(bindingPath, "utf-8");
+    } catch (err) {
+      if (err.code === "ENOENT") continue;
+      throw err;
+    }
+    const trimmed = raw.trim();
+    return UUID_RE.test(trimmed) ? trimmed : null;
   }
-  const trimmed = raw.trim();
-  return UUID_RE.test(trimmed) ? trimmed : null;
+  return null;
 }
-function writeLock(hubId) {
+function writeBinding(hubId) {
   if (!UUID_RE.test(hubId)) {
     throw new Error(`Invalid hub_id (must be a UUID): ${hubId}`);
   }
-  const lockPath = getLockPath();
-  if (!lockPath) {
-    throw new Error("Not inside a git repository \u2014 cannot write hub lock.");
+  const bindingPath = getBindingPath();
+  if (!bindingPath) {
+    throw new Error("Not inside a git repository \u2014 cannot write hub binding.");
   }
-  fs7.writeFileSync(lockPath, `${hubId}
+  fs7.writeFileSync(bindingPath, `${hubId}
 `, "utf-8");
+  removeLegacyBinding();
 }
-function clearLock() {
-  const lockPath = getLockPath();
-  if (!lockPath) return false;
+function removeLegacyBinding() {
+  const legacyPath = getLegacyBindingPath();
+  if (!legacyPath) return;
   try {
-    fs7.unlinkSync(lockPath);
-    return true;
-  } catch (err) {
-    if (err.code === "ENOENT") return false;
-    throw err;
+    fs7.unlinkSync(legacyPath);
+  } catch {
+  }
+}
+function clearBinding() {
+  let removed = false;
+  for (const bindingPath of [getBindingPath(), getLegacyBindingPath()]) {
+    if (!bindingPath) continue;
+    try {
+      fs7.unlinkSync(bindingPath);
+      removed = true;
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
   }
+  return removed;
 }
-function assertHubMatchesLock(resolvedHubId, hubLabel) {
-  const locked = readLock();
-  if (!locked) return;
-  if (locked === resolvedHubId) return;
+function assertHubMatchesBinding(resolvedHubId, hubLabel) {
+  const bound = readBinding();
+  if (!bound) return;
+  if (bound === resolvedHubId) return;
   const target = hubLabel ? `${hubLabel} (${resolvedHubId})` : resolvedHubId;
   console.error(
     [
-      `This worktree is locked to hub ${locked}, but the command resolved to ${target}.`,
+      `This worktree is bound to hub ${bound}, but the command resolved to ${target}.`,
       "",
       "This usually means a prompt was routed to the wrong worktree.",
-      "Confirm with the user before unlocking. To override:",
-      "  wayai unlock              # clear the lock for this worktree",
+      "Confirm with the user before unbinding. To override:",
+      "  wayai unbind             # clear the binding for this worktree",
       `  wayai use ${resolvedHubId}  # rebind this worktree to the new hub`
     ].join("\n")
   );
   process.exit(1);
 }
-function autoLockIfUnlocked(hubId) {
+function autoBindIfUnbound(hubId) {
   try {
-    if (readLock()) return false;
-    writeLock(hubId);
-    console.log(`Worktree locked to hub ${hubId} (run \`wayai unlock\` to clear).`);
+    if (readBinding()) return false;
+    writeBinding(hubId);
+    console.log(`Worktree bound to hub ${hubId} (run \`wayai unbind\` to clear).`);
     return true;
   } catch (err) {
-    console.warn(`  Warning: could not auto-lock worktree (${err instanceof Error ? err.message : String(err)})`);
+    console.warn(`  Warning: could not auto-bind worktree (${err instanceof Error ? err.message : String(err)})`);
     return false;
   }
 }
-function assertNoLockBlocksHubCreation(newHubName) {
-  const locked = readLock();
-  if (!locked) return;
+function assertNoBindingBlocksHubCreation(newHubName) {
+  const bound = readBinding();
+  if (!bound) return;
   console.error(
     [
-      `This worktree is locked to hub ${locked}, but you're about to create a new hub "${newHubName}" here.`,
+      `This worktree is bound to hub ${bound}, but you're about to create a new hub "${newHubName}" here.`,
       "",
       "This usually means a prompt was routed to the wrong worktree.",
-      "Confirm with the user before unlocking. To override:",
-      "  wayai unlock              # clear the lock for this worktree"
+      "Confirm with the user before unbinding. To override:",
+      "  wayai unbind             # clear the binding for this worktree"
     ].join("\n")
   );
   process.exit(1);
 }
-var LOCK_FILENAME, _lockPathCache;
-var init_hub_lock = __esm({
-  "src/lib/hub-lock.ts"() {
+var BINDING_FILENAME, LEGACY_BINDING_FILENAME, _gitDirCache;
+var init_hub_binding = __esm({
+  "src/lib/hub-binding.ts"() {
     "use strict";
     init_utils();
-    LOCK_FILENAME = "wayai-lock";
+    BINDING_FILENAME = "wayai-binding";
+    LEGACY_BINDING_FILENAME = "wayai-lock";
   }
 });
 
@@ -9017,11 +9044,11 @@ async function statusCommand(args2, pkg2) {
   const cachedCliLatest = readCachedLatest(CLI_CACHE_FILE);
   const cliLatest = cachedCliLatest && isNewerVersion(cachedCliLatest, pkg2.version) ? cachedCliLatest : null;
   const skill = buildSkillState();
-  let lockedHubId = null;
+  let boundHubId = null;
   try {
-    lockedHubId = readLock();
+    boundHubId = readBinding();
   } catch {
-    lockedHubId = null;
+    boundHubId = null;
   }
   if (!config) {
     const snapshot2 = {
@@ -9035,7 +9062,8 @@ async function statusCommand(args2, pkg2) {
       orgs: [],
       active_org: null,
       workspace,
-      worktree_lock: { hub_id: lockedHubId }
+      worktree_binding: { hub_id: boundHubId },
+      worktree_lock: { hub_id: boundHubId }
     };
     if (json) {
       console.log(JSON.stringify(snapshot2, null, 2));
@@ -9089,7 +9117,8 @@ async function statusCommand(args2, pkg2) {
     orgs,
     active_org: activeOrg,
     workspace,
-    worktree_lock: { hub_id: lockedHubId }
+    worktree_binding: { hub_id: boundHubId },
+    worktree_lock: { hub_id: boundHubId }
   };
   if (json) {
     console.log(JSON.stringify(snapshot, null, 2));
@@ -9119,8 +9148,8 @@ async function statusCommand(args2, pkg2) {
   } else {
     console.log("No .wayai.yaml found \u2014 run `wayai init` to scope this repo to an organization.");
   }
-  if (lockedHubId) {
-    console.log(`Worktree lock: ${lockedHubId} (run \`wayai unlock\` to clear)`);
+  if (boundHubId) {
+    console.log(`Worktree binding: ${boundHubId} (run \`wayai unbind\` to clear)`);
   }
   if (tokenValid === true && accessToken) {
     await nudgeReportActions(config.api_url, accessToken);
@@ -9133,7 +9162,7 @@ var init_status = __esm({
     init_auth();
     init_repo_config();
     init_workspace();
-    init_hub_lock();
+    init_hub_binding();
     init_api_client();
     init_version_cache();
     init_skill_version();
@@ -10243,7 +10272,7 @@ async function pullCommand(args2) {
   }
   if (gitRoot) warnLayoutOnce(gitRoot);
   const { hubId, hubFolder: existingFolder } = resolveHubTarget(workspaceDir, hubSelector);
-  assertHubMatchesLock(hubId);
+  assertHubMatchesBinding(hubId);
   console.log("Fetching hub configuration...");
   const payload = await client.pull(hubId, organizationId);
   if (payload.hub_environment === "production") {
@@ -10315,7 +10344,7 @@ async function pullCommand(args2) {
     }
     if (cancelled) return;
   }
-  if (wroteFiles) autoLockIfUnlocked(hubId);
+  if (wroteFiles) autoBindIfUnbound(hubId);
 }
 async function downloadBinaryResourceFiles(hubFolder, payload) {
   const resources = payload.resources || [];
@@ -10355,7 +10384,7 @@ var init_pull = __esm({
     init_workspace();
     init_layout();
     init_repo_config();
-    init_hub_lock();
+    init_hub_binding();
   }
 });
 
@@ -10602,7 +10631,7 @@ async function pushSingleHub(client, hubId, hubFolder, autoConfirm, organization
     } else {
       console.log("No changes to push; folder renamed.");
     }
-    autoLockIfUnlocked(hubId);
+    autoBindIfUnbound(hubId);
     return true;
   }
   console.log("\nChanges to push:");
@@ -10618,7 +10647,7 @@ async function pushSingleHub(client, hubId, hubFolder, autoConfirm, organization
   const result = await client.push(hubId, localConfig, organizationId);
   printSyncResult(result);
   await syncAfterPush(client, hubId, hubFolder, organizationId);
-  autoLockIfUnlocked(hubId);
+  autoBindIfUnbound(hubId);
   return true;
 }
 function resolveWorkspaceDir() {
@@ -10677,7 +10706,7 @@ async function pushCommand(args2) {
   const newHubs = scanNewHubs(workspaceDir);
   const existing = selectExistingHub(workspaceDir, existingHubs, hubSelector, wsLabel);
   if (existing) {
-    assertHubMatchesLock(existing.hubId, path14.basename(existing.hubFolder));
+    assertHubMatchesBinding(existing.hubId, path14.basename(existing.hubFolder));
     await pushSingleHub(client, existing.hubId, existing.hubFolder, autoConfirm, organizationId);
     return;
   }
@@ -10696,7 +10725,7 @@ async function pushCommand(args2) {
     }
     process.exit(1);
   }
-  assertNoLockBlocksHubCreation(newHub.hubName);
+  assertNoBindingBlocksHubCreation(newHub.hubName);
   const hubType = newHub.hubType || "chat";
   console.log(`
 New hub detected: "${newHub.hubName}" (${hubType})`);
@@ -10738,7 +10767,7 @@ hub_environment: preview
 ${content}`;
   }
   fs12.writeFileSync(hubYamlPath, updated, "utf-8");
-  autoLockIfUnlocked(hubId);
+  autoBindIfUnbound(hubId);
   await pushSingleHub(client, hubId, newHub.hubFolder, autoConfirm, organizationId, { skipAgentRename: true });
 }
 var init_push = __esm({
@@ -10754,7 +10783,7 @@ var init_push = __esm({
     init_workspace();
     init_layout();
     init_repo_config();
-    init_hub_lock();
+    init_hub_binding();
   }
 });
 
@@ -10792,13 +10821,13 @@ async function useCommand(args2) {
     }
     hubId = match.hubId;
   }
-  const previous = readLock();
+  const previous = readBinding();
   if (previous === hubId) {
-    console.log(`Worktree already locked to ${hubId}.`);
+    console.log(`Worktree already bound to ${hubId}.`);
     return;
   }
   try {
-    writeLock(hubId);
+    writeBinding(hubId);
   } catch (err) {
     console.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
@@ -10806,13 +10835,13 @@ async function useCommand(args2) {
   if (previous) {
     console.log(`Worktree rebound: ${previous} \u2192 ${hubId}`);
   } else {
-    console.log(`Worktree locked to hub ${hubId}.`);
+    console.log(`Worktree bound to hub ${hubId}.`);
   }
 }
 var init_use = __esm({
   "src/commands/use.ts"() {
     "use strict";
-    init_hub_lock();
+    init_hub_binding();
     init_workspace();
     init_layout();
     init_utils();
@@ -10912,24 +10941,24 @@ var init_migrate = __esm({
   }
 });
 
-// src/commands/unlock.ts
-var unlock_exports = {};
-__export(unlock_exports, {
-  unlockCommand: () => unlockCommand
+// src/commands/unbind.ts
+var unbind_exports = {};
+__export(unbind_exports, {
+  unbindCommand: () => unbindCommand
 });
-async function unlockCommand(_args) {
-  const previous = readLock();
+async function unbindCommand(_args) {
+  const previous = readBinding();
   if (!previous) {
-    console.log("No worktree lock to clear.");
+    console.log("No worktree binding to clear.");
     return;
   }
-  clearLock();
-  console.log(`Worktree unlocked (was: ${previous}).`);
+  clearBinding();
+  console.log(`Worktree unbound (was: ${previous}).`);
 }
-var init_unlock = __esm({
-  "src/commands/unlock.ts"() {
+var init_unbind = __esm({
+  "src/commands/unbind.ts"() {
     "use strict";
-    init_hub_lock();
+    init_hub_binding();
   }
 });
 
@@ -11115,7 +11144,41 @@ var conversations_exports = {};
 __export(conversations_exports, {
   conversationsCommand: () => conversationsCommand
 });
+function printConversationsHelp() {
+  console.error(`
+wayai conversations \u2014 list conversations or inspect what an agent received
+
+Usage:
+  wayai conversations                                  List conversations
+  wayai conversations --status <agent|team|ended>      Filter by status
+  wayai conversations --period 7d                      Analytics-powered list
+  wayai conversations --from <date> --to <date>        List within a date range
+  wayai conversations <conversation_id>                Show detail + messages
+  wayai conversations <conversation_id> observability   List the LLM turns (per-message id, latency, tool_calls)
+  wayai conversations <conversation_id> observability --message-id <id>
+                                                       Full record for one turn:
+                                                       resolved system prompt, the exact
+                                                       messages the model saw (rendered
+                                                       additional_context, injected
+                                                       timestamps, replayed history),
+                                                       completion, tool calls, tokens
+
+Options:
+  --message-id <id>   Expand one turn (only with the \`observability\` subcommand)
+  --limit <n>         Max rows (list view)
+  --offset <n>        Skip rows (list view)
+  --json              Raw JSON output
+
+The default text list omits message ids \u2014 use \`--json\` or the \`observability\`
+subcommand to discover them. \`observability\` is the answer to "the agent did X \u2014
+what did it ACTUALLY see?".
+`.trim());
+}
 async function conversationsCommand(args2) {
+  if (wantsHelp(args2)) {
+    printConversationsHelp();
+    return;
+  }
   const hubId = resolveActiveHubId(args2);
   const { config, accessToken } = await requireAuth();
   requireRepoConfig();
@@ -17027,11 +17090,11 @@ var init_admin = __esm({
 
 // src/commands/report-create.ts
 import { readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname7, join as join19 } from "path";
+import { dirname as dirname7, join as join20 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getCliVersion() {
   try {
-    const pkg2 = JSON.parse(readFileSync14(join19(__dirname, "..", "..", "package.json"), "utf-8"));
+    const pkg2 = JSON.parse(readFileSync14(join20(__dirname, "..", "..", "package.json"), "utf-8"));
     return `cli@${pkg2.version}`;
   } catch {
     return "cli@unknown";
@@ -17415,7 +17478,7 @@ var init_update = __esm({
 init_sentry();
 import { readFileSync as readFileSync15 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname8, join as join20 } from "path";
+import { dirname as dirname8, join as join21 } from "path";
 
 // src/lib/errors.ts
 init_api_client();
@@ -17544,10 +17607,9 @@ Run \`npx skills add wayai-pro/wayai-skill -y\` to update.`);
 
 // src/index.ts
 var __dirname2 = dirname8(fileURLToPath3(import.meta.url));
-var pkg = JSON.parse(readFileSync15(join20(__dirname2, "..", "package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync15(join21(__dirname2, "..", "package.json"), "utf-8"));
 var [, , command, ...args] = process.argv;
 var isBackgroundRefresh = command === REFRESH_COMMAND;
-var OWN_HELP_COMMANDS = /* @__PURE__ */ new Set(["eval", "admin", "report"]);
 if (!isBackgroundRefresh) initSentry(command);
 async function main() {
   if (shouldInterceptHelp(command, args, OWN_HELP_COMMANDS)) {
@@ -17600,9 +17662,11 @@ async function main() {
       await migrateCommand2(args);
       break;
     }
+    // `unlock` is the deprecated pre-rename alias for `unbind` (kept for back-compat).
+    case "unbind":
     case "unlock": {
-      const { unlockCommand: unlockCommand2 } = await Promise.resolve().then(() => (init_unlock(), unlock_exports));
-      await unlockCommand2(args);
+      const { unbindCommand: unbindCommand2 } = await Promise.resolve().then(() => (init_unbind(), unbind_exports));
+      await unbindCommand2(args);
       break;
     }
     case "send-message": {
@@ -17726,9 +17790,9 @@ Commands:
   push               Parse local files, show diff, sync to preview (creates hub if new)
   org create         Create a new organization (you become its owner)
   org <pull|push|diff>  Sync org-scoped resources as code (wayai-ws/org/)
-  use <hub>          Lock this worktree to a specific hub (UUID or folder name)
+  use <hub>          Bind this worktree to a specific hub (UUID or folder name)
   migrate            Move a legacy repo to the wayai-ws/{hubs,org} layout
-  unlock             Clear the worktree hub lock
+  unbind             Clear the worktree hub binding
   send-message       Send a test message to a preview hub
   conversations      List or inspect conversations
   analytics          Show analytics summary and metrics (use \`analytics query\` for structured ClickHouse queries)
@@ -17786,12 +17850,12 @@ Org-scoped mode:
   pull/push operate on the single hub in the workspace, or pass
   \`--hub <uuid|name>\` to disambiguate when multiple hubs exist.
 
-Worktree hub lock:
-  Each git checkout (main or linked worktree) can be locked to a single hub.
-  push/pull refuse to run against a different hub once locked. The lock is
-  auto-set on first successful pull (or new-hub creation) into an unlocked
-  checkout. Use \`wayai use <hub>\` to bind manually and \`wayai unlock\` to clear.
-  The lock lives at \`<git-dir>/wayai-lock\` and is naturally per-checkout.
+Worktree hub binding:
+  Each git checkout (main or linked worktree) can be bound to a single hub.
+  push/pull refuse to run against a different hub once bound. The binding is
+  auto-set on first successful pull (or new-hub creation) into an unbound
+  checkout. Use \`wayai use <hub>\` to bind manually and \`wayai unbind\` to clear.
+  The binding lives at \`<git-dir>/wayai-binding\` and is naturally per-checkout.
 
 Examples:
   wayai login