@mcoda/mswarm 0.1.57 → 0.1.60

package/dist/vendor/codali/runtime/Runner.js

@@ -0,0 +1,215 @@
+export class RunnerBudgetError extends Error {
+    constructor(code, metadata) {
+        super(code === "runner_timeout_exceeded"
+            ? "Runner timeout exceeded"
+            : code === "runner_tool_call_limit_exceeded"
+                ? "Tool call limit exceeded"
+                : "Runner step limit exceeded");
+        this.name = "RunnerBudgetError";
+        this.code = code;
+        this.metadata = {
+            reason_code: code,
+            ...metadata,
+        };
+    }
+}
+const buildToolMessage = (call, content) => ({
+    role: "tool",
+    content,
+    toolCallId: call.id,
+    name: call.name,
+});
+export class Runner {
+    constructor(options) {
+        this.provider = options.provider;
+        this.tools = options.tools;
+        this.context = options.context;
+        this.maxSteps = options.maxSteps;
+        this.maxToolCalls = options.maxToolCalls;
+        this.maxTokens = options.maxTokens;
+        this.temperature = options.temperature;
+        this.responseFormat = options.responseFormat;
+        this.toolChoice = options.toolChoice;
+        this.stream = options.stream;
+        this.onEvent = options.onEvent;
+        this.onToken = options.onToken;
+        this.streamFlushMs = options.streamFlushMs;
+        this.timeoutMs = options.timeoutMs;
+        this.logger = options.logger;
+    }
+    async run(initialMessages) {
+        const messages = [...initialMessages];
+        let toolCallsExecuted = 0;
+        let usageTotals;
+        const deadline = this.timeoutMs ? Date.now() + this.timeoutMs : undefined;
+        const emitEvent = (event) => {
+            if (this.onEvent) {
+                this.onEvent(event);
+                return;
+            }
+            if (event.type === "token") {
+                this.onToken?.(event.content);
+            }
+        };
+        const emitStatus = (phase, message) => {
+            this.onEvent?.({ type: "status", phase, message });
+        };
+        const recordUsage = (usage) => {
+            if (!usage)
+                return;
+            if (!usageTotals)
+                usageTotals = {};
+            if (usage.inputTokens !== undefined) {
+                usageTotals.inputTokens = (usageTotals.inputTokens ?? 0) + usage.inputTokens;
+            }
+            if (usage.outputTokens !== undefined) {
+                usageTotals.outputTokens = (usageTotals.outputTokens ?? 0) + usage.outputTokens;
+            }
+            if (usage.totalTokens !== undefined) {
+                usageTotals.totalTokens = (usageTotals.totalTokens ?? 0) + usage.totalTokens;
+            }
+        };
+        const timeRemaining = () => {
+            if (!deadline)
+                return undefined;
+            return deadline - Date.now();
+        };
+        const throwBudgetError = async (code, step) => {
+            const error = new RunnerBudgetError(code, {
+                step,
+                tool_calls_executed: toolCallsExecuted,
+                max_steps: this.maxSteps,
+                max_tool_calls: this.maxToolCalls,
+                timeout_ms: this.timeoutMs,
+            });
+            if (this.logger) {
+                await this.logger.log("runner_budget_failure", error.metadata);
+            }
+            throw error;
+        };
+        const withTimeout = async (promise, label) => {
+            const remaining = timeRemaining();
+            if (remaining === undefined)
+                return promise;
+            if (remaining <= 0) {
+                await throwBudgetError("runner_timeout_exceeded", -1);
+            }
+            let timeoutId;
+            const timeoutPromise = new Promise((_, reject) => {
+                timeoutId = setTimeout(() => reject(new Error("Runner timeout exceeded")), remaining);
+            });
+            try {
+                return await Promise.race([promise, timeoutPromise]);
+            }
+            catch (error) {
+                if (error instanceof Error && /Runner timeout exceeded/i.test(error.message)) {
+                    await throwBudgetError("runner_timeout_exceeded", -1);
+                }
+                throw error;
+            }
+            finally {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+            }
+        };
+        for (let step = 0; step < this.maxSteps; step += 1) {
+            if (deadline && timeRemaining() <= 0) {
+                await throwBudgetError("runner_timeout_exceeded", step);
+            }
+            const toolSpecs = this.tools.describe().map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+            }));
+            const allowTools = toolSpecs.length > 0 && this.toolChoice !== "none";
+            emitStatus("thinking");
+            if (this.logger) {
+                await this.logger.log("provider_request", {
+                    provider: this.provider.name,
+                    messages,
+                    tools: allowTools ? toolSpecs : [],
+                    toolChoice: allowTools ? this.toolChoice ?? "auto" : "none",
+                    responseFormat: this.responseFormat,
+                    temperature: this.temperature,
+                    maxTokens: this.maxTokens,
+                    stream: this.stream ?? false,
+                });
+            }
+            const response = await withTimeout(this.provider.generate({
+                messages,
+                tools: allowTools ? toolSpecs : undefined,
+                toolChoice: allowTools ? this.toolChoice ?? "auto" : undefined,
+                maxTokens: this.maxTokens,
+                temperature: this.temperature,
+                responseFormat: this.responseFormat,
+                stream: this.stream,
+                onEvent: emitEvent,
+                onToken: (token) => emitEvent({ type: "token", content: token }),
+                streamFlushMs: this.streamFlushMs,
+            }), "provider");
+            recordUsage(response.usage);
+            messages.push(response.message);
+            if (this.logger) {
+                await this.logger.log("provider_response", {
+                    message: response.message,
+                    toolCalls: response.toolCalls,
+                    usage: response.usage,
+                });
+            }
+            if (!response.toolCalls || response.toolCalls.length === 0) {
+                return {
+                    finalMessage: response.message,
+                    messages,
+                    toolCallsExecuted,
+                    usage: usageTotals,
+                };
+            }
+            for (const call of response.toolCalls) {
+                if (toolCallsExecuted >= this.maxToolCalls) {
+                    await throwBudgetError("runner_tool_call_limit_exceeded", step);
+                }
+                toolCallsExecuted += 1;
+                emitStatus("executing", call.name);
+                this.onEvent?.({ type: "tool_call", name: call.name, args: call.args });
+                const result = await withTimeout(this.tools.execute(call.name, call.args, this.context), "tool");
+                const toolError = result.error;
+                const content = result.ok
+                    ? result.output
+                    : `ERROR[${toolError?.code ?? "tool_execution_failed"}]: ${toolError?.message ?? "tool failed"}`;
+                messages.push(buildToolMessage(call, content));
+                this.onEvent?.({
+                    type: "tool_result",
+                    name: call.name,
+                    output: content,
+                    ok: result.ok,
+                    errorCode: toolError?.code,
+                    retryable: toolError?.retryable,
+                });
+                if (this.logger) {
+                    await this.logger.log("tool_call", {
+                        name: call.name,
+                        ok: result.ok,
+                        error: toolError?.message,
+                        error_code: toolError?.code,
+                        error_category: toolError?.category,
+                        error_retryable: toolError?.retryable,
+                        error_details: toolError?.details,
+                    });
+                    if (toolError) {
+                        await this.logger.logSafetyEvent({
+                            phase: "act",
+                            category: "tool",
+                            code: toolError.code,
+                            disposition: toolError.retryable ? "retryable" : "non_retryable",
+                            tool: call.name,
+                            message: toolError.message,
+                            details: toolError.details,
+                        });
+                    }
+                }
+            }
+        }
+        await throwBudgetError("runner_step_limit_exceeded", this.maxSteps);
+        throw new Error("unreachable_runner_budget_path");
+    }
+}

