codiedev 0.9.24 → 0.9.26

package/README.md

@@ -17,12 +17,28 @@ If both are installed, hooks are wired up for both. If neither is installed, the
 
 ## What gets captured
 
-- Only sessions inside repos your workspace already tracks
+- Agent sessions from connected devices (capture is enabled by default)
 - Transcript + basic stats (message count, tool calls)
 - Processed into summaries and embeddings server-side for search in `/portal/memories`
 
 Each captured memory records its `source` (`claude-code` or `codex`) so you can filter in the portal.
 
+## Keep folders local
+
+Folder exclusions are device-specific and include every child folder. The CLI
+writes the rule locally before attempting to sync its read-only status to the
+portal, so an offline or failed status sync never weakens the exclusion.
+
+```bash
+codiedev ignore ~/Obsidian
+codiedev ignored ~/Obsidian/People   # check whether a path is ignored
+codiedev ignored                     # list every ignored folder
+codiedev unignore ~/Obsidian
+```
+
+Run `ignore` once per device or persistent VM/container. A new ephemeral
+container needs its own rule unless `~/.codiedev/config.json` is persisted.
+
 ## Codex note
 
 Codex doesn't currently expose a `SessionEnd` event, so the hook runs on `Stop` (fires after each assistant turn). The backend dedupes by `(company, session_id)` and replaces the stored transcript on re-upload so the latest turn's snapshot wins. Summarization happens once per session; subsequent turn uploads keep the raw transcript fresh but don't re-summarize (to avoid running up LLM cost).

package/dist/backup/run.js

@@ -86,6 +86,7 @@ const child_process_1 = require("child_process");
 const utils_1 = require("../utils");
 const cache_2 = require("./cache");
 const push = __importStar(require("../commands/push"));
