resumecontext 0.1.0

package/dist/localHistory/index.js

@@ -0,0 +1,96 @@
+/**
+ * Reads real local coding-agent session files (Claude Code, Codex CLI,
+ * Cursor, opencode) directly off disk and normalizes them into
+ * SyncableTurn[] for one project -- in-process, no subprocess, no
+ * dependency on the separate ingest/ package. This is the CLI's own copy:
+ * every parsing decision and its rationale (documented in each agent's own
+ * file in this directory) was ported from ingest/src/ingest.ts, since that
+ * package's parsers are exactly what this needed and there was no reason
+ * to re-derive them from scratch -- but this directory owns it now, and
+ * the two are free to diverge.
+ *
+ * Unlike ingest/src/ingest.ts (which writes every project's turns to disk
+ * and reports on all of them), this only ever resolves and returns turns
+ * for the ONE project `collectLocalTurns` is asked about -- there's no
+ * output file, no index, no reporting; localCapture.ts calls this
+ * directly and gets SyncableTurn[] back in memory.
+ *
+ * Never assumes the OS-default location for any agent -- only scans the
+ * agents (and directories) present in the user's AgentConfig (see
+ * ../agentConfig.ts). An agent absent from the config is skipped entirely,
+ * even if its default directory exists on disk.
+ */
+import path from "node:path";
+import { findProjectRoot, readProjectMarker } from "../projectRoot.js";
+import { unique } from "../utils.js";
+import { AGENT_ADAPTERS, ALL_AGENT_NAMES } from "./registry.js";
+import { sessionKey } from "../syncState.js";
+function collectAllTurns(config, context) {
+    const turns = [];
+    for (const name of ALL_AGENT_NAMES) {
+        const configured = config.agents[name];
+        if (!configured)
+            continue; // agent not selected -- skip entirely
+        const adapter = AGENT_ADAPTERS[name];
+        // Deduplicate: the same directory listed twice would parse its turns
+        // twice, inflating the per-session counts syncState.ts keeps and
+        // making sync think there's more new history than there is.
+        for (const dir of unique(configured.dirs)) {
+            for (const turn of adapter.collect(dir, context))
+                turns.push(turn);
+        }
+    }
+    return turns;
+}
+/** Resolves each turn's raw session cwd to its project root (see
+ * ../projectRoot.ts), memoized per distinct raw cwd -- resolution does real
+ * filesystem walks, and many turns/sessions typically share the same raw
+ * cwd, so this avoids re-walking the same path repeatedly across a large
+ * corpus. */
+function resolveProjectRoots(turns) {
+    const cache = new Map();
+    const resolveRoot = (rawCwd) => {
+        let root = cache.get(rawCwd);
+        if (root === undefined) {
+            root = findProjectRoot(rawCwd).root;
+            cache.set(rawCwd, root);
+        }
+        return root;
+    };
+    return turns.map((t) => ({ ...t, project_cwd: resolveRoot(t.project_cwd) }));
+}
+/** Scans every local coding-agent session store on this machine, resolves
+ * each turn's project, and returns only the turns belonging to
+ * `projectRoot` (an already-resolved root, e.g. from projectRoot.ts),
+ * sorted chronologically -- the same ordering guarantee syncState.ts's
+ * per-session cursor relies on. */
+export function collectLocalTurns(projectRoot, config) {
+    const target = path.resolve(projectRoot);
+    const marker = readProjectMarker(target);
+    const context = {
+        projectRoot: target,
+        projectInitAt: marker?.createdAt ?? new Date(0).toISOString(),
+    };
+    const turns = resolveProjectRoots(collectAllTurns(config, context)).filter((t) => t.project_cwd === target);
+    turns.sort((a, b) => (a.timestamp || "").localeCompare(b.timestamp || ""));
+    const sessionMtimeMs = {};
+    for (const t of turns) {
+        if (t.source_mtime_ms == null || !t.session_id)
+            continue;
+        const key = sessionKey(t.agent, t.session_id);
+        const prev = sessionMtimeMs[key];
+        if (prev === undefined || t.source_mtime_ms > prev)
+            sessionMtimeMs[key] = t.source_mtime_ms;
+    }
+    return {
+        turns: turns.map((t) => ({
+            sessionId: t.session_id ?? "",
+            agent: t.agent,
+            role: t.role,
+            timestamp: t.timestamp,
+            text: t.text,
+            toolCalls: t.tool_calls,
+        })),
+        sessionMtimeMs,
+    };
+}

