@usepowerplant/cli 0.4.7 → 0.4.8

package/README.md

@@ -22,8 +22,11 @@ re-run at any time — finished steps are skipped with a note:
 2. **Install the background service.** The sync service watches your local
    coding-agent sessions (Claude Code, Codex, and Cursor) and uploads the
    ones in scope. If recent sessions name repositories under a macOS-protected
-   location such as Documents, init lists the location and asks before reading
-   Git metadata there; declining leaves those sessions local. The service
+   location such as Documents, init lists the location and asks once before
+   reading Git metadata there; declining leaves those sessions local, and a
+   yes covers locations that appear later (init still explains before macOS
+   asks). A location macOS refused is re-checked on every init until you
+   enable it in System Settings. The service
    starts on login and keeps itself running. On macOS, init also installs
    the Powerplant menu bar app from this package into `~/Applications` and
    launches it; the app registers itself to start at login (turn that off
@@ -131,9 +134,11 @@ then restarts itself onto it. The choice is per machine and only an
 explicit yes counts: a machine set up before the question existed stays
 off until someone turns it on. `powerplant status` and `powerplant doctor`
 report the current choice, and `powerplant update --automatic on` or
-`--automatic off`, or the menu bar's More menu, change it. A release that
-fails to install is not retried by itself; the menu bar shows the failure
-with a retry and the update log, and the next release clears it.
+`--automatic off`, or the menu bar's More menu, change it. Turning it on
+(there, or at init's question) makes the sync check within seconds, so a
+release already out installs now rather than at the next hourly check. A
+release that fails to install is not retried by itself; the menu bar shows
+the failure with a retry and the update log, and the next release clears it.
 
 Powerplant also publishes the oldest version it still supports. When yours
 is older, `powerplant status`, `powerplant doctor`, the menu bar app, and

package/dist/cli.js

@@ -55485,20 +55485,210 @@ function workspaceClaimsAnyRepo(policy) {
   return policy.repos !== null ? policy.repos.length > 0 : policy.owners.length > 0;
 }
 
+// ../core/src/encodedImages.ts
+var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function isEncodedImage(data, mediaType) {
+  if (data.length < 16 || data.length % 4 !== 0) return false;
+  const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
+  const body = data.slice(0, data.length - padding);
+  if (/[^A-Za-z0-9+/]/.test(body)) return false;
+  const last = BASE64_ALPHABET.indexOf(body.at(-1));
+  if (padding === 2 && (last & 15) !== 0 || padding === 1 && (last & 3) !== 0) return false;
+  switch (mediaType) {
+    case "image/png":
+      return isPng(atob(data));
+    case "image/jpeg":
+      return isJpeg(atob(data));
+    case "image/gif":
+      return isGif(atob(data));
+    case "image/webp":
+      return isWebp(atob(data));
+    default:
+      return false;
+  }
+}
+function u16(data, offset) {
+  return data.charCodeAt(offset) << 8 | data.charCodeAt(offset + 1);
+}
+function u32(data, offset) {
+  return u16(data, offset) * 65536 + u16(data, offset + 2) >>> 0;
+}
+function little32(data, offset) {
+  return (data.charCodeAt(offset) | data.charCodeAt(offset + 1) << 8 | data.charCodeAt(offset + 2) << 16 | data.charCodeAt(offset + 3) << 24) >>> 0;
+}
+var CRC_TABLE = Array.from({ length: 256 }, (_, value) => {
+  for (let bit = 0; bit < 8; bit++) value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+  return value >>> 0;
+});
+function crc32(data, start, end) {
+  let crc = 4294967295;
+  for (let i = start; i < end; i++)
+    crc = CRC_TABLE[(crc ^ data.charCodeAt(i)) & 255] ^ crc >>> 8;
+  return (crc ^ 4294967295) >>> 0;
+}
+function isPng(data) {
+  if (!data.startsWith("\x89PNG\r\n\n")) return false;
+  let offset = 8;
+  let imageData = false;
+  let dataEnded = false;
+  let palette = false;
+  let indexed = false;
+  while (offset + 12 <= data.length) {
+    const size = u32(data, offset);
+    const type = data.slice(offset + 4, offset + 8);
+    const end = offset + 8 + size;
+    if (size > 2147483647 || end + 4 > data.length || !/^[A-Za-z]{2}[A-Z][A-Za-z]$/.test(type))
+      return false;
+    if (u32(data, end) !== crc32(data, offset + 4, end)) return false;
+    if (offset === 8) {
+      if (type !== "IHDR" || size !== 13 || !u32(data, offset + 8) || !u32(data, offset + 12))
+        return false;
+      const depth = data.charCodeAt(offset + 16);
+      const color = data.charCodeAt(offset + 17);
+      const validDepth = color === 0 ? [1, 2, 4, 8, 16] : color === 3 ? [1, 2, 4, 8] : [8, 16];
+      if (![0, 2, 3, 4, 6].includes(color) || !validDepth.includes(depth)) return false;
+      if (data.charCodeAt(offset + 18) !== 0 || data.charCodeAt(offset + 19) !== 0 || data.charCodeAt(offset + 20) > 1)
+        return false;
+      indexed = color === 3;
+    } else if (type === "IHDR") return false;
+    else if (type === "PLTE") {
+      if (imageData || palette || size === 0 || size > 768 || size % 3 !== 0) return false;
+      palette = true;
+    } else if (type === "IDAT") {
+      if (dataEnded || indexed && !palette) return false;
+      imageData = imageData || size > 0;
+    } else if (type === "IEND") return imageData && size === 0 && end + 4 === data.length;
+    else if (type[0] === type[0].toUpperCase()) return false;
+    if (imageData && type !== "IDAT") dataEnded = true;
+    offset = end + 4;
+  }
+  return false;
+}
+function isJpeg(data) {
+  if (!data.startsWith("\xFF\xD8")) return false;
+  let offset = 2;
+  let frame = false;
+  let scan = false;
+  while (offset < data.length) {
+    if (data.charCodeAt(offset++) !== 255) return false;
+    while (data.charCodeAt(offset) === 255) offset++;
+    const marker = data.charCodeAt(offset++);
+    if (marker === 217) return frame && scan && offset === data.length;
+    if (marker === 0 || marker === 216 || marker >= 208 && marker <= 215) return false;
+    if (marker === 1) continue;
+    if (offset + 2 > data.length) return false;
+    const size = u16(data, offset);
+    if (size < 2 || offset + size > data.length) return false;
+    if (marker >= 192 && marker <= 207 && ![196, 200, 204].includes(marker)) {
+      if (size < 11 || size !== 8 + 3 * data.charCodeAt(offset + 7) || !u16(data, offset + 3) || !u16(data, offset + 5))
+        return false;
+      frame = true;
+    }
+    if (marker !== 218) {
+      offset += size;
+      continue;
+    }
+    if (!frame || size < 8 || size !== 6 + 2 * data.charCodeAt(offset + 2)) return false;
+    offset += size;
+    const start = offset;
+    for (; ; ) {
+      const next = data.indexOf("\xFF", offset);
+      if (next < 0 || next + 1 >= data.length) return false;
+      const following = data.charCodeAt(next + 1);
+      if (following === 0 || following >= 208 && following <= 215) offset = next + 2;
+      else if (following === 255) offset = next + 1;
+      else {
+        offset = next;
+        break;
+      }
+    }
+    if (offset <= start) return false;
+    scan = true;
+  }
+  return false;
+}
+function skipGifBlocks(data, offset) {
+  while (offset < data.length) {
+    const size = data.charCodeAt(offset++);
+    if (size === 0) return offset;
+    offset += size;
+  }
+  return -1;
+}
+function isGif(data) {
+  if (!data.startsWith("GIF87a") && !data.startsWith("GIF89a") || data.length < 13) return false;
+  if (!(data.charCodeAt(6) | data.charCodeAt(7)) || !(data.charCodeAt(8) | data.charCodeAt(9)))
+    return false;
+  const packed = data.charCodeAt(10);
+  let offset = 13 + (packed & 128 ? 3 * (2 << (packed & 7)) : 0);
+  let image = false;
+  while (offset < data.length) {
+    const marker = data.charCodeAt(offset++);
+    if (marker === 59) return image && offset === data.length;
+    if (marker === 33) offset = skipGifBlocks(data, offset + 1);
+    else if (marker === 44) {
+      if (offset + 9 > data.length || !(data.charCodeAt(offset + 4) | data.charCodeAt(offset + 5)) || !(data.charCodeAt(offset + 6) | data.charCodeAt(offset + 7)))
+        return false;
+      const local = data.charCodeAt(offset + 8);
+      offset += 9 + (local & 128 ? 3 * (2 << (local & 7)) : 0);
+      const codeSize = data.charCodeAt(offset++);
+      if (codeSize < 2 || codeSize > 8 || offset >= data.length || data.charCodeAt(offset) === 0)
+        return false;
+      offset = skipGifBlocks(data, offset);
+      image = true;
+    } else return false;
+    if (offset < 0) return false;
+  }
+  return false;
+}
+function isWebp(data) {
+  return data.startsWith("RIFF") && data.slice(8, 12) === "WEBP" && little32(data, 4) + 8 === data.length && webpChunks(data, 12, data.length, true);
+}
+function webpChunks(data, start, end, allowFrames) {
+  let image = false;
+  let offset = start;
+  while (offset + 8 <= end) {
+    const type = data.slice(offset, offset + 4);
+    const size = little32(data, offset + 4);
+    const body = offset + 8;
+    const next = body + size + size % 2;
+    if (next > end) return false;
+    if (type === "VP8 ") {
+      if (size < 11 || data.charCodeAt(body) & 1 || data.slice(body + 3, body + 6) !== "\x9D
*")
+        return false;
+      if (!((data.charCodeAt(body + 6) | data.charCodeAt(body + 7) << 8) & 16383) || !((data.charCodeAt(body + 8) | data.charCodeAt(body + 9) << 8) & 16383))
+        return false;
+      image = true;
+    } else if (type === "VP8L") {
+      if (size < 6 || data.charCodeAt(body) !== 47 || data.charCodeAt(body + 4) & 224)
+        return false;
+      image = true;
+    } else if (type === "VP8X") {
+      if (size !== 10 || !allowFrames) return false;
+    } else if (type === "ANMF") {
+      if (!allowFrames || size < 16 || !webpChunks(data, body + 16, body + size, false))
+        return false;
+      image = true;
+    }
+    offset = next;
+  }
+  return image && offset === end;
+}
+
 // ../core/src/transcriptImages.ts
 var IMAGE_DATA_URI_RE = /^data:(image\/[\w.+-]+);base64,([A-Za-z0-9+/=_-]*)$/;
 function isImageDataUri(value) {
-  return value.startsWith("data:image/") && IMAGE_DATA_URI_RE.test(value);
+  if (!value.startsWith("data:image/")) return false;
+  const match = IMAGE_DATA_URI_RE.exec(value);
+  return match !== null && isEncodedImage(match[2], match[1]);
 }
 function isImageBase64Payload(record2, key) {
-  if (typeof record2[key] !== "string") return false;
-  if (key === "data") return record2.type === "base64" && isImageMediaType(record2.media_type);
-  if (key === "base64") return isImageMediaType(record2.type);
+  const data = record2[key];
+  if (typeof data !== "string") return false;
+  if (key === "data" && record2.type === "base64") return isEncodedImage(data, record2.media_type);
+  if (key === "base64") return isEncodedImage(data, record2.type);
   return false;
 }
-function isImageMediaType(value) {
-  return typeof value === "string" && value.startsWith("image/");
-}
 function describeImageBlock(block2) {
   if (block2.type !== "image") return null;
   const source = asRecord(block2.source);
@@ -56388,6 +56578,38 @@ function scrubBreadcrumb(breadcrumb) {
   return breadcrumb;
 }
 
+// ../core/src/freshness.ts
+function describeDataAge(generatedAt, now) {
+  const ageMs = now.getTime() - generatedAt.getTime();
+  if (ageMs < 0) return "just now";
+  const minutes = Math.floor(ageMs / 6e4);
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
+// ../core/src/onboarding.ts
+var SAME_HOUR_MS = 60 * 60 * 1e3;
+function describeSyncSignals(member, now, noUpload = "no sessions uploaded yet") {
+  const session = member.lastSessionActivityAt;
+  const poll = member.lastCheckedInAt;
+  const error62 = member.lastSyncErrorAt;
+  const paused = member.syncPaused === true;
+  if (session === null && poll === null && error62 === null) return null;
+  const age = (at) => describeDataAge(new Date(at), now);
+  const apart = (a, b2) => b2 === null || Math.abs(Date.parse(a) - Date.parse(b2)) > SAME_HOUR_MS;
+  const parts = [session === null ? noUpload : `last uploaded session ${age(session)}`];
+  if (error62 !== null) parts.push(`reported sync error ${age(error62)}`);
+  if (paused) parts.push("syncing paused");
+  const pollSays = error62 !== null ? apart(poll ?? error62, error62) : paused || apart(poll ?? "", session);
+  if (poll !== null && pollSays) parts.push(`last poll ${age(poll)}`);
+  const line = parts.join(", ");
+  return `${line.charAt(0).toUpperCase()}${line.slice(1)}.`;
+}
+
 // ../core/src/sessionIngest.ts
 var SESSION_SOURCES = [
   "claude-code",
@@ -83335,9 +83557,20 @@ var storedCredentialsSchema = external_exports.object({
    * (`powerplant folders add`). */
   scopePaths: external_exports.array(external_exports.string()).optional(),
   /** macOS privacy roots the member explicitly allowed Powerplant to inspect
-   * for Git metadata. This does not widen capture: org policy still decides
-   * which discovered repositories upload. */
+   * for Git metadata, and that macOS let it read. This does not widen
+   * capture: org policy still decides which discovered repositories upload. */
   repoDiscoveryRoots: external_exports.array(external_exports.string()).optional(),
+  /** When the member answered yes to Git metadata scans of macOS-protected
+   * session folders (ISO 8601). One answer for this enrollment: later init
+   * runs scan a newly seen root after an explanation, without asking again.
+   * Absent = never asked, or never answered yes. */
+  repoDiscoveryConsentedAt: external_exports.string().optional(),
+  /** Protected roots the member allowed but macOS refused to let Powerplant
+   * read (a declined Files and Folders dialog). macOS remembers that refusal
+   * and shows no second dialog, so init re-reads these roots on every run
+   * without a question and moves a root to repoDiscoveryRoots once the
+   * member enables it in System Settings. */
+  repoDiscoveryBlockedRoots: external_exports.array(external_exports.string()).optional(),
   /** When this enrollment's deep first sync completed; absent = still owed,
    * so the next sync sweeps DEEP_FIRST_SYNC_DAYS instead of the rolling window. */
   deepSyncedAt: external_exports.string().optional()
@@ -83423,7 +83656,7 @@ import os6 from "node:os";
 // ../../apps/collector/src/http.ts
 var import_undici = __toESM(require_undici(), 1);
 var CLI_VERSION_HEADER = "x-powerplant-cli-version";
-var cliVersion = true ? "0.4.7" : "0.0.0-checkout";
+var cliVersion = true ? "0.4.8" : "0.0.0-checkout";
 function cliVersionHeaders() {
   return { [CLI_VERSION_HEADER]: cliVersion, "user-agent": `powerplant-cli/${cliVersion}` };
 }
@@ -83608,8 +83841,8 @@ function unconsentedProtectedRoot(candidate, environment = {}) {
   );
   return consented ? null : protectedRoot;
 }
-var DENIED = { kind: "denied" };
 var NONE = { kind: "none" };
+var deniedAt = (p) => ({ kind: "denied", path: p });
 function consentGate(candidate, environment) {
   const root = unconsentedProtectedRoot(candidate, environment);
   return root === null ? null : { kind: "unconsented", root, path: path2.resolve(candidate) };
@@ -83618,7 +83851,7 @@ function readProbe(p) {
   try {
     return { kind: "found", value: readFileSync3(p, "utf8") };
   } catch (cause) {
-    return isPermissionError(cause) ? DENIED : NONE;
+    return isPermissionError(cause) ? deniedAt(p) : NONE;
   }
 }
 function gitDirReferenceProbe(cwd, environment) {
@@ -83628,7 +83861,7 @@ function gitDirReferenceProbe(cwd, environment) {
   for (; ; ) {
     const gitPath = path2.join(dir, ".git");
     const kind = statKind(gitPath);
-    if (kind === "denied") return DENIED;
+    if (kind === "denied") return deniedAt(gitPath);
     if (kind === "dir") return { kind: "found", value: gitPath };
     if (kind === "file") {
       const pointer = readProbe(gitPath);
@@ -83652,7 +83885,7 @@ function gitDirsProbe(cwd, environment) {
   const gitDirGate = consentGate(gitDir, environment);
   if (gitDirGate) return gitDirGate;
   const commondir = readProbe(path2.join(gitDir, "commondir"));
-  if (commondir.kind === "denied") return DENIED;
+  if (commondir.kind === "denied") return commondir;
   const pointer = commondir.kind === "found" ? commondir.value.trim() : "";
   const commonDir = pointer ? path2.resolve(gitDir, pointer) : gitDir;
   const commonDirGate = consentGate(commonDir, environment);
@@ -83887,10 +84120,15 @@ function tokenRejected(route) {
     `${route} rejected this machine's token (revoked or unknown). Re-enroll this machine (powerplant enroll, or pnpm collector enroll from the checkout).`
   );
 }
-async function fetchCapturePolicy(apiUrl, machineToken) {
+function capturePolicyUrl(apiUrl, request2) {
+  const url2 = new URL(`${apiUrl}/api/collector/capture-policy`);
+  if (request2.paused !== void 0) url2.searchParams.set("paused", String(request2.paused));
+  return url2.toString();
+}
+async function fetchCapturePolicy(apiUrl, machineToken, request2 = {}) {
   const response = await fetchWithRetry(
     "fetching the org's capture policy",
-    `${apiUrl}/api/collector/capture-policy`,
+    capturePolicyUrl(apiUrl, request2),
     { headers: { authorization: `Bearer ${machineToken}` } }
   );
   if (response.status === 401) {
@@ -83921,6 +84159,19 @@ async function fetchCapturePolicy(apiUrl, machineToken) {
   );
   return result.data;
 }
+var CHECK_IN_INTERVAL_MS = 30 * 6e4;
+async function reportCheckIn(apiUrl, machineToken, paused, fetcher = fetch) {
+  try {
+    const response = await fetcher(capturePolicyUrl(apiUrl, { paused }), {
+      headers: { ...cliVersionHeaders(), authorization: `Bearer ${machineToken}` },
+      signal: AbortSignal.timeout(3e3)
+    });
+    await response.body?.cancel();
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
 async function uploadSessions(apiUrl, machineToken, items) {
   let upserted = 0;
   let unchanged = 0;
@@ -84461,7 +84712,6 @@ function removeFolder(config2, rawPath, enrollCommand, log3, deps = defaultDeps)
 
 // ../../apps/collector/src/diagnostics.ts
 import { createHmac } from "node:crypto";
-var DIAGNOSTIC_INTERVAL_MS = 30 * 6e4;
 function observeFileDiagnostic(observer, file2) {
   try {
     observer?.(file2);
@@ -84579,8 +84829,7 @@ function createDiagnosticsReporter(credentials, send = createDiagnosticSender())
   let pending = Promise.resolve();
   let enrollment = null;
   let lastIssue = null;
-  let paused = false;
-  const report2 = (detailed) => {
+  const report2 = () => {
     try {
       const current = credentials();
       if (!current) return;
@@ -84589,29 +84838,20 @@ function createDiagnosticsReporter(credentials, send = createDiagnosticSender())
         lastIssue = null;
       }
       const matching = pass !== null && passEnrollments.get(pass) === current.token ? pass : null;
-      if (detailed) {
-        if (matching === null) return;
-        const issue2 = issueSignature(matching);
-        if (issue2 === lastIssue) return;
-        lastIssue = issue2;
-      }
-      const body = collectorDiagnosticSchema.parse({
-        state: matching?.outcome === "running" ? "syncing" : paused ? "paused" : "idle",
-        pass: detailed ? matching : null
-      });
+      if (matching === null) return;
+      const issue2 = issueSignature(matching);
+      if (issue2 === lastIssue) return;
+      lastIssue = issue2;
+      const body = collectorDiagnosticSchema.parse({ state: "idle", pass: matching });
       pending = send(current, body).catch(() => void 0);
     } catch {
     }
   };
   return {
-    heartbeat: (isPaused = false) => {
-      paused = isPaused;
-      report2(false);
-    },
     flush: () => pending,
     onDiagnostics: (diagnostic) => {
       pass = diagnostic;
-      if (diagnostic.outcome !== "running") report2(true);
+      if (diagnostic.outcome !== "running") report2();
     }
   };
 }
@@ -86296,25 +86536,33 @@ function groupProtectedSessions(sessions, environment = {}) {
     if (!session.cwd) continue;
     const cwd = path10.resolve(session.cwd);
     const directRoot = macPrivacyProtectedRoot(cwd, environment);
-    const gitDir = directRoot === null ? resolveGitDirReference(cwd, environment) : null;
-    const root = directRoot ?? (gitDir ? macPrivacyProtectedRoot(gitDir, environment) : null);
-    if (root === null) continue;
-    const folder = directRoot !== null || gitDir === null ? cwd : checkoutOfGitDir(gitDir);
-    tally.add(root, folder, cwd);
+    if (directRoot !== null) tally.add(directRoot, cwd, cwd);
+    const gitDir = resolveGitDirReference(cwd, environment);
+    const checkoutRoot = gitDir ? macPrivacyProtectedRoot(gitDir, environment) : null;
+    if (checkoutRoot !== null && checkoutRoot !== directRoot) {
+      tally.add(checkoutRoot, checkoutOfGitDir(gitDir), cwd);
+    }
   }
   return tally.entries();
 }
 var defaultAllowDeps = {
   load: loadCredentials,
   persist: saveCredentials,
-  probeRepo: repoProber
+  probeRepo: repoProber,
+  now: Date.now
 };
+function protectedRootReview(credentials, root) {
+  const resolved = path10.resolve(root);
+  if ((credentials.repoDiscoveryRoots ?? []).includes(resolved)) return "allowed";
+  if ((credentials.repoDiscoveryBlockedRoots ?? []).includes(resolved)) return "blocked";
+  return "unreviewed";
+}
 function allowProtectedRepoDiscovery(config2, found, environment = {}, deps = defaultAllowDeps) {
   const enrollment = deps.load(config2.appEnv);
   if (enrollment === null) {
     throw new ExpectedCliError("This machine must be enrolled before protected folders can be reviewed.");
   }
-  const candidateRoots = found.map((entry) => path10.resolve(entry.root));
+  const candidateRoots = rootsOf(found);
   const invalid = candidateRoots.find(
     (root) => macPrivacyProtectedRoot(root, environment) !== root
   );
@@ -86335,49 +86583,88 @@ function allowProtectedRepoDiscovery(config2, found, environment = {}, deps = de
     needsReview: []
   };
   const needsReview = new ProtectedRootTally(environment);
+  const refusedElsewhere = new ProtectedRootTally(environment);
   for (const entry of found) {
+    const root = path10.resolve(entry.root);
     const probes = entry.folders.flatMap(
       (folder) => folder.cwds.map((cwd) => ({ cwd, probe: probeOf(cwd), folder }))
     );
+    let deniedHere = false;
     let unconsented = 0;
     const countedFolderTargets = /* @__PURE__ */ new Set();
+    const countOnce = (target, sessionCount) => {
+      const counted = countedFolderTargets.has(target);
+      countedFolderTargets.add(target);
+      return counted ? 0 : sessionCount;
+    };
     for (const { cwd, probe, folder } of probes) {
+      if (probe.kind === "denied") {
+        const refusedRoot = macPrivacyProtectedRoot(probe.path, environment);
+        if (refusedRoot === root) deniedHere = true;
+        else if (refusedRoot !== null) {
+          const checkout2 = checkoutOfGitDir(probe.path);
+          const target2 = [folder.path, refusedRoot, checkout2].join("\0");
+          refusedElsewhere.add(refusedRoot, checkout2, cwd, countOnce(target2, folder.sessionCount));
+        }
+        continue;
+      }
       if (probe.kind !== "unconsented") continue;
       unconsented += 1;
       const checkout = checkoutOfGitDir(probe.path);
       const target = [folder.path, probe.root, checkout].join("\0");
-      needsReview.add(
-        probe.root,
-        checkout,
-        cwd,
-        countedFolderTargets.has(target) ? 0 : folder.sessionCount
-      );
-      countedFolderTargets.add(target);
+      needsReview.add(probe.root, checkout, cwd, countOnce(target, folder.sessionCount));
     }
     if (probes.some(({ probe }) => probe.kind === "found")) outcome.enabled.push(entry);
-    else if (probes.some(({ probe }) => probe.kind === "denied")) outcome.blocked.push(entry);
+    else if (deniedHere) outcome.blocked.push(entry);
     else if (unconsented > 0) outcome.unreviewed.push(entry);
     else outcome.unmatched.push(entry);
   }
+  const blockedRoots = new Set(rootsOf(outcome.blocked));
+  outcome.blocked.push(
+    ...refusedElsewhere.entries().filter((entry) => !blockedRoots.has(entry.root))
+  );
   outcome.needsReview = needsReview.entries();
-  const consented = [...outcome.enabled, ...outcome.unmatched];
-  if (consented.length === 0) return outcome;
   const credentials = deps.load(config2.appEnv);
   if (credentials === null || credentials.token !== enrollment.token || credentials.enrolledAt !== enrollment.enrolledAt) {
     throw new ExpectedCliError(
-      "This machine's enrollment changed while the folders were being reviewed, so the approval was not saved, run `powerplant init` again to review them."
+      "This machine's enrollment changed while the folders were being reviewed, so nothing was saved, run `powerplant init` again to review them."
     );
   }
-  const allowedProtectedRoots = [
+  const next = credentialsAfterRepoDiscovery(credentials, outcome, deps.now);
+  if (next !== null) deps.persist(config2.appEnv, next);
+  return outcome;
+}
+function rootsOf(entries) {
+  return entries.map((entry) => path10.resolve(entry.root));
+}
+function credentialsAfterRepoDiscovery(credentials, outcome, now) {
+  const readable = rootsOf([...outcome.enabled, ...outcome.unmatched]);
+  const denied = rootsOf(outcome.blocked).filter((root) => !readable.includes(root));
+  const allowedRoots = [
     .../* @__PURE__ */ new Set([
-      ...credentials.repoDiscoveryRoots ?? [],
-      ...consented.map((entry) => path10.resolve(entry.root))
+      ...(credentials.repoDiscoveryRoots ?? []).filter((root) => !denied.includes(root)),
+      ...readable
     ])
   ];
-  if (allowedProtectedRoots.length !== (credentials.repoDiscoveryRoots ?? []).length) {
-    deps.persist(config2.appEnv, { ...credentials, repoDiscoveryRoots: allowedProtectedRoots });
-  }
-  return outcome;
+  const blockedRoots = [
+    .../* @__PURE__ */ new Set([
+      ...(credentials.repoDiscoveryBlockedRoots ?? []).filter((root) => !readable.includes(root)),
+      ...denied
+    ])
+  ];
+  const unchanged = credentials.repoDiscoveryConsentedAt !== void 0 && sameList(allowedRoots, credentials.repoDiscoveryRoots ?? []) && sameList(blockedRoots, credentials.repoDiscoveryBlockedRoots ?? []);
+  if (unchanged) return null;
+  return {
+    ...credentials,
+    repoDiscoveryConsentedAt: credentials.repoDiscoveryConsentedAt ?? new Date(now()).toISOString(),
+    // Both lists clear on empty: keeping a stale allowed list would read a
+    // root as consent after macOS refused it.
+    repoDiscoveryRoots: allowedRoots.length > 0 ? allowedRoots : void 0,
+    repoDiscoveryBlockedRoots: blockedRoots.length > 0 ? blockedRoots : void 0
+  };
+}
+function sameList(a, b2) {
+  return a.length === b2.length && a.every((root, index) => root === b2[index]);
 }
 
 // ../../apps/collector/src/hookInstall.ts
@@ -86709,6 +86996,9 @@ var collectorStatusSchema = external_exports.object({
   /** Last pass that completed without error — everything eligible had been
    * uploaded as of this time. */
   lastSyncAt: external_exports.string().optional(),
+  /** Last pass that upserted at least one session; missing = no session
+   * has uploaded in this daemon's lifetime, not "never". */
+  lastUploadAt: external_exports.string().optional(),
   consecutiveFailures: external_exports.number().int().nonnegative()
 });
 var controlSchema = external_exports.object({
@@ -86725,7 +87015,8 @@ var controlSchema = external_exports.object({
 function interpretControlChange(previous, current) {
   const transitioned = previous.paused !== current.paused;
   const nudge = !current.paused && (transitioned || current.resumedAt !== previous.resumedAt);
-  return { transitioned, nudge };
+  const updateOptIn = current.autoUpdate === true && previous.autoUpdate !== true;
+  return { transitioned, nudge, updateOptIn };
 }
 function collectorStateDir(homeDir = os14.homedir()) {
   return path13.join(homeDir, ".config", "powerplant", "state");
@@ -86748,6 +87039,10 @@ function writeAtomically(file2, payload) {
 function writeCollectorStatus(appEnv, status, homeDir) {
   writeAtomically(statusFilePath(appEnv, homeDir), JSON.stringify(status, null, 2));
 }
+function carriedUploadClock(previous, machineId) {
+  if (previous.file !== "ok" || machineId === void 0) return void 0;
+  return previous.status.machineId === machineId ? previous.status.lastUploadAt : void 0;
+}
 function readCollectorStatus(appEnv, homeDir) {
   let raw;
   try {
@@ -87856,6 +88151,10 @@ function startWatch(config2, homeDir, runtime = { version: "checkout" }) {
   const presentRoots = storeRoots.filter(({ dir }) => existsSync6(dir)).map(({ dir }) => dir);
   const initialControl = readCollectorControl(config2.appEnv, home);
   const pausedAtMs = initialControl.paused ? Date.parse(initialControl.pausedAt ?? "") : Number.NaN;
+  const lastUploadAt = carriedUploadClock(
+    readCollectorStatus(config2.appEnv, home),
+    credentials?.machineId
+  );
   let status = {
     pid: process.pid,
     version: runtime.version,
@@ -87871,6 +88170,7 @@ function startWatch(config2, homeDir, runtime = { version: "checkout" }) {
     },
     watchedRoots: presentRoots,
     paused: initialControl.paused,
+    ...lastUploadAt !== void 0 && { lastUploadAt },
     consecutiveFailures: 0
   };
   let statusWriteFailed = false;
@@ -87889,9 +88189,19 @@ function startWatch(config2, homeDir, runtime = { version: "checkout" }) {
   };
   writeStatus({});
   const diagnostics = createDiagnosticsReporter(() => loadCredentials(config2.appEnv));
-  diagnostics.heartbeat(initialControl.paused);
-  const diagnosticHeartbeat = setInterval(() => diagnostics.heartbeat(status.paused), DIAGNOSTIC_INTERVAL_MS);
-  diagnosticHeartbeat.unref?.();
+  const checkIn = () => {
+    let current;
+    try {
+      current = loadCredentials(config2.appEnv);
+    } catch {
+      return;
+    }
+    if (current === null) return;
+    void reportCheckIn(current.apiUrl, current.token, status.paused);
+  };
+  checkIn();
+  const checkInTimer = setInterval(checkIn, CHECK_IN_INTERVAL_MS);
+  checkInTimer.unref?.();
   const heartbeat = setInterval(() => writeStatus({}), HEARTBEAT_INTERVAL_MS);
   heartbeat.unref?.();
   const noticeIfUnsupported = async () => {
@@ -87989,6 +88299,7 @@ function startWatch(config2, homeDir, runtime = { version: "checkout" }) {
         ...result.diagnostic && { diagnostic: result.diagnostic }
       },
       ...result.ok && { lastSyncAt: new Date(result.at).toISOString() },
+      ...result.ok && result.upserted > 0 && { lastUploadAt: new Date(result.at).toISOString() },
       consecutiveFailures: result.ok ? 0 : status.consecutiveFailures + 1
     }),
     reportError: reportCollectorError,
@@ -88020,16 +88331,21 @@ function startWatch(config2, homeDir, runtime = { version: "checkout" }) {
   let lastControl = initialControl;
   const controlPoll = setInterval(() => {
     const control = readCollectorControl(config2.appEnv, home);
-    const { transitioned, nudge } = interpretControlChange(lastControl, control);
+    const { transitioned, nudge, updateOptIn } = interpretControlChange(lastControl, control);
     lastControl = control;
     if (transitioned) {
       log3(control.paused ? "syncing paused via control file" : "syncing resumed");
       writeStatus({ paused: control.paused });
+      checkIn();
     }
     if (nudge) {
       log3("running a catch-up pass to cover the pause");
       loop.nudge();
     }
+    if (updateOptIn) {
+      log3("automatic updates turned on, checking for a release now");
+      void checkForUpdate();
+    }
   }, CONTROL_POLL_MS);
   controlPoll.unref?.();
   if (runtime.entryPath) {
@@ -89852,7 +90168,7 @@ import { accessSync, constants as constants2 } from "node:fs";
 import path23 from "node:path";
 
 // src/version.ts
-var CLI_VERSION = true ? "0.4.7" : "0.0.0-checkout";
+var CLI_VERSION = true ? "0.4.8" : "0.0.0-checkout";
 var CLI_RELEASE_BUILD = true ? true : false;
 var CLI_PACKAGE_NAME = "@usepowerplant/cli";
 
@@ -90424,6 +90740,9 @@ async function confirmResume(deps, log3, indent) {
   }
 }
 
+// src/protectedFolders.ts
+var MACOS_BLOCKED_FOLDER_REMEDY = "To allow it, open System Settings > Privacy & Security > Files and Folders, enable the folder for node, then run `powerplant init`.";
+
 // src/init.ts
 function syncNote(credentials) {
   const org = credentials.orgName ?? "your organization";
@@ -90468,7 +90787,7 @@ async function runInit(deps) {
   }
   log3("");
   const orgName = credentials.orgName;
-  let repoDiscoveryEnabled = false;
+  let repoDiscoveryDidWork = false;
   let protectedFoldersNeedAttention = false;
   let installed = false;
   let menubarDidWork = false;
@@ -90481,56 +90800,68 @@ async function runInit(deps) {
       "Checking recent session locations\u2026",
       deps.findProtectedSessions
     );
-    const alreadyAllowed = new Set(credentials.repoDiscoveryRoots ?? []);
-    const needsReview = protectedSessions.filter((entry) => !alreadyAllowed.has(entry.root));
-    if (needsReview.length > 0) {
-      protectedFoldersNeedAttention = true;
-      log3("     Coding agents recorded recent sessions in folders macOS is currently hiding from Powerplant:");
-      logProtectedFolders(log3, needsReview);
-      log3("     Powerplant will scan only Git metadata in those recorded session folders.");
-      if (deps.promptAllowed) {
-        const allowed = await confirmProtectedRepoDiscovery(deps);
-        if (allowed) {
-          log3(
-            '     macOS may label Powerplant as "node" because Powerplant runs on Node.js.'
-          );
+    const reviewOf = (entry) => protectedRootReview(credentials, entry.root);
+    const blocked = protectedSessions.filter((entry) => reviewOf(entry) === "blocked");
+    const fresh = protectedSessions.filter((entry) => reviewOf(entry) === "unreviewed");
+    if (blocked.length > 0 || fresh.length > 0) {
+      const org = orgName ?? "your organization";
+      const consented = credentials.repoDiscoveryConsentedAt !== void 0;
+      const toProbe = [];
+      let needsAttention = false;
+      if (fresh.length > 0) {
+        log3("     Coding agents recorded recent sessions in folders macOS is currently hiding from Powerplant:");
+        logProtectedFolders(log3, fresh);
+        if (!deps.promptAllowed) {
+          needsAttention = true;
+          logProtectedSessionsStayLocal(log3, fresh);
+          log3(`       Run \`powerplant init\` in a terminal to ${consented ? "scan" : "review"} them.`);
+        } else {
           log3(
-            `     If permission is added, Powerplant will only read Git metadata in these folders to check for ${orgName ?? "your organization's"} sessions.`
+            consented ? `     You already allowed Git metadata scans. Checking those folders for ${org}'s work repositories.` : `     If you allow it, Powerplant reads only Git metadata there, to find ${org}'s work repositories.`
           );
-          const result = await deps.activity(
+          if (consented || await confirmProtectedRepoDiscovery(deps)) toProbe.push(...fresh);
+          else {
+            needsAttention = true;
+            logProtectedSessionsStayLocal(log3, fresh);
+          }
+        }
+      }
+      if (blocked.length > 0) {
+        if (deps.promptAllowed) {
+          log3(`     Checking whether macOS still blocks ${displayRoots(blocked)}.`);
+          toProbe.push(...blocked);
+        } else {
+          needsAttention = true;
+          logBlockedByMacOS(log3, blocked);
+        }
+      }
+      if (toProbe.length > 0) {
+        log3('     macOS may label Powerplant as "node" because Powerplant runs on Node.js.');
+        const probe = async (roots) => {
+          const result2 = await deps.activity(
             "Scanning recorded session folders for Git repositories\u2026",
-            () => deps.allowProtectedRepoDiscovery(needsReview)
+            () => deps.allowProtectedRepoDiscovery(roots)
           );
-          let needsAttention = reportProtectedRepoDiscovery(log3, result);
-          if (result.enabled.length > 0) repoDiscoveryEnabled = true;
-          if (result.needsReview.length > 0) {
-            log3("     Some of those sessions use Git checkouts in other folders macOS is hiding from Powerplant:");
-            logProtectedFolders(log3, result.needsReview);
-            const again = await confirmProtectedRepoDiscovery(deps);
-            if (again) {
-              const second = await deps.activity(
-                "Scanning recorded session folders for Git repositories\u2026",
-                () => deps.allowProtectedRepoDiscovery([...result.unreviewed, ...result.needsReview])
-              );
-              needsAttention = reportProtectedRepoDiscovery(log3, second) || needsAttention;
-              if (second.enabled.length > 0) repoDiscoveryEnabled = true;
-              if (second.unreviewed.length > 0) {
-                logProtectedSessionsStayLocal(log3, second.unreviewed);
-                needsAttention = true;
-              }
-            } else {
-              logProtectedSessionsStayLocal(log3, result.needsReview);
-              needsAttention = true;
-            }
+          needsAttention = reportProtectedRepoDiscovery(log3, result2) || needsAttention;
+          const unblocked = result2.unmatched.filter((entry) => reviewOf(entry) === "blocked");
+          if (unblocked.length > 0) {
+            log3(`     \u2713 macOS now lets Powerplant read ${displayRoots(unblocked)}. No work repositories were found there.`);
+          }
+          if (result2.enabled.length > 0 || unblocked.length > 0) repoDiscoveryDidWork = true;
+          return result2;
+        };
+        const result = await probe(toProbe);
+        if (result.needsReview.length > 0) {
+          log3("     Some of those sessions use Git checkouts in other folders macOS is hiding from Powerplant:");
+          logProtectedFolders(log3, result.needsReview);
+          const second = await probe([...result.unreviewed, ...result.needsReview]);
+          if (second.unreviewed.length > 0) {
+            logProtectedSessionsStayLocal(log3, second.unreviewed);
+            needsAttention = true;
           }
-          protectedFoldersNeedAttention = needsAttention;
-        } else {
-          logProtectedSessionsStayLocal(log3, needsReview);
         }
-      } else {
-        logProtectedSessionsStayLocal(log3, needsReview);
-        log3("       Run `powerplant init` in a terminal to review them.");
       }
+      protectedFoldersNeedAttention = needsAttention;
     }
   }
   if (deps.platform !== "darwin") {
@@ -90570,7 +90901,7 @@ async function runInit(deps) {
   log3("");
   const connectDidWork = outcome !== null && outcome.connected + outcome.configured > outcome.unchanged;
   const connectSettled = outcome !== null && outcome.found > 0 && outcome.pending === 0 && outcome.failed === 0 && outcome.skipped === 0 && outcome.unchanged === outcome.found && !connectDidWork;
-  if (!enrolled && !installed && !menubarDidWork && !repoDiscoveryEnabled && !protectedFoldersNeedAttention && pauseOffer === "not-paused" && connectSettled) {
+  if (!enrolled && !installed && !menubarDidWork && !repoDiscoveryDidWork && !protectedFoldersNeedAttention && pauseOffer === "not-paused" && connectSettled) {
     log3("Everything is already set up.");
     return;
   }
@@ -90647,24 +90978,22 @@ function logProtectedFolders(log3, roots) {
 }
 function reportProtectedRepoDiscovery(log3, result) {
   if (result.enabled.length > 0) {
-    log3(
-      `     \u2713 Repository scanning enabled for ${result.enabled.map((entry) => entry.displayRoot).join(", ")}`
-    );
-  }
-  if (result.blocked.length > 0) {
-    log3(
-      `     ! macOS blocked Powerplant from reading ${result.blocked.map((entry) => entry.displayRoot).join(", ")}.`
-    );
-    log3(
-      "       Sessions there will stay local. To allow it, open System Settings > Privacy & Security > Files and Folders, enable the folder for node, then rerun `powerplant init`."
-    );
+    log3(`     \u2713 Repository scanning enabled for ${displayRoots(result.enabled)}`);
   }
+  if (result.blocked.length > 0) logBlockedByMacOS(log3, result.blocked);
   return result.blocked.length > 0;
 }
+function logBlockedByMacOS(log3, roots) {
+  log3(`     ! macOS blocked Powerplant from reading ${displayRoots(roots)}.`);
+  log3(`       Sessions there will stay local. ${MACOS_BLOCKED_FOLDER_REMEDY}`);
+}
+function displayRoots(roots) {
+  return roots.map((entry) => entry.displayRoot).join(", ");
+}
 function logProtectedSessionsStayLocal(log3, found) {
   const total = found.reduce((sum2, entry) => sum2 + entry.sessionCount, 0);
   log3(
-    `     ! Repository matching for ${total} recent session${total === 1 ? "" : "s"} under ${found.map((entry) => entry.displayRoot).join(", ")} was not enabled.`
+    `     ! Repository matching for ${total} recent session${total === 1 ? "" : "s"} under ${displayRoots(found)} was not enabled.`
   );
   log3("       Sessions outside folders you explicitly added will stay local.");
 }
@@ -91313,8 +91642,9 @@ function renderStatus(i) {
     );
     lines.push(`Syncing: ${describeStoredCapture(i.credentials)}.`);
     for (const entry of i.protectedSessions ?? []) {
+      const sessions = `${entry.sessionCount} recent agent session${entry.sessionCount === 1 ? "" : "s"}`;
       lines.push(
-        `\u26A0 Repository matching is not enabled for ${entry.sessionCount} recent agent session${entry.sessionCount === 1 ? "" : "s"} under ${entry.displayRoot}. Sessions outside folders you explicitly added are staying local, run \`powerplant init\` to review Git repository scanning.`
+        protectedRootReview(i.credentials, entry.root) === "blocked" ? `\u26A0 macOS is blocking Powerplant from reading ${entry.displayRoot} (${sessions}). Those sessions are staying local. ${MACOS_BLOCKED_FOLDER_REMEDY}` : `\u26A0 Repository matching is not enabled for ${sessions} under ${entry.displayRoot}. Sessions outside folders you explicitly added are staying local, run \`powerplant init\` to review Git repository scanning.`
       );
     }
   }
@@ -91366,9 +91696,17 @@ function renderDaemon(i) {
       `  The daemon is on ${status.version}, this CLI is ${i.cliVersion}, it restarts onto the installed version within minutes, or now via: powerplant restart`
     );
   }
-  lines.push(
-    status.lastSyncAt !== void 0 ? `  Last successful sync: ${ago(i.now - Date.parse(status.lastSyncAt))}.` : "  No successful sync yet in this run."
+  const signals = describeSyncSignals(
+    {
+      lastSessionActivityAt: status.lastUploadAt ?? null,
+      lastCheckedInAt: status.lastPass?.at ?? null,
+      syncPaused: null,
+      lastSyncErrorAt: status.lastPass && !status.lastPass.ok ? status.lastPass.at : null
+    },
+    new Date(i.now),
+    "last upload unmeasured"
   );
+  lines.push(signals === null ? "  No pass has run yet in this run." : `  ${signals}`);
   if (status.lastPass && !status.lastPass.ok) {
     lines.push(
       `  \u26A0 Last pass failed: ${status.lastPass.error ?? "unknown error"} (${status.consecutiveFailures} consecutive failure${status.consecutiveFailures === 1 ? "" : "s"}).`
@@ -91395,7 +91733,10 @@ function statusJson(i) {
     },
     protectedRepoDiscoveryNeeded: (i.protectedSessions ?? []).map((entry) => ({
       displayRoot: entry.displayRoot,
-      sessionCount: entry.sessionCount
+      sessionCount: entry.sessionCount,
+      // The member said yes and macOS refused: System Settings, not init,
+      // is the fix, so a tool rendering this must not say "review".
+      blockedByMacOS: i.credentials !== null && protectedRootReview(i.credentials, entry.root) === "blocked"
     })),
     ...i.credentialsError !== void 0 && { credentialsError: i.credentialsError },
     service: i.service,
@@ -91990,7 +92331,11 @@ ${USAGE}`);
         // Enrollment's own narration (org, token location, capture boundary)
         // indents under stage 1.
         enroll: () => enroll2((line) => terminal.log(`     ${line}`)),
-        findProtectedSessions: () => findRecentProtectedSessions(),
+        // Discovery may read a worktree pointer under a root the store
+        // already allows, so a revoked checkout root still surfaces.
+        findProtectedSessions: () => findRecentProtectedSessions({
+          environment: { allowedProtectedRoots: loadCredentials(config2.appEnv)?.repoDiscoveryRoots ?? [] }
+        }),
         promptAllowed: pickerOn,
         promptLine: realPromptLine,
         allowProtectedRepoDiscovery: (found) => allowProtectedRepoDiscovery(config2, found),
@@ -92064,12 +92409,14 @@ The access you granted these agents stays on your Powerplant account until you r
     }
     case "status": {
       const stored = loadCredentialsSafely(config2);
-      const allowedProtectedRoots = new Set(stored.credentials?.repoDiscoveryRoots ?? []);
+      const credentials = stored.credentials;
       const [latestVersion, oldestSupportedVersion, protectedSessions] = await Promise.all([
-        fetchAvailableVersion(config2, stored.credentials),
-        oldestSupportedFor(stored.credentials),
-        process.platform === "darwin" && stored.credentials ? findRecentProtectedSessions().then(
-          (found) => found.filter((entry) => !allowedProtectedRoots.has(entry.root))
+        fetchAvailableVersion(config2, credentials),
+        oldestSupportedFor(credentials),
+        process.platform === "darwin" && credentials ? findRecentProtectedSessions({
+          environment: { allowedProtectedRoots: credentials.repoDiscoveryRoots ?? [] }
+        }).then(
+          (found) => found.filter((entry) => protectedRootReview(credentials, entry.root) !== "allowed")
         ) : []
       ]);
       const inputs = {
@@ -92212,7 +92559,7 @@ The access you granted these agents stays on your Powerplant account until you r
         const on = parseAutomaticFlag(values.automatic);
         setAutomaticUpdates(config2.appEnv, on);
         console.log(
-          on ? "Automatic updates on: the background sync installs each new release within an hour of publication." : "Automatic updates off: powerplant status and the menu bar still say when a release is available."
+          on ? "Automatic updates on: the background sync checks for a release now and installs each new one within an hour of publication." : "Automatic updates off: powerplant status and the menu bar still say when a release is available."
         );
         return;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usepowerplant/cli",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "publishConfig": {
     "access": "public"
   },