package/dist/vendor/codali/runtime/StoragePaths.d.ts

@@ -0,0 +1,3 @@
+export declare const getGlobalMcodaDir: () => string;
+export declare const getGlobalWorkspaceDir: (workspaceRoot: string) => string;
+//# sourceMappingURL=StoragePaths.d.ts.map

package/dist/vendor/codali/runtime/StoragePaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StoragePaths.d.ts","sourceRoot":"","sources":["../../src/runtime/StoragePaths.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,iBAAiB,QAAO,MAIpC,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,eAAe,MAAM,KAAG,MAM7D,CAAC"}

package/dist/vendor/codali/runtime/StoragePaths.js

@@ -0,0 +1,19 @@
+import os from "node:os";
+import path from "node:path";
+import { createHash } from "node:crypto";
+const normalizePathCase = (value) => {
+    const normalized = path.normalize(value);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+};
+export const getGlobalMcodaDir = () => {
+    const envHome = process.env.HOME ?? process.env.USERPROFILE;
+    const homeDir = envHome && envHome.trim().length > 0 ? envHome : os.homedir();
+    return path.join(homeDir, ".mcoda");
+};
+export const getGlobalWorkspaceDir = (workspaceRoot) => {
+    const normalizedRoot = normalizePathCase(path.resolve(workspaceRoot));
+    const hash = createHash("sha256").update(normalizedRoot).digest("hex").slice(0, 12);
+    const rawName = path.basename(normalizedRoot) || "workspace";
+    const safeName = rawName.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 32) || "workspace";
+    return path.join(getGlobalMcodaDir(), "workspaces", `${safeName}-${hash}`);
+};

