codiedev 0.9.25 → 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/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;
@@ -171,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;
@@ -262,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;
@@ -122,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
@@ -2199,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.25",
+  "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",