ctxcarry 0.3.0

package/dist/distill.js

@@ -0,0 +1,249 @@
+import { freshState, readEvents, writeMarkdownState, writeState } from "./store.js";
+export function compactState() {
+    const events = readEvents();
+    const state = freshState();
+    for (const event of events) {
+        applyEvent(state, event);
+    }
+    state.updatedAt = new Date().toISOString();
+    postProcessState(state);
+    writeState(state);
+    writeMarkdownState(renderStateMarkdown(state));
+    return state;
+}
+export function renderStateMarkdown(state) {
+    return [
+        "# ctxcarry State",
+        "",
+        "## Current Task",
+        state.working.currentTask,
+        "",
+        "## Current Status",
+        state.working.status,
+        "",
+        "## Files Touched",
+        renderList(state.working.touchedFiles),
+        "",
+        "## Decisions Made",
+        renderMemoryList(state.episodic.decisions),
+        "",
+        "## Constraints",
+        renderMemoryList(state.working.constraints),
+        "",
+        "## Known Failures",
+        renderMemoryList(state.working.failures),
+        "",
+        "## Last Commands",
+        renderList(state.working.lastCommands),
+        "",
+        "## Next Steps",
+        renderMemoryList(state.working.nextSteps)
+    ].join("\n");
+}
+function applyEvent(state, event) {
+    switch (event.type) {
+        case "note":
+            applyNote(state, event);
+            break;
+        case "repo_snapshot":
+            applySnapshot(state, event);
+            break;
+        case "agent_session":
+            applySession(state, event);
+            break;
+        case "command_run":
+            applyCommand(state, event);
+            break;
+        case "file_changed":
+            applyFileChanged(state, event);
+            break;
+        case "session_fallback":
+            applyFallback(state, event);
+            break;
+    }
+}
+function applyNote(state, event) {
+    const noteType = String(event.noteType ?? "");
+    const content = String(event.content ?? "").trim();
+    if (!content) {
+        return;
+    }
+    const item = toMemoryItem(event, content);
+    if (noteType === "decision") {
+        state.episodic.decisions.push(item);
+    }
+    else if (noteType === "failure") {
+        state.working.failures.push(item);
+        state.working.status = "in_progress";
+    }
+    else if (noteType === "todo") {
+        state.working.todos.push(item);
+    }
+    else if (noteType === "constraint") {
+        state.working.constraints.push(item);
+    }
+    else if (noteType === "task") {
+        state.working.currentTask = content;
+        state.working.status = "in_progress";
+    }
+    else if (noteType === "next") {
+        state.working.nextSteps.push(item);
+    }
+    else if (noteType === "resolved") {
+        state.episodic.resolved.push(item);
+    }
+}
+function applySnapshot(state, event) {
+    const branch = typeof event.branch === "string" ? event.branch : null;
+    const files = Array.isArray(event.changedFiles) ? event.changedFiles.filter((file) => typeof file === "string") : [];
+    state.working.currentBranch = branch;
+    state.working.touchedFiles.push(...files);
+    if (files.length > 0 && state.working.status === "not_started") {
+        state.working.status = "in_progress";
+    }
+}
+function applySession(state, event) {
+    const agent = typeof event.agent === "string" ? event.agent : "unknown";
+    const exitCode = typeof event.exitCode === "number" ? event.exitCode : null;
+    const summary = exitCode === 0 ? `${agent} session completed.` : `${agent} session exited with code ${exitCode ?? "unknown"}.`;
+    state.episodic.sessions.push(toMemoryItem(event, summary));
+    if (typeof event.branch === "string") {
+        state.working.currentBranch = event.branch;
+    }
+    const files = Array.isArray(event.changedFiles) ? event.changedFiles.filter((file) => typeof file === "string") : [];
+    state.working.touchedFiles.push(...files);
+    if (exitCode !== 0) {
+        state.working.failures.push(toMemoryItem(event, summary));
+    }
+}
+function applyFileChanged(state, event) {
+    const file = typeof event.path === "string" ? event.path : "";
+    if (file) {
+        state.working.touchedFiles.push(file);
+        state.working.status = "in_progress";
+    }
+}
+function applyFallback(state, event) {
+    if (typeof event.branch === "string") {
+        state.working.currentBranch = event.branch;
+    }
+    const files = Array.isArray(event.changedFiles) ? event.changedFiles.filter((file) => typeof file === "string") : [];
+    state.working.touchedFiles.push(...files);
+    if (files.length > 0 && state.working.currentTask === "Unspecified") {
+        state.working.currentTask = "Continue work from latest agent session";
+    }
+    if (files.length > 0) {
+        state.working.status = "in_progress";
+    }
+}
+function applyCommand(state, event) {
+    const command = String(event.command ?? "").trim();
+    if (!command) {
+        return;
+    }
+    state.working.lastCommands.push(command);
+    if (event.status === "failed") {
+        const summary = summarizeFailure(String(event.summary ?? `${command} failed.`), command);
+        state.working.failures.push(toMemoryItem(event, summary));
+    }
+}
+function toMemoryItem(event, content) {
+    return {
+        content,
+        timestamp: event.timestamp,
+        agent: typeof event.agent === "string" ? event.agent : undefined
+    };
+}
+function renderMemoryList(items) {
+    return renderList(items.map((item) => item.content));
+}
+function renderList(items) {
+    if (items.length === 0) {
+        return "- None recorded";
+    }
+    return items.map((item) => `- ${item}`).join("\n");
+}
+function unique(values) {
+    return [...new Set(values.filter(Boolean))].sort();
+}
+function postProcessState(state) {
+    state.working.touchedFiles = unique(state.working.touchedFiles.map(summarizeDiffPath));
+    state.working.lastCommands = dedupeStrings(state.working.lastCommands).slice(-10);
+    state.working.constraints = dedupeMemoryItems(state.working.constraints);
+    state.working.failures = removeResolvedFailures(dedupeMemoryItems(state.working.failures), state.episodic.resolved);
+    state.working.todos = dedupeMemoryItems(state.working.todos);
+    state.working.nextSteps = dedupeMemoryItems(state.working.nextSteps);
+    state.episodic.sessions = dedupeMemoryItems(state.episodic.sessions);
+    state.episodic.decisions = dedupeMemoryItems(state.episodic.decisions);
+    state.episodic.attempts = dedupeMemoryItems(state.episodic.attempts);
+    state.episodic.resolved = dedupeMemoryItems(state.episodic.resolved);
+}
+function dedupeStrings(items) {
+    const seen = new Set();
+    const result = [];
+    for (const item of items) {
+        const normalized = normalize(item);
+        if (!normalized || seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        result.push(item);
+    }
+    return result;
+}
+function dedupeMemoryItems(items) {
+    const seen = new Set();
+    const result = [];
+    for (const item of items) {
+        const content = summarizeFailure(item.content);
+        const normalized = normalize(content);
+        if (!normalized || seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        result.push({ ...item, content });
+    }
+    return result;
+}
+function removeResolvedFailures(failures, resolved) {
+    if (resolved.length === 0) {
+        return failures;
+    }
+    const resolvedText = resolved.map((item) => normalize(item.content));
+    return failures.filter((failure) => {
+        const text = normalize(failure.content);
+        return !resolvedText.some((resolvedItem) => text.includes(resolvedItem) || resolvedItem.includes(text));
+    });
+}
+function summarizeFailure(content, command) {
+    const lines = dedupeStrings(content
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean));
+    if (lines.length <= 3 && !content.includes(" at ")) {
+        return content.trim();
+    }
+    const error = lines.find((line) => /(?:error:|expected|received|exception|timeout)/i.test(line)) ??
+        lines.find((line) => /(?:fail|failed)/i.test(line)) ??
+        lines[0] ??
+        "Command failed";
+    const failingTest = lines.find((line) => /\.(?:test|spec)\.[tj]sx?/i.test(line));
+    const appFrame = lines.find((line) => /\bat .*?(?:src|app|lib|components|tests)\//.test(line));
+    const parts = [`Error summary: ${error}`];
+    if (appFrame) {
+        parts.push(`Top app frame: ${appFrame}`);
+    }
+    if (failingTest && failingTest !== error) {
+        parts.push(`Failing test: ${failingTest}`);
+    }
+    if (command) {
+        parts.push(`Command: ${command}`);
+    }
+    return parts.join("; ");
+}
+function summarizeDiffPath(value) {
+    return value.replace(/\s+\|.*$/, "").trim();
+}
+function normalize(value) {
+    return value.toLowerCase().replace(/\s+/g, " ").trim();
+}

package/dist/git.js

@@ -0,0 +1,65 @@
+import { execFileSync } from "node:child_process";
+export function getGitSnapshot() {
+    if (!isGitRepo()) {
+        return {
+            isRepo: false,
+            branch: null,
+            status: [],
+            changedFiles: [],
+            diffStat: ""
+        };
+    }
+    const branch = runGit(["branch", "--show-current"]).trim() || null;
+    const status = lines(runGit(["status", "--short", "--untracked-files=all"]));
+    const changedFiles = unique([
+        ...lines(runGit(["diff", "--name-only"])),
+        ...lines(runGit(["diff", "--cached", "--name-only"])),
+        ...status.map((line) => line.slice(3).trim()).filter(Boolean)
+    ].filter((file) => !file.startsWith(".ctxcarry/")));
+    const diffStat = runGit(["diff", "--stat"]);
+    return {
+        isRepo: true,
+        branch,
+        status,
+        changedFiles,
+        diffStat
+    };
+}
+export function summarizeSnapshot(snapshot) {
+    if (!snapshot.isRepo) {
+        return "Not a git repository.";
+    }
+    const changed = snapshot.changedFiles.length === 0 ? "No changed files." : `${snapshot.changedFiles.length} changed file(s).`;
+    const branch = snapshot.branch ? `Branch ${snapshot.branch}.` : "Detached or unknown branch.";
+    return `${branch} ${changed}`;
+}
+function isGitRepo() {
+    try {
+        runGit(["rev-parse", "--is-inside-work-tree"]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function runGit(args) {
+    try {
+        return execFileSync("git", args, {
+            cwd: process.cwd(),
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"]
+        });
+    }
+    catch {
+        return "";
+    }
+}
+function lines(value) {
+    return value
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .filter(Boolean);
+}
+function unique(values) {
+    return [...new Set(values.filter(Boolean))].sort();
+}

package/dist/learn.js

@@ -0,0 +1,30 @@
+import fs from "node:fs";
+import { ctxcarryPath } from "./paths.js";
+import { readState, writeManagedFile } from "./store.js";
+export function learnFromSessions(apply) {
+    const state = readState();
+    const lines = [
+        "# ctxcarry Learned Guidance",
+        "",
+        "These rules were mined from local ctxcarry memory. Review before relying on them.",
+        "",
+        "## Decisions To Preserve",
+        ...list(state.episodic.decisions.map((item) => item.content)),
+        "",
+        "## Resolved Failure Lessons",
+        ...list(state.episodic.resolved.map((item) => item.content)),
+        "",
+        "## Active Failure Warnings",
+        ...list(state.working.failures.map((item) => item.content))
+    ];
+    const markdown = lines.join("\n");
+    if (apply) {
+        fs.writeFileSync(ctxcarryPath("learned.md"), `${markdown}\n`);
+        writeManagedFile("AGENTS.md", markdown);
+        writeManagedFile("CLAUDE.md", markdown);
+    }
+    return markdown;
+}
+function list(items) {
+    return items.length > 0 ? items.map((item) => `- ${item}`) : ["- None recorded"];
+}

package/dist/mcp-server.js

@@ -0,0 +1,94 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ctxcarryPath } from "./paths.js";
+import { readState } from "./store.js";
+export async function serveMcp() {
+    process.stdin.setEncoding("utf8");
+    let buffer = "";
+    process.stdin.on("data", (chunk) => {
+        buffer += chunk;
+        let index;
+        while ((index = buffer.indexOf("\n")) >= 0) {
+            const line = buffer.slice(0, index).trim();
+            buffer = buffer.slice(index + 1);
+            if (line)
+                handleLine(line);
+        }
+    });
+    process.stdin.on("end", () => {
+        process.exit(0);
+    });
+}
+function handleLine(line) {
+    try {
+        const request = JSON.parse(line);
+        respond(request.id, dispatch(request));
+    }
+    catch (error) {
+        respond(null, null, error instanceof Error ? error.message : String(error));
+    }
+}
+function dispatch(request) {
+    if (request.method === "initialize") {
+        return {
+            protocolVersion: "2024-11-05",
+            serverInfo: { name: "ctxcarry", version: "0.3.0" },
+            capabilities: { tools: {} }
+        };
+    }
+    if (request.method === "tools/list") {
+        return {
+            tools: [
+                { name: "get_current_task", description: "Return current ctxcarry task state.", inputSchema: { type: "object", properties: {} } },
+                { name: "get_latest_ctxcarry", description: "Return latest ctxcarry markdown.", inputSchema: { type: "object", properties: { agent: { type: "string" } } } },
+                { name: "get_relevant_session_events", description: "Return recent session events.", inputSchema: { type: "object", properties: { limit: { type: "number" } } } },
+                { name: "expand_session_artifact", description: "Read a raw archived session artifact.", inputSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
+                { name: "summarize_latest_failure", description: "Return the latest active failure.", inputSchema: { type: "object", properties: {} } }
+            ]
+        };
+    }
+    if (request.method === "tools/call") {
+        return callTool(request.params?.name, request.params?.arguments ?? {});
+    }
+    return {};
+}
+function callTool(name, args) {
+    const state = readState();
+    if (name === "get_current_task") {
+        return toolText(JSON.stringify(state.working, null, 2));
+    }
+    if (name === "get_latest_ctxcarry") {
+        const agent = typeof args.agent === "string" ? args.agent : "codex";
+        const file = ctxcarryPath("ctxcarrys", `${agent}.md`);
+        return toolText(fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "");
+    }
+    if (name === "get_relevant_session_events") {
+        const limit = typeof args.limit === "number" ? args.limit : 20;
+        const events = readJsonl(ctxcarryPath("events.jsonl")).slice(-limit);
+        return toolText(JSON.stringify(events, null, 2));
+    }
+    if (name === "expand_session_artifact") {
+        const requestedPath = String(args.path ?? "");
+        const safeRoot = ctxcarryPath("sessions");
+        const absolute = path.resolve(requestedPath);
+        if (!absolute.startsWith(path.resolve(safeRoot))) {
+            throw new Error("Artifact path must be inside .ctxcarry/sessions.");
+        }
+        return toolText(fs.existsSync(absolute) ? fs.readFileSync(absolute, "utf8") : "");
+    }
+    if (name === "summarize_latest_failure") {
+        return toolText(state.working.failures.at(-1)?.content ?? "No active failure recorded.");
+    }
+    throw new Error(`Unknown tool: ${name}`);
+}
+function readJsonl(file) {
+    if (!fs.existsSync(file))
+        return [];
+    return fs.readFileSync(file, "utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line));
+}
+function toolText(text) {
+    return { content: [{ type: "text", text }] };
+}
+function respond(id, result, error) {
+    process.stdout.write(`${JSON.stringify(error ? { jsonrpc: "2.0", id, error: { code: -32000, message: error } } : { jsonrpc: "2.0", id, result })}\n`);
+}

package/dist/paths.js

@@ -0,0 +1,8 @@
+import path from "node:path";
+export const CTXCARRY_DIR = ".ctxcarry";
+export function rootPath(...parts) {
+    return path.join(process.cwd(), ...parts);
+}
+export function ctxcarryPath(...parts) {
+    return rootPath(CTXCARRY_DIR, ...parts);
+}

package/dist/redact.js

@@ -0,0 +1,26 @@
+const SECRET_PATTERNS = [
+    [/\b(OPENAI_API_KEY|ANTHROPIC_API_KEY|JWT_SECRET)\s*=\s*[^\s"'`]+/gi, "$1=[REDACTED]"],
+    [/\bDATABASE_URL\s*=\s*postgres:\/\/[^\s"'`]+/gi, "DATABASE_URL=[REDACTED]"],
+    [/postgres:\/\/[^:\s"'`]+:[^@\s"'`]+@[^\s"'`]+/gi, "postgres://[REDACTED]"],
+    [/sk-[A-Za-z0-9_-]+/g, "sk-[REDACTED]"],
+    [/-----BEGIN PRIVATE KEY-----[\s\S]*?-----END PRIVATE KEY-----/g, "[REDACTED PRIVATE KEY]"]
+];
+export function redactText(value) {
+    let redacted = value;
+    for (const [pattern, replacement] of SECRET_PATTERNS) {
+        redacted = redacted.replace(pattern, replacement);
+    }
+    return redacted;
+}
+export function redactValue(value) {
+    if (typeof value === "string") {
+        return redactText(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => redactValue(item));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, redactValue(nested)]));
+    }
+    return value;
+}

package/dist/store.js

@@ -0,0 +1,175 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CTXCARRY_DIR, ctxcarryPath, rootPath } from "./paths.js";
+import { redactText, redactValue } from "./redact.js";
+const DEFAULT_STATE = {
+    version: 1,
+    updatedAt: new Date(0).toISOString(),
+    persistent: {
+        architecture: [],
+        installCommands: [],
+        testCommands: [],
+        conventions: [],
+        deploymentNotes: []
+    },
+    working: {
+        currentTask: "Unspecified",
+        status: "not_started",
+        currentBranch: null,
+        touchedFiles: [],
+        constraints: [],
+        failures: [],
+        todos: [],
+        nextSteps: [],
+        lastCommands: []
+    },
+    episodic: {
+        sessions: [],
+        decisions: [],
+        attempts: [],
+        resolved: []
+    }
+};
+export function defaultConfig(project = path.basename(process.cwd())) {
+    return {
+        project,
+        default_budget_tokens: 12000,
+        agents: {
+            codex: {
+                enabled: true,
+                output: "AGENTS.md"
+            },
+            claude: {
+                enabled: true,
+                output: "CLAUDE.md",
+                command: "claude"
+            }
+        },
+        ignore: ["node_modules/**", ".next/**", "dist/**", "build/**", "pnpm-lock.yaml"],
+        capture: {
+            git_diff: true,
+            commands: true,
+            test_outputs: true,
+            file_changes: true
+        },
+        summarizer: {
+            provider: "deterministic"
+        }
+    };
+}
+export function ensureInitialized() {
+    if (!fs.existsSync(ctxcarryPath())) {
+        throw new Error("ctxcarry is not initialized. Run `ctxcarry init` first.");
+    }
+}
+export function initStore() {
+    fs.mkdirSync(ctxcarryPath("summaries"), { recursive: true });
+    fs.mkdirSync(ctxcarryPath("ctxcarrys"), { recursive: true });
+    fs.mkdirSync(ctxcarryPath("index"), { recursive: true });
+    fs.mkdirSync(ctxcarryPath("sessions"), { recursive: true });
+    writeFileIfMissing(rootPath("ctxcarry.config.json"), JSON.stringify(defaultConfig(), null, 2) + "\n");
+    writeFileIfMissing(ctxcarryPath("events.jsonl"), "");
+    writeFileIfMissing(ctxcarryPath("commands.jsonl"), "");
+    writeFileIfMissing(ctxcarryPath("state.json"), JSON.stringify(freshState(), null, 2) + "\n");
+    writeFileIfMissing(ctxcarryPath("state.md"), "# ctxcarry State\n\nNo compacted state yet.\n");
+}
+export function readConfig() {
+    const configPath = rootPath("ctxcarry.config.json");
+    if (!fs.existsSync(configPath)) {
+        return defaultConfig();
+    }
+    return JSON.parse(fs.readFileSync(configPath, "utf8"));
+}
+export function readState() {
+    const statePath = ctxcarryPath("state.json");
+    if (!fs.existsSync(statePath)) {
+        return freshState();
+    }
+    return JSON.parse(fs.readFileSync(statePath, "utf8"));
+}
+export function writeState(state) {
+    fs.writeFileSync(ctxcarryPath("state.json"), JSON.stringify(redactValue(state), null, 2) + "\n");
+}
+export function appendEvent(event) {
+    ensureInitialized();
+    const fullEvent = redactValue({
+        ...event,
+        timestamp: event.timestamp ?? new Date().toISOString(),
+    });
+    fs.appendFileSync(ctxcarryPath("events.jsonl"), JSON.stringify(fullEvent) + "\n");
+    if (fullEvent.type === "command_run") {
+        fs.appendFileSync(ctxcarryPath("commands.jsonl"), JSON.stringify(fullEvent) + "\n");
+    }
+    return fullEvent;
+}
+export function readEvents() {
+    ensureInitialized();
+    const file = ctxcarryPath("events.jsonl");
+    if (!fs.existsSync(file)) {
+        return [];
+    }
+    return fs
+        .readFileSync(file, "utf8")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+export function writeMarkdownState(markdown) {
+    const redacted = redactText(markdown);
+    fs.writeFileSync(ctxcarryPath("state.md"), redacted.endsWith("\n") ? redacted : redacted + "\n");
+}
+export function writeHandoff(agent, markdown) {
+    const output = ctxcarryPath("ctxcarrys", `${agent}.md`);
+    const redacted = redactText(markdown);
+    fs.writeFileSync(output, redacted.endsWith("\n") ? redacted : redacted + "\n");
+    return output;
+}
+export function writeManagedFile(filePath, markdown) {
+    const absolutePath = rootPath(filePath);
+    fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+    const start = "<!-- ctxcarry:start -->";
+    const end = "<!-- ctxcarry:end -->";
+    const block = `${start}\n${redactText(markdown).trim()}\n${end}`;
+    if (!fs.existsSync(absolutePath)) {
+        fs.writeFileSync(absolutePath, `${block}\n`);
+        return;
+    }
+    const existing = fs.readFileSync(absolutePath, "utf8");
+    const pattern = new RegExp(`${escapeRegExp(start)}[\\s\\S]*?${escapeRegExp(end)}`);
+    const next = pattern.test(existing) ? existing.replace(pattern, block) : `${existing.trimEnd()}\n\n${block}\n`;
+    fs.writeFileSync(absolutePath, next.endsWith("\n") ? next : next + "\n");
+}
+export function freshState() {
+    return {
+        ...DEFAULT_STATE,
+        updatedAt: new Date().toISOString(),
+        persistent: { ...DEFAULT_STATE.persistent },
+        working: {
+            ...DEFAULT_STATE.working,
+            touchedFiles: [],
+            constraints: [],
+            failures: [],
+            todos: [],
+            nextSteps: [],
+            lastCommands: []
+        },
+        episodic: {
+            sessions: [],
+            decisions: [],
+            attempts: [],
+            resolved: []
+        }
+    };
+}
+function writeFileIfMissing(filePath, content) {
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, content);
+    }
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function ctxcarryDirName() {
+    return CTXCARRY_DIR;
+}

package/dist/summarizers/openai.js

@@ -0,0 +1,41 @@
+export class OpenAISummarizer {
+    apiKey;
+    model;
+    constructor(apiKey = process.env.OPENAI_API_KEY, model = process.env.CTXCARRY_OPENAI_MODEL) {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async summarize(input) {
+        if (!this.apiKey) {
+            throw new Error("OPENAI_API_KEY is required for OpenAI summarization.");
+        }
+        if (!this.model) {
+            throw new Error("CTXCARRY_OPENAI_MODEL is required for OpenAI summarization.");
+        }
+        const response = await fetch("https://api.openai.com/v1/responses", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                model: this.model,
+                input: [
+                    {
+                        role: "system",
+                        content: "Summarize coding-agent session history into compact project ctxcarry state. Preserve decisions, failures, files, constraints, and next steps."
+                    },
+                    {
+                        role: "user",
+                        content: `Budget: ${input.budgetTokens} tokens\n\n${input.text}`
+                    }
+                ]
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`OpenAI summarization failed with HTTP ${response.status}.`);
+        }
+        const json = (await response.json());
+        return json.output_text?.trim() ?? "";
+    }
+}