package/dist/vendor/codali/runtime/WorkspaceLock.d.ts

@@ -0,0 +1,30 @@
+export interface WorkspaceLockInfo {
+    runId: string;
+    acquiredAt: number;
+    pid?: number;
+    hostname?: string;
+}
+export interface WorkspaceLockSignalOptions {
+    exitOnSignal?: boolean;
+    onSignal?: (signal: NodeJS.Signals) => void | Promise<void>;
+    exitCodeForSignal?: (signal: NodeJS.Signals) => number;
+}
+export declare class WorkspaceLock {
+    private workspaceRoot;
+    private runId;
+    private maxAgeMs;
+    private lockPath;
+    private acquired;
+    private readonly hostname;
+    constructor(workspaceRoot: string, runId: string, maxAgeMs?: number);
+    private readLock;
+    private isStale;
+    private isSameHost;
+    private isProcessAlive;
+    private hasTerminalRunLog;
+    private shouldClearExisting;
+    acquire(): Promise<void>;
+    release(): Promise<void>;
+    registerSignalHandlers(options?: WorkspaceLockSignalOptions): () => void;
+}
+//# sourceMappingURL=WorkspaceLock.d.ts.map

package/dist/vendor/codali/runtime/WorkspaceLock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkspaceLock.d.ts","sourceRoot":"","sources":["../../src/runtime/WorkspaceLock.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,0BAA0B;IACzC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,iBAAiB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,KAAK,MAAM,CAAC;CACxD;AAED,qBAAa,aAAa;IAMtB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,QAAQ;IAPlB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;gBAGhC,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,EACb,QAAQ,GAAE,MAAuB;YAK7B,QAAQ;IAStB,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,cAAc;YAcR,iBAAiB;YAuBjB,mBAAmB;IAQ3B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAmBxB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAU9B,sBAAsB,CAAC,OAAO,GAAE,0BAA+B,GAAG,MAAM,IAAI;CAmC7E"}

package/dist/vendor/codali/runtime/WorkspaceLock.js

