@tryarcanist/cli 0.1.175 → 0.1.177

package/README.md

@@ -266,9 +266,12 @@ arcanist sessions list
 arcanist sessions list --status idle --limit 20 --json
 arcanist sessions list --search "architect agent" --repo your-org/your-repo
 arcanist sessions list --scope business --cursor <cursor>
+arcanist sessions list --all --json
 ```
 
-JSON mode returns `{sessions, nextCursor}`. Search is metadata-only: generated titles and repo metadata.
+JSON mode returns `{sessions, nextCursor}`.
+`--all` follows cursors until completion and returns `nextCursor: null`.
+Search is metadata-only: generated titles and repo metadata.
 
 ### `arcanist sessions search <query>`
 
@@ -276,9 +279,10 @@ JSON mode returns `{sessions, nextCursor}`. Search is metadata-only: generated t
 arcanist sessions search "architect agent"
 arcanist sessions search "mcp debugging" --repo your-org/your-repo --json
 arcanist sessions search "repo access" --status idle --scope business --limit 20 --cursor <cursor>
+arcanist sessions search "repo access" --all --json
 ```
 
-Uses the same metadata-only index and filters as `sessions list`: `--status`, `--scope`, `--repo`, `--limit`, and `--cursor`.
+Uses the same metadata-only index and filters as `sessions list`: `--status`, `--scope`, `--repo`, `--limit`, `--cursor`, and `--all`.
 
 ### `arcanist sessions events <session-id>`
 
@@ -309,8 +313,11 @@ Renders a session transcript from the stored session export.
 ```bash
 arcanist sessions transcript abc123
 arcanist sessions transcript abc123 --json
+arcanist sessions transcript abc123 --last 20
 ```
 
+`--last <n>` renders only the last `n` stored transcript events after fetching the session export.
+
 ### `arcanist sessions watch <session-id>`
 
 Watches session activity until the session becomes idle. For machine-readable streaming, prefer `arcanist sessions events --follow --json`.
@@ -327,6 +334,42 @@ arcanist sessions usage abc123
 arcanist sessions usage abc123 --json
 ```
 
+### `arcanist repos list`
+
+```bash
+arcanist repos list
+arcanist repos list --json
+```
+
+JSON mode returns `{repos, ssoOrgs}`.
+
+### `arcanist repos branches [repo]`
+
+```bash
+arcanist repos branches tryarcanist/arcanist
+arcanist repos branches https://github.com/tryarcanist/arcanist --json
+```
+
+JSON mode returns `{branches}`.
+
+### `arcanist repos skills [repo]`
+
+```bash
+arcanist repos skills tryarcanist/arcanist
+arcanist repos skills https://github.com/tryarcanist/arcanist --json
+```
+
+JSON mode returns `{skills}`.
+
+### `arcanist models list`
+
+```bash
+arcanist models list
+arcanist models list --json
+```
+
+JSON mode returns `{models}`.
+
 ### `arcanist automations create <repo-url> [prompt]`
 
 Creates a scheduled automation for a GitHub repo. Create/delete require a write-scoped CLI token; read-scoped tokens can list automations. The server validates repo access, normalizes cron expressions, dedupes retries by repo+cron+prompt, and caps each business at 20 enabled rules.
@@ -368,8 +411,11 @@ arcanist automations delete rule_123 --yes --json
 arcanist tokens list
 arcanist tokens list --limit 10 --json
 arcanist tokens list --cursor <cursor> --json
+arcanist tokens list --all --json
 ```
 
+`--all` follows cursors until completion and returns `nextCursor: null` in JSON mode.
+
 ### `arcanist tokens create`
 
 Creates a CLI token and prints the plaintext token exactly once.

package/dist/index.js

@@ -952,9 +952,9 @@ function formatModelLabel(raw, options = {}) {
   const providerName = MODEL_PROVIDER_NAMES[selection.providerID];
   return includeProvider ? `${providerName} / ${selection.modelID}` : selection.modelID;
 }
