@use-aistack/cli 0.4.0 → 0.5.0

package/README.md

@@ -20,6 +20,18 @@ npx @use-aistack/cli sync
 
 Requires a one-time `login` first.
 
+### `npx @use-aistack/cli sync --auto on` / `off`
+
+Optional: keep your stack fresh without manual syncs. `on` writes a `SessionStart` hook (`async: true`) into `~/.claude/settings.json`. The hook runs a silent sync at most once per day when a Claude Code session starts. `off` removes the hook and revokes the standing opt-in.
+
+```sh
+npx @use-aistack/cli sync --auto on            # enable, default every 24h
+npx @use-aistack/cli sync --auto on --every 12 # custom frequency in hours
+npx @use-aistack/cli sync --auto off           # revoke
+```
+
+The silent run (`sync --auto`) never prompts and publishes only under this opt-in. Each run appends one line to `~/.config/aistack/sync.log` (capped at 200 lines). The next interactive `sync` reports the last result. After 3 failures in a row, one visible message appears in Claude Code and names the fix. No email, no dialogs.
+
 ### `npx @use-aistack/cli login`
 
 Link this machine to your AI Stack account via browser.

package/dist/index.js

@@ -182,39 +182,67 @@ function classify(files) {
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
+import { dirname as dirname2, join } from "path";
 var CONFIG_DIR = join(homedir(), ".config", "aistack");
 var CREDENTIALS_FILE = join(CONFIG_DIR, "credentials.json");
-function getToken() {
-  if (!existsSync(CREDENTIALS_FILE)) return null;
+var DEFAULT_SERVER_URL = "https://aistack.to";
+function readCredentials(file) {
+  const empty = { data: { servers: {} }, legacy: false };
+  if (!existsSync(file)) return empty;
   try {
-    const data = JSON.parse(
-      readFileSync(CREDENTIALS_FILE, "utf-8")
-    );
-    return data.token ?? null;
+    const raw = JSON.parse(readFileSync(file, "utf-8"));
+    if (!raw || typeof raw !== "object") return empty;
+    if (raw.servers && typeof raw.servers === "object") {
+      return {
+        data: { servers: raw.servers },
+        legacy: false
+      };
+    }
+    if (typeof raw.token === "string" && raw.token) {
+      return {
+        data: {
+          servers: {
+            [DEFAULT_SERVER_URL]: { token: raw.token, userId: raw.userId }
+          }
+        },
+        legacy: true
+      };
+    }
+    return { data: { servers: {} }, legacy: true };
   } catch {
-    return null;
+    return empty;
   }
 }
-function saveToken(token, userId) {
-  mkdirSync(CONFIG_DIR, { recursive: true });
-  writeFileSync(CREDENTIALS_FILE, JSON.stringify({ token, userId }, null, 2));
+function writeCredentials(file, data) {
+  mkdirSync(dirname2(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(data, null, 2));
+}
+function getToken(serverUrl = BASE_URL, file = CREDENTIALS_FILE) {
+  const { data, legacy } = readCredentials(file);
+  if (legacy) writeCredentials(file, data);
+  return data.servers[serverUrl]?.token ?? null;
+}
+function saveToken(token, userId, serverUrl = BASE_URL, file = CREDENTIALS_FILE) {
+  const { data } = readCredentials(file);
+  data.servers[serverUrl] = { token, userId };
+  writeCredentials(file, data);
 }
 var SETTINGS_FILE = join(CONFIG_DIR, "settings.json");
-function getSettings() {
-  if (!existsSync(SETTINGS_FILE)) return {};
+var DEFAULT_FREQUENCY_HOURS = 24;
+function getSettings(file = SETTINGS_FILE) {
+  if (!existsSync(file)) return {};
   try {
-    const raw = JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
+    const raw = JSON.parse(readFileSync(file, "utf-8"));
     return raw && typeof raw === "object" ? raw : {};
   } catch {
     return {};
   }
 }
-function saveSettings(patch) {
-  mkdirSync(CONFIG_DIR, { recursive: true });
+function saveSettings(patch, file = SETTINGS_FILE) {
+  mkdirSync(dirname2(file), { recursive: true });
   writeFileSync(
-    SETTINGS_FILE,
-    JSON.stringify({ ...getSettings(), ...patch }, null, 2)
+    file,
+    JSON.stringify({ ...getSettings(file), ...patch }, null, 2)
   );
 }
 var PROJECTS_FILE = join(CONFIG_DIR, "projects.json");
@@ -650,7 +678,7 @@ function resolvePluginLinks(installed, marketplaces, manifests) {
     const marketplace = key.slice(at + 1);
     const mpRepoUrl = marketplaceRepoUrl(marketplaces[marketplace]);
     const entry = manifests[marketplace]?.plugins?.find(
-      (p7) => p7.name === pluginName
+      (p8) => p8.name === pluginName
     );
     if (!entry) continue;
     const resolved = resolveSource(entry, mpRepoUrl);
@@ -1289,7 +1317,7 @@ function diffResources(current, existing) {
 import { spawnSync } from "child_process";
 import { cpSync, existsSync as existsSync6 } from "fs";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname2, join as join6 } from "path";
+import { dirname as dirname3, join as join6 } from "path";
 import { fileURLToPath } from "url";
 import * as p3 from "@clack/prompts";
 var MANUAL_MCP_ADD = "claude mcp add --scope user aistack -- npx -y @use-aistack/cli mcp";
@@ -1319,12 +1347,12 @@ function runClaude(args) {
 function claudeOnPath(run = runClaude) {
   return !run(["--version"]).notFound;
 }
-function findSkillSource(fromDir = dirname2(fileURLToPath(import.meta.url))) {
+function findSkillSource(fromDir = dirname3(fileURLToPath(import.meta.url))) {
   let dir = fromDir;
   for (let i = 0; i < 4; i++) {
     const candidate = join6(dir, "skills", "aistack-sync");
     if (existsSync6(join6(candidate, "SKILL.md"))) return candidate;
-    const parent = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -1431,7 +1459,7 @@ async function offerConnectUpsell() {
 
 // src/commands/create.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname3, join as join7 } from "path";
+import { dirname as dirname4, join as join7 } from "path";
 import * as p4 from "@clack/prompts";
 async function createCommand() {
   intro2("create");
@@ -1521,7 +1549,7 @@ async function createCommand() {
   }
   for (const f of toWrite) {
     const fullPath = join7(cwd, f.path);
-    const dir = dirname3(fullPath);
+    const dir = dirname4(fullPath);
     mkdirSync2(dir, { recursive: true });
     writeFileSync2(fullPath, f.content);
   }
@@ -1602,8 +1630,166 @@ async function loginCommand() {
 }
 
 // src/commands/sync.ts
+import * as p7 from "@clack/prompts";
+
+// src/autosync/optin.ts
 import * as p6 from "@clack/prompts";
 
+// src/autosync/hook.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname5, join as join8 } from "path";
+var CLAUDE_SETTINGS_FILE = join8(homedir7(), ".claude", "settings.json");
+var AUTO_SYNC_HOOK_COMMAND = "npx -y @use-aistack/cli@latest sync --auto || npx -y --prefer-offline @use-aistack/cli sync --auto";
+function isOurs(entry) {
+  return typeof entry.command === "string" && entry.command.includes("@use-aistack/cli") && entry.command.includes("sync --auto");
+}
+function readClaudeSettings(file) {
+  if (!existsSync8(file)) return { settings: {} };
+  try {
+    const raw = JSON.parse(readFileSync7(file, "utf-8"));
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      return { settings: raw };
+    }
+    return { error: `${file} does not hold a JSON object` };
+  } catch {
+    return { error: `${file} is not valid JSON \u2014 fix it, then retry` };
+  }
+}
+function installAutoSyncHook(file = CLAUDE_SETTINGS_FILE) {
+  const read = readClaudeSettings(file);
+  if ("error" in read) return { ok: false, message: read.error };
+  const settings = read.settings;
+  const hooks = settings.hooks ?? {};
+  const sessionStart = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+  const kept = sessionStart.map((m) => ({
+    ...m,
+    hooks: (m.hooks ?? []).filter((h) => !isOurs(h))
+  })).filter((m) => (m.hooks?.length ?? 0) > 0);
+  kept.push({
+    hooks: [{ type: "command", command: AUTO_SYNC_HOOK_COMMAND, async: true }]
+  });
+  settings.hooks = { ...hooks, SessionStart: kept };
+  mkdirSync3(dirname5(file), { recursive: true });
+  writeFileSync3(file, `${JSON.stringify(settings, null, 2)}
+`);
+  return { ok: true, message: `SessionStart hook written to ${file}` };
+}
+function removeAutoSyncHook(file = CLAUDE_SETTINGS_FILE) {
+  if (!existsSync8(file)) return { ok: true, message: "no hook to remove" };
+  const read = readClaudeSettings(file);
+  if ("error" in read) return { ok: false, message: read.error };
+  const settings = read.settings;
+  const sessionStart = settings.hooks?.SessionStart;
+  if (!Array.isArray(sessionStart)) {
+    return { ok: true, message: "no hook to remove" };
+  }
+  const kept = sessionStart.map((m) => ({
+    ...m,
+    hooks: (m.hooks ?? []).filter((h) => !isOurs(h))
+  })).filter((m) => (m.hooks?.length ?? 0) > 0);
+  const hooks = { ...settings.hooks };
+  if (kept.length > 0) {
+    hooks.SessionStart = kept;
+  } else {
+    delete hooks.SessionStart;
+  }
+  if (Object.keys(hooks).length > 0) {
+    settings.hooks = hooks;
+  } else {
+    delete settings.hooks;
+  }
+  writeFileSync3(file, `${JSON.stringify(settings, null, 2)}
+`);
+  return { ok: true, message: `hook removed from ${file}` };
+}
+
+// src/autosync/optin.ts
+function enableAutoSync(frequencyHours = DEFAULT_FREQUENCY_HOURS, deps = {}) {
+  const install = deps.installHook ?? installAutoSyncHook;
+  const result = install();
+  if (!result.ok) return result;
+  saveSettings(
+    {
+      autoSyncAnswered: true,
+      autoSync: { enabled: true, frequencyHours }
+    },
+    deps.settingsFile
+  );
+  return {
+    ok: true,
+    message: `Auto-sync is on \u2014 about every ${frequencyHours}h when a Claude Code session starts. Turn it off any time: npx @use-aistack/cli sync --auto off`
+  };
+}
+function disableAutoSync(deps = {}) {
+  const remove = deps.removeHook ?? removeAutoSyncHook;
+  const settings = getSettings(deps.settingsFile);
+  saveSettings(
+    {
+      autoSyncAnswered: true,
+      autoSync: {
+        enabled: false,
+        frequencyHours: settings.autoSync?.frequencyHours ?? DEFAULT_FREQUENCY_HOURS
+      }
+    },
+    deps.settingsFile
+  );
+  const result = remove();
+  if (!result.ok) {
+    return {
+      ok: false,
+      message: `Auto-sync is off (nothing will publish), but the hook could not be removed: ${result.message}`
+    };
+  }
+  return { ok: true, message: "Auto-sync is off. The hook was removed." };
+}
+async function offerAutoSyncOptIn() {
+  if (getSettings().autoSyncAnswered === true) return false;
+  const answer = await p6.select({
+    message: "Keep this stack fresh automatically?",
+    options: [
+      {
+        value: "later",
+        label: "Not now",
+        hint: "this question will not come back"
+      },
+      {
+        value: "enable",
+        label: "Enable",
+        hint: "a silent daily sync when a Claude Code session starts"
+      }
+    ],
+    initialValue: "later"
+  });
+  if (p6.isCancel(answer)) return true;
+  if (answer === "enable") {
+    const result = enableAutoSync();
+    if (result.ok) {
+      p6.log.success(result.message);
+    } else {
+      p6.log.error(result.message);
+    }
+    return true;
+  }
+  saveSettings({ autoSyncAnswered: true });
+  p6.log.message(
+    `If you change your mind: ${limeBold("npx @use-aistack/cli sync --auto on")} ${dim(
+      "(and --auto off to revoke)"
+    )}`
+  );
+  return true;
+}
+
+// src/autosync/run.ts
+import {
+  appendFileSync,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync8,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { homedir as homedir9 } from "os";
+import { dirname as dirname6, join as join9 } from "path";
+
 // src/sync/stage.ts
 import { createHash } from "crypto";
 
@@ -1643,9 +1829,9 @@ function priceAt(modelKey, atMs) {
   if (atMs === null) return null;
   const periods = PRICES[modelKey];
   if (!periods) return null;
-  for (const p7 of periods) {
-    if ((p7.from === null || atMs >= p7.from) && (p7.to === null || atMs < p7.to)) {
-      return p7;
+  for (const p8 of periods) {
+    if ((p8.from === null || atMs >= p8.from) && (p8.to === null || atMs < p8.to)) {
+      return p8;
     }
   }
   return null;
@@ -1654,10 +1840,10 @@ function isPricedModel(modelKey) {
   return PRICES[modelKey] !== void 0;
 }
 function apiEquivalentCost(modelKey, t, atMs) {
-  const p7 = priceAt(modelKey, atMs);
-  if (!p7) return null;
+  const p8 = priceAt(modelKey, atMs);
+  if (!p8) return null;
   const M = 1e6;
-  return (t.input * p7.input + t.output * p7.output + (t.cacheWrite5m + t.cacheWriteUnsplit) * p7.input * CACHE_WRITE_5M_MULTIPLIER + t.cacheWrite1h * p7.input * CACHE_WRITE_1H_MULTIPLIER + t.cacheRead * p7.input * CACHE_READ_MULTIPLIER) / M;
+  return (t.input * p8.input + t.output * p8.output + (t.cacheWrite5m + t.cacheWriteUnsplit) * p8.input * CACHE_WRITE_5M_MULTIPLIER + t.cacheWrite1h * p8.input * CACHE_WRITE_1H_MULTIPLIER + t.cacheRead * p8.input * CACHE_READ_MULTIPLIER) / M;
 }
 
 // src/transcripts/analyzer.ts
@@ -2024,7 +2210,7 @@ function newestVersion(versions) {
   let best = null;
   let bestParts = [];
   for (const v of versions) {
-    const parts = v.split(".").map((p7) => Number.parseInt(p7, 10));
+    const parts = v.split(".").map((p8) => Number.parseInt(p8, 10));
     if (parts.some((n) => !Number.isFinite(n))) continue;
     if (best === null || compareParts(parts, bestParts) > 0) {
       best = v;
@@ -2385,7 +2571,7 @@ function filterAtoms(atoms, sets) {
 // src/transcripts/scan.ts
 import { createReadStream } from "fs";
 import { readdir, realpath, stat } from "fs/promises";
-import { homedir as homedir7 } from "os";
+import { homedir as homedir8 } from "os";
 import path from "path";
 import readline from "readline";
 function transcriptRoots() {
@@ -2393,8 +2579,8 @@ function transcriptRoots() {
   if (env) {
     return env.split(",").map((s) => s.trim()).filter(Boolean).map((s) => path.join(s, "projects"));
   }
-  const roots = [path.join(homedir7(), ".claude", "projects")];
-  const xdg = process.env.XDG_CONFIG_HOME ?? path.join(homedir7(), ".config");
+  const roots = [path.join(homedir8(), ".claude", "projects")];
+  const xdg = process.env.XDG_CONFIG_HOME ?? path.join(homedir8(), ".config");
   roots.push(path.join(xdg, "claude", "projects"));
   return roots;
 }
@@ -2468,9 +2654,9 @@ async function scan(agg, opts = {}) {
   }
   return stats;
 }
-async function exists(p7) {
+async function exists(p8) {
   try {
-    await stat(p7);
+    await stat(p8);
     return true;
   } catch {
     return false;
@@ -2889,15 +3075,132 @@ async function stageSync(deps) {
   };
 }
 
+// src/autosync/run.ts
+var SYNC_LOG_FILE = join9(homedir9(), ".config", "aistack", "sync.log");
+var SYNC_LOG_MAX_LINES = 200;
+var FIX_COMMAND = "npx @use-aistack/cli sync";
+function appendLogLine(file, line) {
+  mkdirSync4(dirname6(file), { recursive: true });
+  appendFileSync(file, `${line}
+`);
+  const lines2 = readFileSync8(file, "utf-8").split("\n").filter(Boolean);
+  if (lines2.length > SYNC_LOG_MAX_LINES) {
+    writeFileSync4(file, `${lines2.slice(-SYNC_LOG_MAX_LINES).join("\n")}
+`);
+  }
+}
+async function runAutoSync(deps) {
+  const now = (deps.now ?? Date.now)();
+  const settingsFile = deps.settingsFile;
+  const logFile = deps.logFile ?? SYNC_LOG_FILE;
+  const emit = deps.emit ?? ((line) => process.stdout.write(`${line}
+`));
+  const stamp = new Date(now).toISOString();
+  const settings = getSettings(settingsFile);
+  const config = settings.autoSync;
+  if (config?.enabled !== true) {
+    appendLogLine(logFile, `${stamp} skipped \u2014 auto-sync is not enabled`);
+    return;
+  }
+  const frequencyHours = config.frequencyHours || DEFAULT_FREQUENCY_HOURS;
+  const state = settings.autoSyncState ?? {};
+  const lastRunAt = state.lastRunAt ?? 0;
+  if (now - lastRunAt < frequencyHours * 36e5) return;
+  const stage = deps.stageImpl ?? stageSync;
+  const publish = deps.publishImpl ?? syncPublish;
+  let failure2 = null;
+  let url;
+  try {
+    const staged = await stage({ baseUrl: deps.baseUrl, now: () => now });
+    if (staged.blockedReason !== null) {
+      failure2 = staged.blockedReason;
+    } else {
+      const res = await publish(staged.token, staged.bodyJson);
+      url = res.url;
+    }
+  } catch (e) {
+    failure2 = e instanceof Error ? e.message : String(e);
+  }
+  if (failure2 === null) {
+    saveSettings(
+      {
+        autoSyncState: {
+          lastRunAt: now,
+          lastSuccessAt: now,
+          lastResult: `ok \u2014 published at ${stamp}`,
+          consecutiveFailures: 0,
+          failureWarned: false
+        }
+      },
+      settingsFile
+    );
+    appendLogLine(logFile, `${stamp} ok \u2014 published${url ? ` ${url}` : ""}`);
+    return;
+  }
+  const consecutiveFailures = (state.consecutiveFailures ?? 0) + 1;
+  const shouldWarn = consecutiveFailures >= 3 && state.failureWarned !== true;
+  saveSettings(
+    {
+      autoSyncState: {
+        ...state,
+        lastRunAt: now,
+        lastResult: `failed at ${stamp} \u2014 ${failure2}`,
+        consecutiveFailures,
+        failureWarned: state.failureWarned === true || shouldWarn
+      }
+    },
+    settingsFile
+  );
+  appendLogLine(
+    logFile,
+    `${stamp} fail (${consecutiveFailures} in a row) \u2014 ${failure2}`
+  );
+  if (shouldWarn) {
+    emit(
+      JSON.stringify({
+        systemMessage: `aistack auto-sync failed ${consecutiveFailures} times in a row (${failure2}). Run \`${FIX_COMMAND}\` in a terminal to fix it, or \`${FIX_COMMAND} --auto off\` to stop these runs.`
+      })
+    );
+  }
+}
+
 // src/commands/sync.ts
-async function syncCommand() {
+async function syncCommand(options = {}) {
+  if (options.auto === true) {
+    await runAutoSync({ baseUrl: BASE_URL });
+    return;
+  }
+  if (options.auto === "on" || options.auto === "off") {
+    intro2("sync");
+    const result = options.auto === "on" ? enableAutoSync(
+      options.every ? Number.parseInt(options.every, 10) || DEFAULT_FREQUENCY_HOURS : DEFAULT_FREQUENCY_HOURS
+    ) : disableAutoSync();
+    if (result.ok) {
+      p7.log.success(result.message);
+      outro2("done");
+    } else {
+      outroError(result.message);
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (options.auto !== void 0) {
+    intro2("sync");
+    outroError(`unknown --auto value "${options.auto}" \u2014 use on or off`);
+    process.exitCode = 1;
+    return;
+  }
   intro2("sync");
+  const lastAuto = getSettings().autoSyncState?.lastResult;
+  if (lastAuto !== void 0) {
+    p7.log.message(dim(`auto-sync: ${lastAuto}`));
+  }
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     outroError("sync needs an interactive terminal \u2014 nothing was sent");
     process.exitCode = 1;
     return;
   }
-  const s = p6.spinner();
+  const s = p7.spinner();
   s.start("Scanning local Claude Code transcripts");
   let staged;
   try {
@@ -2909,13 +3212,13 @@ async function syncCommand() {
     return;
   }
   s.stop("Scan complete");
-  p6.log.message(staged.summary.split("\n").join("\n"));
+  p7.log.message(staged.summary.split("\n").join("\n"));
   if (staged.blockedReason !== null) {
     outroError(staged.blockedReason);
     process.exitCode = 1;
     return;
   }
-  const decision = await p6.select({
+  const decision = await p7.select({
     message: staged.dialog.split("\n").join(dim(" \xB7 ")),
     options: [
       { value: "cancel", label: "Cancel", hint: "nothing leaves this machine" },
@@ -2923,7 +3226,7 @@ async function syncCommand() {
     ],
     initialValue: "cancel"
   });
-  if (p6.isCancel(decision) || decision !== "publish") {
+  if (p7.isCancel(decision) || decision !== "publish") {
     outroCancel("nothing was sent");
     return;
   }
@@ -2944,8 +3247,9 @@ async function syncCommand() {
         `${res.keptPrivate.stored} kept-private names went up for your review at ${res.url}/changes`
       );
     }
-    p6.log.message(lines2.join("\n"));
-    await offerConnectUpsell();
+    p7.log.message(lines2.join("\n"));
+    const asked = await offerAutoSyncOptIn();
+    if (!asked) await offerConnectUpsell();
     outro2("done");
   } catch (e) {
     s.stop("Publish failed");
@@ -2996,7 +3300,7 @@ function createSyncServer(deps, send) {
   const now = deps.now ?? Date.now;
   const stage = deps.stageImpl ?? stageSync;
   const publish = deps.publishImpl ?? syncPublish;
-  const log6 = deps.log ?? (() => {
+  const log7 = deps.log ?? (() => {
   });
   const elicitTimeoutMs = deps.elicitTimeoutMs ?? ELICIT_TIMEOUT_MS;
   let clientSupportsElicitation = false;
@@ -3076,7 +3380,7 @@ function createSyncServer(deps, send) {
       );
     }
     const approvedStage = staged;
-    log6(`elicitation raised for stage ${approvedStage.id}`);
+    log7(`elicitation raised for stage ${approvedStage.id}`);
     request2(
       "elicitation/create",
       {
@@ -3099,7 +3403,7 @@ function createSyncServer(deps, send) {
         const approved = result?.action === "accept" && result?.content?.decision === "publish";
         if (!approved) {
           const outcome = reply === null ? "timed out" : result?.action ?? "error";
-          log6(`elicitation resolved without consent: ${outcome}`);
+          log7(`elicitation resolved without consent: ${outcome}`);
           return ok(
             id,
             textResult(
@@ -3107,7 +3411,7 @@ function createSyncServer(deps, send) {
             )
           );
         }
-        log6(`consent received, sending stage ${approvedStage.id}`);
+        log7(`consent received, sending stage ${approvedStage.id}`);
         publish(approvedStage.token, approvedStage.bodyJson).then(
           (res) => {
             if (staged?.id === approvedStage.id) staged = null;
@@ -3150,7 +3454,7 @@ function createSyncServer(deps, send) {
       case "initialize": {
         const capabilities = params?.capabilities ?? {};
         clientSupportsElicitation = "elicitation" in capabilities;
-        log6(
+        log7(
           `initialize: elicitation ${clientSupportsElicitation ? "declared" : "ABSENT"}`
         );
         return ok(id, {
@@ -3205,7 +3509,7 @@ function runStdioSyncServer(deps) {
 
 // src/index.ts
 var program = new Command();
-program.name("aistack").description("Measure and share your AI stack from your terminal").version("0.4.0");
+program.name("aistack").description("Measure and share your AI stack from your terminal").version("0.5.0");
 program.command("login").description("Authenticate with AI Stack").action(loginCommand);
 program.command("collect").description("Scan and upload AI config files from your project").option("--no-global", "Exclude global config files (~/.claude, etc.)").action((options) => collectCommand({ global: options.global ?? true }));
 program.command("create").description("Download and write your stack's AI config files").action(createCommand);
@@ -3218,7 +3522,13 @@ program.command("mcp").description(
 `)
   });
 });
-program.command("sync").description("Scan, preview, and publish measured usage (rolling 30 days)").action(syncCommand);
+program.command("sync").description("Scan, preview, and publish measured usage (rolling 30 days)").option(
+  "--auto [state]",
+  "silent background sync; 'on' enables the SessionStart hook, 'off' revokes it"
+).option(
+  "--every <hours>",
+  "with --auto on: hours between auto-syncs (default 24)"
+).action((options) => syncCommand(options));
 program.command("connect").description("Install the in-session sync surface (MCP server + Skill)").argument("<harness>", 'the harness to connect ("claude")').action(connectCommand);
 program.parse();
 //# sourceMappingURL=index.js.map