codiedev 0.9.2 → 0.9.4-beta.0

package/dist/backup/cache.d.ts

@@ -0,0 +1,14 @@
+import * as fs from "fs";
+export type HashCache = Record<string, string>;
+export interface Candidate {
+    rel: string;
+    hash: string;
+    abs?: string;
+}
+export declare function cacheKey(repoKey: string, rel: string): string;
+export declare function loadCache(readFileSync?: typeof fs.readFileSync): HashCache;
+export declare function saveCache(cache: HashCache, deps?: typeof fs): void;
+export declare function applyCache(prev: HashCache, repoKey: string, candidates: Candidate[]): {
+    changed: Candidate[];
+    next: HashCache;
+};

package/dist/backup/cache.js

@@ -0,0 +1,78 @@
+"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.cacheKey = cacheKey;
+exports.loadCache = loadCache;
+exports.saveCache = saveCache;
+exports.applyCache = applyCache;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const CACHE_PATH = path.join(os.homedir(), ".codiedev", "backup-state.json");
+function cacheKey(repoKey, rel) {
+    return `${repoKey}::${rel}`;
+}
+function loadCache(readFileSync = fs.readFileSync) {
+    try {
+        return JSON.parse(readFileSync(CACHE_PATH, "utf8"));
+    }
+    catch {
+        return {}; // missing or corrupt → empty
+    }
+}
+function saveCache(cache, deps = fs) {
+    try {
+        deps.mkdirSync(path.dirname(CACHE_PATH), { recursive: true });
+        deps.writeFileSync(CACHE_PATH, JSON.stringify(cache), { mode: 0o600 });
+    }
+    catch {
+        // best-effort — a failed cache write just means a redundant push next turn,
+        // which the server idempotently no-ops.
+    }
+}
+// Pure: given the prior cache, a repo key, and this turn's candidates, return
+// the subset whose hash changed plus the cache to persist.
+function applyCache(prev, repoKey, candidates) {
+    const next = { ...prev };
+    const changed = [];
+    for (const c of candidates) {
+        const k = cacheKey(repoKey, c.rel);
+        if (prev[k] === c.hash)
+            continue;
+        next[k] = c.hash;
+        changed.push(c);
+    }
+    return { changed, next };
+}

package/dist/backup/match.d.ts

@@ -0,0 +1,2 @@
+export declare function hasSkillFrontmatter(md: string): boolean;
+export declare function isArtifactPath(rel: string, getContent: () => string): boolean;

package/dist/backup/match.js

@@ -0,0 +1,68 @@
+"use strict";
+// Pure path matcher for the auto-backup hook. Decides whether a repo-relative
+// path is an "artifact" worth backing up. Deny rules win over allow rules.
+// `getContent` is lazy: only called when a path-level allow needs the
+// skill-frontmatter exclusion (skills are pushed deliberately, not auto-backed).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasSkillFrontmatter = hasSkillFrontmatter;
+exports.isArtifactPath = isArtifactPath;
+const DENY_BASENAMES = new Set([
+    "AGENTS.md", "CLAUDE.md", "GEMINI.md", "README.md", "CHANGELOG.md",
+    "LICENSE.md", "CONTRIBUTING.md", "notes.md",
+]);
+const DENY_DIR_SEGMENTS = ["node_modules/", ".git/", ".claude/", "dist/", "build/"];
+function basename(p) {
+    const i = p.lastIndexOf("/");
+    return i === -1 ? p : p.slice(i + 1);
+}
+// A leading `---` block containing both `name:` and `description:` → skill.
+function hasSkillFrontmatter(md) {
+    const m = md.match(/^?---\s*\n([\s\S]*?)\n---/);
+    if (!m)
+        return false;
+    const fm = m[1];
+    return /^\s*name\s*:/m.test(fm) && /^\s*description\s*:/m.test(fm);
+}
+function pathAllows(rel) {
+    const base = basename(rel);
+    if (!base.toLowerCase().endsWith(".md"))
+        return false;
+    if (/^(docs\/superpowers\/(plans|specs)\/).+\.md$/i.test(rel))
+        return true;
+    if (/(^|\/)(spec|plan|tasks)\.md$/i.test(rel))
+        return true;
+    if (/^\.specify\/.+\.md$/i.test(rel))
+        return true;
+    if (/^specs\/.+\.md$/i.test(rel))
+        return true;
+    if (/^(spec|decision|proposal|bugfix|review|rfc|adr|prd)[-_].+\.md$/i.test(base))
+        return true;
+    if (/^(SPEC|PLAN|DESIGN|PRD)\.md$/.test(base))
+        return true;
+    if (/^(ADR|RFC)-.+\.md$/i.test(base))
+        return true;
+    if (/-design\.md$/i.test(base))
+        return true;
+    return false;
+}
+function isArtifactPath(rel, getContent) {
+    const norm = rel.replace(/\\/g, "/");
+    for (const seg of DENY_DIR_SEGMENTS)
+        if (norm.includes(seg))
+            return false;
+    const base = basename(norm);
+    if (DENY_BASENAMES.has(base))
+        return false;
+    if (/^snapshot-.+\.md$/i.test(base))
+        return false;
+    if (!pathAllows(norm))
+        return false;
+    try {
+        if (hasSkillFrontmatter(getContent()))
+            return false;
+    }
+    catch {
+        // unreadable → treat as non-skill; the push will fail harmlessly later
+    }
+    return true;
+}

