@balise.dev/cli 0.1.2 → 0.2.0

package/README.md

@@ -61,6 +61,25 @@ Tokens are written to a plaintext JSON file with restrictive permissions:
 
 If you need OS-keychain-grade protection, set `BALISE_CREDENTIALS_FILE` to a path on an encrypted volume, or feed `BALISE_TOKEN` from your existing secret manager.
 
+## Build-time policy patterns
+
+`balise init` ships with two compile-time pattern lists baked into the bundle via tsup `define`:
+
+| Env var (build) | Used for | SSOT contract |
+|---|---|---|
+| `BALISE_BAN_PATTERNS` | Directories the extractor will never read (`.git`, `node_modules`, …). Displayed as 🔒 read-only in the `balise init` ignore tree. | **MUST** match the worker-side env var of the same name (read by `balise_mcp/diff_loc.py`). Changing one without the other breaks the SSOT verrou between credit estimate and what the agent sees. |
+| `BALISE_DEFAULT_PATTERNS` | Globs pre-checked-out in the ignore tree as a sensible default (lockfiles, minified assets, snapshots, …). User remains free to scan them — they just pay the tokens. | CLI-only. |
+
+Override at build time:
+
+```bash
+BALISE_BAN_PATTERNS=.git,node_modules,dist \
+BALISE_DEFAULT_PATTERNS='*.lock,*.min.js' \
+  npm run build
+```
+
+The defaults baked when these env vars are unset are visible in `cli/tsup.config.ts`.
+
 ## Dev
 
 ```bash

package/dist/index.js

@@ -548,8 +548,8 @@ var ApiClient = class {
     }
     return res.json();
   }
-  async getJson(path4) {
-    const url = joinUrl(this.opts.apiUrl, path4);
+  async getJson(path7) {
+    const url = joinUrl(this.opts.apiUrl, path7);
     return this.withAuth(async (headers) => {
       const { statusCode, body } = await wrapNetwork(() => request2(url, {
         method: "GET",
@@ -564,8 +564,8 @@ var ApiClient = class {
       };
     });
   }
-  async postJson(path4, payload) {
-    const url = joinUrl(this.opts.apiUrl, path4);
+  async postJson(path7, payload) {
+    const url = joinUrl(this.opts.apiUrl, path7);
     return this.withAuth(async (headers) => {
       const { statusCode, body } = await wrapNetwork(() => request2(url, {
         method: "POST",
@@ -589,10 +589,10 @@ var ApiClient = class {
    * metadata travels in the query string. Matches the FastAPI contract
    * `POST /v1/repos/:owner/:slug/sync?commit_sha=...&branch=...`.
    */
-  async uploadBundle(path4, opts) {
+  async uploadBundle(path7, opts) {
     await this.ensureFreshToken();
     const qs = new URLSearchParams(opts.query).toString();
-    const url = `${joinUrl(this.opts.apiUrl, path4)}${qs ? `?${qs}` : ""}`;
+    const url = `${joinUrl(this.opts.apiUrl, path7)}${qs ? `?${qs}` : ""}`;
     return this.withAuth(async (headers) => {
       const { statusCode, body } = await wrapNetwork(() => request2(url, {
         method: "POST",
@@ -613,9 +613,43 @@ var ApiClient = class {
       };
     });
   }
+  /**
+   * Same wire as `uploadBundle` but returns the raw `(status, text)` pair so
+   * callers can branch on response shape (200 dry-run, 202 happy, 409
+   * idempotency, 422 invalid base) without `ApiError` swallowing the body.
+   *
+   * Token refresh and auth attachment behave identically; we still rely on
+   * `withAuth` for the 401-then-retry plumbing. Non-401 statuses are
+   * returned to the caller verbatim — `withAuth` only treats 401 specially.
+   */
+  async uploadBundleRaw(path7, opts) {
+    await this.ensureFreshToken();
+    const qs = new URLSearchParams(opts.query).toString();
+    const url = `${joinUrl(this.opts.apiUrl, path7)}${qs ? `?${qs}` : ""}`;
+    let tokens = await loadTokens();
+    if (!tokens) throw new NotAuthenticatedError();
+    const exec = async (token) => {
+      const { statusCode, body } = await wrapNetwork(
+        () => request2(url, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/octet-stream"
+          },
+          body: opts.bundleStream,
+          dispatcher: this.opts.dispatcher
+        })
+      );
+      const text = await body.text();
+      return { status: statusCode, text };
+    };
+    const first = await exec(tokens.access_token);
+    if (first.status !== 401) return first;
+    throw new NotAuthenticatedError();
+  }
 };
-function joinUrl(base, path4) {
-  return `${base.replace(/\/$/, "")}${path4.startsWith("/") ? path4 : `/${path4}`}`;
+function joinUrl(base, path7) {
+  return `${base.replace(/\/$/, "")}${path7.startsWith("/") ? path7 : `/${path7}`}`;
 }
 
 // src/config.ts
@@ -700,8 +734,8 @@ account_id  : ${me.account_id}
 }
 
 // src/commands/init.ts
-import path3 from "path";
-import React2 from "react";
+import path5 from "path";
+import React3 from "react";
 import { render } from "ink";
 
 // src/git.ts
@@ -795,7 +829,6 @@ async function gitBundle(opts) {
 }
 
 // src/auth-ensure.ts
-import readline from "readline/promises";
 import crypto3 from "crypto";
 import open2 from "open";
 var LoginDeclinedError = class extends Error {
@@ -808,6 +841,7 @@ function isInteractive(stdin) {
   const s = stdin ?? process.stdin;
   return Boolean(s.isTTY);
 }
+var LOGIN_AUTOLAUNCH_MESSAGE = "Not logged in, launching balise login...";
 async function ensureAuthenticated(opts) {
   const existing = await loadTokens();
   if (existing) return;
@@ -815,19 +849,8 @@ async function ensureAuthenticated(opts) {
   if (!isInteractive(opts.stdin)) {
     throw new LoginDeclinedError();
   }
-  const rl = readline.createInterface({
-    input: opts.stdin ?? process.stdin,
-    output: opts.stdout ?? process.stdout
-  });
-  let answer;
-  try {
-    answer = (await rl.question("Not logged in. Login now? (Y/n) ")).trim();
-  } finally {
-    rl.close();
-  }
-  if (answer && !/^y(es)?$/i.test(answer)) {
-    throw new LoginDeclinedError();
-  }
+  stderr.write(`${LOGIN_AUTOLAUNCH_MESSAGE}
+`);
   const verifier = generateCodeVerifier();
   const challenge = codeChallengeFor(verifier);
   const state = crypto3.randomBytes(16).toString("hex");
@@ -892,55 +915,626 @@ ${credentialsHelpMessage()}
 // src/ui/InitPicker.tsx
 import React, { useState } from "react";
 import { Box, Text, useApp, useInput } from "ink";
+import { Select, TextInput } from "@inkjs/ui";
+function normalizeSlug(raw) {
+  return raw.toLowerCase().replace(/[^a-z0-9-]/g, "");
+}
 function InitPicker(props) {
   const { exit } = useApp();
-  const [zone, setZone] = useState(
-    props.repos.length > 0 ? "link" : "create"
+  const currentMatches = props.currentRepoId !== void 0 && props.repos.some((r) => r.id === props.currentRepoId);
+  const [field, setField] = useState(currentMatches ? "link" : "slug");
+  const [slug, setSlug] = useState(normalizeSlug(props.defaultSlug));
+  const [ownerId, setOwnerId] = useState(
+    props.ownerships[0]?.id
   );
-  const [slug, setSlug] = useState(props.defaultSlug);
-  const [ownerIdx, setOwnerIdx] = useState(0);
-  const [repoIdx, setRepoIdx] = useState(0);
-  useInput((input, key) => {
+  const [repoId, setRepoId] = useState(
+    currentMatches ? props.currentRepoId : props.repos[0]?.id
+  );
+  const submit = () => {
+    if (field === "link") {
+      const repo = props.repos.find((r) => r.id === repoId);
+      if (!repo) return;
+      props.onDone({ action: "link", repo });
+    } else {
+      const owner = props.ownerships.find((o) => o.id === ownerId);
+      if (!owner || !slug) return;
+      props.onDone({ action: "create", slug, owner });
+    }
+    exit();
+  };
+  useInput((_input, key) => {
     if (key.escape) {
       props.onDone({ action: "cancel" });
       exit();
       return;
     }
     if (key.tab) {
-      setZone((z) => z === "create" ? "link" : "create");
+      setField((f) => {
+        if (f === "slug") return "owner";
+        if (f === "owner") return props.repos.length > 0 ? "link" : "slug";
+        return "slug";
+      });
       return;
     }
     if (key.return) {
-      if (zone === "create") {
-        if (!props.ownerships[ownerIdx]) return;
-        props.onDone({
-          action: "create",
-          slug,
-          owner: props.ownerships[ownerIdx]
+      submit();
+    }
+  });
+  const ownerOptions = props.ownerships.map((o) => ({
+    label: `${o.login} (${o.type})`,
+    value: o.id
+  }));
+  const repoOptions = props.repos.map((r) => ({
+    label: r.id === props.currentRepoId ? `${r.owner_login}/${r.slug} (current)` : `${r.owner_login}/${r.slug}`,
+    value: r.id
+  }));
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true }, "Balise \u2014 link or create a repo"), /* @__PURE__ */ React.createElement(Box, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: field === "slug" ? "cyan" : "gray" }, field === "slug" ? "\u25B8 " : "  ", "New repo slug"), /* @__PURE__ */ React.createElement(Box, { marginLeft: 2 }, /* @__PURE__ */ React.createElement(
+    TextInput,
+    {
+      defaultValue: slug,
+      placeholder: "repo-slug",
+      isDisabled: field !== "slug",
+      onChange: (v) => setSlug(normalizeSlug(v))
+    }
+  ))), /* @__PURE__ */ React.createElement(Box, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: field === "owner" ? "cyan" : "gray" }, field === "owner" ? "\u25B8 " : "  ", "Owner"), /* @__PURE__ */ React.createElement(Box, { marginLeft: 2 }, field === "owner" ? /* @__PURE__ */ React.createElement(
+    Select,
+    {
+      options: ownerOptions,
+      defaultValue: ownerId,
+      onChange: setOwnerId
+    }
+  ) : /* @__PURE__ */ React.createElement(Text, { dimColor: true }, ownerOptions.find((o) => o.value === ownerId)?.label ?? "\u2014"))), props.repos.length > 0 && /* @__PURE__ */ React.createElement(Box, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: field === "link" ? "cyan" : "gray" }, field === "link" ? "\u25B8 " : "  ", "Link existing (", props.repos.length, ")"), /* @__PURE__ */ React.createElement(Box, { marginLeft: 2 }, field === "link" ? /* @__PURE__ */ React.createElement(
+    Select,
+    {
+      options: repoOptions,
+      defaultValue: repoId,
+      onChange: setRepoId
+    }
+  ) : /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "tab to browse"))), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "Tab: next field \xB7 \u2191/\u2193: navigate \xB7 Enter: confirm \xB7 Esc: cancel")));
+}
+
+// src/scan.ts
+import { isUtf8 } from "buffer";
+import { execFile as execFileCb } from "child_process";
+import { promises as fs3 } from "fs";
+import path3 from "path";
+import { promisify } from "util";
+import picomatch from "picomatch";
+
+// src/policy.ts
+var BAN_PATTERNS = [
+  ".git",
+  "node_modules",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "dist",
+  "build",
+  ".next",
+  ".turbo",
+  ".cache",
+  "target"
+];
+var DEFAULT_PATTERNS = [
+  "*.lock",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "*.min.js",
+  "*.min.css",
+  "*.svg",
+  "*.png",
+  "*.jpg",
+  "*.jpeg",
+  "*.gif",
+  "*.ico",
+  "*.woff",
+  "*.woff2",
+  "*.snap",
+  "CHANGELOG.md"
+];
+var LOC_THRESHOLD = 2500;
+var MAX_FILE_BYTES = 1e6;
+
+// src/scan.ts
+var execFile = promisify(execFileCb);
+var BAN_DIRS = new Set(BAN_PATTERNS);
+var matchesDefault = DEFAULT_PATTERNS.length > 0 ? picomatch([...DEFAULT_PATTERNS], { dot: true, matchBase: true }) : () => false;
+function countLines(buf) {
+  let count = 0;
+  for (let i = 0; i < buf.length; i++) {
+    if (buf[i] === 10) count++;
+  }
+  if (buf.length > 0 && buf[buf.length - 1] !== 10) count++;
+  return count;
+}
+async function scanFile(absPath) {
+  let stat;
+  try {
+    stat = await fs3.stat(absPath);
+  } catch {
+    return null;
+  }
+  if (stat.size > MAX_FILE_BYTES) return null;
+  const buf = await fs3.readFile(absPath);
+  if (!isUtf8(buf)) return null;
+  return countLines(buf);
+}
+async function listTrackedFiles(cwd) {
+  try {
+    const { stdout } = await execFile("git", ["ls-files", "-z"], {
+      cwd,
+      maxBuffer: 50 * 1024 * 1024
+    });
+    return new Set(stdout.split("\0").filter((l) => l.length > 0));
+  } catch {
+    return null;
+  }
+}
+async function walk(absDir, relDir, out, tracked) {
+  let dirents;
+  try {
+    dirents = await fs3.readdir(absDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const d of dirents) {
+    const relPath = relDir ? `${relDir}/${d.name}` : d.name;
+    const absPath = path3.join(absDir, d.name);
+    if (d.isDirectory()) {
+      if (BAN_DIRS.has(d.name)) {
+        out.push({
+          path: relPath,
+          locCount: 0,
+          isBan: true,
+          isDefault: false,
+          isLarge: false
         });
+        continue;
+      }
+      await walk(absPath, relPath, out, tracked);
+    } else if (d.isFile()) {
+      if (tracked !== null && !tracked.has(relPath)) continue;
+      const locCount = await scanFile(absPath);
+      if (locCount === null) continue;
+      out.push({
+        path: relPath,
+        locCount,
+        isBan: false,
+        isDefault: matchesDefault(relPath),
+        isLarge: locCount > LOC_THRESHOLD
+      });
+    }
+  }
+}
+async function scan(cwd) {
+  const tracked = await listTrackedFiles(cwd);
+  const out = [];
+  await walk(cwd, "", out, tracked);
+  return out;
+}
+
+// src/baliseignore.ts
+import { promises as fs4 } from "fs";
+import path4 from "path";
+var FILENAME2 = ".baliseignore";
+var HEADER = [
+  "# Generated by balise init.",
+  "# balise init will overwrite this file on next run.",
+  ""
+].join("\n");
+async function readBaliseignore(cwd) {
+  const file = path4.join(cwd, FILENAME2);
+  let raw;
+  try {
+    raw = await fs4.readFile(file, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") return /* @__PURE__ */ new Set();
+    throw err;
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    out.add(trimmed);
+  }
+  return out;
+}
+async function writeBaliseignore(cwd, patterns) {
+  const sorted = [...new Set(patterns)].filter((p) => p.length > 0).sort((a, b) => a.localeCompare(b));
+  const body = sorted.length > 0 ? sorted.join("\n") + "\n" : "";
+  await fs4.writeFile(path4.join(cwd, FILENAME2), HEADER + body, "utf-8");
+}
+
+// src/ui/IgnoreTree.tsx
+import React2, { useMemo, useState as useState2 } from "react";
+import { Box as Box2, Text as Text2, useApp as useApp2, useInput as useInput2 } from "ink";
+function buildTree(entries) {
+  const root = {
+    path: "",
+    name: ".",
+    isDir: true,
+    isBan: false,
+    locCount: 0,
+    isDefault: false,
+    isLarge: false,
+    children: [],
+    parent: null
+  };
+  const dirMap = /* @__PURE__ */ new Map();
+  dirMap.set("", root);
+  const ensureDir = (dirPath) => {
+    if (!dirPath) return root;
+    const existing = dirMap.get(dirPath);
+    if (existing) return existing;
+    const parts = dirPath.split("/");
+    const name = parts[parts.length - 1];
+    const parentPath = parts.slice(0, -1).join("/");
+    const parent = ensureDir(parentPath);
+    const node = {
+      path: dirPath,
+      name,
+      isDir: true,
+      isBan: false,
+      locCount: 0,
+      isDefault: false,
+      isLarge: false,
+      children: [],
+      parent
+    };
+    parent.children.push(node);
+    dirMap.set(dirPath, node);
+    return node;
+  };
+  const sorted = [...entries].sort((a, b) => a.path.localeCompare(b.path));
+  for (const e of sorted) {
+    const parts = e.path.split("/");
+    const name = parts[parts.length - 1];
+    const parentPath = parts.slice(0, -1).join("/");
+    const parent = ensureDir(parentPath);
+    const node = {
+      path: e.path,
+      name,
+      isDir: e.isBan,
+      // ban entries from scan() are directories by construction
+      isBan: e.isBan,
+      locCount: e.locCount,
+      isDefault: e.isDefault,
+      isLarge: e.isLarge,
+      children: [],
+      parent
+    };
+    parent.children.push(node);
+    if (e.isBan) dirMap.set(e.path, node);
+  }
+  const sortChildren = (n) => {
+    n.children.sort((a, b) => {
+      if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    for (const c of n.children) sortChildren(c);
+  };
+  sortChildren(root);
+  return root;
+}
+function collectDescendantFiles(node) {
+  const out = [];
+  const recurse = (n) => {
+    if (!n.isDir && !n.isBan) out.push(n.path);
+    for (const c of n.children) recurse(c);
+  };
+  recurse(node);
+  return out;
+}
+function flattenVisible(root, expanded) {
+  const out = [];
+  const recurse = (node, depth) => {
+    if (node !== root) {
+      out.push({ node, depth });
+    }
+    if (node === root || node.isDir && !node.isBan && expanded.has(node.path)) {
+      for (const c of node.children) recurse(c, depth + 1);
+    }
+  };
+  recurse(root, -1);
+  return out;
+}
+function dirAllIncluded(node, excluded) {
+  const files = collectDescendantFiles(node);
+  if (files.length === 0) return true;
+  return files.every((f) => !excluded.has(f));
+}
+function computeInitialExcluded(scan2, current) {
+  const out = /* @__PURE__ */ new Set();
+  const scanPaths = /* @__PURE__ */ new Set();
+  for (const e of scan2) {
+    if (e.isBan) continue;
+    scanPaths.add(e.path);
+    if (e.isDefault || e.isLarge) out.add(e.path);
+  }
+  for (const p of current) {
+    if (!scanPaths.has(p)) out.add(p);
+  }
+  return out;
+}
+function computeDiff(current, excluded) {
+  const all = /* @__PURE__ */ new Set([...current, ...excluded]);
+  return [...all].sort((a, b) => a.localeCompare(b)).map((pattern) => {
+    const inCurrent = current.has(pattern);
+    const inExcluded = excluded.has(pattern);
+    const kind = inCurrent && inExcluded ? "unchanged" : inExcluded ? "added" : "removed";
+    return { pattern, kind };
+  });
+}
+var VIEWPORT_HEIGHT = 18;
+function IgnoreTree(props) {
+  const { exit } = useApp2();
+  const root = useMemo(() => buildTree(props.scan), [props.scan]);
+  const [excluded, setExcluded] = useState2(
+    () => computeInitialExcluded(props.scan, props.currentBaliseignore)
+  );
+  const [expandedDirs, setExpandedDirs] = useState2(/* @__PURE__ */ new Set());
+  const [focus, setFocus] = useState2("tree");
+  const [treeCursor, setTreeCursor] = useState2("");
+  const [diffCursor, setDiffCursor] = useState2(0);
+  const [modalOpen, setModalOpen] = useState2(false);
+  const visible = useMemo(
+    () => flattenVisible(root, expandedDirs),
+    [root, expandedDirs]
+  );
+  const diff = useMemo(
+    () => computeDiff(props.currentBaliseignore, excluded),
+    [props.currentBaliseignore, excluded]
+  );
+  const treeIdx = useMemo(() => {
+    if (visible.length === 0) return -1;
+    const i = visible.findIndex((v) => v.node.path === treeCursor);
+    return i >= 0 ? i : 0;
+  }, [visible, treeCursor]);
+  const safeDiffIdx = diff.length === 0 ? -1 : Math.max(0, Math.min(diffCursor, diff.length - 1));
+  const stats = useMemo(() => {
+    let added = 0;
+    let removed = 0;
+    let unchanged = 0;
+    for (const p of excluded) {
+      if (props.currentBaliseignore.has(p)) unchanged++;
+      else added++;
+    }
+    for (const p of props.currentBaliseignore) {
+      if (!excluded.has(p)) removed++;
+    }
+    return { added, removed, unchanged };
+  }, [excluded, props.currentBaliseignore]);
+  const toggleFile = (path7) => {
+    setExcluded((prev) => {
+      const next = new Set(prev);
+      if (next.has(path7)) next.delete(path7);
+      else next.add(path7);
+      return next;
+    });
+  };
+  const toggleDir = (dirNode) => {
+    const descendants = collectDescendantFiles(dirNode);
+    if (descendants.length === 0) return;
+    const allIncluded = descendants.every((p) => !excluded.has(p));
+    setExcluded((prev) => {
+      const next = new Set(prev);
+      if (allIncluded) {
+        for (const p of descendants) next.add(p);
       } else {
-        if (!props.repos[repoIdx]) return;
-        props.onDone({ action: "link", repo: props.repos[repoIdx] });
+        for (const p of descendants) next.delete(p);
+      }
+      return next;
+    });
+  };
+  useInput2((input, key) => {
+    if (modalOpen) {
+      if (input === "y" || input === "Y") {
+        props.onDone({
+          action: "save",
+          patterns: [...excluded].sort((a, b) => a.localeCompare(b))
+        });
+        exit();
+        return;
+      }
+      if (input === "n" || input === "N") {
+        setModalOpen(false);
+        return;
+      }
+      if (input === "q" || input === "Q" || key.escape) {
+        props.onDone({ action: "cancel", patterns: [] });
+        exit();
+        return;
       }
-      exit();
       return;
     }
-    if (zone === "create") {
-      if (key.upArrow)
-        setOwnerIdx((i) => (i - 1 + props.ownerships.length) % Math.max(1, props.ownerships.length));
-      else if (key.downArrow)
-        setOwnerIdx((i) => (i + 1) % Math.max(1, props.ownerships.length));
-      else if (key.backspace || key.delete) setSlug((s) => s.slice(0, -1));
-      else if (input && /^[a-z0-9-]$/i.test(input))
-        setSlug((s) => (s + input).toLowerCase());
+    if (key.tab) {
+      setFocus((f) => f === "tree" ? "diff" : "tree");
+      return;
+    }
+    if (key.return) {
+      setModalOpen(true);
+      return;
+    }
+    if (key.escape || input === "q") {
+      setModalOpen(true);
+      return;
+    }
+    if (focus === "tree") {
+      if (key.downArrow) {
+        const i = Math.min(treeIdx + 1, visible.length - 1);
+        if (i >= 0) setTreeCursor(visible[i].node.path);
+        return;
+      }
+      if (key.upArrow) {
+        const i = Math.max(treeIdx - 1, 0);
+        if (i >= 0) setTreeCursor(visible[i].node.path);
+        return;
+      }
+      if (key.rightArrow) {
+        const cur = treeIdx >= 0 ? visible[treeIdx].node : null;
+        if (!cur || !cur.isDir || cur.isBan) return;
+        if (!expandedDirs.has(cur.path)) {
+          setExpandedDirs((s) => {
+            const next = new Set(s);
+            next.add(cur.path);
+            return next;
+          });
+        } else if (cur.children.length > 0) {
+          setTreeCursor(cur.children[0].path);
+        }
+        return;
+      }
+      if (key.leftArrow) {
+        const cur = treeIdx >= 0 ? visible[treeIdx].node : null;
+        if (!cur) return;
+        if (cur.isDir && !cur.isBan && expandedDirs.has(cur.path)) {
+          setExpandedDirs((s) => {
+            const next = new Set(s);
+            next.delete(cur.path);
+            return next;
+          });
+        } else if (cur.parent && cur.parent.path !== "") {
+          setTreeCursor(cur.parent.path);
+        }
+        return;
+      }
+      if (input === " ") {
+        const cur = treeIdx >= 0 ? visible[treeIdx].node : null;
+        if (!cur || cur.isBan) return;
+        if (cur.isDir) toggleDir(cur);
+        else toggleFile(cur.path);
+        return;
+      }
     } else {
-      if (key.upArrow)
-        setRepoIdx((i) => (i - 1 + props.repos.length) % Math.max(1, props.repos.length));
-      else if (key.downArrow)
-        setRepoIdx((i) => (i + 1) % Math.max(1, props.repos.length));
+      if (key.downArrow) {
+        setDiffCursor((c) => Math.min(c + 1, Math.max(diff.length - 1, 0)));
+        return;
+      }
+      if (key.upArrow) {
+        setDiffCursor((c) => Math.max(c - 1, 0));
+        return;
+      }
+      if (input === " ") {
+        if (safeDiffIdx < 0) return;
+        toggleFile(diff[safeDiffIdx].pattern);
+        return;
+      }
     }
   });
-  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true }, "Balise \u2014 link or create a repo"), /* @__PURE__ */ React.createElement(Box, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: zone === "create" ? "cyan" : "gray" }, zone === "create" ? "\u25B8 " : "  ", "Create new repo"), zone === "create" && /* @__PURE__ */ React.createElement(Box, { marginLeft: 2, flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, null, "slug : ", /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, slug)), /* @__PURE__ */ React.createElement(Text, null, "owner: ", /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, props.ownerships[ownerIdx] ? `${props.ownerships[ownerIdx].login} (${props.ownerships[ownerIdx].type})` : "<no ownership>"), " (\u2191/\u2193 to change)"))), /* @__PURE__ */ React.createElement(Box, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: zone === "link" ? "cyan" : "gray" }, zone === "link" ? "\u25B8 " : "  ", "Link existing (", props.repos.length, ")"), zone === "link" && props.repos.length > 0 && /* @__PURE__ */ React.createElement(Box, { marginLeft: 2, flexDirection: "column" }, props.repos.map((r, i) => /* @__PURE__ */ React.createElement(Text, { key: r.id, color: i === repoIdx ? "yellow" : void 0 }, i === repoIdx ? "\u25B8 " : "  ", r.owner_login, "/", r.slug)))), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "Tab: switch zone \xB7 \u2191/\u2193: navigate \xB7 Enter: confirm \xB7 Esc: cancel")));
+  if (modalOpen) {
+    return /* @__PURE__ */ React2.createElement(ConfirmModal, { stats, excludedSize: excluded.size });
+  }
+  const treeStart = Math.max(
+    0,
+    Math.min(
+      treeIdx - Math.floor(VIEWPORT_HEIGHT / 2),
+      visible.length - VIEWPORT_HEIGHT
+    )
+  );
+  const treeWindow = visible.slice(
+    Math.max(treeStart, 0),
+    Math.max(treeStart, 0) + VIEWPORT_HEIGHT
+  );
+  const diffStart = Math.max(
+    0,
+    Math.min(
+      safeDiffIdx - Math.floor(VIEWPORT_HEIGHT / 2),
+      diff.length - VIEWPORT_HEIGHT
+    )
+  );
+  const diffWindow = diff.slice(
+    Math.max(diffStart, 0),
+    Math.max(diffStart, 0) + VIEWPORT_HEIGHT
+  );
+  const treeWindowStart = Math.max(treeStart, 0);
+  const diffWindowStart = Math.max(diffStart, 0);
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true }, "Balise \u2014 configure .baliseignore"), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "Tab: panel \xB7 \u2191/\u2193: nav \xB7 \u2192/\u2190: open/close \xB7 Space: toggle \xB7 Enter: save \xB7 Esc: cancel"), /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(
+    Box2,
+    {
+      flexDirection: "column",
+      width: "50%",
+      paddingRight: 1,
+      borderStyle: "round",
+      borderColor: focus === "tree" ? "cyan" : "gray"
+    },
+    /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: focus === "tree" ? "cyan" : void 0 }, "Files"),
+    treeWindow.length === 0 ? /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "(no files)") : treeWindow.map((v, i) => /* @__PURE__ */ React2.createElement(
+      TreeRow,
+      {
+        key: v.node.path,
+        node: v.node,
+        depth: v.depth,
+        expanded: expandedDirs.has(v.node.path),
+        excluded,
+        isFocused: focus === "tree" && treeWindowStart + i === treeIdx
+      }
+    ))
+  ), /* @__PURE__ */ React2.createElement(
+    Box2,
+    {
+      flexDirection: "column",
+      width: "50%",
+      paddingLeft: 1,
+      borderStyle: "round",
+      borderColor: focus === "diff" ? "cyan" : "gray"
+    },
+    /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: focus === "diff" ? "cyan" : void 0 }, "Diff vs .baliseignore"),
+    diff.length === 0 ? /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "(no changes)") : diffWindow.map((d, i) => /* @__PURE__ */ React2.createElement(
+      DiffRow,
+      {
+        key: d.pattern,
+        entry: d,
+        isFocused: focus === "diff" && diffWindowStart + i === safeDiffIdx
+      }
+    ))
+  )), /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, stats.added > 0 || stats.removed > 0 ? `${stats.added} additions, ${stats.removed} removals` : "(no changes vs current .baliseignore)")));
+}
+function TreeRow(props) {
+  const { node, depth, expanded, excluded, isFocused } = props;
+  const indent = "  ".repeat(Math.max(depth, 0));
+  let label;
+  let dim = false;
+  if (node.isBan) {
+    label = `\u{1F512} ${node.name} [ban]`;
+    dim = true;
+  } else if (node.isDir) {
+    const allIncluded = dirAllIncluded(node, excluded);
+    const arrow = expanded ? "\u25BE" : "\u25B8";
+    const box = allIncluded ? "\u2611" : "\u2610";
+    label = `${arrow} ${box} ${node.name}/`;
+  } else {
+    const box = excluded.has(node.path) ? "\u2610" : "\u2611";
+    const loc = node.locCount > 0 ? ` (${node.locCount} LoC)` : "";
+    const flags = [];
+    if (node.isLarge) flags.push("large");
+    if (node.isDefault) flags.push("default");
+    const flagStr = flags.length > 0 ? ` [${flags.join(",")}]` : "";
+    label = `${box} ${node.name}${loc}${flagStr}`;
+  }
+  return /* @__PURE__ */ React2.createElement(Text2, { color: isFocused ? "cyan" : void 0, dimColor: dim }, isFocused ? "\u25B8 " : "  ", indent, label);
+}
+function DiffRow(props) {
+  const { entry, isFocused } = props;
+  const sigil = entry.kind === "added" ? "+" : entry.kind === "removed" ? "-" : " ";
+  const color = isFocused ? "cyan" : entry.kind === "added" ? "green" : entry.kind === "removed" ? "red" : void 0;
+  return /* @__PURE__ */ React2.createElement(Text2, { color }, isFocused ? "\u25B8 " : "  ", sigil, " ", entry.pattern);
+}
+function ConfirmModal(props) {
+  const { stats, excludedSize } = props;
+  return /* @__PURE__ */ React2.createElement(
+    Box2,
+    {
+      flexDirection: "column",
+      padding: 1,
+      borderStyle: "double",
+      borderColor: "cyan"
+    },
+    /* @__PURE__ */ React2.createElement(Text2, { bold: true }, "Save changes to .baliseignore?"),
+    /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1, flexDirection: "row", gap: 2 }, /* @__PURE__ */ React2.createElement(Text2, { color: "green" }, "+", stats.added, " added"), /* @__PURE__ */ React2.createElement(Text2, { color: "red" }, "-", stats.removed, " removed"), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, stats.unchanged, " unchanged")),
+    /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, excludedSize, " total patterns in resulting file")),
+    /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, null, "[y] Confirm   [n] Back to edit   [q/Esc] Cancel without saving"))
+  );
 }
 
 // src/commands/init.ts
@@ -966,6 +1560,13 @@ async function runInit(opts) {
     }
     throw err;
   }
+  const existingConfig = await readConfig(cwd);
+  if (existingConfig) {
+    process.stdout.write(
+      `Re-configuring ${existingConfig.repo.owner_login}/${existingConfig.repo.slug}.
+`
+    );
+  }
   const apiUrl = DEFAULT_API_URL;
   const client = new ApiClient({
     apiUrl,
@@ -994,13 +1595,14 @@ async function runInit(opts) {
   const sortedRepos = [...repos].sort(
     (a, b) => `${a.owner_login}/${a.slug}`.localeCompare(`${b.owner_login}/${b.slug}`)
   );
-  const defaultSlug = path3.basename(cwd).toLowerCase();
+  const defaultSlug = path5.basename(cwd).toLowerCase();
   const result = await new Promise((resolve) => {
     const app = render(
-      React2.createElement(InitPicker, {
+      React3.createElement(InitPicker, {
         defaultSlug,
         ownerships,
         repos: sortedRepos,
+        currentRepoId: existingConfig?.repo.id,
         onDone: (r) => {
           resolve(r);
           app.unmount();
@@ -1040,160 +1642,143 @@ async function runInit(opts) {
   await ensureGitignored(cwd);
   process.stdout.write(
     `Linked ${cfg.repo.owner_login}/${cfg.repo.slug} \u2192 .balise/config