@@ -0,0 +1,141 @@
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export class WorkspaceLock {
+    constructor(workspaceRoot, runId, maxAgeMs = 60 * 60 * 1000) {
+        this.workspaceRoot = workspaceRoot;
+        this.runId = runId;
+        this.maxAgeMs = maxAgeMs;
+        this.acquired = false;
+        this.hostname = os.hostname();
+        this.lockPath = path.join(this.workspaceRoot, "locks", "codali.lock");
+    }
+    async readLock() {
+        try {
+            const raw = await fs.readFile(this.lockPath, "utf8");
+            return JSON.parse(raw);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    isStale(info) {
+        return Date.now() - info.acquiredAt > this.maxAgeMs;
+    }
+    isSameHost(info) {
+        return !info.hostname || info.hostname === this.hostname;
+    }
+    isProcessAlive(info) {
+        if (!this.isSameHost(info))
+            return undefined;
+        if (!Number.isInteger(info.pid) || (info.pid ?? 0) <= 0)
+            return undefined;
+        try {
+            process.kill(info.pid, 0);
+            return true;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ESRCH")
+                return false;
+            if (code === "EPERM")
+                return true;
+            return undefined;
+        }
+    }
+    async hasTerminalRunLog(runId) {
+        const logPath = path.join(this.workspaceRoot, "logs", `${runId}.jsonl`);
+        try {
+            const content = await fs.readFile(logPath, "utf8");
+            const lines = content.split("\n");
+            for (let index = lines.length - 1; index >= 0; index -= 1) {
+                const line = lines[index]?.trim();
+                if (!line)
+                    continue;
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed.type === "run_summary" || parsed.type === "run_failed" || parsed.type === "run_cancelled") {
+                        return true;
+                    }
+                }
+                catch {
+                    // Ignore malformed log lines and continue scanning older entries.
+                }
+            }
+        }
+        catch {
+            return false;
+        }
+        return false;
+    }
+    async shouldClearExisting(info) {
+        if (this.isStale(info))
+            return true;
+        const processAlive = this.isProcessAlive(info);
+        if (processAlive === false)
+            return true;
+        if (processAlive === true)
+            return false;
+        return this.hasTerminalRunLog(info.runId);
+    }
+    async acquire() {
+        await fs.mkdir(path.dirname(this.lockPath), { recursive: true });
+        const existing = await this.readLock();
+        if (existing && !(await this.shouldClearExisting(existing))) {
+            throw new Error(`Workspace is locked by run ${existing.runId}`);
+        }
+        if (existing) {
+            await fs.unlink(this.lockPath).catch(() => undefined);
+        }
+        const payload = {
+            runId: this.runId,
+            acquiredAt: Date.now(),
+            pid: process.pid,
+            hostname: this.hostname,
+        };
+        await fs.writeFile(this.lockPath, JSON.stringify(payload, null, 2), "utf8");
+        this.acquired = true;
+    }
+    async release() {
+        if (!this.acquired)
+            return;
+        const existing = await this.readLock();
+        if (existing?.runId && existing.runId !== this.runId) {
+            return;
+        }
+        await fs.unlink(this.lockPath).catch(() => undefined);
+        this.acquired = false;
+    }
+    registerSignalHandlers(options = {}) {
+        const exitOnSignal = options.exitOnSignal ?? true;
+        const exitCodeForSignal = options.exitCodeForSignal ?? ((signal) => (signal === "SIGTERM" ? 143 : 130));
+        let handled = false;
+        const listeners = new Map();
+        const signals = ["SIGINT", "SIGTERM", "SIGTSTP", "SIGQUIT", "SIGHUP"];
+        const handler = (signal) => {
+            if (handled)
+                return;
+            handled = true;
+            const releasePromise = this.release().catch(() => undefined);
+            // Fire and forget any extra signal handling to avoid delaying unlock/exit.
+            Promise.resolve(options.onSignal?.(signal)).catch(() => undefined);
+            releasePromise.finally(() => {
+                if (exitOnSignal) {
+                    process.exitCode = exitCodeForSignal(signal);
+                    process.exit();
+                }
+            });
+        };
+        for (const signal of signals) {
+            const listener = () => handler(signal);
+            listeners.set(signal, listener);
+            process.once(signal, listener);
+        }
+        return () => {
+            for (const [signal, listener] of listeners.entries()) {
+                process.off(signal, listener);
+            }
+            listeners.clear();
+        };
+    }
+}

package/dist/vendor/codali/session/InstructionLoader.d.ts

@@ -0,0 +1,14 @@
+export interface InstructionBlock {
+    sourcePath: string;
+    scope: string;
+    precedence: number;
+    content: string;
+}
+export interface InstructionLoadOptions {
+    workspaceRoot: string;
+    focusPaths?: string[];
+    includeLocal?: boolean;
+}
+export declare const loadInstructionBlocks: (options: InstructionLoadOptions) => Promise<InstructionBlock[]>;
+export declare const formatInstructionBlocks: (blocks: InstructionBlock[]) => string;
+//# sourceMappingURL=InstructionLoader.d.ts.map