-function buildModelProviderGroups(models) {
+function buildModelProviderGroups(models2) {
   const groups = /* @__PURE__ */ new Map();
-  for (const model of models) {
+  for (const model of models2) {
     let group = groups.get(model.provider);
     if (!group) {
       group = { id: model.provider, name: MODEL_PROVIDER_NAMES[model.provider], models: [] };
@@ -3380,6 +3380,31 @@ async function messageCommand(sessionId, promptArg, options = {}, command) {
   console.log(`Message sent to session ${sessionId}.`);
 }
 
+// src/commands/models.ts
+async function modelsListCommand(options = {}, command) {
+  const { config } = resolveBusinessContext(command, options);
+  const groups = await apiFetch(config, "/api/models");
+  const models2 = groups.flatMap(
+    (group) => group.models.map((model) => {
+      const backends = model.backends ?? [group.id];
+      return {
+        ...model,
+        backend: group.id,
+        provider: group.id,
+        backends,
+        default: backends.some(
+          (backend) => DEFAULT_SESSION_START_MODEL_ID_BY_BACKEND[backend] === model.id
+        )
+      };
+    })
+  );
+  emit(command, options, { models: models2 }, (payload) => {
+    for (const model of payload.models) {
+      console.log(`${String(model.id)}	${String(model.backend)}${model.default ? "	default" : ""}`);
+    }
+  });
+}
+
 // ../../shared/agent/verify-directive.ts
 var MAX_TARGET_PR_URL_LENGTH = 500;
 function normalizeGithubPullRequestUrl(rawUrl) {
@@ -3511,6 +3536,63 @@ async function qaCommand(prUrl, options, command) {
   console.log(`Follow with: arcanist sessions events ${sessionId} --follow --json`);
 }
 
+// src/commands/repos.ts
+import { execFileSync } from "child_process";
+function git(args) {
+  try {
+    return execFileSync("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+  } catch (err) {
+    throw new CliError("user", `git ${args.join(" ")} failed: ${stringifyError(err)}`);
+  }
+}
+function currentRepo() {
+  const parsed = parseGithubRepoFullName(git(["remote", "get-url", "origin"]));
+  if (!parsed) throw new CliError("user", "origin remote must point at a GitHub repository");
+  return { owner: parsed.owner, repo: parsed.repo };
+}
+function parseRepoArg2(value) {
+  if (!value) return currentRepo();
+  const parsed = parseGithubRepoFullName(value);
+  if (!parsed) throw new CliError("user", "repo must be owner/name or a GitHub URL");
+  return { owner: parsed.owner, repo: parsed.repo };
+}
+async function reposListCommand(options = {}, command) {
+  const { config } = resolveBusinessContext(command, options);
+  const payload = await apiFetch(
+    config,
+    "/api/repos"
+  );
+  emit(command, options, { repos: payload.repos, ssoOrgs: payload.ssoOrgs }, (data) => {
+    for (const repo of data.repos) {
+      console.log(`${String(repo.fullName ?? repo.name ?? repo.repo ?? "")}	${String(repo.defaultBranch ?? "")}`);
+    }
+    if (data.ssoOrgs.length > 0) console.log(`SSO withheld orgs: ${data.ssoOrgs.length}`);
+  });
+}
+async function repoBranchesCommand(repoArg, options = {}, command) {
+  const { config } = resolveBusinessContext(command, options);
+  const repo = parseRepoArg2(repoArg);
+  await apiFetch(config, "/api/repos");
+  const payload = await apiFetch(
+    config,
+    `/api/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.repo)}/branches`
+  );
+  emit(command, options, payload, (data) => {
+    for (const branch of data.branches) console.log(String(branch.name ?? branch.branch ?? ""));
+  });
+}
+async function repoSkillsCommand(repoArg, options = {}, command) {
+  const { config } = resolveBusinessContext(command, options);
+  const repo = parseRepoArg2(repoArg);
+  const payload = await apiFetch(
+    config,
+    `/api/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.repo)}/skills`
+  );
+  emit(command, options, payload, (data) => {
+    for (const skill of data.skills) console.log(`${String(skill.name ?? "")}	${String(skill.description ?? "")}`);
+  });
+}
+
 // src/commands/respond.ts
 async function resolveAnswerInput(answerArg, options) {
   const shouldReadStdin = options.answerStdin === true || answerArg === "-";
@@ -3563,7 +3645,7 @@ function parseRespondConflict(err) {
 }
 
 // src/commands/sandbox.ts
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { dirname as dirname2 } from "path";
 
@@ -4099,34 +4181,34 @@ var DEFAULT_MANIFEST_PATH = SANDBOX_LAYER_MANIFEST_PATH;
 var DEFAULT_POLL_INTERVAL_MS = 2500;
 var MIN_POLL_INTERVAL_MS = 250;
 var TERMINAL_BUILD_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "canceled"]);
-function git(args) {
+function git2(args) {
   try {
-    return execFileSync("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+    return execFileSync2("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
   } catch (err) {
     throw new CliError("user", `git ${args.join(" ")} failed: ${stringifyError(err)}`);
   }
 }
-function currentRepo() {
-  const remote = git(["remote", "get-url", "origin"]);
+function currentRepo2() {
+  const remote = git2(["remote", "get-url", "origin"]);
   const parsed = parseGithubRepoFullName(remote);
   if (!parsed) throw new CliError("user", "origin remote must point at a GitHub repository");
   return { owner: parsed.owner, repo: parsed.repo };
 }
 function currentRef() {
-  return git(["rev-parse", "--abbrev-ref", "HEAD"]);
+  return git2(["rev-parse", "--abbrev-ref", "HEAD"]);
 }
 function assertCleanAndPushed() {
-  const dirty = git(["status", "--porcelain"]);
+  const dirty = git2(["status", "--porcelain"]);
   if (dirty) throw new CliError("user", "Sandbox layer source must be committed before build.");
-  const upstream = git(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]);
-  const ahead = git(["rev-list", "--count", `${upstream}..HEAD`]);
+  const upstream = git2(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]);
+  const ahead = git2(["rev-list", "--count", `${upstream}..HEAD`]);
   if (ahead !== "0")
     throw new CliError("user", "Current commit is not pushed; push before building the sandbox layer.");
 }
 function assertManifestExists(path) {
   if (!existsSync2(path)) throw new CliError("user", `Missing sandbox manifest: ${path}`);
 }
-function parseRepoArg2(value, fallback) {
+function parseRepoArg3(value, fallback) {
   if (!value) return fallback();
   const parsed = parseGithubRepoFullName(value);
   if (!parsed) throw new CliError("user", "repo must be owner/name or a GitHub URL");
@@ -4303,7 +4385,7 @@ function formatValidationPayload(input) {
 }
 function nextBuildCommand(manifestPath) {
   try {
-    const repo = currentRepo();
+    const repo = currentRepo2();
     const manifestArg = manifestPath === DEFAULT_MANIFEST_PATH ? "" : ` --manifest ${manifestPath}`;
     return `arcanist sandbox build ${repoPath(repo)} --wait --follow${manifestArg}`;
   } catch {
@@ -4393,8 +4475,8 @@ async function sandboxBuildCommand(sourceRepoArg, options = {}, command) {
   const manifestPath = options.manifest ?? DEFAULT_MANIFEST_PATH;
   assertManifestExists(manifestPath);
   if (!options.ref) assertCleanAndPushed();
-  const sourceRepo = parseRepoArg2(sourceRepoArg, currentRepo);
-  const targetRepo = options.targetRepo ? parseRepoArg2(options.targetRepo, currentRepo) : null;
+  const sourceRepo = parseRepoArg3(sourceRepoArg, currentRepo2);
+  const targetRepo = options.targetRepo ? parseRepoArg3(options.targetRepo, currentRepo2) : null;
   const businessId = await resolveBusinessId(config, options);
   const ref = options.ref ?? currentRef();
   let payload;
@@ -4445,7 +4527,7 @@ async function sandboxBuildCommand(sourceRepoArg, options = {}, command) {
 async function sandboxStatusCommand(repoArg, options = {}, command) {
   const { config } = resolveBusinessContext(command, options);
   const businessId = await resolveBusinessId(config, options);
-  const repo = parseRepoArg2(repoArg, currentRepo);
+  const repo = parseRepoArg3(repoArg, currentRepo2);
   const payload = await apiFetch(
     config,
     `/api/businesses/${encodeURIComponent(businessId)}/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(
@@ -4457,9 +4539,9 @@ async function sandboxStatusCommand(repoArg, options = {}, command) {
 async function sandboxHistoryCommand(sourceRepoArg, options = {}, command) {
   const { config } = resolveBusinessContext(command, options);
   const businessId = await resolveBusinessId(config, options);
-  const sourceRepo = parseRepoArg2(sourceRepoArg, currentRepo);
+  const sourceRepo = parseRepoArg3(sourceRepoArg, currentRepo2);
   const params = new URLSearchParams({ sourceRepo: repoPath(sourceRepo) });
-  if (options.targetRepo) params.set("targetRepo", repoPath(parseRepoArg2(options.targetRepo, currentRepo)));
+  if (options.targetRepo) params.set("targetRepo", repoPath(parseRepoArg3(options.targetRepo, currentRepo2)));
   if (options.status) params.set("status", options.status);
   if (options.limit) {
     const limit = Number(options.limit);
@@ -4560,7 +4642,7 @@ async function sandboxLogsCommand(buildId, options = {}, command) {
 async function sandboxAssignDefaultCommand(sourceRepoArg, options = {}, command) {
   const { config } = resolveBusinessContext(command, options);
   const businessId = await resolveBusinessId(config, options);
-  const sourceRepo = parseRepoArg2(sourceRepoArg, currentRepo);
+  const sourceRepo = parseRepoArg3(sourceRepoArg, currentRepo2);
   const manifestPath = options.manifest ?? DEFAULT_MANIFEST_PATH;
   const payload = await apiFetch(
     config,
@@ -4577,8 +4659,8 @@ async function sandboxAssignDefaultCommand(sourceRepoArg, options = {}, command)
 async function sandboxAssignRepoCommand(targetRepoArg, sourceRepoArg, options = {}, command) {
   const { config } = resolveBusinessContext(command, options);
   const businessId = await resolveBusinessId(config, options);
-  const targetRepo = parseRepoArg2(targetRepoArg, currentRepo);
-  const sourceRepo = parseRepoArg2(sourceRepoArg, currentRepo);
+  const targetRepo = parseRepoArg3(targetRepoArg, currentRepo2);
+  const sourceRepo = parseRepoArg3(sourceRepoArg, currentRepo2);
   const manifestPath = options.manifest ?? DEFAULT_MANIFEST_PATH;
   const payload = await apiFetch(
     config,
@@ -4616,7 +4698,7 @@ async function sandboxUnassignRepoCommand(targetRepoArg, options = {}, command)
   }
   const { config } = resolveBusinessContext(command, options);
   const businessId = await resolveBusinessId(config, options);
-  const targetRepo = parseRepoArg2(targetRepoArg, currentRepo);
+  const targetRepo = parseRepoArg3(targetRepoArg, currentRepo2);
   if (!options.yes) await confirmOrThrow(`Clear sandbox layer assignment for ${repoPath(targetRepo)}?`);
   const payload = await apiFetch(
     config,
@@ -4629,20 +4711,35 @@ async function sandboxUnassignRepoCommand(targetRepoArg, options = {}, command)
 }
 
 // src/commands/sessions.ts
+var MAX_ALL_PAGES = 1e3;
 async function listSessionsCommand(options, command) {
   const runtime = getRuntimeOptions(command, options);
   const config = requireConfig(runtime);
-  const query = new URLSearchParams();
-  if (options.status) query.set("status", options.status);
-  if (options.scope) query.set("scope", options.scope);
-  if (options.search) query.set("q", options.search);
-  if (options.repo) query.set("repo", options.repo);
-  if (options.limit) query.set("limit", options.limit);
-  if (options.cursor) query.set("cursor", options.cursor);
-  const payload = await apiFetch(
-    config,
-    `/api/sessions${query.size ? `?${query.toString()}` : ""}`
-  );
+  const sessions2 = [];
+  let cursor = options.cursor;
+  let nextCursor = null;
+  let pageCount = 0;
+  do {
+    pageCount += 1;
+    if (options.all === true && pageCount > MAX_ALL_PAGES) {
+      throw new CliError("user", `sessions list --all exceeded ${MAX_ALL_PAGES} pages without reaching the end.`);
+    }
+    const query = new URLSearchParams();
+    if (options.status) query.set("status", options.status);
+    if (options.scope) query.set("scope", options.scope);
+    if (options.search) query.set("q", options.search);
+    if (options.repo) query.set("repo", options.repo);
+    if (options.limit) query.set("limit", options.limit);
+    if (cursor) query.set("cursor", cursor);
+    const payload2 = await apiFetch(
+      config,
+      `/api/sessions${query.size ? `?${query.toString()}` : ""}`
+    );
+    sessions2.push(...payload2.sessions);
+    nextCursor = payload2.nextCursor;
+    cursor = nextCursor ?? void 0;
+  } while (options.all === true && nextCursor);
+  const payload = { sessions: sessions2, nextCursor: options.all === true ? null : nextCursor };
   if (isJson(command, options)) {
     writeJson(payload);
     return;
@@ -4796,7 +4893,7 @@ function parseStopBlocked(err) {
 
 // src/commands/test-creds.ts
 import { readFileSync as readFileSync4 } from "fs";
-function parseRepoArg3(repo) {
+function parseRepoArg4(repo) {
   const trimmed = repo.trim();
   const slashIndex = trimmed.indexOf("/");
   if (slashIndex <= 0 || slashIndex === trimmed.length - 1) {
@@ -4818,7 +4915,7 @@ function readValue(options) {
 }
 async function listTestCredentialsCommand(repo, options, command) {
   const { config } = resolveBusinessContext(command, options);
-  const repoArg = parseRepoArg3(repo);
+  const repoArg = parseRepoArg4(repo);
   const payload = await apiFetch(config, basePath(options.business, repoArg));
   emit(command, options, payload, (listPayload) => {
     if (listPayload.credentials.length === 0) {
@@ -4833,7 +4930,7 @@ async function listTestCredentialsCommand(repo, options, command) {
 }
 async function setTestCredentialCommand(repo, name, options, command) {
   const { config } = resolveBusinessContext(command, options);
-  const repoArg = parseRepoArg3(repo);
+  const repoArg = parseRepoArg4(repo);
   const value = readValue(options);
   const payload = await apiFetch(
     config,
@@ -4852,11 +4949,11 @@ async function deleteTestCredentialCommand(repo, name, options, command) {
     throw new CliError("user", "`test-creds delete --json` requires --yes.");
   }
   if (options.yes !== true) {
-    const repoArg2 = parseRepoArg3(repo);
+    const repoArg2 = parseRepoArg4(repo);
     await confirmOrThrow(`Delete test credential '${name}' for ${repoArg2.owner}/${repoArg2.name}?`);
   }
   const { config } = resolveBusinessContext(command, options);
-  const repoArg = parseRepoArg3(repo);
+  const repoArg = parseRepoArg4(repo);
   const payload = await apiFetch(
     config,
     `${basePath(options.business, repoArg)}/${encodeURIComponent(name)}`,
@@ -4871,15 +4968,30 @@ async function deleteTestCredentialCommand(repo, name, options, command) {
 }
 
 // src/commands/tokens.ts
+var MAX_ALL_PAGES2 = 1e3;
 async function listTokensCommand(options, command) {
   const { config } = resolveBusinessContext(command, options);
-  const query = new URLSearchParams();
-  if (options.limit) query.set("limit", options.limit);
-  if (options.cursor) query.set("cursor", options.cursor);
-  const payload = await apiFetch(
-    config,
-    `/api/cli-tokens${query.size ? `?${query.toString()}` : ""}`
-  );
+  const data = [];
+  let cursor = options.cursor;
+  let nextCursor = null;
+  let pageCount = 0;
+  do {
+    pageCount += 1;
+    if (options.all === true && pageCount > MAX_ALL_PAGES2) {
+      throw new CliError("user", `tokens list --all exceeded ${MAX_ALL_PAGES2} pages without reaching the end.`);
+    }
+    const query = new URLSearchParams();
+    if (options.limit) query.set("limit", options.limit);
+    if (cursor) query.set("cursor", cursor);
+    const payload2 = await apiFetch(
+      config,
+      `/api/cli-tokens${query.size ? `?${query.toString()}` : ""}`
+    );
+    data.push(...payload2.data);
+    nextCursor = payload2.nextCursor;
+    cursor = nextCursor ?? void 0;
+  } while (options.all === true && nextCursor);
+  const payload = { data, nextCursor: options.all === true ? null : nextCursor };
   emit(command, options, payload, (listPayload) => {
     if (listPayload.data.length === 0) {
       console.log("No CLI tokens found.");
@@ -4943,8 +5055,44 @@ async function revokeTokenCommand(tokenId, options, command) {
 // src/commands/transcript.ts
 async function transcriptCommand(sessionId, options, command) {
   const { config } = resolveBusinessContext(command, options);
+  const last = parseLast(options.last);
   const exportData = await apiFetch(config, `/api/sessions/${sessionId}/export`);
-  emit(command, options, exportData, (payload) => console.log(renderSessionTranscript(payload)));
+  const payload = last == null ? exportData : sliceTranscript(exportData, last, { includeBoundaryEvent: !isJson(command, options) });
+  emit(command, options, payload, (data) => console.log(renderSessionTranscript(data)));
+}
+function parseLast(raw) {
+  if (raw === void 0) return null;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed <= 0) throw new CliError("user", "--last must be a positive integer.");
+  return parsed;
+}
+function sliceTranscript(exportData, last, options) {
+  const start = Math.max(0, exportData.events.length - last);
+  const boundary = findPromptBoundary(exportData.events, start);
+  const tail = exportData.events.slice(start);
+  const events = options.includeBoundaryEvent && boundary !== null && boundary < start ? [exportData.events[boundary], ...tail] : tail;
+  const promptIds = promptIdsForEvents(events);
+  if (boundary !== null) {
+    const boundaryPromptId = getRawSessionEventPromptId(exportData.events[boundary]);
+    if (boundaryPromptId) promptIds.add(boundaryPromptId);
+  }
+  const prompts = exportData.prompts.filter((prompt) => promptIds.has(prompt.id));
+  return { ...exportData, prompts, events };
+}
+function findPromptBoundary(events, start) {
+  for (let index = start; index >= 0; index--) {
+    const event = events[index];
+    if (event && getRawSessionEventKind(event) === "prompt_processing") return index;
+  }
+  return null;
+}
+function promptIdsForEvents(events) {
+  const promptIds = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    const promptId = getRawSessionEventPromptId(event);
+    if (promptId) promptIds.add(promptId);
+  }
+  return promptIds;
 }
 
 // src/index.ts
@@ -5103,27 +5251,29 @@ JSON:
 JSON mode returns the raw session payload. Result fields are at .session.prUrl, .session.publishedBranch, and .session.lastBranch.
 `
 ).action((sessionId, options, command) => getSessionCommand(sessionId, options, command));
-sessions.command("list").description("List sessions").option("--status <status>", "Filter by session status").option("--scope <scope>", "Session scope: mine or business").option("--search <query>", "Search session titles and repo metadata").option("--repo <repo>", "Filter by repo metadata").option("--limit <n>", "Maximum sessions to return").option("--cursor <cursor>", "Pagination cursor").addHelpText(
+sessions.command("list").description("List sessions").option("--status <status>", "Filter by session status").option("--scope <scope>", "Session scope: mine or business").option("--search <query>", "Search session titles and repo metadata").option("--repo <repo>", "Filter by repo metadata").option("--limit <n>", "Maximum sessions to return").option("--cursor <cursor>", "Pagination cursor").option("--all", "Fetch all pages").addHelpText(
   "after",
   `
 Examples:
   arcanist sessions list
   arcanist sessions list --status idle --json
   arcanist sessions list --search "architect agent" --repo owner/repo
+  arcanist sessions list --all --json
 
 JSON:
-JSON mode returns {sessions, nextCursor}
+JSON mode returns {sessions, nextCursor}. --all follows cursors until nextCursor is null.
 `
 ).action((options, command) => listSessionsCommand(options, command));
-sessions.command("search").description("Search sessions by title and repo metadata").argument("<query>", "Search query").option("--status <status>", "Filter by session status").option("--scope <scope>", "Session scope: mine or business").option("--repo <repo>", "Filter by repo metadata").option("--limit <n>", "Maximum sessions to return").option("--cursor <cursor>", "Pagination cursor").addHelpText(
+sessions.command("search").description("Search sessions by title and repo metadata").argument("<query>", "Search query").option("--status <status>", "Filter by session status").option("--scope <scope>", "Session scope: mine or business").option("--repo <repo>", "Filter by repo metadata").option("--limit <n>", "Maximum sessions to return").option("--cursor <cursor>", "Pagination cursor").option("--all", "Fetch all pages").addHelpText(
   "after",
   `
 Examples:
   arcanist sessions search "architect agent"
   arcanist sessions search "mcp debugging" --repo owner/repo --json
+  arcanist sessions search "repo access" --all --json
 
 JSON:
-JSON mode returns {sessions, nextCursor}
+JSON mode returns {sessions, nextCursor}. --all follows cursors until nextCursor is null.
 `
 ).action((query, options, command) => searchSessionsCommand(query, options, command));
 sessions.command("events").description("Read or follow session replay events").argument("<session-id>", "Session ID").option("--after-sequence <n>", "Return events after this sequence").option("--after <n>", "Alias for --after-sequence").option("--before-sequence <n>", "Return events before this sequence").option("--before <n>", "Alias for --before-sequence").option("--prompt-id <id>", "Filter events by prompt ID").option("--limit <n>", "Maximum events to return").option("--follow", "Follow events until the session is idle").option("--poll-interval <ms>", "Polling interval in milliseconds", String(DEFAULT_WATCH_POLL_INTERVAL_MS)).addHelpText(
@@ -5141,12 +5291,13 @@ JSON mode without --follow returns one JSON object from /events/history: {events
   Actionable follow types: pr_created/pr_updated use data.prUrl; question uses data.question; terminal types are prompt_completed, prompt_failed, and session_idle.
 `
 ).action((sessionId, options, command) => sessionEventsCommand(sessionId, options, command));
-sessions.command("transcript").description("Render a session transcript").argument("<session-id>", "Session ID").addHelpText(
+sessions.command("transcript").description("Render a session transcript").argument("<session-id>", "Session ID").option("--last <n>", "Render only the last n transcript entries").addHelpText(
   "after",
   `
 Examples:
   arcanist sessions transcript <session-id>
   arcanist sessions transcript <session-id> --json
+  arcanist sessions transcript <session-id> --last 20
 `
 ).action((sessionId, options, command) => transcriptCommand(sessionId, options, command));
 sessions.command("watch").description("Watch session activity until it becomes idle").argument("<session-id>", "Session ID").option("--poll-interval <ms>", "Polling interval in milliseconds", String(DEFAULT_WATCH_POLL_INTERVAL_MS)).addHelpText(
@@ -5165,6 +5316,36 @@ Examples:
   arcanist sessions usage <session-id> --json
 `
 ).action((sessionId, options, command) => usageCommand(sessionId, options, command));
+var repos = program.command("repos").description("Repository discovery commands");
+repos.command("list").description("List accessible repositories").addHelpText(
+  "after",
+  `
+JSON:
+JSON mode returns {repos, ssoOrgs}
+`
+).action((options, command) => reposListCommand(options, command));
+repos.command("branches").description("List repository branches").argument("[repo]", "Repository owner/name; defaults to current git remote").addHelpText(
+  "after",
+  `
+JSON:
+JSON mode returns {branches}
+`
+).action((repo, options, command) => repoBranchesCommand(repo, options, command));
+repos.command("skills").description("List repository skills").argument("[repo]", "Repository owner/name; defaults to current git remote").addHelpText(
+  "after",
+  `
+JSON:
+JSON mode returns {skills}
+`
+).action((repo, options, command) => repoSkillsCommand(repo, options, command));
+var models = program.command("models").description("Model discovery commands");
+models.command("list").description("List session-start models").addHelpText(
+  "after",
+  `
+JSON:
+JSON mode returns {models}
+`
+).action((options, command) => modelsListCommand(options, command));
 var automations = program.command("automations").description("Automation commands");
 automations.command("create").description("Create a scheduled automation").argument("<repo-url>", "Repository URL").argument("[prompt]", "Prompt to run, or '-' to read stdin").requiredOption("--cron <expr>", "Cron expression").option("--name <name>", "Automation display name").option(
   "--model <model>",
@@ -5236,7 +5417,7 @@ egress.command("add").description("Open or update a PR adding domains to the egr
 egress.command("sync").description("Apply the merged egress allowlist source file to the runtime business policy").option("--business <id>", "Business ID; defaults to authenticated user's business").action((options, command) => egressSyncCommand(options, command));
 egress.command("validate").description("Validate a local egress allowlist source file").argument("[path]", "Path to validate", ".arcanist/egress-allowlist.txt").action((path, options, command) => egressValidateCommand(path, options, command));
 var tokens = program.command("tokens").description("CLI token commands");
-tokens.command("list").description("List CLI tokens").option("--limit <n>", "Maximum tokens to return").option("--cursor <cursor>", "Pagination cursor").action((options, command) => listTokensCommand(options, command));
+tokens.command("list").description("List CLI tokens").option("--limit <n>", "Maximum tokens to return").option("--cursor <cursor>", "Pagination cursor").option("--all", "Fetch all pages").action((options, command) => listTokensCommand(options, command));
 tokens.command("create").description("Create a CLI token and print it once").option("--scope <scope>", "Token scope: read or write", "read").option("--expires-in-days <days>", "Token expiry in days").option("--idempotency-key <uuid>", "Request idempotency key for safe manual retries").addHelpText(
   "after",
   `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryarcanist/cli",
-  "version": "0.1.175",
+  "version": "0.1.177",
   "description": "CLI for Arcanist — create and manage coding agent sessions",
   "type": "module",
   "bin": {