+`
+  );
+  const [scanResult, currentBaliseignore] = await Promise.all([
+    scan(cwd),
+    readBaliseignore(cwd)
+  ]);
+  const treeResult = await new Promise((resolve) => {
+    const app = render(
+      React3.createElement(IgnoreTree, {
+        scan: scanResult,
+        currentBaliseignore,
+        onDone: (r) => {
+          resolve(r);
+          app.unmount();
+        }
+      })
+    );
+  });
+  if (treeResult.action === "cancel") {
+    process.stderr.write(
+      "Ignore configuration cancelled. .baliseignore unchanged.\n"
+    );
+    process.exit(1);
+  }
+  await writeBaliseignore(cwd, treeResult.patterns);
+  process.stdout.write(
+    `Wrote ${treeResult.patterns.length} patterns to .baliseignore
 `
   );
 }
 
 // src/commands/sync.ts
-import React4 from "react";
-import { render as render2 } from "ink";
+import readline from "readline/promises";
 
-// src/ui/SyncProgress.tsx
-import React3, { useEffect, useState as useState2 } from "react";
-import { Box as Box2, Text as Text2, useApp as useApp2 } from "ink";
-import Spinner from "ink-spinner";
-var QUEUED_MESSAGES = [
-  "Waiting for an agent willing to accept the job\u2026",
-  "Your request is in line. An agent will be assigned once one stops pretending to be busy.",
-  'Looking for an available agent. Most are currently "in a meeting."',
-  "Queued. An agent will pick this up as soon as they finish rereading the spec.",
-  "Your task is waiting for an agent with the right vibes.",
-  "Negotiating with an agent. They want a raise.",
-  "All agents are currently on strike. Sending in a scab.",
-  "Waiting for an agent to finish their coffee \u2615",
-  "An agent saw your task and walked away slowly. Finding another one.",
-  "Your task is being passed around like a hot potato. Someone will catch it eventually.",
-  "Agents are currently arguing about who has to do this one.",
-  "Waiting for an agent brave enough to open your repo.",
-  "Your task is sitting in the agent break room. Someone will notice it soon.",
-  "An agent was assigned, but they ghosted. Recruiting a replacement.",
-  "Paging an agent. Please hold while we bribe one.",
-  "Queued. Waiting for an agent with enough context window to care.",
-  "An agent is spinning up. They're doing their stretches.",
-  "Looking for an agent whose system prompt allows this.",
-  "Waiting for a worker. Their last task traumatized them.",
-  "Your task is in queue. Agents are busy arguing about tabs vs spaces.",
-  "Finding an agent\u2026",
-  "Found one. They said no.",
-  "Finding another agent\u2026",
-  "This one looks promising.",
-  "Negotiating\u2026"
-];
-var RUNNING_MESSAGES = [
-  "An agent is on it. Try not to watch.",
-  "Your task has an owner. They seem focused.",
-  "An agent accepted the job. Surprisingly.",
-  "Working. The agent asked not to be disturbed.",
-  "An agent is handling it. They'll let us know if they need anything.",
-  "Progress is happening. Allegedly.",
-  "An agent rolled up their sleeves. Mostly for show.",
-  "Hard at work. The agent has opened seventeen browser tabs.",
-  "Your agent is locked in. Do not make eye contact.",
-  "An agent is typing furiously. Some of it might be relevant.",
-  "Working. The agent has entered the zone. And also a Wikipedia rabbit hole.",
-  "An agent is deep in thought. Or buffering. Hard to tell.",
-  "Your task is being handled. The agent is muttering to themselves.",
-  "Cooking. \u{1F9D1}\u200D\u{1F373}",
-  "The agent is working. They've asked for snacks.",
-  "An agent is doing the thing. Please clap.",
-  "Agent is crunching tokens.",
-  "Working. The agent is reasoning about your reasoning.",
-  "An agent is in a tool-use loop. Going well so far.",
-  "Thinking hard. The agent just discovered your codebase has opinions.",
-  "Working. The agent is negotiating with your linter.",
-  "An agent is running. They promise it's not an infinite loop.",
-  "The agent is writing, deleting, and rewriting. Classic.",
-  "An agent picked it up.",
-  "They're reading the task\u2026",
-  "Looks like they have a plan.",
-  "Executing\u2026",
-  "Still going. Confidently.",
-  "Almost there. (They always say that.)"
-];
-function pickInitialIndex(len) {
-  return Math.floor(Math.random() * len);
+// src/logger.ts
+import { promises as fs5 } from "fs";
+import path6 from "path";
+import os2 from "os";
+var APP_DIR2 = ".balise";
+var FILENAME3 = "balise.log";
+function logPath() {
+  const override = process.env.BALISE_LOG_FILE;
+  if (override && override.length > 0) return override;
+  return path6.join(os2.homedir(), APP_DIR2, FILENAME3);
 }
-function SyncProgress(props) {
-  const { exit } = useApp2();
-  const [status, setStatus] = useState2(null);
-  const [error, setError] = useState2(null);
-  const [startedAt] = useState2(() => Date.now());
-  const [queuedIdx, setQueuedIdx] = useState2(
-    () => pickInitialIndex(QUEUED_MESSAGES.length)
-  );
-  const [runningIdx, setRunningIdx] = useState2(
-    () => pickInitialIndex(RUNNING_MESSAGES.length)
-  );
-  useEffect(() => {
-    let cancelled = false;
-    const tick = async () => {
-      try {
-        const s = await props.client.getJson(
-          `/v1/syncs/${props.syncId}`
-        );
-        if (cancelled) return;
-        setStatus(s);
-        if (s.status === "done") {
-          props.onDone(true);
-          exit();
-          return;
-        }
-        if (s.status === "failed") {
-          props.onDone(false);
-          exit();
-          return;
-        }
-      } catch (err) {
-        if (cancelled) return;
-        setError(err.message);
-        props.onDone(false);
-        exit();
-        return;
-      }
-      setTimeout(tick, props.pollIntervalMs ?? 1e3);
-    };
-    void tick();
-    return () => {
-      cancelled = true;
-    };
-  }, []);
-  useEffect(() => {
-    const period = props.messageRotationMs ?? 1e4;
-    const h = setInterval(() => {
-      setQueuedIdx((i) => (i + 1) % QUEUED_MESSAGES.length);
-      setRunningIdx((i) => (i + 1) % RUNNING_MESSAGES.length);
-    }, period);
-    return () => clearInterval(h);
-  }, [props.messageRotationMs]);
-  if (error) {
-    return /* @__PURE__ */ React3.createElement(Text2, { color: "red" }, "\u2717 Failed");
-  }
-  if (!status) {
-    return /* @__PURE__ */ React3.createElement(Box2, null, /* @__PURE__ */ React3.createElement(Text2, { color: "cyan" }, /* @__PURE__ */ React3.createElement(Spinner, { type: "dots" })), /* @__PURE__ */ React3.createElement(Text2, null, " Getting things ready\u2026"));
-  }
-  if (status.status === "done") {
-    return /* @__PURE__ */ React3.createElement(Text2, { color: "green" }, "\u2713 Done");
-  }
-  if (status.status === "failed") {
-    return /* @__PURE__ */ React3.createElement(Text2, { color: "red" }, "\u2717 Failed");
-  }
-  const message = status.status === "queued" ? QUEUED_MESSAGES[queuedIdx] : RUNNING_MESSAGES[runningIdx];
-  const { files_processed, files_total, nodes_pushed } = status.progress;
-  const hasCounters = status.status === "running" && (files_total > 0 || nodes_pushed > 0);
-  return /* @__PURE__ */ React3.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Box2, null, /* @__PURE__ */ React3.createElement(Text2, { color: "cyan" }, /* @__PURE__ */ React3.createElement(Spinner, { type: "dots" })), /* @__PURE__ */ React3.createElement(Text2, null, " ", message)), hasCounters ? /* @__PURE__ */ React3.createElement(Text2, { dimColor: true }, "  ", files_processed, "/", files_total, " files \xB7 ", nodes_pushed, " concepts") : null);
+function formatError(err) {
+  if (err instanceof Error) {
+    const stack = err.stack ?? `${err.name}: ${err.message}`;
+    const extras = [];
+    const cause = err.cause;
+    if (cause) extras.push(`  caused by: ${formatError(cause)}`);
+    return extras.length ? `${stack}
+${extras.join("\n")}` : stack;
+  }
+  if (typeof err === "string") return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+async function logError(context, err) {
+  try {
+    const p = logPath();
+    await fs5.mkdir(path6.dirname(p), { recursive: true, mode: 448 });
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const line = `[${ts}] ERROR ${context}
+${formatError(err)}
+
+`;
+    await fs5.appendFile(p, line, { mode: 384 });
+  } catch {
+  }
 }
 
 // src/commands/sync.ts
+function buildSyncQuery(opts) {
+  const q = { commit_sha: opts.commitSha };
+  if (opts.branch) q.branch = opts.branch;
+  q.force = opts.force ? "true" : "false";
+  q.dry_run = opts.dryRun ? "true" : "false";
+  if (opts.base) q.base = opts.base;
+  return q;
+}
+var INIT_AUTOLAUNCH_MESSAGE = "Repo not initialized, launching balise init...";
+function drainStdinBuffer(stdin) {
+  if (stdin !== process.stdin) return;
+  const s = stdin;
+  if (typeof s.read !== "function") return;
+  while (s.read() !== null) {
+  }
+}
+async function confirmRetryWithForce(opts) {
+  const stderr = opts.stderr ?? process.stderr;
+  const synced = opts.body.synced_at ?? "unknown time";
+  stderr.write(
+    `commit already synced at tag ${opts.body.tag} (synced at ${synced}), re-run ?
+`
+  );
+  if (opts.autoConfirm) {
+    return false;
+  }
+  const input = opts.stdin ?? process.stdin;
+  drainStdinBuffer(input);
+  const rl = readline.createInterface({
+    input,
+    output: opts.stdout ?? process.stdout
+  });
+  let answer;
+  try {
+    answer = (await rl.question("re-run ? (y/N) ")).trim();
+  } finally {
+    rl.close();
+  }
+  return /^y(es)?$/i.test(answer);
+}
+function formatDryRunSummary(body) {
+  const fromDiff = body.would_be_cold_start ? "cold-start (no prior tag)" : `from-commit=${body.from_commit ?? "?"}` + (body.from_commit_distance !== null ? ` distance=${body.from_commit_distance}` : "");
+  return `Sync would use: base=${body.base_dolt_ref} (${body.base_kind}) / ${fromDiff}`;
+}
+function formatAcceptedSummary(body) {
+  return `Sync queued. Track it here: ${body.web_url}`;
+}
 async function runSync(opts) {
   try {
     await runSyncInner(opts);
   } catch (err) {
+    await logError("sync", err);
     if (err instanceof ApiUnreachableError) {
       process.stderr.write(
         "Cannot reach the Balise service. Please try again in a moment.\n"
       );
     } else {
-      process.stderr.write("Something went wrong. Please try again.\n");
+      process.stderr.write(
+        `Something went wrong. Please try again. (details: ${logPath()})
+`
+      );
     }
     process.exit(1);
   }
@@ -1222,7 +1807,8 @@ async function runSyncInner(opts) {
   }
   let cfg = await readConfig(cwd);
   if (!cfg) {
-    process.stderr.write("No .balise/config \u2014 running `balise init` first.\n");
+    process.stderr.write(`${INIT_AUTOLAUNCH_MESSAGE}
+`);
     await runInit({ ...opts, cwd });
     cfg = await readConfig(cwd);
     if (!cfg) {
@@ -1243,65 +1829,131 @@ async function runSyncInner(opts) {
     `Packing ${cfg.repo.owner_login}/${cfg.repo.slug} at HEAD\u2026
 `
   );
-  const { stream, commitSha, branch } = await gitBundle({ cwd });
-  let accepted;
+  const submit = async (force) => {
+    const { stream, commitSha, branch } = await gitBundle({ cwd });
+    const query = buildSyncQuery({
+      commitSha,
+      branch,
+      force,
+      base: opts.base,
+      dryRun: opts.dryRun ?? false
+    });
+    return uploadOnce(client, cfg.repo.owner_login, cfg.repo.slug, stream, query);
+  };
+  let outcome;
   try {
-    accepted = await client.uploadBundle(
-      `/v1/repos/${cfg.repo.owner_login}/${cfg.repo.slug}/sync`,
-      {
-        bundleStream: stream,
-        query: { commit_sha: commitSha, branch }
-      }
-    );
+    outcome = await submit(opts.force ?? false);
   } catch (err) {
-    if (err instanceof NotAuthenticatedError) {
-      process.stderr.write("Not logged in \u2014 run `balise login`.\n");
+    handleUploadError(err);
+    process.exit(1);
+  }
+  if (outcome.kind === "conflict") {
+    const proceedForce = await confirmRetryWithForce({
+      body: outcome.body,
+      autoConfirm: opts.autoConfirm ?? false
+    });
+    if (!proceedForce) {
       process.exit(1);
     }
-    if (err instanceof ApiUnreachableError) {
-      process.stderr.write(
-        "Cannot reach the Balise service. Please try again in a moment.\n"
-      );
+    try {
+      outcome = await submit(true);
+    } catch (err) {
+      handleUploadError(err);
       process.exit(1);
     }
-    process.stderr.write(
-      "Something went wrong while uploading. Please try again.\n"
-    );
+  }
+  if (outcome.kind === "invalid_base") {
+    process.stderr.write(`invalid base ref: ${opts.base}
+`);
     process.exit(1);
   }
-  const result = await new Promise((resolve) => {
-    const app = render2(
-      React4.createElement(SyncProgress, {
-        client,
-        syncId: accepted.sync_id,
-        onDone: (ok) => {
-          resolve(ok);
-          app.unmount();
-        }
-      })
+  if (outcome.kind === "dry_run") {
+    process.stdout.write(formatDryRunSummary(outcome.body) + "\n");
+    process.exit(0);
+  }
+  if (outcome.kind !== "accepted") {
+    process.exit(1);
+  }
+  process.stdout.write(formatAcceptedSummary(outcome.body) + "\n");
+  process.exit(0);
+}
+async function uploadOnce(client, owner, slug, stream, query) {
+  const raw = await client.uploadBundleRaw(
+    `/v1/repos/${owner}/${slug}/sync`,
+    {
+      bundleStream: stream,
+      query
+    }
+  );
+  if (raw.status === 202) {
+    return { kind: "accepted", body: JSON.parse(raw.text) };
+  }
+  if (raw.status === 200) {
+    return { kind: "dry_run", body: JSON.parse(raw.text) };
+  }
+  if (raw.status === 409) {
+    const parsed = JSON.parse(raw.text);
+    const body = "detail" in parsed && parsed.detail ? parsed.detail : parsed;
+    return { kind: "conflict", body };
+  }
+  if (raw.status === 422) {
+    let detail;
+    try {
+      const parsed = JSON.parse(raw.text);
+      if (typeof parsed.detail === "string") detail = parsed.detail;
+    } catch {
+    }
+    if (detail === "invalid_base_ref") return { kind: "invalid_base" };
+    throw new ApiError(raw.status, raw.text);
+  }
+  throw new ApiError(raw.status, raw.text);
+}
+function handleUploadError(err) {
+  if (err instanceof NotAuthenticatedError) {
+    process.stderr.write("Not logged in \u2014 run `balise login`.\n");
+    return;
+  }
+  if (err instanceof ApiUnreachableError) {
+    process.stderr.write(
+      "Cannot reach the Balise service. Please try again in a moment.\n"
     );
-  });
-  process.exit(result ? 0 : 1);
+    return;
+  }
+  process.stderr.write(
+    "Something went wrong while uploading. Please try again.\n"
+  );
 }
 
 // src/index.ts
+async function withLog(name, fn) {
+  try {
+    await fn();
+  } catch (err) {
+    await logError(name, err);
+    process.stderr.write(
+      `Something went wrong (${name}). Details: ${logPath()}
+`
+    );
+    process.exit(1);
+  }
+}
 var SUPABASE_URL = process.env.BALISE_SUPABASE_URL ?? "https://api.balise.dev";
 var loginCmd = defineCommand({
   meta: { name: "login", description: "Authenticate via OAuth (PKCE loopback)." },
   async run() {
-    await runLogin({ supabaseUrl: SUPABASE_URL });
+    await withLog("login", () => runLogin({ supabaseUrl: SUPABASE_URL }));
   }
 });
 var logoutCmd = defineCommand({
   meta: { name: "logout", description: "Clear stored credentials." },
   async run() {
-    await runLogout();
+    await withLog("logout", () => runLogout());
   }
 });
 var whoamiCmd = defineCommand({
   meta: { name: "whoami", description: "Show current authenticated user." },
   async run() {
-    await runWhoami({ supabaseUrl: SUPABASE_URL });
+    await withLog("whoami", () => runWhoami({ supabaseUrl: SUPABASE_URL }));
   }
 });
 var initCmd = defineCommand({
@@ -1310,7 +1962,7 @@ var initCmd = defineCommand({
     description: "Link or create a Balise repo and write .balise/config."
   },
   async run() {
-    await runInit({ supabaseUrl: SUPABASE_URL });
+    await withLog("init", () => runInit({ supabaseUrl: SUPABASE_URL }));
   }
 });
 var syncCmd = defineCommand({
@@ -1318,8 +1970,36 @@ var syncCmd = defineCommand({
     name: "sync",
     description: "Tarball current repo \u2192 upload \u2192 poll extraction progress."
   },
-  async run() {
-    await runSync({ supabaseUrl: SUPABASE_URL });
+  args: {
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Skip sync confirmations (warning prompt + future 409 retry).",
+      default: false
+    },
+    force: {
+      type: "boolean",
+      description: "Bypass idempotency 409 + resume-reuse: re-tag from scratch and re-resolve base.",
+      default: false
+    },
+    base: {
+      type: "string",
+      description: "Explicit base balise ref (branch/tag/commit) to start from. Validated server-side."
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the resolution without uploading the bundle or enqueuing the worker.",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await runSync({
+      supabaseUrl: SUPABASE_URL,
+      autoConfirm: Boolean(args.yes),
+      force: Boolean(args.force),
+      base: typeof args.base === "string" && args.base.length > 0 ? args.base : void 0,
+      dryRun: Boolean(args["dry-run"])
+    });
   }
 });
 var main = defineCommand({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@balise.dev/cli",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Balise CLI — push codebase to Balise backend for spec extraction.",
   "type": "module",
   "bin": {
@@ -22,12 +22,12 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@inkjs/ui": "^2.0.0",
     "citty": "^0.2.2",
     "ini": "^5.0.0",
     "ink": "^5.0.1",
-    "ink-progress-bar": "^3.0.0",
-    "ink-spinner": "^5.0.0",
     "open": "^10.1.0",
+    "picomatch": "^4.0.2",
     "react": "^18.3.1",
     "tar": "^7.4.3",
     "undici": "^6.19.8"
@@ -35,8 +35,10 @@
   "devDependencies": {
     "@types/ini": "^4.1.1",
     "@types/node": "^20.14.0",
+    "@types/picomatch": "^3.0.2",
     "@types/react": "^18.3.3",
     "@types/tar": "^6.1.13",
+    "ink-testing-library": "^4.0.0",
     "tsup": "^8.2.4",
     "typescript": "^5.5.4",
     "vitest": "^2.0.5"