package/dist/localHistory/opencode.js

@@ -0,0 +1,148 @@
+/**
+ * opencode's storage is plain JSON files, three levels deep, no reverse
+ * engineering needed:
+ *   storage/session/<projectId>/<sessionId>.json  -- id, directory (cwd), time
+ *   storage/message/<sessionId>/<messageId>.json  -- role, time.created
+ *   storage/part/<messageId>/<partId>.json        -- the actual content
+ * A "part" is opencode's block: text, reasoning, tool (call+result already
+ * combined in one part, unlike Claude/Codex/Cursor which split them into
+ * separate turns -- rendered as one call+result pair within the owning
+ * message's turn, matching how opencode itself models it), step-start/
+ * step-finish (pure bookkeeping: cost/token counters, no conversational
+ * content -- skipped, nothing lost), and patch (a file-diff marker with a
+ * file list but no inline diff text in this store).
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { listDirs, listFiles, msToIso, newestMtimeMs, readJsonSafe } from "./shared.js";
+export const DEFAULT_OPENCODE_DIR = path.join(os.homedir(), ".local", "share", "opencode");
+export const DEFAULT_OPENCODE_STORAGE_DIR = path.join(DEFAULT_OPENCODE_DIR, "storage");
+export function opencodeStorageDir(configuredDir) {
+    return path.join(path.resolve(configuredDir), "storage");
+}
+function renderOpencodePart(part) {
+    const ptype = part.type;
+    if (ptype === "text")
+        return part.text || "";
+    if (ptype === "reasoning") {
+        const text = part.text;
+        return text ? `[thinking] ${text}` : "";
+    }
+    if (ptype === "tool") {
+        const name = part.tool || "unknown_tool";
+        const state = part.state || {};
+        const call = `[tool_call: ${name}] ${JSON.stringify(state.input ?? {})}`;
+        if (state.status === "error") {
+            return `${call}\n[tool_result:error] ${state.error ?? ""}`;
+        }
+        if ("output" in state) {
+            let output = state.output;
+            if (typeof output !== "string")
+                output = JSON.stringify(output);
+            return `${call}\n[tool_result] ${output}`;
+        }
+        return call; // still running/pending -- no result yet
+    }
+    if (ptype === "patch") {
+        const files = part.files || [];
+        return `[patch] changed files: ${JSON.stringify(files)}`;
+    }
+    if (ptype === "step-start" || ptype === "step-finish") {
+        return ""; // bookkeeping only (snapshot hash, cost, token counts)
+    }
+    // Unrecognized part type -- dump raw rather than silently drop.
+    return `[${ptype || "unknown_part"}] ${JSON.stringify(part)}`;
+}
+/** Yields normalized turns from one opencode session.json, pulling its
+ * messages and their parts from the sibling message/ and part/ stores under
+ * `storageDir`. */
+function parseOpencodeSession(sessionPath, storageDir) {
+    const session = readJsonSafe(sessionPath);
+    if (!session)
+        return [];
+    const cwd = session.directory;
+    const sessionId = session.id;
+    if (!cwd || !sessionId)
+        return [];
+    const messageDir = path.join(storageDir, "message", sessionId);
+    const partRootDir = path.join(storageDir, "part");
+    if (!fs.existsSync(messageDir))
+        return [];
+    const messages = [];
+    for (const fname of fs.readdirSync(messageDir)) {
+        if (!fname.endsWith(".json"))
+            continue;
+        const messagePath = path.join(messageDir, fname);
+        const m = readJsonSafe(messagePath);
+        if (m && (m.role === "user" || m.role === "assistant"))
+            messages.push({ m, path: messagePath });
+    }
+    messages.sort((a, b) => (a.m.time?.created || 0) - (b.m.time?.created || 0));
+    const turns = [];
+    for (const { m, path: messagePath } of messages) {
+        const messageId = m.id;
+        const createdMs = m.time?.created ?? null;
+        const msgPartDir = messageId ? path.join(partRootDir, messageId) : null;
+        const parts = [];
+        const partPaths = [];
+        if (msgPartDir && fs.existsSync(msgPartDir)) {
+            for (const fname of fs.readdirSync(msgPartDir)) {
+                if (!fname.endsWith(".json"))
+                    continue;
+                const partPath = path.join(msgPartDir, fname);
+                const p = readJsonSafe(partPath);
+                if (p) {
+                    parts.push(p);
+                    partPaths.push(partPath);
+                }
+            }
+            // Part filenames are ULID-like (lexicographically time-sortable);
+            // fall back to that when a part lacks its own time.start (e.g.
+            // step-start/step-finish, tool calls still in flight).
+            parts.sort((a, b) => {
+                const ta = a.time?.start || 0;
+                const tb = b.time?.start || 0;
+                if (ta !== tb)
+                    return ta - tb;
+                return String(a.id || "").localeCompare(String(b.id || ""));
+            });
+        }
+        const rendered = parts.map(renderOpencodePart).filter((r) => r);
+        const text = rendered.join("\n");
+        const toolCalls = parts.filter((p) => p.type === "tool").map((p) => p.tool || "unknown_tool");
+        if (!text && toolCalls.length === 0)
+            continue;
+        const source_mtime_ms = newestMtimeMs([sessionPath, messagePath, ...partPaths]);
+        turns.push({
+            project_cwd: cwd, // resolved to the real project root later
+            session_id: sessionId,
+            agent: "opencode",
+            timestamp: createdMs !== null ? msToIso(createdMs) : null,
+            role: m.role,
+            text,
+            tool_calls: toolCalls,
+            source_mtime_ms,
+        });
+    }
+    return turns;
+}
+export const OPENCODE_DIR_SHAPE = "~/.local/share/opencode (storage/session|message|part/ is resolved at sync time)";
+/** True when `dir` is the top-level opencode install dir (~/.local/share/opencode). */
+export function looksLikeOpencodeDir(dir) {
+    const storageDir = opencodeStorageDir(dir);
+    return fs.existsSync(path.join(storageDir, "session")) && fs.existsSync(path.join(storageDir, "message"));
+}
+/** `configuredDir` is the user-configured top-level dir (~/.local/share/opencode). */
+export function collectOpencodeTurns(configuredDir) {
+    const turns = [];
+    const storageDir = opencodeStorageDir(configuredDir);
+    const opencodeSessionDir = path.join(storageDir, "session");
+    for (const projectDir of listDirs(opencodeSessionDir)) {
+        for (const sessionFile of listFiles(projectDir, ".json")) {
+            for (const turn of parseOpencodeSession(sessionFile, storageDir))
+                turns.push(turn);
+        }
+    }
+    return turns;
+}