package/dist/backup/run.d.ts

@@ -0,0 +1,23 @@
+import { type HashCache, type Candidate } from "./cache";
+export interface SelectDeps {
+    readFile: (rel: string) => string;
+    sha256: (content: string) => string;
+}
+export declare function selectBackupFiles(input: {
+    repoKey: string;
+    statusPaths: string[];
+    prevCache: HashCache;
+    deps: SelectDeps;
+}): {
+    changed: Candidate[];
+    next: HashCache;
+};
+import { readConfig } from "../utils";
+import { loadCache, saveCache } from "./cache";
+export declare function runBackup(cwd: string, hookScriptPath: string): void;
+export interface BackupUploadDeps {
+    readConfig: typeof readConfig;
+    loadCache: typeof loadCache;
+    saveCache: typeof saveCache;
+}
+export declare function runBackupUpload(jobFile: string, deps?: BackupUploadDeps): Promise<void>;

package/dist/backup/run.js

@@ -0,0 +1,188 @@
+"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.selectBackupFiles = selectBackupFiles;
+exports.runBackup = runBackup;
+exports.runBackupUpload = runBackupUpload;
+const match_1 = require("./match");
+const cache_1 = require("./cache");
+// Pure: from this turn's git-status paths, keep artifact files whose content
+// hash changed since the cache. Returns the changed candidates + next cache.
+function selectBackupFiles(input) {
+    const candidates = [];
+    for (const rel of input.statusPaths) {
+        let content;
+        const getContent = () => (content ??= input.deps.readFile(rel));
+        if (!(0, match_1.isArtifactPath)(rel, getContent))
+            continue;
+        let c;
+        try {
+            c = getContent();
+        }
+        catch {
+            continue; // deleted/unreadable → skip
+        }
+        if (c === undefined || c === null)
+            continue;
+        candidates.push({ rel, hash: input.deps.sha256(c) });
+    }
+    return (0, cache_1.applyCache)(input.prevCache, input.repoKey, candidates);
+}
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const child_process_1 = require("child_process");
+const utils_1 = require("../utils");
+const cache_2 = require("./cache");
+const push = __importStar(require("../commands/push"));
+function gitRoot(cwd) {
+    try {
+        return (0, child_process_1.execFileSync)("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
+            encoding: "utf8",
+        }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function gitStatusPaths(root) {
+    try {
+        // --untracked-files=all is REQUIRED: the default collapses untracked files
+        // into their top-level directory (a new docs/superpowers/plans/x.md shows as
+        // just "docs/"), which would make the hook miss brand-new artifact files.
+        const out = (0, child_process_1.execFileSync)("git", ["-C", root, "status", "--porcelain", "-z", "--untracked-files=all"], { encoding: "utf8" });
+        // -z: NUL-separated, each entry "XY <path>"; rename entries have two paths.
+        return out
+            .split("\0")
+            .filter(Boolean)
+            .map((e) => e.slice(3))
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+const sha256 = (s) => crypto.createHash("sha256").update(s, "utf8").digest("hex");
+// Stop/sessionEnd hook entry. Best-effort, never throws.
+function runBackup(cwd, hookScriptPath) {
+    try {
+        if (process.env.CODIEDEV_NO_AUTOBACKUP)
+            return;
+        const config = (0, utils_1.readConfig)();
+        if (!config)
+            return;
+        const root = gitRoot(cwd);
+        if (!root)
+            return;
+        const repoKey = (0, utils_1.getGitRemoteUrl)(root) ?? root;
+        const statusPaths = gitStatusPaths(root);
+        if (statusPaths.length === 0)
+            return;
+        const prevCache = (0, cache_2.loadCache)();
+        const { changed } = selectBackupFiles({
+            repoKey,
+            statusPaths,
+            prevCache,
+            deps: { readFile: (rel) => fs.readFileSync(path.join(root, rel), "utf8"), sha256 },
+        });
+        if (changed.length === 0)
+            return;
+        // The detached child owns the cache: it writes each file's hash ONLY after a
+        // successful push, so a genuine push failure (network/500) leaves the hash
+        // uncached and the file retries next turn. (Persisting here optimistically
+        // would suppress that retry, since the server no-op only covers successes.)
+        // Job carries root + repoKey + files; the child re-reads config from disk
+        // via readConfig() (same machine), avoiding any config-shape guessing.
+        const job = {
+            root,
+            repoKey,
+            files: changed.map((c) => ({ rel: c.rel, hash: c.hash })),
+        };
+        const tmpFile = path.join(os.tmpdir(), `codiedev-backup-${process.pid}.json`);
+        fs.writeFileSync(tmpFile, JSON.stringify(job), { mode: 0o600 });
+        const child = (0, child_process_1.spawn)(process.execPath, [hookScriptPath, "backup-upload", tmpFile], {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+    }
+    catch {
+        // best-effort
+    }
+}
+const DEFAULT_BACKUP_UPLOAD_DEPS = { readConfig: utils_1.readConfig, loadCache: cache_2.loadCache, saveCache: cache_2.saveCache };
+// Detached child: push each queued file privately, caching its hash ONLY on a
+// successful push (so a failed push retries next turn), then delete the job
+// file. Deps are injectable so the cache write is testable without touching the
+// global ~/.codiedev cache.
+async function runBackupUpload(jobFile, deps = DEFAULT_BACKUP_UPLOAD_DEPS) {
+    try {
+        const job = JSON.parse(fs.readFileSync(jobFile, "utf8"));
+        const config = deps.readConfig(); // same machine — read full config from disk
+        if (!config)
+            return;
+        const cache = deps.loadCache();
+        let dirty = false;
+        for (const f of job.files) {
+            try {
+                await push.pushFile(config, {
+                    absPath: path.join(job.root, f.rel),
+                    key: f.rel,
+                    visibility: "private",
+                    contentHash: f.hash,
+                });
+                // Only now that the push landed do we record the hash — a prior failure
+                // leaves it uncached so the next turn retries it.
+                cache[(0, cache_2.cacheKey)(job.repoKey, f.rel)] = f.hash;
+                dirty = true;
+            }
+            catch {
+                // one file failing must not abort the rest, and its hash stays uncached
+            }
+        }
+        if (dirty)
+            deps.saveCache(cache);
+    }
+    catch {
+        // best-effort
+    }
+    finally {
+        try {
+            fs.unlinkSync(jobFile);
+        }
+        catch { /* gone */ }
+    }
+}

package/dist/commands/push.d.ts

@@ -1 +1,37 @@
+import { requireConfig } from "./shared";
+interface PushResponse {
+    ok: boolean;
+    artifactId: string;
+    key: string;
+    version: number;
+    type: string;
+    kind: "doc" | "skill";
+    tags: string[];
+    destination: string;
+    workspaceName: string;
+    matchedRepo: {
+        fullName: string;
+    } | null;
+}
+export interface ParsedArgs {
+    file: string;
+    type?: string;
+    kind?: string;
+    tags: string[];
+    force: boolean;
+    as?: string;
+    private?: boolean;
+}
+export declare function parseArgs(args: string[]): ParsedArgs;
+export declare function pushFile(config: ReturnType<typeof requireConfig>, opts: {
+    absPath: string;
+    key: string;
+    visibility?: "private" | "team";
+    contentHash?: string;
+    type?: string;
+    kind?: string;
+    tags?: string[];
+    force?: boolean;
+}): Promise<PushResponse>;
 export declare function runPush(args: string[]): Promise<void>;
+export {};

package/dist/commands/push.js

@@ -33,9 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.pushFile = pushFile;
 exports.runPush = runPush;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const shared = __importStar(require("./shared"));
 const shared_1 = require("./shared");
 const utils_1 = require("../utils");
 const scope_1 = require("../scope");
@@ -53,6 +56,8 @@ function parseArgs(args) {
     let type;
     let kind;
     let force = false;
+    let as;
+    let priv = false;
     const tags = [];
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
@@ -74,15 +79,24 @@ function parseArgs(args) {
         else if (a.startsWith("--tag=")) {
             tags.push(a.slice("--tag=".length));
         }
+        else if (a === "--as" && i + 1 < args.length) {
+            as = args[++i];
+        }
+        else if (a.startsWith("--as=")) {
+            as = a.slice("--as=".length);
+        }
         else if (a === "--force") {
             force = true;
         }
+        else if (a === "--private") {
+            priv = true;
+        }
         else if (!a.startsWith("--") && !file) {
             file = a;
         }
     }
     if (!file) {
-        console.error("Usage: codiedev push <file.md> [--kind doc|skill] [--tag <name>] [--force]");
+        console.error("Usage: codiedev push <file.md> [--as <key>] [--kind doc|skill] [--tag <name>] [--private] [--force]");
         process.exit(1);
     }
     if (type && !VALID_TYPES.has(type)) {
@@ -93,10 +107,39 @@ function parseArgs(args) {
         console.error(`Invalid --kind. Valid kinds: ${[...VALID_KINDS].join(", ")}`);
         process.exit(1);
     }
-    return { file, type, kind, tags, force };
+    // The override key is stored verbatim by the server (docs key off it, and a
+    // path-y value like "specs/feature-a/plan.md" populates folderPath). Strip a
+    // leading slash so it can't be confused with an absolute path, and reject an
+    // empty value — but otherwise allow slashes so callers can namespace.
+    if (as !== undefined) {
+        as = as.replace(/^\/+/, "").trim();
+        if (!as) {
+            console.error("--as requires a non-empty key.");
+            process.exit(1);
+        }
+    }
+    return { file, type, kind, tags, force, as, private: priv };
+}
+async function pushFile(config, opts) {
+    const markdown = fs.readFileSync(opts.absPath, "utf8");
+    const gitRemoteUrl = (0, utils_1.getGitRemoteUrl)(process.cwd()) ?? undefined;
+    return shared.apiRequest("POST", "/api/cli/push", {
+        config,
+        body: {
+            filename: opts.key,
+            markdown,
+            type: opts.type,
+            kind: opts.kind,
+            tags: opts.tags && opts.tags.length > 0 ? opts.tags : undefined,
+            force: opts.force,
+            gitRemoteUrl,
+            visibility: opts.visibility,
+            contentHash: opts.contentHash,
+        },
+    });
 }
 async function runPush(args) {
-    const { file, type, kind, tags, force } = parseArgs(args);
+    const { file, type, kind, tags, force, as, private: priv } = parseArgs(args);
     const config = (0, shared_1.requireConfig)();
     let absolute = file;
     if (!path.isAbsolute(absolute)) {
@@ -111,21 +154,21 @@ async function runPush(args) {
         console.error(`File is empty: ${absolute}`);
         process.exit(1);
     }
-    const filename = path.basename(absolute);
-    const gitRemoteUrl = (0, utils_1.getGitRemoteUrl)(process.cwd()) ?? undefined;
+    // Stored key defaults to the basename (legacy behavior). `--as` overrides it
+    // so callers can namespace generically-named files — e.g. Spec Kit emits a
+    // `plan.md`/`spec.md` per feature, which would otherwise all collide on one
+    // key and silently version over each other.
+    const filename = as ?? path.basename(absolute);
     const start = Date.now();
     try {
-        const res = await (0, shared_1.apiRequest)("POST", "/api/cli/push", {
-            config,
-            body: {
-                filename,
-                markdown,
-                type,
-                kind,
-                tags: tags.length > 0 ? tags : undefined,
-                force,
-                gitRemoteUrl,
-            },
+        const res = await pushFile(config, {
+            absPath: absolute,
+            key: filename,
+            type,
+            kind,
+            tags,
+            force,
+            visibility: priv ? "private" : undefined,
         });
         (0, shared_1.recordAgentEvent)(config, {
             tool: "codiedev_push",

package/dist/connect.js

@@ -278,15 +278,15 @@ async function runConnect(args = []) {
         }
     };
     if (hasClaude) {
-        runInstall("claude-code-hook", utils_1.installHook, "Claude Code SessionEnd (capture) + UserPromptSubmit (skill discovery) hooks (~/.claude/settings.json)", "claudeCode-hook");
+        runInstall("claude-code-hook", utils_1.installHook, "Claude Code SessionEnd (capture) + UserPromptSubmit (skill discovery) + Stop (auto-backup) hooks (~/.claude/settings.json)", "claudeCode-hook");
         runInstall("claude-code-instructions", utils_1.installClaudeCodeInstructions, "Claude Code agent instructions (~/.claude/CLAUDE.md)", "claudeCode-instructions");
     }
     if (hasCodex) {
-        runInstall("codex-hook", utils_1.installCodexHook, "Codex Stop hook (~/.codex/hooks.json)", "codex-hook");
+        runInstall("codex-hook", utils_1.installCodexHook, "Codex Stop (capture + auto-backup) hooks (~/.codex/hooks.json)", "codex-hook");
         runInstall("codex-instructions", utils_1.installCodexInstructions, "Codex agent instructions (~/.codex/AGENTS.md)", "codex-instructions");
     }
     if (hasCursor) {
-        runInstall("cursor-hook", utils_1.installCursorHook, "Cursor sessionEnd hook (~/.cursor/hooks.json)", "cursor-hook");
+        runInstall("cursor-hook", utils_1.installCursorHook, "Cursor sessionEnd (capture + auto-backup) hooks (~/.cursor/hooks.json)", "cursor-hook");
         runInstall("cursor-instructions", utils_1.installCursorInstructions, "Cursor agent instructions (~/.cursor/rules/codiedev.mdc)", "cursor-instructions");
     }
     // Tell the backend which targets we wired up so the portal's onboarding

package/dist/hook.js

@@ -172,6 +172,14 @@ async function main() {
         }
         process.exit(0);
     }
+    // Detached backup uploader child (spawned by runBackup below). The job file
+    // carries only { root, files }; the child re-reads config from disk. No stdin
+    // needed, so handle it before readStdin() like the capture uploader above.
+    if (process.argv[2] === "backup-upload") {
+        const { runBackupUpload } = await Promise.resolve().then(() => __importStar(require("./backup/run")));
+        await runBackupUpload(process.argv[3]);
+        process.exit(0);
+    }
     let hookInput = {};
     try {
         const raw = await readStdin();
@@ -189,12 +197,22 @@ async function main() {
     }
     const mode = resolveMode(process.argv[2]);
     // Self-heal: a user who upgraded the CLI but hasn't re-run `connect` gets the
-    // discovery hook wired on their next SessionEnd, without re-connecting.
+    // discovery + auto-backup hooks wired on their next SessionEnd, without
+    // re-connecting.
     (0, utils_1.ensureDiscoveryHookInstalled)();
+    (0, utils_1.ensureBackupHookInstalled)();
     const { session_id, transcript_path, cwd, workspace_roots } = hookInput;
     const workspaceRoot = workspace_roots && workspace_roots.length > 0
         ? workspace_roots[0]
         : cwd || process.cwd();
+    // Stop/sessionEnd backup path — separate from session capture and needs no
+    // transcript. Lists changed artifact files in the workspace and dispatches a
+    // detached child that backs them up privately. Best-effort, never blocks.
+    if (process.argv[2] === "backup") {
+        const { runBackup } = await Promise.resolve().then(() => __importStar(require("./backup/run")));
+        runBackup(workspaceRoot, process.argv[1]);
+        process.exit(0);
+    }
     const config = (0, utils_1.readConfig)();
     if (!config) {
         process.exit(0);

package/dist/utils.d.ts

@@ -38,6 +38,7 @@ export declare function vscodeCopilotInstalled(): boolean;
 export declare function upsertCodiedevHook(hooks: Record<string, unknown>, eventName: string, subcommand: string): void;
 export declare function installHook(): void;
 export declare function ensureDiscoveryHookInstalled(): void;
+export declare function ensureBackupHookInstalled(): void;
 export declare function installClaudeCodeInstructions(): void;
 export declare function installCodexInstructions(): void;
 export declare function installCursorInstructions(): void;

package/dist/utils.js

@@ -46,6 +46,7 @@ exports.vscodeCopilotInstalled = vscodeCopilotInstalled;
 exports.upsertCodiedevHook = upsertCodiedevHook;
 exports.installHook = installHook;
 exports.ensureDiscoveryHookInstalled = ensureDiscoveryHookInstalled;
+exports.ensureBackupHookInstalled = ensureBackupHookInstalled;
 exports.installClaudeCodeInstructions = installClaudeCodeInstructions;
 exports.installCodexInstructions = installCodexInstructions;
 exports.installCursorInstructions = installCursorInstructions;
@@ -274,6 +275,8 @@ function installHook() {
     upsertCodiedevHook(hooks, "SessionEnd", "capture");
     // UserPromptSubmit → discover (surface a matching team skill for the task).
     upsertCodiedevHook(hooks, "UserPromptSubmit", "discover");
+    // Stop → backup (auto-back-up changed artifact files to your private library).
+    upsertCodiedevHook(hooks, "Stop", "backup");
     if (!fs.existsSync(CLAUDE_DIR)) {
         fs.mkdirSync(CLAUDE_DIR, { recursive: true });
     }
@@ -306,6 +309,29 @@ function ensureDiscoveryHookInstalled() {
         // Best-effort — never block a session on self-heal.
     }
 }
+// Self-heal: ensure the Stop → backup hook is present without a full `connect`
+// re-run, mirroring ensureDiscoveryHookInstalled. Called from the capture hook
+// so an upgraded-but-not-reconnected user gets auto-backup on their next
+// session. Only writes when missing, to avoid churning settings.json every run.
+function ensureBackupHookInstalled() {
+    try {
+        if (!fs.existsSync(CLAUDE_SETTINGS_PATH))
+            return;
+        const settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf8"));
+        const hooks = (settings.hooks ?? {});
+        const stop = (hooks.Stop ?? []);
+        const present = stop.some((h) => {
+            const inner = h.hooks;
+            return Array.isArray(inner) && inner.some((x) => (0, detection_1.isCodiedevHookCommand)(x.command));
+        });
+        if (present)
+            return;
+        settings.hooks = hooks;
+        upsertCodiedevHook(hooks, "Stop", "backup");
+        fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf8");
+    }
+    catch { /* best-effort */ }
+}
 // ─────────────────────────────────────────────────────────────────────────────
 // MCP server installation — writes the codiedev MCP server config into each
 // agent CLI's expected location so "npx codiedev connect" wires it up once.
@@ -731,6 +757,16 @@ function installCodexHook() {
             },
         ],
     });
+    // Stop → backup: auto-back-up changed artifact files to the private library.
+    filtered.push({
+        hooks: [
+            {
+                type: "command",
+                command: resolveHookCommand("backup"),
+                timeout: 30,
+            },
+        ],
+    });
     hooks.Stop = filtered;
     if (!fs.existsSync(CODEX_DIR)) {
         fs.mkdirSync(CODEX_DIR, { recursive: true });
@@ -772,6 +808,12 @@ function installCursorHook() {
         type: "command",
         timeout: 30,
     });
+    // sessionEnd → backup: auto-back-up changed artifact files to the private library.
+    filtered.push({
+        command: resolveHookCommand("backup"),
+        type: "command",
+        timeout: 30,
+    });
     hooks.sessionEnd = filtered;
     fs.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(hooksFile, null, 2), "utf8");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.2",
+  "version": "0.9.4-beta.0",
   "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",