package/dist/vendor/codali/session/InstructionLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstructionLoader.d.ts","sourceRoot":"","sources":["../../src/session/InstructionLoader.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAoED,eAAO,MAAM,qBAAqB,GAChC,SAAS,sBAAsB,KAC9B,OAAO,CAAC,gBAAgB,EAAE,CAiC5B,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,gBAAgB,EAAE,KAAG,MAWpE,CAAC"}

package/dist/vendor/codali/session/InstructionLoader.js

@@ -0,0 +1,107 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const fileExists = async (filePath) => {
+    try {
+        const stat = await fs.stat(filePath);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+};
+const normalizeFocusPath = (workspaceRoot, value) => {
+    const resolved = path.resolve(workspaceRoot, value);
+    const relative = path.relative(workspaceRoot, resolved);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error("Instruction focus path is outside workspace root");
+    }
+    return resolved;
+};
+const focusDirForPath = async (workspaceRoot, value) => {
+    const resolved = normalizeFocusPath(workspaceRoot, value);
+    try {
+        const stat = await fs.stat(resolved);
+        return stat.isDirectory() ? resolved : path.dirname(resolved);
+    }
+    catch {
+        return path.extname(resolved) ? path.dirname(resolved) : resolved;
+    }
+};
+const ancestorDirs = (workspaceRoot, targetDir) => {
+    const dirs = [];
+    let current = path.resolve(targetDir);
+    const root = path.resolve(workspaceRoot);
+    while (true) {
+        const relative = path.relative(root, current);
+        if (relative.startsWith("..") || path.isAbsolute(relative))
+            break;
+        dirs.push(current);
+        if (current === root)
+            break;
+        current = path.dirname(current);
+    }
+    return dirs.reverse();
+};
+const toRepoRelativePath = (workspaceRoot, filePath) => {
+    const relative = path.relative(workspaceRoot, filePath) || path.basename(filePath);
+    return relative.split(path.sep).join("/");
+};
+const readBlock = async (workspaceRoot, filePath, precedence) => {
+    if (!(await fileExists(filePath)))
+        return undefined;
+    const content = await fs.readFile(filePath, "utf8");
+    if (!content.trim())
+        return undefined;
+    const relative = toRepoRelativePath(workspaceRoot, filePath);
+    const sourceDir = path.posix.dirname(relative);
+    const scope = sourceDir === "." ? "." : sourceDir;
+    return {
+        sourcePath: relative,
+        scope,
+        precedence,
+        content,
+    };
+};
+export const loadInstructionBlocks = async (options) => {
+    const workspaceRoot = path.resolve(options.workspaceRoot);
+    const includeLocal = options.includeLocal ?? true;
+    const focusPaths = options.focusPaths?.length ? options.focusPaths : ["."];
+    const blocks = [];
+    const seen = new Set();
+    let precedence = 0;
+    const addFile = async (filePath) => {
+        const resolved = path.resolve(filePath);
+        if (seen.has(resolved))
+            return;
+        seen.add(resolved);
+        const block = await readBlock(workspaceRoot, resolved, precedence);
+        precedence += 1;
+        if (block)
+            blocks.push(block);
+    };
+    await addFile(path.join(workspaceRoot, ".codali", "instructions.md"));
+    const dirs = new Set();
+    for (const focusPath of focusPaths) {
+        const focusDir = await focusDirForPath(workspaceRoot, focusPath);
+        for (const dir of ancestorDirs(workspaceRoot, focusDir))
+            dirs.add(dir);
+    }
+    for (const dir of Array.from(dirs).sort((a, b) => a.length - b.length || a.localeCompare(b))) {
+        await addFile(path.join(dir, "AGENTS.md"));
+    }
+    if (includeLocal) {
+        await addFile(path.join(workspaceRoot, ".codali", "local.md"));
+    }
+    return blocks.sort((a, b) => a.precedence - b.precedence);
+};
+export const formatInstructionBlocks = (blocks) => {
+    if (!blocks.length)
+        return "";
+    return blocks
+        .map((block) => [
+        `Instruction source: ${block.sourcePath}`,
+        `Scope: ${block.scope}`,
+        block.content.trim(),
+    ].join("\n"))
+        .join("\n\n---\n\n");
+};