package/dist/localHistory/registry.js

@@ -0,0 +1,66 @@
+/**
+ * One entry per supported coding agent, tying together everything the rest
+ * of the CLI needs to know about it: what to call it, where it usually
+ * lives, how to recognize a valid data directory, and how to read turns out
+ * of one. Supporting a new agent is a new file in this directory plus one
+ * entry here -- nothing else in the codebase enumerates agents.
+ */
+import { DEFAULT_CLAUDE_DIR, CLAUDE_CODE_DIR_SHAPE, claudeProjectsDir, looksLikeClaudeCodeDir, collectClaudeCodeTurns, } from "./claudeCode.js";
+import { DEFAULT_CODEX_DIR, CODEX_DIR_SHAPE, codexSessionsDir, looksLikeCodexDir, collectCodexTurns } from "./codex.js";
+import { DEFAULT_CURSOR_DIR, CURSOR_DIR_SHAPE, cursorDerivedDirs, looksLikeCursorDir, collectCursorTurns, collectCursorTurnsForProject } from "./cursor.js";
+import { DEFAULT_OPENCODE_DIR, OPENCODE_DIR_SHAPE, opencodeStorageDir, looksLikeOpencodeDir, collectOpencodeTurns, } from "./opencode.js";
+export const AGENT_ADAPTERS = {
+    "claude-code": {
+        name: "claude-code",
+        label: "Claude Code",
+        defaultDir: DEFAULT_CLAUDE_DIR,
+        expectedShape: CLAUDE_CODE_DIR_SHAPE,
+        looksLikeDataDir: looksLikeClaudeCodeDir,
+        collect: collectClaudeCodeTurns,
+        fingerprintDirs: (_projectRoot, configuredDir) => [claudeProjectsDir(configuredDir)],
+    },
+    codex: {
+        name: "codex",
+        label: "Codex CLI",
+        defaultDir: DEFAULT_CODEX_DIR,
+        expectedShape: CODEX_DIR_SHAPE,
+        looksLikeDataDir: looksLikeCodexDir,
+        collect: collectCodexTurns,
+        fingerprintDirs: (_projectRoot, configuredDir) => [codexSessionsDir(configuredDir)],
+    },
+    cursor: {
+        name: "cursor",
+        label: "Cursor",
+        defaultDir: DEFAULT_CURSOR_DIR,
+        expectedShape: CURSOR_DIR_SHAPE,
+        looksLikeDataDir: looksLikeCursorDir,
+        collect: (dir, context) => context
+            ? collectCursorTurnsForProject(context.projectRoot, Date.parse(context.projectInitAt), dir)
+            : collectCursorTurns(dir),
+        fingerprintDirs: (projectRoot, configuredDir) => cursorDerivedDirs(projectRoot, configuredDir).transcriptsDirs,
+    },
+    opencode: {
+        name: "opencode",
+        label: "opencode",
+        defaultDir: DEFAULT_OPENCODE_DIR,
+        expectedShape: OPENCODE_DIR_SHAPE,
+        looksLikeDataDir: looksLikeOpencodeDir,
+        collect: collectOpencodeTurns,
+        fingerprintDirs: (_projectRoot, configuredDir) => [opencodeStorageDir(configuredDir)],
+    },
+};
+/** Resolve configured agent dirs to the paths the daemon should fingerprint. */
+export function fingerprintDirsForConfig(projectRoot, config) {
+    const dirs = [];
+    for (const name of ALL_AGENT_NAMES) {
+        const agent = config.agents[name];
+        if (!agent)
+            continue;
+        const adapter = AGENT_ADAPTERS[name];
+        for (const configured of agent.dirs) {
+            dirs.push(...adapter.fingerprintDirs(projectRoot, configured));
+        }
+    }
+    return dirs;
+}
+export const ALL_AGENT_NAMES = Object.keys(AGENT_ADAPTERS);

