codehere 0.8.0 → 1.0.2

package/dist/infrastructure/orchestration/graphify-context.js

@@ -1,254 +0,0 @@
-/**
- * graphify-context — shared structural memory layer (P1).
- *
- * Wraps `graphify-ts` CLI to compile compact context packs for agent prompts.
- * Every spawn can optionally get a graphify context pack that replaces
- * raw file reads + unstructured JSONL scans.
- *
- * All functions are synchronous (execFileSync) to slot into the sync
- * spawn() call chain without breaking the API.
- *
- * P1 integration points:
- *   - Session spawn: inject context pack into prompt prefix
- *   - Failover handoff (P2): replacement agent inherits the same pack
- *   - S7 compaction (future): use graph to prune stale session logs
- *   - PM-brain routing (future): community_overview for agent selection
- */
-import { execFileSync } from 'child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { randomUUID } from 'crypto';
-// ── Constants ──────────────────────────────────────────────────────────────────
-const GRAPHIFY_OUT = 'graphify-out';
-const GRAPH_JSON = 'graph.json';
-const CONTEXT_PACKS_DIR = '.codehere';
-const CONTEXT_PACKS_FILE = 'context-packs.jsonl';
-// ── Helpers ────────────────────────────────────────────────────────────────────
-function getGraphPath(cwd) {
-    return join(cwd, GRAPHIFY_OUT, GRAPH_JSON);
-}
-function getGraphStats(cwd) {
-    const graphPath = getGraphPath(cwd);
-    try {
-        if (!existsSync(graphPath)) {
-            return { nodeCount: 0, edgeCount: 0 };
-        }
-        const graphJson = JSON.parse(readFileSync(graphPath, 'utf-8'));
-        return {
-            nodeCount: graphJson.nodes?.length ?? 0,
-            edgeCount: graphJson.edges?.length ?? 0,
-        };
-    }
-    catch {
-        return { nodeCount: 0, edgeCount: 0 };
-    }
-}
-// ── Graph management (sync) ────────────────────────────────────────────────────
-/**
- * Build or update the knowledge graph for a workspace directory.
- * Writes to <cwd>/graphify-out/graph.json (graphify-ts default).
- * Synchronous — runs synchronously so it can be called from spawn().
- */
-export function buildGraphSync(cwd, { incremental = true } = {}) {
-    const startTime = Date.now();
-    const graphPath = getGraphPath(cwd);
-    const args = ['generate', cwd];
-    if (incremental && existsSync(graphPath)) {
-        args.push('--update');
-    }
-    try {
-        execFileSync('npx', ['graphify-ts', ...args], {
-            cwd,
-            stdio: 'ignore',
-            timeout: 120_000,
-        });
-    }
-    catch {
-        // Non-zero exit is fine — graphify-ts returns 1 when no files changed.
-        // Also swallow ENOENT (graphify-ts not installed) — degrade gracefully.
-    }
-    return { elapsedMs: Date.now() - startTime };
-}
-// ── Context pack compilation (sync) ────────────────────────────────────────────
-/**
- * Compile a compact context pack for a prompt + workspace.
- * Synchronous — calls graphify-ts pack and returns the payload.
- */
-export function compileContextPackSync(prompt, cwd, { task = 'explain', budget = 3000 } = {}) {
-    const startTime = Date.now();
-    const graphPath = getGraphPath(cwd);
-    // Build graph if it doesn't exist yet
-    if (!existsSync(graphPath)) {
-        buildGraphSync(cwd, { incremental: false });
-    }
-    // Degrade gracefully if graph still doesn't exist
-    if (!existsSync(graphPath)) {
-        return null;
-    }
-    try {
-        const output = execFileSync('npx', ['graphify-ts', 'pack', prompt, '--graph', graphPath, '--task', task, '--budget', String(budget)], {
-            cwd,
-            encoding: 'utf-8',
-            maxBuffer: 512 * 1024,
-            timeout: 30_000,
-        });
-        const { nodeCount, edgeCount } = getGraphStats(cwd);
-        return {
-            graphPath,
-            payload: output.trim(),
-            budget,
-            task,
-            nodeCount,
-            edgeCount,
-            elapsedMs: Date.now() - startTime,
-            packId: randomUUID(),
-        };
-    }
-    catch {
-        // graphify-ts may return non-zero or hit timeout — degrade gracefully.
-        return null;
-    }
-}
-/**
- * Compile a context pack from a session's final state (prompt + artifacts + steps).
- * Used for P1 session-exit persistence and P2 handoff enrichment.
- */
-export function compileSessionPackSync(cwd, { prompt, artifacts, steps, agent }) {
-    // Combine prompt + artifacts + steps into a rich prompt for the pack
-    const sessionContext = [
-        prompt,
-        agent ? `Agent: ${agent}` : undefined,
-        artifacts ? `Artifacts:\n${artifacts}` : undefined,
-        steps ? `Steps taken:\n${steps}` : undefined,
-    ]
-        .filter(Boolean)
-        .join('\n\n');
-    return compileContextPackSync(sessionContext, cwd, { task: 'impact', budget: 2500 });
-}
-// ── Context pack persistence ───────────────────────────────────────────────────
-/**
- * Persist a context pack to disk for cross-session handoff (P2).
- * Returns the path to the packs file.
- */
-export function persistContextPack(pack, cwd) {
-    const packsDir = join(cwd, CONTEXT_PACKS_DIR);
-    if (!existsSync(packsDir)) {
-        mkdirSync(packsDir, { recursive: true });
-    }
-    const packsFile = join(packsDir, CONTEXT_PACKS_FILE);
-    const entry = {
-        packId: pack.packId,
-        timestamp: Date.now(),
-        task: pack.task,
-        nodeCount: pack.nodeCount,
-        edgeCount: pack.edgeCount,
-        graphPath: pack.graphPath,
-        payloadPreview: pack.payload.slice(0, 500), // truncate for log
-        payloadLength: pack.payload.length,
-    };
-    writeFileSync(packsFile, JSON.stringify(entry) + '\n', { flag: 'a' });
-    return packsFile;
-}
-/**
- * Load the most recent context pack from disk (for P2 handoff).
- */
-export function loadRecentContextPack(cwd) {
-    const packsFile = join(cwd, CONTEXT_PACKS_DIR, CONTEXT_PACKS_FILE);
-    if (!existsSync(packsFile)) {
-        return null;
-    }
-    try {
-        const lines = readFileSync(packsFile, 'utf-8').split('\n').filter(Boolean);
-        if (lines.length === 0)
-            return null;
-        const lastEntry = JSON.parse(lines[lines.length - 1]);
-        return {
-            packId: lastEntry.packId,
-            graphPath: lastEntry.graphPath,
-            payload: '', // payload is truncated in disk storage
-            budget: 3000,
-            task: lastEntry.task,
-            nodeCount: lastEntry.nodeCount,
-            edgeCount: lastEntry.edgeCount,
-            elapsedMs: 0,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-// ── Prompt enrichment (sync) ───────────────────────────────────────────────────
-/**
- * Prepend a context pack to a prompt if graphify-ts is available.
- *
- * Synchronous — can be called directly from spawn().
- * Returns the original prompt if graphify-ts fails or is unavailable.
- *
- * Respects CODEHERE_GRAPHIFY env var:
- *   - unset or "auto" (default): enrich ONLY from a pre-existing graph/pack;
- *     NEVER compile on the spawn hot path (root-cause fix 2026-06-02 for
- *     "every task calls graphify" — `npx graphify-ts pack` was shelling out
- *     synchronously on every spawn, slowing crucial tasks + prepending a
- *     verbose context blob the user never asked for).
- *   - "force": compile a fresh pack on spawn (explicit opt-in for the cost).
- *   - "off": skip entirely.
- */
-export function enrichPromptWithPackSync(prompt, cwd, { force = false } = {}) {
-    const mode = process.env.CODEHERE_GRAPHIFY ?? 'auto';
-    if (mode === 'off')
-        return prompt;
-    const forceCompile = force || mode === 'force';
-    // 'auto' must NEVER touch the user's prompt — not by compiling (npx subprocess
-    // on the hot path) AND not by prepending an existing pack's "[graphify context:
-    // …]" reference blob. That blob leaked into the visible prompt, the Final
-    // Report summary, and the conversation ("On it — [graphify context: 1017
-    // nodes…]") — user-reported 2026-06-02 with a graph present. Structural
-    // context enrichment is now 'force'-only opt-in; a normal task gets a clean prompt.
-    if (!forceCompile)
-        return prompt;
-    // Compile a fresh pack (force only)
-    // Compile a fresh pack (force only)
-    const pack = compileContextPackSync(prompt, cwd, { task: 'explain', budget: 2500 });
-    if (!pack) {
-        return prompt;
-    }
-    // Persist for P2 handoff
-    persistContextPack(pack, cwd);
-    // Prepend context pack as a system hint so the agent sees it first
-    return [
-        `[graphify-ts context pack — ${pack.nodeCount} nodes, ${pack.edgeCount} edges, ${pack.elapsedMs}ms]`,
-        pack.payload,
-        '---',
-        prompt,
-    ].join('\n\n');
-}
-// ── Graph querying (sync) ──────────────────────────────────────────────────────
-/**
- * Query the knowledge graph for a question.
- * Useful for PM-brain routing and structured context handoff (P2).
- */
-export function queryGraphSync(question, cwd, { maxTokens = 2000 } = {}) {
-    const startTime = Date.now();
-    const graphPath = getGraphPath(cwd);
-    if (!existsSync(graphPath)) {
-        return null;
-    }
-    try {
-        const output = execFileSync('npx', ['graphify-ts', 'query', question, '--graph', graphPath, '--budget', String(maxTokens)], {
-            cwd,
-            encoding: 'utf-8',
-            maxBuffer: 256 * 1024,
-            timeout: 15_000,
-        });
-        return {
-            question,
-            answer: output.trim(),
-            elapsedMs: Date.now() - startTime,
-            graphPath,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=graphify-context.js.map

package/dist/infrastructure/orchestration/memory-injector.js

@@ -1,380 +0,0 @@
-/**
- * F3 Task 8 — memory injection into spawned-agent prompts.
- *
- * Builds a prompt prefix from the project's `.codehere/` memory layers
- * (AGENTS.md briefing + working/session.md + semantic/lessons.jsonl + a
- * slice of episodic/repo_map.json topSymbols) so spawned agents start
- * warm — with the project's conventions, in-flight context, accumulated
- * lessons, and the most-referenced symbols already in their context window.
- *
- * Pure, side-effect-free, fully unit-tested. Each adapter calls
- * `buildMemoryPrefix(projectRoot)` near the top of `spawn()`, prepends
- * the resulting prefix to the user's prompt, and exposes the metadata via
- * `TaskSession.memoryInjection`.
- *
- * Token budget is char-count-approximated (4 chars ≈ 1 token, the
- * Anthropic / OpenAI rule-of-thumb). Default cap is 3000 tokens —
- * generous but well under any realistic context window. When budget is
- * exceeded, sections are dropped in priority order:
- *
- *   keep    AGENTS.md         — never dropped if user-edited (the briefing
- *                                is the primary value)
- *   drop 3  repo_map slice    — symbols are nice-to-have; the agent can
- *                                discover them via grep if missing
- *   drop 2  lessons           — useful but not load-bearing
- *   drop 1  session.md        — useful for hand-off but redundant if the
- *                                user re-states their task
- *
- * Default-seed detection skips placeholder content (the init seeds for
- * AGENTS.md / session.md). Same byte-equality-based detection pattern as
- * memory-command.ts (per feedback_implementation_patterns_v05.md Pattern #1).
- */
-import { existsSync, readFileSync, realpathSync, writeFileSync } from 'fs';
-import { join, dirname, resolve } from 'path';
-const DEFAULT_MAX_TOKENS = 3000;
-const DEFAULT_MAX_LESSONS = 10;
-const DEFAULT_MAX_SYMBOLS = 30;
-// 3 chars per token — conservative ratio per K2 Round 1 feedback. Code
-// tokenizes denser than prose under typical BPE, so the safer-defaults 4/1
-// rule-of-thumb underestimates by 1.5-2x for code-heavy prefixes (which
-// repo_map + lessons.jsonl frequently are). 3/1 stays well clear of model
-// per-message caps without dropping useful content from typical repos.
-const CHARS_PER_TOKEN = 3;
-/** Char-count → token estimate. Conservative — actual tokenization may differ. */
-function estimateTokens(s) {
-    return Math.ceil(s.length / CHARS_PER_TOKEN);
-}
-/**
- * Detect whether the given file content is still the init-time placeholder.
- * If so, the user hasn't customized it — injecting the placeholder would
- * just confuse the agent with template instructions.
- *
- * Heuristic: presence of bracketed-instruction lines like `[One-paragraph
- * description...]` or the `> Per-machine, gitignored` boilerplate, AND no
- * substantive non-template content after the markers. Conservative — when
- * in doubt, INCLUDE rather than exclude (better to over-share than miss
- * the briefing).
- */
-function looksLikeInitSeed(content, kind) {
-    if (kind === 'agents') {
-        // The init AGENTS/CONTEXT seed has these distinctive bracketed placeholders.
-        // If at least 2 of them are present, treat as untouched.
-        const markers = [
-            /\[One-paragraph description of what this repo does/,
-            /\[How this codebase is organized/,
-            /\[Tone for generated code\./,
-            /\[Don't do X\. Always do Y\./,
-        ];
-        const hits = markers.filter((re) => re.test(content)).length;
-        return hits >= 2;
-    }
-    if (kind === 'session') {
-        // The init session.md seed has this header + structure
-        const markers = [/^# Working session/m, /^> Per-machine, gitignored/m, /^## In flight\s*\n+- \[ \]\s*$/m];
-        const hits = markers.filter((re) => re.test(content)).length;
-        return hits >= 2;
-    }
-    return false;
-}
-/**
- * Read the project briefing. Search order (highest-priority first):
- *   1. <projectRoot>/AGENTS.md  — agentic-stack convention; if the user
- *      has this file at the repo root with real content, it IS their
- *      canonical briefing and codehere must respect it (Bug 2 from the
- *      Apr 28 EXP-2 dogfood on `~/code/clipa`).
- *   2. <codehereDir>/AGENTS.md  — F3-canonical (codehere's own)
- *   3. <codehereDir>/CONTEXT.md — v0.4.1 back-compat
- *
- * Returns the body string + the path that was read (for the prefix
- * header), or null if no usable briefing exists at any tier (every
- * candidate is missing, empty, or looks like the init placeholder).
- */
-function readBriefing(projectRoot, codehereDir) {
-    const candidates = [
-        { path: join(projectRoot, 'AGENTS.md'), label: 'AGENTS.md (repo root)' },
-        { path: join(codehereDir, 'AGENTS.md'), label: '.codehere/AGENTS.md' },
-        { path: join(codehereDir, 'CONTEXT.md'), label: '.codehere/CONTEXT.md' },
-    ];
-    for (const c of candidates) {
-        if (existsSync(c.path)) {
-            try {
-                const body = readFileSync(c.path, 'utf8').trim();
-                if (body.length === 0)
-                    continue;
-                if (looksLikeInitSeed(body, 'agents'))
-                    continue; // placeholder — try next
-                return { body, sourcePath: c.label };
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    return null;
-}
-/** Read working/session.md. Skip if seed-shaped or empty. */
-function readSession(codehereDir) {
-    const p = join(codehereDir, 'memory/working/session.md');
-    if (!existsSync(p))
-        return null;
-    try {
-        const body = readFileSync(p, 'utf8').trim();
-        if (body.length === 0)
-            return null;
-        if (looksLikeInitSeed(body, 'session'))
-            return null;
-        return body;
-    }
-    catch {
-        return null;
-    }
-}
-/** Read up to N lessons from semantic/lessons.jsonl. */
-function readLessons(codehereDir, n) {
-    const p = join(codehereDir, 'memory/semantic/lessons.jsonl');
-    if (!existsSync(p))
-        return [];
-    try {
-        const body = readFileSync(p, 'utf8');
-        return body
-            .split('\n')
-            .filter((line) => line.trim().length > 0)
-            .slice(0, n)
-            .map((line) => {
-            try {
-                const obj = JSON.parse(line);
-                return typeof obj.text === 'string' ? obj.text : line;
-            }
-            catch {
-                return line;
-            }
-        });
-    }
-    catch {
-        return [];
-    }
-}
-function readTopSymbols(codehereDir, n) {
-    const p = join(codehereDir, 'memory/episodic/repo_map.json');
-    if (!existsSync(p))
-        return [];
-    try {
-        const body = JSON.parse(readFileSync(p, 'utf8'));
-        if (!Array.isArray(body.topSymbols))
-            return [];
-        return body.topSymbols.slice(0, n);
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Format individual sections. Each returns `null` if empty/skipped.
- */
-function formatBriefing(briefing, sourcePath) {
-    return `# Project briefing (${sourcePath})\n\n${briefing}\n`;
-}
-function formatSession(session) {
-    return `# Current session scratch (.codehere/memory/working/session.md)\n\n${session}\n`;
-}
-function formatLessons(lessons) {
-    const items = lessons.map((l) => `- ${l}`).join('\n');
-    return `# Project lessons (.codehere/memory/semantic/lessons.jsonl)\n\n${items}\n`;
-}
-function formatSymbols(symbols) {
-    const lines = symbols.map((s) => `- \`${s.name}\` — ${s.file}:${s.line} (${s.references} refs)`).join('\n');
-    return `# Top symbols in this repo (.codehere/memory/episodic/repo_map.json)\n\n${lines}\n`;
-}
-/**
- * Build the memory-injection prefix for the project at `projectRoot`.
- *
- * If `.codehere/` doesn't exist, returns empty (nothing to inject).
- * Otherwise reads the four sections, formats each, fits to the token
- * budget by dropping low-priority sections first.
- */
-export function buildMemoryPrefix(projectRoot, options = {}) {
-    const codehereDir = join(projectRoot, '.codehere');
-    const hasCodehereDir = existsSync(codehereDir);
-    const maxTokens = options.maxTokens ?? DEFAULT_MAX_TOKENS;
-    const maxLessons = options.maxLessons ?? DEFAULT_MAX_LESSONS;
-    const maxSymbols = options.maxSymbols ?? DEFAULT_MAX_SYMBOLS;
-    // Briefing discovery is INDEPENDENT of .codehere/ presence — a pure
-    // agentic-stack repo (root AGENTS.md, no .codehere/) is a valid
-    // injection source on its own (codex Round 1 fix on Bug 2). Only
-    // session/lessons/repo_map require the .codehere/ tree.
-    const briefing = readBriefing(projectRoot, codehereDir);
-    const session = hasCodehereDir ? readSession(codehereDir) : null;
-    const lessons = hasCodehereDir ? readLessons(codehereDir, maxLessons) : [];
-    const symbols = hasCodehereDir ? readTopSymbols(codehereDir, maxSymbols) : [];
-    // Build candidate sections in PRIORITY order (most-essential first).
-    // Drop direction is REVERSE — least-essential drops first.
-    const candidates = [];
-    if (briefing)
-        candidates.push({ key: 'agents', body: formatBriefing(briefing.body, briefing.sourcePath) });
-    if (session)
-        candidates.push({ key: 'session', body: formatSession(session) });
-    if (lessons.length > 0)
-        candidates.push({ key: 'lessons', body: formatLessons(lessons) });
-    if (symbols.length > 0)
-        candidates.push({ key: 'repo_map', body: formatSymbols(symbols) });
-    if (candidates.length === 0) {
-        return { prefix: '', included: [], tokens: 0, truncated: false };
-    }
-    // Closing separator, always added at the end.
-    const SEPARATOR = '\n---\n\n';
-    const separatorTokens = estimateTokens(SEPARATOR);
-    // Drop from least-essential (last) until everything fits in budget.
-    let truncated = false;
-    let kept = [...candidates];
-    while (kept.length > 0) {
-        const totalChars = kept.reduce((acc, c) => acc + c.body.length, 0);
-        const totalTokens = estimateTokens(kept.map((c) => c.body).join('\n')) + separatorTokens;
-        if (totalTokens <= maxTokens)
-            break;
-        // Drop the last (least-essential) section.
-        kept.pop();
-        truncated = true;
-        void totalChars;
-    }
-    // Edge: even AGENTS alone is over budget — truncate AGENTS body itself.
-    if (kept.length === 1 && estimateTokens(kept[0].body) + separatorTokens > maxTokens) {
-        const room = (maxTokens - separatorTokens) * CHARS_PER_TOKEN;
-        const truncatedBody = kept[0].body.slice(0, Math.max(0, room - 32)) + '\n... [truncated to fit]\n';
-        kept = [{ key: kept[0].key, body: truncatedBody }];
-        truncated = true;
-    }
-    if (kept.length === 0) {
-        return { prefix: '', included: [], tokens: 0, truncated };
-    }
-    const prefix = kept.map((c) => c.body).join('\n') + SEPARATOR;
-    return {
-        prefix,
-        included: kept.map((c) => c.key),
-        tokens: estimateTokens(prefix),
-        truncated,
-    };
-}
-/**
- * Walk up from `startPath` looking for the nearest ancestor (inclusive)
- * that codehere can inject memory FROM — meaning EITHER:
- *   - has a `.codehere/` directory (codehere-initialized project), OR
- *   - has a root-level `AGENTS.md` (agentic-stack convention)
- *
- * Returns the REAL filesystem ancestor path (symlinks resolved), or
- * `null` if no such ancestor exists.
- *
- * codex Round 1 BLOCKER fix: spawning a task from a subdirectory (e.g.
- * `cd src/auth && codehere task ...`) would miss the project root if we
- * only used the immediate cwd. Hence the upward walk.
- *
- * codex Round 2 BLOCKER fix: the upward walk must walk the REAL
- * filesystem ancestry, not the LEXICAL one. Without `realpathSync`,
- * `cwd` inside a symlinked subtree ascends through the lexical path and
- * misses the real project root. Real scenario for iCloud-symlinked /
- * shared-volume / mounted-drive projects.
- *
- * Bug 2 Round 2 BLOCKER fix: also accept a project root that has a
- * root-level `AGENTS.md` even WITHOUT `.codehere/`. A pure agentic-stack
- * repo (clipa-style) is a valid injection source on its own.
- *
- * Stops at the filesystem root. Symlink-following on read is the right
- * asymmetry per ADR-012 (the symlink defense applies to writes, not reads).
- *
- * Exported for the daemon's /api/memory/status route (the room's init nudge
- * must report the SAME readiness the injector itself would act on).
- */
-export function findProjectRoot(startPath) {
-    let current;
-    try {
-        current = realpathSync(resolve(startPath));
-    }
-    catch {
-        // Broken symlink at startPath itself — fall back to lexical resolve.
-        // (Better to attempt some lookup than fail outright.)
-        current = resolve(startPath);
-    }
-    // Bound the loop at the filesystem root by checking dirname stability.
-    for (;;) {
-        if (existsSync(join(current, '.codehere')) || existsSync(join(current, 'AGENTS.md'))) {
-            return current;
-        }
-        const parent = dirname(current);
-        if (parent === current)
-            return null;
-        current = parent;
-    }
-}
-/**
- * Adapter-side convenience: turn a raw user prompt into the spawn-ready
- * prompt + the diagnostic record. Each of the 5 built-in adapters calls
- * this near the top of `spawn()` and uses the returned `prompt` going
- * forward, plus exposes `record` via `TaskSession.memoryInjection`.
- *
- * Walks UPWARD from `cwd` to find the nearest ancestor with `.codehere/`,
- * so spawning from a subdirectory still gets injection (codex Round 1 fix).
- *
- * Returns `{ prompt: <unchanged>, record: undefined }` when:
- *   - `options.noMemoryPrefix` is true (caller opted out)
- *   - no ancestor of `cwd` has `.codehere/` (nothing to inject)
- *   - all sections are empty / placeholder seeds
- */
-export function applyMemoryPrefix(prompt, cwd, options) {
-    if (options.noMemoryPrefix)
-        return { prompt, record: undefined };
-    const projectRoot = findProjectRoot(cwd);
-    if (projectRoot === null)
-        return { prompt, record: undefined };
-    const r = buildMemoryPrefix(projectRoot);
-    if (r.prefix === '')
-        return { prompt, record: undefined };
-    return {
-        prompt: r.prefix + prompt,
-        record: { included: r.included, tokens: r.tokens, truncated: r.truncated },
-    };
-}
-/**
- * Write-back side of the shared-room hand-off: append a finished turn's outcome
- * to the project's `working/session.md` so the NEXT agent spawned in this
- * project reads it via buildMemoryPrefix() — closing the loop ("agents take
- * turns in a shared room, each building on the last").
- *
- * Resolves the SAME project root as the read path (findProjectRoot), so it only
- * writes when the project is codehere-initialized — it never creates `.codehere/`
- * in an uninitialized repo. The scratch is capped (the injector also budgets it).
- * Best-effort: a memory-write failure must never break a run.
- */
-export function recordTurnToWorkingMemory(cwd, entry) {
-    try {
-        const projectRoot = findProjectRoot(cwd);
-        if (projectRoot === null)
-            return; // not a codehere-initialized project
-        const dir = join(projectRoot, '.codehere', 'memory', 'working');
-        if (!existsSync(dir))
-            return;
-        const p = join(dir, 'session.md');
-        const HEADER = '# Working session log - codehere auto-records each agent turn so the next one picks up here\n';
-        const agent = (entry.agent || 'agent').replace(/\s+/g, ' ').trim().slice(0, 40);
-        const prompt = (entry.prompt || '').replace(/\s+/g, ' ').trim().slice(0, 120);
-        const summary = (entry.summary || '').replace(/\s+/g, ' ').trim().slice(0, 600);
-        const files = entry.files ? ` - ${entry.files} file${entry.files === 1 ? '' : 's'} changed` : '';
-        const block = `\n## ${agent}${prompt ? ' - ' + prompt : ''}${files}\n${summary || '(no written summary)'}\n`;
-        let cur = '';
-        try {
-            cur = existsSync(p) ? readFileSync(p, 'utf8') : '';
-        }
-        catch {
-            cur = '';
-        }
-        if (!cur.trim() || looksLikeInitSeed(cur, 'session'))
-            cur = HEADER;
-        cur += block;
-        const CAP = 8000;
-        if (cur.length > CAP)
-            cur = HEADER + cur.slice(cur.length - (CAP - HEADER.length));
-        writeFileSync(p, cur, 'utf8');
-    }
-    catch {
-        /* never break a run on a memory-write failure */
-    }
-}
-//# sourceMappingURL=memory-injector.js.map