package/dist/vendor/codali/session/SessionStore.d.ts

@@ -0,0 +1,81 @@
+export type CodaliSessionStatus = "active" | "paused" | "completed" | "failed";
+export interface CodaliSessionMetadata {
+    schemaVersion: 1;
+    sessionId: string;
+    repoRoot: string;
+    task: string;
+    status: CodaliSessionStatus;
+    branch?: string;
+    parentSessionId?: string;
+    runIds: string[];
+    transcriptRefs: string[];
+    summaryRefs: string[];
+    contextLaneRefs: string[];
+    instructionSources: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export type CodaliSessionTranscriptEventType = "run_started" | "provider_request" | "provider_response" | "tool_result" | "codali_response" | "subagent_result" | "final" | "error" | "note";
+export interface CodaliSessionTranscriptEvent {
+    schemaVersion: 1;
+    sessionId: string;
+    type: CodaliSessionTranscriptEventType;
+    timestamp: string;
+    runId?: string;
+    data: Record<string, unknown>;
+}
+export interface CodaliSessionSummary {
+    schemaVersion: 1;
+    sessionId: string;
+    createdAt: string;
+    eventCount: number;
+    summary: string;
+    highlights: string[];
+}
+export interface CodaliResumeBundle {
+    metadata: CodaliSessionMetadata;
+    latestSummary?: CodaliSessionSummary;
+    recentEvents: CodaliSessionTranscriptEvent[];
+}
+export interface SessionStoreOptions {
+    workspaceRoot: string;
+    storageDir?: string;
+}
+export interface CreateSessionInput {
+    sessionId?: string;
+    repoRoot: string;
+    task: string;
+    status?: CodaliSessionStatus;
+    branch?: string;
+    parentSessionId?: string;
+    contextLaneRefs?: string[];
+    instructionSources?: string[];
+}
+export declare class SessionStore {
+    readonly workspaceRoot: string;
+    readonly storageDir: string;
+    private lastTimestampMs;
+    constructor(options: SessionStoreOptions);
+    private rootDir;
+    private sessionDir;
+    private metadataPath;
+    private transcriptPath;
+    private summariesDir;
+    private nextTimestampIso;
+    createSession(input: CreateSessionInput): Promise<CodaliSessionMetadata>;
+    readSession(sessionId: string): Promise<CodaliSessionMetadata>;
+    getOrCreateSession(input: CreateSessionInput): Promise<CodaliSessionMetadata>;
+    updateSession(sessionId: string, patch: Partial<Omit<CodaliSessionMetadata, "schemaVersion" | "sessionId" | "createdAt">>): Promise<CodaliSessionMetadata>;
+    addRun(sessionId: string, runId: string): Promise<CodaliSessionMetadata>;
+    appendTranscript(sessionId: string, event: Omit<CodaliSessionTranscriptEvent, "schemaVersion" | "sessionId" | "timestamp"> & {
+        timestamp?: string;
+    }): Promise<CodaliSessionTranscriptEvent>;
+    readTranscript(sessionId: string): Promise<CodaliSessionTranscriptEvent[]>;
+    listSessions(): Promise<CodaliSessionMetadata[]>;
+    compactSession(sessionId: string): Promise<CodaliSessionSummary>;
+    readLatestSummary(sessionId: string): Promise<CodaliSessionSummary | undefined>;
+    buildResumeBundle(sessionId: string, options?: {
+        recentEvents?: number;
+    }): Promise<CodaliResumeBundle>;
+}
+//# sourceMappingURL=SessionStore.d.ts.map

package/dist/vendor/codali/session/SessionStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionStore.d.ts","sourceRoot":"","sources":["../../src/session/SessionStore.ts"],"names":[],"mappings":"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"}