package/dist/localHistory/shared.js

@@ -0,0 +1,174 @@
+/**
+ * Types and helpers shared across the per-agent parsers in this directory --
+ * the common turn shape they all produce, and generic filesystem/rendering
+ * helpers with no agent-specific knowledge in them.
+ */
+import fs from "node:fs";
+import path from "node:path";
+/** Newest mtime (epoch ms) across `paths`, ignoring unreadable ones.
+ * null when none of the paths could be stat'd. */
+export function newestMtimeMs(paths) {
+    let newest = null;
+    for (const p of paths) {
+        try {
+            const ms = fs.statSync(p).mtimeMs;
+            if (newest === null || ms > newest)
+                newest = ms;
+        }
+        catch {
+            // unreadable -- skip
+        }
+    }
+    return newest;
+}
+/** Epoch milliseconds -> the same 'YYYY-MM-DDTHH:MM:SS.mmmZ' shape Claude
+ * Code and Codex already write natively, so all four agents sort/slice
+ * identically downstream (lexicographic ISO8601, millisecond precision).
+ * Date#toISOString() already produces exactly this format. */
+export function msToIso(ms) {
+    return new Date(ms).toISOString();
+}
+export function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+ * Render a single content block to text, keeping everything -- known block
+ * types get a readable rendering (including full tool arguments and full
+ * tool output, not just names or truncated snippets); any block type not
+ * explicitly recognized falls back to a raw JSON dump rather than being
+ * silently dropped. Covers Claude Code/Codex block-type spellings (thinking,
+ * tool_use, tool_result) and Cursor's own spellings for the same concepts
+ * (reasoning, tool-call, tool-result), since both feed the same renderer.
+ * Deliberate exclusions (opaque, non-informative): `encrypted_content` on
+ * Claude/Codex `reasoning` blocks, `data` on Cursor `redacted-reasoning`
+ * blocks, and `signature` on either -- all are encrypted/opaque blobs, not
+ * text either we or the model can read. Cursor tool-result's
+ * `experimental_content` is also skipped: verified to always duplicate the
+ * same text already in `result`, not additional information.
+ */
+export function renderBlock(block) {
+    if (!isPlainObject(block)) {
+        return block === null || block === undefined ? "" : String(block);
+    }
+    const btype = block.type;
+    if (btype === "text" || btype === "input_text" || btype === "output_text" || btype === "summary_text") {
+        return block.text || "";
+    }
+    if (btype === "thinking") {
+        const thinking = block.thinking;
+        return thinking ? `[thinking] ${thinking}` : "";
+    }
+    if (btype === "reasoning") {
+        // Cursor's content-block spelling of Claude's "thinking" -- same shape
+        // (a `text` field, often empty when only a signature is kept).
+        const text = block.text;
+        return text ? `[thinking] ${text}` : "";
+    }
+    if (btype === "redacted-reasoning") {
+        // Cursor's opaque encrypted reasoning blob (`data`) -- analogous to the
+        // Claude/Codex `encrypted_content` exclusion above.
+        return "";
+    }
+    if (btype === "tool_use") {
+        const name = block.name || "unknown_tool";
+        return `[tool_call: ${name}] ${JSON.stringify(block.input ?? {})}`;
+    }
+    if (btype === "tool-call") {
+        // Cursor's spelling: {toolName, args} instead of {name, input}.
+        const name = block.toolName || "unknown_tool";
+        return `[tool_call: ${name}] ${JSON.stringify(block.args ?? {})}`;
+    }
+    if (btype === "tool_result") {
+        const prefix = block.is_error ? "[tool_result:error]" : "[tool_result]";
+        return `${prefix} ${renderContent(block.content)}`;
+    }
+    if (btype === "tool-result") {
+        // Cursor's spelling: {toolName, result} instead of {content, is_error}.
+        // No error flag is exposed at this level, so no :error suffix.
+        let result = block.result;
+        if (typeof result !== "string")
+            result = JSON.stringify(result ?? "");
+        return `[tool_result] ${result}`;
+    }
+    // Unrecognized block type -- dump the whole thing raw so nothing is lost.
+    return `[${btype || "unknown_block"}] ${JSON.stringify(block)}`;
+}
+/** content may be a plain string, a list of blocks, or (rarely) something
+ * else entirely -- render whatever it is rather than assuming a shape. */
+export function renderContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map(renderBlock)
+            .filter((p) => p)
+            .join("\n");
+    }
+    if (content === null || content === undefined)
+        return "";
+    return JSON.stringify(content);
+}
+export function listDirs(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    return fs
+        .readdirSync(dir, { withFileTypes: true })
+        .filter((e) => e.isDirectory())
+        .map((e) => path.join(dir, e.name));
+}
+export function listFiles(dir, suffix) {
+    if (!fs.existsSync(dir))
+        return [];
+    return fs
+        .readdirSync(dir, { withFileTypes: true })
+        .filter((e) => e.isFile() && e.name.endsWith(suffix))
+        .map((e) => path.join(dir, e.name));
+}
+/** Recursive .jsonl walk -- Codex nests rollout files under dated
+ * subdirectories (sessions/YYYY/MM/DD/*.jsonl). */
+export function walkJsonl(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    const out = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        // Not out.push(...walkJsonl(full)): spreading a large array into a
+        // function call hits V8's per-call argument limit (~65k+ elements) and
+        // throws "Maximum call stack size exceeded" -- not a stack-depth
+        // problem, an argument-count one. A directory of years of Codex
+        // sessions.YYYY/MM/DD/*.jsonl is exactly the shape that can accumulate
+        // enough files to hit it.
+        if (entry.isDirectory())
+            for (const file of walkJsonl(full))
+                out.push(file);
+        else if (entry.isFile() && entry.name.endsWith(".jsonl"))
+            out.push(full);
+    }
+    return out;
+}
+/** Short-circuiting, depth-bounded "is there any <suffix> file under here?"
+ * -- used to validate a user-entered data directory. Deliberately NOT
+ * walkJsonl(): a mistyped path (say `/`) would otherwise walk the entire
+ * filesystem collecting every match before answering a yes/no question. */
+export function hasFileWithSuffix(dir, suffix, maxDepth = 6) {
+    if (maxDepth < 0)
+        return false;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return false; // missing, or not readable -- either way, nothing to find
+    }
+    if (entries.some((e) => e.isFile() && e.name.endsWith(suffix)))
+        return true;
+    return entries.some((e) => e.isDirectory() && hasFileWithSuffix(path.join(dir, e.name), suffix, maxDepth - 1));
+}
+export function readJsonSafe(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/paths.js

@@ -0,0 +1,85 @@
+/**
+ * Where this CLI keeps its local state. Overridable via RESUMECONTEXT_HOME
+ * (tests point this at a temp directory so nothing touches a real user's
+ * `~/.resumecontext`, and no test run can affect another).
+ */
+import os from "node:os";
+import path from "node:path";
+export function resumecontextHome() {
+    return process.env.RESUMECONTEXT_HOME || defaultResumecontextHome();
+}
+/** The canonical state directory when RESUMECONTEXT_HOME is unset. */
+export function defaultResumecontextHome() {
+    return path.join(os.homedir(), ".resumecontext");
+}
+/** Top-level entries this CLI creates under resumecontextHome(), plus a few
+ * legacy names kept so uninstall shape checks stay permissive across
+ * upgrades. Uninstall uses this as a positive signal (see
+ * looksLikeResumecontextHome in uninstall.ts), not a strict allowlist of
+ * every file that may exist. */
+export const KNOWN_HOME_ENTRIES = new Set([
+    "credentials.json",
+    "device.json",
+    "fake-cloud.json",
+    "sync-state",
+    "agents",
+    "agents.json", // legacy single-file agent config, pre per-project layout
+    "daemon",
+]);
+export function credentialsFile() {
+    return path.join(resumecontextHome(), "credentials.json");
+}
+/** This machine's id (see device.ts). Per machine, not per project, and kept
+ * separate from credentials so signing out does not change which machine this
+ * is. */
+export function deviceFile() {
+    return path.join(resumecontextHome(), "device.json");
+}
+/** Per-project record of sync progress (see syncState.ts) -- keyed by
+ * projectId, not written into the project directory, since it's local
+ * progress tracking, not something meant to be shared or committed (unlike
+ * the `.resumecontext.json` marker). */
+export function syncStateFile(projectId) {
+    return path.join(resumecontextHome(), "sync-state", `${projectId}.json`);
+}
+/** Per-project record of which coding agents to scan for local history and
+ * where their data lives (see agentConfig.ts). Keyed by projectId and kept
+ * here rather than in the project's own `.resumecontext.json` marker on
+ * purpose: the marker is meant to be committed and shared with teammates,
+ * whereas these are absolute paths that are only meaningful on this
+ * machine. Same reasoning, and same layout, as syncStateFile above. */
+export function agentConfigFile(projectId) {
+    return path.join(resumecontextHome(), "agents", `${projectId}.json`);
+}
+function daemonDir() {
+    return path.join(resumecontextHome(), "daemon");
+}
+/** The set of projects the background auto-sync daemon polls -- one shared
+ * file across every project on this machine (see daemon.ts). */
+export function daemonRegistryFile() {
+    return path.join(daemonDir(), "projects.json");
+}
+/** The daemon runs detached with no terminal of its own, so its stdio is
+ * redirected here instead of being discarded -- a silently-failing
+ * background sync would otherwise be nearly impossible to debug. */
+export function daemonLogFile() {
+    return path.join(daemonDir(), "daemon.log");
+}
+/** Each tick is now its own short-lived process (see daemon.ts's module
+ * doc for why), scheduled by the OS every DAEMON_INTERVAL_MS -- so two
+ * ticks CAN briefly overlap (a slow tick still running when the next one
+ * is scheduled). This file is an exclusive-create lock a tick holds for
+ * its duration; a second tick that finds it already held (and the holder
+ * still alive) skips its run rather than piling on top of the first. */
+export function daemonLockFile() {
+    return path.join(daemonDir(), "lock");
+}
+/** Since each tick is a fresh process with no memory of the last one, the
+ * "skip scanning if nothing on disk changed" fingerprint (see
+ * fingerprintDirs in daemon.ts) has to be persisted here instead of held
+ * in memory -- otherwise every single tick would pay the full scan cost
+ * regardless of whether anything actually changed, which is exactly the
+ * cost fingerprinting exists to avoid. */
+export function daemonFingerprintCacheFile() {
+    return path.join(daemonDir(), "fingerprints.json");
+}

package/dist/projectRoot.js

@@ -0,0 +1,77 @@
+/**
+ * Resolves the PROJECT a directory belongs to, walking up the filesystem
+ * looking ONLY for a `.resumecontext.json` marker -- nearest ancestor wins,
+ * not an exact path match. There is no `.git`-based fallback: project
+ * identity depends solely on this marker (see cloudApi.ts's module doc and
+ * commands/init.ts), so a directory with no marker anywhere above it simply
+ * has no project, full stop. Self-contained copy of the same validated
+ * logic in ingest/src/projectRoot.ts (this package is deliberately
+ * standalone, not dependent on ingest/'s internals -- see
+ * cli/src/localCapture.ts for how the two packages actually connect, via
+ * ingest's OUTPUT files, not its code).
+ *
+ * Resolution order, nearest-first, walking from the given directory upward:
+ *   1. A `.resumecontext.json` marker (written by `init`) -- explicit,
+ *      user-declared project boundary. This is the ONLY thing that counts,
+ *      so a monorepo subfolder with its own marker is its own project
+ *      regardless of any enclosing repo.
+ *   2. No marker anywhere above the given directory -- caller decides what
+ *      to do (init marks the exact directory given; other commands should
+ *      treat this as "no project here").
+ */
+import fs from "node:fs";
+import path from "node:path";
+export const MARKER_FILENAME = ".resumecontext.json";
+function readMarker(dir) {
+    try {
+        const raw = fs.readFileSync(path.join(dir, MARKER_FILENAME), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.projectId === "string" && parsed.projectId) {
+            return { projectId: parsed.projectId, createdAt: parsed.createdAt ?? "" };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Walks from `startDir` up to the filesystem root looking only for a
+ * `.resumecontext.json` marker. Never throws -- a nonexistent/inaccessible
+ * `startDir`, or simply finding no marker anywhere above it, just resolves
+ * to "none". */
+export function findProjectRoot(startDir) {
+    let dir = path.resolve(startDir);
+    while (true) {
+        const marker = readMarker(dir);
+        if (marker)
+            return { root: dir, projectId: marker.projectId };
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break; // filesystem root
+        dir = parent;
+    }
+    return { root: path.resolve(startDir), projectId: null };
+}
+/** Reads the marker at `root` when present; null otherwise. */
+export function readProjectMarker(root) {
+    return readMarker(path.resolve(root));
+}
+/** Writes the marker at `root`. Caller decides what root should be -- for
+ * `init`, always the exact directory the command was run in (see
+ * commands/init.ts for why that's deliberate, not some inferred parent
+ * directory). */
+export function writeMarker(root, projectId) {
+    const marker = { projectId, createdAt: new Date().toISOString() };
+    fs.writeFileSync(path.join(root, MARKER_FILENAME), JSON.stringify(marker, null, 2) + "\n");
+    return marker;
+}
+/** Every project-scoped command (sync/share/accept/revoke/members) needs
+ * exactly this: an existing local marker, or a clear error telling the user
+ * to run `init` first. Centralized here so all of them fail identically. */
+export function requireProject(cwd) {
+    const resolved = findProjectRoot(cwd);
+    if (!resolved.projectId) {
+        throw new Error(`No resumecontext project found at ${cwd} or any parent directory. Run \`resumecontext init\` here first.`);
+    }
+    return resolved;
+}