+const captureExclusions_1 = require("../captureExclusions");
 function gitRoot(cwd) {
     try {
         return (0, child_process_1.execFileSync)("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
@@ -143,6 +144,8 @@ function runBackup(cwd, hookScriptPath) {
         const config = (0, utils_1.readConfig)();
         if (!config)
             return;
+        if ((0, captureExclusions_1.isCaptureIgnored)(cwd, config.captureIgnoredPaths))
+            return;
         const root = gitRoot(cwd);
         if (!root)
             return;
@@ -195,6 +198,8 @@ async function runBackupUpload(jobFile, deps = DEFAULT_BACKUP_UPLOAD_DEPS) {
         const config = deps.readConfig(); // same machine — read full config from disk
         if (!config)
             return;
+        if ((0, captureExclusions_1.isCaptureIgnored)(job.root, config.captureIgnoredPaths))
+            return;
         const cache = deps.loadCache();
         let dirty = false;
         for (const f of job.files) {

package/dist/captureExclusions.d.ts

@@ -0,0 +1,30 @@
+import type { CodiedevConfig } from "./utils";
+export interface NormalizeCapturePathDeps {
+    cwd?: () => string;
+    homedir?: () => string;
+    realpathSync?: (value: string) => string;
+}
+/**
+ * Convert a user-entered path into the canonical absolute form persisted in
+ * ~/.codiedev/config.json. Existing symlinks resolve to their real target so a
+ * session cannot bypass an exclusion by entering the same folder through a
+ * different alias. Non-existent paths still normalize deterministically.
+ */
+export declare function normalizeCapturePath(input: string, deps?: NormalizeCapturePathDeps): string;
+export declare function findMatchingCaptureExclusion(candidate: string | string[] | undefined, ignoredPaths: string[] | undefined): string | null;
+export declare function isCaptureIgnored(candidate: string | string[] | undefined, ignoredPaths: string[] | undefined): boolean;
+export interface CaptureScopeInput {
+    cwd?: string;
+    workspace_roots?: string[];
+}
+/** Every local root associated with a hook event, deduped in stable order. */
+export declare function captureScopePaths(input: CaptureScopeInput, fallback?: string): string[];
+export declare function shouldIgnoreCaptureInput(config: Pick<CodiedevConfig, "captureIgnoredPaths"> | null | undefined, input: CaptureScopeInput, fallback?: string): boolean;
+/**
+ * Final egress decision for queued transcript uploads. Jobs written by older
+ * CLI versions have no scope metadata; once any exclusion exists, dropping
+ * those legacy jobs is safer than guessing that they are public.
+ */
+export declare function shouldSkipCaptureUploadJob(job: {
+    scopePaths?: string[];
+}, config: Pick<CodiedevConfig, "captureIgnoredPaths"> | null | undefined): boolean;

package/dist/captureExclusions.js

@@ -0,0 +1,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCapturePath = normalizeCapturePath;
+exports.findMatchingCaptureExclusion = findMatchingCaptureExclusion;
+exports.isCaptureIgnored = isCaptureIgnored;
+exports.captureScopePaths = captureScopePaths;
+exports.shouldIgnoreCaptureInput = shouldIgnoreCaptureInput;
+exports.shouldSkipCaptureUploadJob = shouldSkipCaptureUploadJob;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const DEFAULT_NORMALIZE_DEPS = {
+    cwd: () => process.cwd(),
+    homedir: () => os.homedir(),
+    realpathSync: (value) => fs.realpathSync.native(value),
+};
+/**
+ * Convert a user-entered path into the canonical absolute form persisted in
+ * ~/.codiedev/config.json. Existing symlinks resolve to their real target so a
+ * session cannot bypass an exclusion by entering the same folder through a
+ * different alias. Non-existent paths still normalize deterministically.
+ */
+function normalizeCapturePath(input, deps = {}) {
+    const d = { ...DEFAULT_NORMALIZE_DEPS, ...deps };
+    const trimmed = input.trim();
+    if (!trimmed)
+        throw new Error("Folder path is required");
+    const expanded = /^~(?=$|[\\/])/.test(trimmed)
+        ? path.join(d.homedir(), trimmed.slice(1))
+        : trimmed;
+    const absolute = path.resolve(d.cwd(), expanded);
+    try {
+        return path.normalize(d.realpathSync(absolute));
+    }
+    catch {
+        return path.normalize(absolute);
+    }
+}
+function comparisonKey(value) {
+    const normalized = path.normalize(value);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function containsPath(root, candidate) {
+    const relative = path.relative(comparisonKey(root), comparisonKey(candidate));
+    return (relative === "" ||
+        (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)));
+}
+function findMatchingCaptureExclusion(candidate, ignoredPaths) {
+    if (!candidate || !ignoredPaths || ignoredPaths.length === 0)
+        return null;
+    const candidates = Array.isArray(candidate) ? candidate : [candidate];
+    for (const ignored of ignoredPaths) {
+        const root = normalizeCapturePath(ignored);
+        for (const value of candidates) {
+            if (containsPath(root, normalizeCapturePath(value)))
+                return root;
+        }
+    }
+    return null;
+}
+function isCaptureIgnored(candidate, ignoredPaths) {
+    return findMatchingCaptureExclusion(candidate, ignoredPaths) !== null;
+}
+/** Every local root associated with a hook event, deduped in stable order. */
+function captureScopePaths(input, fallback = process.cwd()) {
+    const values = [input.cwd, ...(input.workspace_roots ?? [])]
+        .filter((value) => typeof value === "string" && value.length > 0);
+    return [...new Set(values.length > 0 ? values : [fallback])];
+}
+function shouldIgnoreCaptureInput(config, input, fallback) {
+    return isCaptureIgnored(captureScopePaths(input, fallback), config?.captureIgnoredPaths);
+}
+/**
+ * Final egress decision for queued transcript uploads. Jobs written by older
+ * CLI versions have no scope metadata; once any exclusion exists, dropping
+ * those legacy jobs is safer than guessing that they are public.
+ */
+function shouldSkipCaptureUploadJob(job, config) {
+    const ignoredPaths = config?.captureIgnoredPaths ?? [];
+    if (ignoredPaths.length === 0)
+        return false;
+    if (!job.scopePaths || job.scopePaths.length === 0)
+        return true;
+    return isCaptureIgnored(job.scopePaths, ignoredPaths);
+}

package/dist/cli.js

@@ -33,6 +33,7 @@ const post_1 = require("./commands/post");
 const share_1 = require("./commands/share");
 const send_1 = require("./commands/send");
 const react_1 = require("./commands/react");
+const capture_1 = require("./commands/capture");
 const version_1 = require("./version");
 const HELP = `
 Codiedev CLI
@@ -95,6 +96,11 @@ Feed:
                 [--mention <name>]...    Publish to the team feed
   codiedev react <postId> <emoji>        Toggle a reaction on a feed post
 
+Privacy:
+  codiedev ignore <path>                 Never capture this folder or its children
+  codiedev unignore <path>               Stop ignoring a folder
+  codiedev ignored [path]                List ignored folders, or check one path
+
 Capture:
   codiedev note "<text>"                 Capture a passing thought
 
@@ -130,6 +136,18 @@ Backend: ${process.env.CODIEDEV_URL ?? "https://codiedev.com"}
 Token:   https://codiedev.com/portal/integrations/claude-code
 Docs:    codiedev docs
 `.trim();
+const IGNORE_HELP = `
+codiedev ignore — keep folders out of session capture
+
+  codiedev ignore <path>      Never capture this folder or its children
+  codiedev unignore <path>    Stop ignoring a folder
+  codiedev ignored            List ignored folders on this device
+  codiedev ignored <path>     Check whether a specific path is ignored
+
+Exclusions are per-device and cover every child folder. The rule is written
+locally before any capture leaves your machine, so an offline or failed portal
+status sync never weakens it.
+`.trim();
 const COMMAND_HELP = {
     connect: `
 codiedev connect — link your agent CLI to Codiedev
@@ -237,6 +255,10 @@ codiedev note — capture a passing thought, linked to your session
     codiedev note "idempotency key is worth a follow-up"
     codiedev note "timeout threshold feels arbitrary — validate on slow networks"
 `.trim(),
+    ignore: IGNORE_HELP,
+    unignore: IGNORE_HELP,
+    ignored: IGNORE_HELP,
+    capture: IGNORE_HELP,
     promote: `
 codiedev promote — promote an auto-extracted artifact to authored
 
@@ -482,6 +504,15 @@ async function main() {
             case "react":
                 await (0, react_1.runReact)(rest);
                 return;
+            case "ignore":
+            case "unignore":
+            case "ignored":
+                await (0, capture_1.runCaptureCommand)([command, ...rest]);
+                return;
+            case "capture":
+                // Back-compat alias for the earlier `codiedev capture <sub>` form.
+                await (0, capture_1.runCaptureCommand)(rest);
+                return;
             default:
                 console.error(`Unknown command: ${command}`);
                 console.error(HELP);

package/dist/commands/capture.d.ts

@@ -0,0 +1,14 @@
+import { type CodiedevConfig } from "../utils";
+import { apiRequest } from "./shared";
+export interface CaptureCommandDeps {
+    readConfig: () => CodiedevConfig | null;
+    writeConfig: (config: CodiedevConfig) => void;
+    apiRequest: typeof apiRequest;
+    log: (line: string) => void;
+    warn: (line: string) => void;
+    randomUUID: () => string;
+    hostname: () => string;
+    normalizePath: (value: string) => string;
+    configForRequest: (config: CodiedevConfig) => CodiedevConfig;
+}
+export declare function runCaptureCommand(args: string[], depsOverride?: Partial<CaptureCommandDeps>): Promise<void>;

package/dist/commands/capture.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCaptureCommand = runCaptureCommand;
+const crypto = __importStar(require("crypto"));
+const os = __importStar(require("os"));
+const captureExclusions_1 = require("../captureExclusions");
+const utils_1 = require("../utils");
+const shared_1 = require("./shared");
+const DEFAULT_DEPS = {
+    readConfig: utils_1.readConfig,
+    writeConfig: utils_1.writeConfig,
+    apiRequest: shared_1.apiRequest,
+    log: console.log,
+    warn: console.warn,
+    randomUUID: () => crypto.randomUUID(),
+    hostname: () => os.hostname(),
+    normalizePath: captureExclusions_1.normalizeCapturePath,
+    configForRequest: shared_1.applyConfigEnvOverrides,
+};
+function requireConnectedConfig(deps) {
+    const config = deps.readConfig();
+    if (!config) {
+        throw new Error("Not connected. Run `npx codiedev connect` first.");
+    }
+    return config;
+}
+function withDeviceIdentity(config, deps) {
+    return {
+        ...config,
+        deviceId: config.deviceId || deps.randomUUID(),
+        deviceName: config.deviceName || deps.hostname(),
+    };
+}
+async function syncExclusions(config, deps) {
+    try {
+        await deps.apiRequest("POST", "/api/cli/capture-exclusions", {
+            config: deps.configForRequest(config),
+            body: {
+                deviceId: config.deviceId,
+                deviceName: config.deviceName,
+                ignoredPaths: config.captureIgnoredPaths ?? [],
+            },
+        });
+        deps.log("Portal status synced.");
+    }
+    catch (error) {
+        deps.warn(`Privacy setting saved locally, but portal status did not sync: ${error.message}`);
+    }
+}
+function requirePath(args) {
+    const value = args.slice(1).join(" ").trim();
+    if (!value) {
+        throw new Error("Usage: codiedev ignore <path> | codiedev unignore <path>");
+    }
+    return value;
+}
+function reportCheck(rawPath, current, deps) {
+    const target = deps.normalizePath(rawPath);
+    const match = (0, captureExclusions_1.findMatchingCaptureExclusion)(target, current.captureIgnoredPaths);
+    if (match) {
+        deps.log(`IGNORED: ${target}`);
+        deps.log(`Matched exclusion: ${match}`);
+    }
+    else {
+        deps.log(`CAPTURED: ${target}`);
+        deps.log("No ignored-folder rule matches this path.");
+    }
+}
+async function runCaptureCommand(args, depsOverride = {}) {
+    const deps = { ...DEFAULT_DEPS, ...depsOverride };
+    const subcommand = args[0];
+    const current = requireConnectedConfig(deps);
+    if (subcommand === "ignore") {
+        const target = deps.normalizePath(requirePath(args));
+        const existing = (current.captureIgnoredPaths ?? []).map(deps.normalizePath);
+        const nextPaths = existing.includes(target) ? existing : [...existing, target];
+        const next = withDeviceIdentity({ ...current, captureIgnoredPaths: nextPaths }, deps);
+        deps.writeConfig(next);
+        deps.log(`Ignoring ${target} and all child folders.`);
+        await syncExclusions(next, deps);
+        return;
+    }
+    if (subcommand === "unignore") {
+        const target = deps.normalizePath(requirePath(args));
+        const existing = (current.captureIgnoredPaths ?? []).map(deps.normalizePath);
+        const next = withDeviceIdentity({ ...current, captureIgnoredPaths: existing.filter((value) => value !== target) }, deps);
+        deps.writeConfig(next);
+        deps.log(`No longer ignoring ${target}.`);
+        await syncExclusions(next, deps);
+        return;
+    }
+    if (subcommand === "ignored") {
+        // `ignored` lists everything; `ignored <path>` answers "is this ignored?".
+        const query = args.slice(1).join(" ").trim();
+        if (query) {
+            reportCheck(query, current, deps);
+            return;
+        }
+        const paths = current.captureIgnoredPaths ?? [];
+        if (paths.length === 0) {
+            deps.log("No ignored folders configured on this device.");
+            return;
+        }
+        deps.log("Ignored folders:");
+        for (const value of paths)
+            deps.log(`  ${value}`);
+        return;
+    }
+    // Back-compat: the earlier `codiedev capture check <path>` form.
+    if (subcommand === "check") {
+        reportCheck(requirePath(args), current, deps);
+        return;
+    }
+    throw new Error(`Unknown command: ${subcommand ?? "(missing)"}. Use ignore, unignore, or ignored.`);
+}

package/dist/commands/doctor.js

@@ -165,6 +165,9 @@ async function runDoctor(_args) {
     catch {
         // malformed backendUrl in config — keep the generic placeholder
     }
+    // Live tracked-repo list fetched from validateToken below. Null until (and
+    // unless) the backend answers; the checks fall back to `config.repos`.
+    let liveRepos = null;
     try {
         const res = await fetch(`${config.backendUrl}/api/cli/validateToken`, {
             method: "POST",
@@ -180,6 +183,21 @@ async function runDoctor(_args) {
                 status: "pass",
                 detail: backendHost,
             });
+            // validateToken returns the company's CURRENT tracked repos. Capture
+            // them: the repo-resolution checks below must reflect what the SERVER
+            // will resolve at capture time (repoResolver.ts resolves against the
+            // live list), not the possibly-stale `config.repos` frozen at the last
+            // `connect`. A repo linked in the portal after that connect otherwise
+            // reports a false "isn't a tracked repo — link it in the portal" here
+            // even though sessions/MRs for it attribute fine server-side.
+            try {
+                const data = (await res.json());
+                if (Array.isArray(data.repos))
+                    liveRepos = data.repos;
+            }
+            catch {
+                liveRepos = null; // malformed body → fall back to the cached list
+            }
         }
         else {
             checks.push({
@@ -219,13 +237,46 @@ async function runDoctor(_args) {
             detail: err.message,
         });
     }
-    // 4. Tracked repos
-    const repoCount = config.repos?.length ?? 0;
+    // 4. Tracked repos. Prefer the live list from validateToken over the cache:
+    // a repo linked after the last `connect` is tracked server-side but absent
+    // from `config.repos`, and resolving against the stale cache is exactly what
+    // produced the false "isn't a tracked repo — link it in the portal" warning.
+    // Treat an EMPTY live list as "no usable live data", NOT an authoritative
+    // zero: a transient permission glitch / backend hiccup can return `repos: []`,
+    // and both driving the checks from it AND healing the cache to empty would be
+    // wrong — the write would durably break every offline doctor run (and the
+    // capture hook's providedRepoId) until the next successful connect. So when
+    // live is empty, fall back to the cache and skip the write, exactly like
+    // backend-unreachable. A genuinely repo-less company also has an empty cache,
+    // so it still reports "0 repos" correctly.
+    const trackedRepos = liveRepos !== null && liveRepos.length > 0 ? liveRepos : (config.repos ?? []);
+    // Detect drift by CONTENT, not count: a same-size swap (one repo removed +
+    // another added between connects) or a repo whose path/URL changed while its
+    // id stayed stable (GitLab move/rename — exactly the SONIFI migration case)
+    // both leave the count unchanged. A length-only check would skip the heal and
+    // leave the capture hook's cache — and its advisory providedRepoId — stale.
+    const canonRepos = (rs) => JSON.stringify([...rs].map((r) => [r.repoId, r.url, r.fullName]).sort());
+    const cacheRefreshed = liveRepos !== null &&
+        liveRepos.length > 0 &&
+        canonRepos(liveRepos) !== canonRepos(config.repos ?? []);
+    // Heal the on-disk cache so the capture hook (which reads `config.repos` for
+    // the advisory providedRepoId) stops trailing the portal too. Best-effort:
+    // doctor must never fail because the config couldn't be rewritten.
+    if (cacheRefreshed && liveRepos) {
+        try {
+            (0, utils_1.writeConfig)({ ...config, repos: liveRepos, lastSynced: new Date().toISOString() });
+        }
+        catch {
+            // read-only home / permission issue — the in-memory list still drives
+            // the checks below; the user just re-syncs on the next `connect`.
+        }
+    }
+    const repoCount = trackedRepos.length;
     checks.push({
         name: "Tracked repos",
         status: repoCount > 0 ? "pass" : "warn",
         detail: repoCount > 0
-            ? `${repoCount} repo${repoCount === 1 ? "" : "s"}`
+            ? `${repoCount} repo${repoCount === 1 ? "" : "s"}${cacheRefreshed ? " (refreshed from portal)" : ""}`
             : "0 — link repos in the portal so sessions get captured",
     });
     // 4b. Capture readiness — the part that actually decides whether a session
@@ -234,7 +285,7 @@ async function runDoctor(_args) {
     // last one?" — the blind spot behind lean-container / submodule / no-remote
     // zeros.
     const cwd = process.cwd();
-    const readiness = (0, captureReadiness_1.assessCaptureReadiness)(cwd, config.repos ?? [], {
+    const readiness = (0, captureReadiness_1.assessCaptureReadiness)(cwd, trackedRepos, {
         exec: (cmd, dir) => (0, child_process_1.execSync)(cmd, { cwd: dir, stdio: ["pipe", "pipe", "pipe"] }).toString(),
         getRemoteUrl: utils_1.getGitRemoteUrl,
         matchRepo: utils_1.matchRepo,
@@ -247,7 +298,7 @@ async function runDoctor(_args) {
     // instead of flatly warning "not a work tree / no remote" — the exact output
     // that made working workspace-root setups read as broken.
     const workspaceScan = readiness.gitOnPath && !readiness.insideWorkTree
-        ? (0, captureReadiness_1.assessWorkspaceRepos)(cwd, config.repos ?? [], {
+        ? (0, captureReadiness_1.assessWorkspaceRepos)(cwd, trackedRepos, {
             listChildDirs: (dir) => fs
                 .readdirSync(dir, { withFileTypes: true })
                 .filter((e) => e.isDirectory())

package/dist/connect.js

@@ -37,6 +37,8 @@ exports.runConnect = runConnect;
 const readline = __importStar(require("readline"));
 const https = __importStar(require("https"));
 const http = __importStar(require("http"));
+const crypto = __importStar(require("crypto"));
+const os = __importStar(require("os"));
 const utils_1 = require("./utils");
 const connectFlow_1 = require("./connectFlow");
 const version_1 = require("./version");
@@ -210,6 +212,9 @@ async function runConnect(args = []) {
         repos,
         lastSynced: new Date().toISOString(),
         backendUrl: BACKEND_URL,
+        deviceId: saved?.deviceId || crypto.randomUUID(),
+        deviceName: saved?.deviceName || os.hostname(),
+        captureIgnoredPaths: saved?.captureIgnoredPaths ?? [],
     };
     try {
         (0, utils_1.writeConfig)(config);
@@ -223,6 +228,20 @@ async function runConnect(args = []) {
     // a timeline when a customer says "it connected but it doesn't work."
     // Fire-and-forget — never blocks the connect flow.
     (0, shared_1.recordInstallEvent)(config, { step: "started", ok: true });
+    // One-way device status sync. Local config remains authoritative: a network
+    // failure here never removes or weakens an ignored path. This also registers
+    // a freshly connected device with an empty list so the portal can distinguish
+    // "connected, no exclusions" from "old CLI has never reported status".
+    try {
+        await postJson(`${BACKEND_URL}/api/cli/capture-exclusions`, {
+            deviceId: config.deviceId,
+            deviceName: config.deviceName,
+            ignoredPaths: config.captureIgnoredPaths,
+        }, { Authorization: `Bearer ${token}` });
+    }
+    catch (err) {
+        console.warn(`Warning: Local capture settings are active, but portal status did not sync — ${err.message}`);
+    }
     // Migration: strip MCP server entries written by pre-CLI-only versions
     // of `codiedev connect`. These pointed at `npx codiedev-mcp`, a binary
     // that was removed in 0.3.4 and that 0.7.11+ no longer ships. Without

package/dist/hook.js

@@ -45,6 +45,7 @@ const utils_1 = require("./utils");
 const limitEvent_1 = require("./limitEvent");
 const version_1 = require("./version");
 const captureLog_1 = require("./captureLog");
+const captureExclusions_1 = require("./captureExclusions");
 function getJson(url, bearerToken) {
     return new Promise((resolve, reject) => {
         const parsed = new URL(url);
@@ -368,6 +369,12 @@ async function main() {
             // Write per-session upload state so the throttle can defer later
             // non-final uploads within the same window.
             writeSessionState: utils_1.writeSessionUploadState,
+            // Re-read local config in the uploader so adding an exclusion after a
+            // job was queued still prevents its transcript from leaving the device.
+            shouldSkipJob: (job) => {
+                const config = (0, utils_1.readConfig)();
+                return (0, captureExclusions_1.shouldSkipCaptureUploadJob)(job, config);
+            },
         };
     }
     // Detached uploader child (spawned by the capture path below). The job —
@@ -441,6 +448,13 @@ async function main() {
     catch {
         process.exit(0);
     }
+    // Local privacy boundary: every stdin-driven hook mode passes through this
+    // check BEFORE prompt discovery, limit-event tails, SessionStart pings,
+    // backup, self-heal, transcript reads, or detached dispatch. Ignored means
+    // no Codiedev request at all for this session.
+    if ((0, captureExclusions_1.shouldIgnoreCaptureInput)((0, utils_1.readConfig)(), hookInput)) {
+        process.exit(0);
+    }
     // UserPromptSubmit discovery path — separate from session capture.
     if (process.argv[2] === "discover") {
         await runDiscover(hookInput.prompt);
@@ -563,6 +577,17 @@ async function runCaptureFinish(input) {
     const config = (0, utils_1.readConfig)();
     if (!config)
         return;
+    // Re-check in the detached child: the user may have added an exclusion
+    // after the parent hook dispatched this job but before it started.
+    if ((0, captureExclusions_1.shouldIgnoreCaptureInput)(config, input)) {
+        (0, captureLog_1.appendCaptureLog)({
+            stage: "capture-finish",
+            sessionId: input.session_id,
+            outcome: "skip",
+            detail: "ignored-path",
+        });
+        return;
+    }
     const { session_id, transcript_path, cwd, workspace_roots } = input;
     if (!transcript_path) {
         await postSessionSkip(config, session_id, "no-transcript-path");
@@ -588,6 +613,7 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     const workspaceRoot = workspace_roots && workspace_roots.length > 0
         ? workspace_roots[0]
         : cwd || process.cwd();
+    const scopePaths = (0, captureExclusions_1.captureScopePaths)({ cwd, workspace_roots }, workspaceRoot);
     let transcriptContent;
     try {
         transcriptContent = fs.readFileSync(transcript_path, "utf8");
@@ -718,7 +744,12 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         const hookScriptPath = process.argv[1];
         const tmpFile = path.join(os.tmpdir(), `codiedev-capture-${session_id ?? process.pid}.json`);
         if (decision.mode === "immediate") {
-            (0, utils_1.dispatchCaptureDetached)({ url: `${config.backendUrl}/api/captureSession`, token: config.token, body: payload }, hookScriptPath, { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile, openSync: fs.openSync, closeSync: fs.closeSync });
+            (0, utils_1.dispatchCaptureDetached)({
+                url: `${config.backendUrl}/api/captureSession`,
+                token: config.token,
+                body: payload,
+                scopePaths,
+            }, hookScriptPath, { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile, openSync: fs.openSync, closeSync: fs.closeSync });
             // Retry any earlier capture jobs that failed to upload (transient network
             // blips), excluding the one we just dispatched. Best-effort, detached.
             // Skip the sweep on deferred path — the deferred child will handle uploading.
@@ -754,7 +785,12 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
             // Deferred: write the job file (newer turns overwrite = supersede), then
             // spawn the deferred-upload child which will sleep, claim, and upload.
             // Same stdio/fd-hygiene contract as dispatchCaptureDetached.
-            (0, utils_1.dispatchDeferredUpload)({ url: `${config.backendUrl}/api/captureSession`, token: config.token, body: payload }, hookScriptPath, { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile, openSync: fs.openSync, closeSync: fs.closeSync }, decision.delayMs);
+            (0, utils_1.dispatchDeferredUpload)({
+                url: `${config.backendUrl}/api/captureSession`,
+                token: config.token,
+                body: payload,
+                scopePaths,
+            }, hookScriptPath, { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile, openSync: fs.openSync, closeSync: fs.closeSync }, decision.delayMs);
         }
     }
     catch (err) {

package/dist/utils.d.ts

@@ -12,9 +12,14 @@ export interface CodiedevConfig {
     }>;
     lastSynced: string;
     backendUrl: string;
+    deviceId?: string;
+    deviceName?: string;
+    captureIgnoredPaths?: string[];
 }
 export declare function readConfig(): CodiedevConfig | null;
 export declare function writeConfig(config: CodiedevConfig): void;
+/** Exported for permission-focused tests; normal callers use writeConfig. */
+export declare function writeConfigAtPath(config: CodiedevConfig, configDir: string, configPath: string): void;
 export declare function parseGitRemoteFromConfig(configText: string): string | null;
 export declare function readGitRemoteFromConfig(startDir: string): string | null;
 export declare function getGitRemoteUrl(cwd: string): string | null;
@@ -67,6 +72,8 @@ export interface CapturePayloadInput {
 }
 export declare function buildCapturePayload(input: CapturePayloadInput): Record<string, unknown>;
 export declare function hashToken(token: string): string;
+export declare function extractHookNodePath(cmd: string | undefined): string | undefined;
+export declare function resetStableNodeCacheForTests(): void;
 export declare function claudeCodeInstalled(): boolean;
 export declare function codexInstalled(): boolean;
 export declare function cursorInstalled(): boolean;
@@ -169,6 +176,7 @@ export interface CaptureUploadJob {
     body: Record<string, unknown>;
     attempts?: number;
     queuedAt?: number;
+    scopePaths?: string[];
 }
 export declare const MAX_UPLOAD_ATTEMPTS = 5;
 export declare const UPLOAD_TTL_MS: number;
@@ -260,6 +268,7 @@ interface UploadDeps {
     recordSuccess?: (job: CaptureUploadJob) => void;
     log?: (entry: CaptureLogEntry) => void;
     writeSessionState?: (sessionId: string, state: SessionUploadState) => void;
+    shouldSkipJob?: (job: CaptureUploadJob) => boolean;
 }
 export interface LastCaptureRecord {
     sessionId: string | undefined;

package/dist/utils.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DIRECT_UPLOAD_THRESHOLD_CHARS = exports.SWEEP_MIN_AGE_MS = exports.CAPTURE_THROTTLE_MS = exports.FINISH_ORPHAN_AGE_MS = exports.CLAIM_STALE_MS = exports.UPLOAD_TTL_MS = exports.MAX_UPLOAD_ATTEMPTS = void 0;
 exports.readConfig = readConfig;
 exports.writeConfig = writeConfig;
+exports.writeConfigAtPath = writeConfigAtPath;
 exports.parseGitRemoteFromConfig = parseGitRemoteFromConfig;
 exports.readGitRemoteFromConfig = readGitRemoteFromConfig;
 exports.getGitRemoteUrl = getGitRemoteUrl;
@@ -52,6 +53,8 @@ exports.getGitBranch = getGitBranch;
 exports.getGitHeadSha = getGitHeadSha;
 exports.buildCapturePayload = buildCapturePayload;
 exports.hashToken = hashToken;
+exports.extractHookNodePath = extractHookNodePath;
+exports.resetStableNodeCacheForTests = resetStableNodeCacheForTests;
 exports.claudeCodeInstalled = claudeCodeInstalled;
 exports.codexInstalled = codexInstalled;
 exports.cursorInstalled = cursorInstalled;
@@ -120,10 +123,19 @@ function readConfig() {
     }
 }
 function writeConfig(config) {
-    if (!fs.existsSync(CONFIG_DIR)) {
-        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    writeConfigAtPath(config, CONFIG_DIR, CONFIG_PATH);
+}
+/** Exported for permission-focused tests; normal callers use writeConfig. */
+function writeConfigAtPath(config, configDir, configPath) {
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
     }
-    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf8");
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    // writeFile's mode does not replace permissions on a pre-existing file.
+    fs.chmodSync(configPath, 0o600);
 }
 // Parse a remote URL out of git-config INI text WITHOUT invoking git. Prefers
 // the "origin" remote; falls back to the first remote found. Returns null if
@@ -733,7 +745,94 @@ const VSCODE_USER_MCP_PATH = path.join(VSCODE_USER_DIR, "mcp.json");
 function shellQuote(s) {
     return `'${s.replace(/'/g, `'\\''`)}'`;
 }
-function resolveHookCommand(subcommand) {
+// Pull the `<node>` prefix out of a codiedev hook command we previously wrote.
+// Commands take the form `'<node>' '<hookScript>' <subcommand>` (each path
+// single-quoted by shellQuote). Returns undefined for the legacy
+// `npx codiedev-hook <subcommand>` form (no explicit node path) or if the
+// command doesn't start with a quoted token. Exported for unit testing.
+function extractHookNodePath(cmd) {
+    if (!cmd)
+        return undefined;
+    // Match the first single-quoted token, honoring shellQuote's `'\''` escape.
+    const m = cmd.match(/^'((?:[^']|'\\'')*)'/);
+    if (!m)
+        return undefined;
+    return m[1].replace(/'\\''/g, "'");
+}
+// `process.execPath` is the *resolved* path to the running node binary, so under
+// Homebrew it's the version-specific Cellar path (e.g.
+// /opt/homebrew/Cellar/node/26.4.0/bin/node). Baking that into the hook means a
+// later `brew upgrade node` moves the Cellar dir and the hook path 404s. Prefer
+// a stable alias for the *same* binary:
+//   1. A node path from a hook we previously wrote that still resolves — usually
+//      a symlink the user deliberately pinned (e.g. /opt/homebrew/bin/node). A
+//      re-`connect`/self-heal then honors it instead of clobbering it.
+//   2. Otherwise, `node` as found on PATH when it points at the binary we're
+//      running (the Homebrew symlink, an nvm `current` alias, etc.).
+//   3. Last resort: the resolved `process.execPath`. Always valid right now, and
+//      still an absolute path a GUI-launched agent can execute without PATH.
+function realpathOrSelf(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+}
+// A stable `node` alias on PATH (Homebrew symlink, nvm `current`, …) that points
+// at the very binary we're running, or undefined if none. `installHook` writes
+// five hooks per run, so memoize: `command -v node` is a synchronous subprocess
+// spawn and its result can't change within a process. `null` = "looked, none".
+let cachedStableNodeOnPath;
+// Test-only: the memo lives for the process lifetime, so suites that stage
+// their own PATH/symlink fixtures must clear it between tests.
+function resetStableNodeCacheForTests() {
+    cachedStableNodeOnPath = undefined;
+}
+function stableNodeOnPath() {
+    if (cachedStableNodeOnPath !== undefined) {
+        return cachedStableNodeOnPath ?? undefined;
+    }
+    const execReal = realpathOrSelf(process.execPath);
+    try {
+        const onPath = (0, child_process_1.execSync)("command -v node", {
+            stdio: ["pipe", "pipe", "pipe"],
+        })
+            .toString()
+            .trim();
+        if (onPath && onPath !== process.execPath && realpathOrSelf(onPath) === execReal) {
+            cachedStableNodeOnPath = onPath;
+            return onPath;
+        }
+    }
+    catch {
+        // No node on PATH (e.g. GUI-launched agent) — fall through.
+    }
+    cachedStableNodeOnPath = null;
+    return undefined;
+}
+function resolveHookNodePath(preferredNodePath) {
+    const execReal = realpathOrSelf(process.execPath);
+    // 1. Honor a still-working node path from the existing hook — but only when
+    //    it's a *different* string than the resolved realpath. If the existing
+    //    path already IS `process.execPath` it's the version-specific realpath we
+    //    want to upgrade away from (that's the Homebrew bug), so fall through to
+    //    hunt for a stable alias in step 2.
+    if (preferredNodePath &&
+        preferredNodePath !== process.execPath &&
+        fs.existsSync(preferredNodePath) &&
+        realpathOrSelf(preferredNodePath) === execReal) {
+        return preferredNodePath;
+    }
+    // 2. Prefer a stable `node` on PATH over the version-specific realpath.
+    const onPath = stableNodeOnPath();
+    if (onPath)
+        return onPath;
+    // 3. Last resort: the resolved absolute path. Always valid right now, and
+    //    still an absolute path a GUI-launched agent can execute without PATH.
+    return process.execPath;
+}
+function resolveHookCommand(subcommand, preferredNodePath) {
     try {
         const cliEntry = process.argv[1];
         if (cliEntry) {
@@ -741,7 +840,8 @@ function resolveHookCommand(subcommand) {
             const distDir = path.dirname(realCli);
             const hookScript = path.join(distDir, "hook.js");
             if (fs.existsSync(hookScript)) {
-                return `${shellQuote(process.execPath)} ${shellQuote(hookScript)} ${subcommand}`;
+                const nodePath = resolveHookNodePath(preferredNodePath);
+                return `${shellQuote(nodePath)} ${shellQuote(hookScript)} ${subcommand}`;
             }
         }
     }
@@ -798,6 +898,22 @@ function upsertCodiedevHook(hooks, eventName, subcommand, matcher = ".*") {
     if (!hooks[eventName])
         hooks[eventName] = [];
     const existing = hooks[eventName];
+    // Before stripping the old codiedev entry, remember the node path it used so a
+    // re-run/upgrade can honor a stable symlink the user pinned instead of
+    // overwriting it with the version-specific `process.execPath` (see
+    // resolveHookNodePath). Done in an explicit scan rather than as a side effect
+    // of the filter predicate below, which stays a pure predicate.
+    let preservedNodePath;
+    for (const hook of existing) {
+        const inner = hook.hooks;
+        if (!Array.isArray(inner))
+            continue;
+        const codiedevInner = inner.find((h) => (0, detection_1.isCodiedevHookCommand)(h.command));
+        if (codiedevInner) {
+            preservedNodePath = extractHookNodePath(codiedevInner.command);
+            break;
+        }
+    }
     const filtered = existing.filter((hook) => {
         const inner = hook.hooks;
         if (Array.isArray(inner)) {
@@ -807,7 +923,7 @@ function upsertCodiedevHook(hooks, eventName, subcommand, matcher = ".*") {
     });
     filtered.push({
         matcher,
-        hooks: [{ type: "command", command: resolveHookCommand(subcommand) }],
+        hooks: [{ type: "command", command: resolveHookCommand(subcommand, preservedNodePath) }],
     });
     hooks[eventName] = filtered;
 }
@@ -2093,6 +2209,19 @@ async function runCaptureUpload(jobFile, deps) {
         return;
     }
     const sessionId = job.body?.sessionId;
+    if (deps.shouldSkipJob?.(job)) {
+        if (deps.log) {
+            try {
+                deps.log({ stage: "upload", sessionId, outcome: "skip", detail: "ignored-path" });
+            }
+            catch { /* log is best-effort */ }
+        }
+        try {
+            deps.unlinkSync(jobFile);
+        }
+        catch { /* gone */ }
+        return;
+    }
     try {
         // Big transcript + capable deps → direct-to-storage: fetch a one-time
         // upload URL, PUT the raw bytes, send captureSession the storageId. Any

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.24",
+  "version": "0.9.26",
   "description": "Connect Claude Code, Codex, Cursor, or VS Code Copilot to Codiedev for org-wide session capture and artifact collaboration",
   "bin": {
     "codiedev": "dist/cli.js",