@sema-agent/core 7.48.0 → 7.49.0

package/dist/stores/cc/roster-adapter.js

@@ -1,117 +0,0 @@
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
-import { basename, join, resolve } from "node:path";
-import { entryAccessible } from "../../agents/roster-store.js";
-import { normalizeAgentName } from "../../core/task-registry.js";
-import { atomicWriteFile } from "../file/fs-atomic.js";
-import { withCcLock } from "./lockfile.js";
-export function createCcTeamsRosterAdapter(opts) {
-    const scope = opts.scope ?? "default";
-    if (scope !== "default") {
-        throw new Error(`CcTeamsRosterAdapter: CC team files carry no tenant axis — this adapter is licensed for single-tenant scope:"default" deployments only (D-1); got scope ${JSON.stringify(scope)}`);
-    }
-    const dir = resolve(opts.teamDir);
-    const configPath = join(dir, "config.json");
-    const now = opts.now ?? Date.now;
-    const load = () => {
-        try {
-            return JSON.parse(readFileSync(configPath, "utf8"));
-        }
-        catch (err) {
-            if (err.code === "ENOENT")
-                return undefined;
-            throw err;
-        }
-    };
-    const save = (config) => {
-        atomicWriteFile(dir, configPath, JSON.stringify(config, null, 2));
-    };
-    const toEntry = (m) => ({
-        name: m.name,
-        agentId: m.agentId,
-        ...(typeof m.semaSessionId === "string" ? { sessionId: m.semaSessionId } : {}),
-        ...(typeof m.semaToolUseId === "string" ? { toolUseId: m.semaToolUseId } : {}),
-        ...(typeof m.semaRootSessionId === "string" ? { rootSessionId: m.semaRootSessionId } : {}),
-        ...(typeof m.semaModel === "string" ? { model: m.semaModel } : {}),
-        ...(m.semaSessionScoped === true ? { sessionScoped: true } : {}),
-        owner: typeof m.semaOwner === "string" ? m.semaOwner : opts.owner,
-        scope,
-        createdAt: typeof m.joinedAt === "number" ? m.joinedAt : 0,
-    });
-    const absent = () => !existsSync(configPath);
-    return {
-        record: (entry) => {
-            if (entry.scope !== scope) {
-                throw new Error(`CcTeamsRosterAdapter: cannot record entry with scope ${JSON.stringify(entry.scope)} — this adapter persists scope:"${scope}" bindings only (D-1 single-tenant)`);
-            }
-            mkdirSync(dir, { recursive: true });
-            return withCcLock(configPath, () => {
-                const config = load() ?? {
-                    name: basename(dir),
-                    createdAt: now(),
-                    members: [],
-                };
-                const members = Array.isArray(config.members) ? config.members : [];
-                const prior = members.find((m) => m.agentId === entry.agentId);
-                const member = {
-                    ...(prior ?? {}),
-                    agentId: entry.agentId,
-                    name: entry.name,
-                    ...(entry.model !== undefined ? { semaModel: entry.model } : {}),
-                    ...(entry.sessionId !== undefined ? { semaSessionId: entry.sessionId } : {}),
-                    ...(entry.toolUseId !== undefined ? { semaToolUseId: entry.toolUseId } : {}),
-                    ...(entry.rootSessionId !== undefined ? { semaRootSessionId: entry.rootSessionId } : {}),
-                    ...(entry.sessionScoped === true ? { semaSessionScoped: true } : {}),
-                    semaOwner: entry.owner,
-                    joinedAt: entry.createdAt,
-                };
-                config.members = [...members.filter((m) => m.agentId !== entry.agentId), member];
-                save(config);
-            });
-        },
-        resolve: (name, access) => {
-            if (absent())
-                return undefined;
-            return withCcLock(configPath, () => {
-                const config = load();
-                if (config === undefined || !Array.isArray(config.members))
-                    return undefined;
-                const key = normalizeAgentName(name);
-                if (key === "")
-                    return undefined;
-                const pool = config.members
-                    .filter((m) => typeof m.agentId === "string" && typeof m.name === "string")
-                    .map(toEntry)
-                    .filter((e) => normalizeAgentName(e.name) === key && entryAccessible(e, access));
-                let best;
-                for (const e of pool)
-                    if (best === undefined || e.createdAt >= best.createdAt)
-                        best = e;
-                return best;
-            });
-        },
-        list: () => {
-            if (absent())
-                return [];
-            return withCcLock(configPath, () => {
-                const config = load();
-                if (config === undefined || !Array.isArray(config.members))
-                    return [];
-                return config.members.filter((m) => typeof m.agentId === "string" && typeof m.name === "string").map(toEntry);
-            });
-        },
-        releaseAgent: (agentId) => {
-            if (absent())
-                return;
-            return withCcLock(configPath, () => {
-                const config = load();
-                if (config === undefined || !Array.isArray(config.members))
-                    return;
-                const next = config.members.filter((m) => m.agentId !== agentId);
-                if (next.length === config.members.length)
-                    return;
-                config.members = next;
-                save(config);
-            });
-        },
-    };
-}

package/dist/stores/cc/sidecar-transcript.d.ts

@@ -1,97 +0,0 @@
-import type { Message } from "../../internal/llm.js";
-/**
- * design/152 S4b D-2 — READ-ONLY adapter over the Claude Code subagent transcript sidecars
- * (`~/.claude/projects/<proj>/<sid>/subagents/agent-<id>.jsonl` + companion
- * `agent-<id>.meta.json`), so a sema engine taking over a CC-created team (D-3: sequential
- * handover) can enumerate the teammates' transcript sidecars and project them into sema message
- * shapes for resume context.
- *
- * D-2 ruling (design/152 §3): the sidecar is CC→sema ONE-WAY. sema's transcript truth source
- * is the SessionStore — this module never writes, and nothing here mints a second truth source
- * (the dual-truth-source pathology design/151 just eliminated stays eliminated). Dual-write is a
- * separate ruling gated on a real user need.
- *
- * Disk shape (cc-teams-diskform README):
- *  - flat sidecars:    `subagents/agent-<id>.jsonl`
- *  - nested children:  `subagents/<parentSeg>/agent-<id>.jsonl` (parent-segment subdirectories)
- *  - workflow runs:    `subagents/workflows/<runId>/agent-<t>.jsonl`
- *  - remote agents:    `subagents/remote-agents/...` (CC's own migration walks the three siblings;
- *    we walk EVERY subdirectory — symlinks are not followed)
- *  - companion meta:   `agent-<id>.meta.json` = `{agentType, description, name, toolUseId,
- *    spawnDepth}` (revival lookup keys; same family as BackgroundAgentRecord's meta-sidecar parity
- *    fields). Absent meta is tolerated (fail-soft) — the jsonl alone still enumerates.
- *
- * Line container = the CC session-entry envelope (same container as the main-session transcript):
- * `{type:"user"|"assistant", message:{...}, uuid, parentUuid, timestamp, ...}` interleaved with
- * attachment/marker lines that carry no `message`. Projection keeps ONLY the message-bearing
- * user/assistant lines; everything else is counted, never silently vanished.
- *
- * Locking: none. CC appends whole lines; reads tolerate a torn trailing line as one malformed line
- * (counted). D-3 promises sequential handover only — a concurrently-writing CC process is outside
- * the supported envelope, and read-side locks would not widen it.
- */
-/** Companion `agent-<id>.meta.json` shape (loose — unknown keys ride through verbatim). */
-export interface CcSidecarMeta extends Record<string, unknown> {
-    agentType?: string;
-    description?: string;
-    name?: string;
-    toolUseId?: string;
-    spawnDepth?: number;
-}
-/** One enumerated sidecar transcript (jsonl + optional companion meta). */
-export interface CcSidecarHandle {
-    /** The `<id>` from the `agent-<id>.jsonl` filename. */
-    agentId: string;
-    /** Absolute path to the transcript jsonl. */
-    jsonlPath: string;
-    /** Directory segments under `subagents/` (nesting/workflows/remote-agents); flat sidecar = []. */
-    segments: string[];
-    /** Parsed companion meta; `undefined` when the meta file is absent or unparseable (fail-soft). */
-    meta?: CcSidecarMeta;
-}
-/**
- * Enumerate every transcript sidecar under a CC `subagents/` directory, walking nested
- * parent-segment subdirectories (symlinks not followed). Missing directory ⇒ `[]` — the CC tree is
- * a PARTIAL tree (headless runs write sidecars but a REPL-only subtree may be absent entirely), so
- * absence is a normal state, never a throw.
- * Order is deterministic: lexicographic by (segments join, agentId).
- */
-export declare function listCcSidecarAgents(subagentsDir: string): CcSidecarHandle[];
-/** One parsed jsonl line, verbatim (the raw CC session-entry envelope). */
-export interface CcSidecarLine {
-    raw: Record<string, unknown>;
-}
-/** A parsed sidecar transcript: verbatim lines + an honest malformed-line count. */
-export interface CcSidecarTranscript {
-    lines: CcSidecarLine[];
-    /** Lines that failed JSON.parse or were not objects (e.g. a torn trailing append). */
-    malformedLines: number;
-}
-export declare function readCcSidecarTranscript(jsonlPath: string): CcSidecarTranscript;
-/** Projection result: sema-shaped messages + honest counts for what was NOT projected. */
-export interface CcSidecarMessages {
-    messages: Message[];
-    /** Envelope lines without a projectable user/assistant message (attachments, markers, …). */
-    skippedLines: number;
-}
-/**
- * Project parsed sidecar lines into sema message shapes for resume context.
- *
- * Mapping (CC session-entry → sema):
- *  - `type:"user"`, string content            → {@link UserMessage} verbatim.
- *  - `type:"user"`, array content             → contiguous `text`/`image` runs fold into
- *    {@link UserMessage}s and `tool_result` blocks become {@link ToolResultMessage} rows, in DISK
- *    BLOCK ORDER (toolName recovered from the preceding assistant `tool_use` id — "unknown" when
- *    the pairing is outside the file; base64 image sources map to sema ImageContent).
- *  - `type:"assistant"`                       → {@link AssistantMessage}; `text`/`thinking`/
- *    `redacted_thinking`/`tool_use` blocks map to their sema block shapes; `api:"anthropic-messages"`,
- *    `provider:"claude-code"` (an honest origin label — this transcript was produced by CC, not by
- *    a sema brain), model/usage/stop_reason carried over (`cost` unpriced-zero).
- *  - anything else (attachment lines, marker lines, unknown block types) → counted in
- *    `skippedLines`, never a throw and never a silent drop.
- */
-export declare function ccSidecarToMessages(lines: CcSidecarLine[]): CcSidecarMessages;
-/** Convenience: enumerate + parse + project one sidecar in a single read-only call. */
-export declare function readCcSidecarMessages(handle: CcSidecarHandle): CcSidecarMessages & {
-    malformedLines: number;
-};

package/dist/stores/cc/sidecar-transcript.js

@@ -1,264 +0,0 @@
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-const SIDECAR_RE = /^agent-(.+)\.jsonl$/;
-export function listCcSidecarAgents(subagentsDir) {
-    if (!existsSync(subagentsDir))
-        return [];
-    const out = [];
-    const walk = (dir, segments) => {
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const ent of entries) {
-            if (ent.isDirectory()) {
-                walk(join(dir, ent.name), [...segments, ent.name]);
-                continue;
-            }
-            if (!ent.isFile())
-                continue;
-            const m = SIDECAR_RE.exec(ent.name);
-            if (!m)
-                continue;
-            const agentId = m[1];
-            const jsonlPath = join(dir, ent.name);
-            const metaPath = join(dir, `agent-${agentId}.meta.json`);
-            let meta;
-            if (existsSync(metaPath)) {
-                try {
-                    const parsed = JSON.parse(readFileSync(metaPath, "utf8"));
-                    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-                        meta = parsed;
-                    }
-                }
-                catch {
-                    meta = undefined;
-                }
-            }
-            out.push({ agentId, jsonlPath, segments, meta });
-        }
-    };
-    walk(subagentsDir, []);
-    out.sort((a, b) => {
-        const sa = a.segments.join("/");
-        const sb = b.segments.join("/");
-        return sa < sb ? -1 : sa > sb ? 1 : a.agentId < b.agentId ? -1 : a.agentId > b.agentId ? 1 : 0;
-    });
-    return out;
-}
-function splitLines(bytes) {
-    const out = [];
-    let start = 0;
-    for (let i = 0; i < bytes.length; i++) {
-        if (bytes[i] === 0x0a) {
-            out.push(bytes.subarray(start, i));
-            start = i + 1;
-        }
-    }
-    out.push(bytes.subarray(start));
-    return out;
-}
-export function readCcSidecarTranscript(jsonlPath) {
-    let bytes;
-    try {
-        bytes = readFileSync(jsonlPath);
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === "ENOENT" || code === "ENOTDIR")
-            return { lines: [], malformedLines: 0 };
-        throw err;
-    }
-    const lines = [];
-    let malformedLines = 0;
-    const decoder = new TextDecoder("utf-8", { fatal: true });
-    for (const lineBytes of splitLines(bytes)) {
-        let rawLine;
-        try {
-            rawLine = decoder.decode(lineBytes);
-        }
-        catch {
-            if (lineBytes.length > 0)
-                malformedLines += 1;
-            continue;
-        }
-        if (rawLine.trim() === "")
-            continue;
-        try {
-            const parsed = JSON.parse(rawLine);
-            if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-                lines.push({ raw: parsed });
-            }
-            else {
-                malformedLines += 1;
-            }
-        }
-        catch {
-            malformedLines += 1;
-        }
-    }
-    return { lines, malformedLines };
-}
-function asRecord(v) {
-    return v !== null && typeof v === "object" && !Array.isArray(v) ? v : undefined;
-}
-function toMs(iso) {
-    if (typeof iso !== "string")
-        return 0;
-    const ms = Date.parse(iso);
-    return Number.isFinite(ms) ? ms : 0;
-}
-function num(v) {
-    return typeof v === "number" && Number.isFinite(v) ? v : 0;
-}
-function mapStopReason(v) {
-    switch (v) {
-        case "tool_use":
-            return "toolUse";
-        case "max_tokens":
-            return "length";
-        default:
-            return "stop";
-    }
-}
-function mapUsage(v) {
-    const u = asRecord(v);
-    const input = num(u?.input_tokens);
-    const output = num(u?.output_tokens);
-    const cacheRead = num(u?.cache_read_input_tokens);
-    const cacheWrite = num(u?.cache_creation_input_tokens);
-    return {
-        usage: {
-            input,
-            output,
-            cacheRead,
-            cacheWrite,
-            totalTokens: input + output + cacheRead + cacheWrite,
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-        },
-        usageMissing: u === undefined,
-    };
-}
-export function ccSidecarToMessages(lines) {
-    const messages = [];
-    let skippedLines = 0;
-    const toolNames = new Map();
-    for (const { raw } of lines) {
-        const message = asRecord(raw.message);
-        const timestamp = toMs(raw.timestamp);
-        if (raw.type === "user" && message !== undefined) {
-            const content = message.content;
-            if (typeof content === "string") {
-                const m = { role: "user", content, timestamp };
-                messages.push(m);
-                continue;
-            }
-            if (Array.isArray(content)) {
-                let userBlocks = [];
-                let projectedAny = false;
-                const flushUser = () => {
-                    if (userBlocks.length > 0) {
-                        messages.push({ role: "user", content: userBlocks, timestamp });
-                        userBlocks = [];
-                        projectedAny = true;
-                    }
-                };
-                for (const block of content) {
-                    const b = asRecord(block);
-                    if (b?.type === "text" && typeof b.text === "string") {
-                        userBlocks.push({ type: "text", text: b.text });
-                    }
-                    else if (b?.type === "image") {
-                        const source = asRecord(b.source);
-                        if (source?.type === "base64" && typeof source.data === "string" && typeof source.media_type === "string") {
-                            userBlocks.push({ type: "image", data: source.data, mimeType: source.media_type });
-                        }
-                    }
-                    else if (b?.type === "tool_result" && typeof b.tool_use_id === "string") {
-                        flushUser();
-                        const m = {
-                            role: "toolResult",
-                            toolCallId: b.tool_use_id,
-                            toolName: toolNames.get(b.tool_use_id) ?? "unknown",
-                            content: projectToolResultContent(b.content),
-                            isError: b.is_error === true,
-                            timestamp,
-                        };
-                        messages.push(m);
-                        projectedAny = true;
-                    }
-                }
-                flushUser();
-                if (!projectedAny)
-                    skippedLines += 1;
-                continue;
-            }
-            skippedLines += 1;
-            continue;
-        }
-        if (raw.type === "assistant" && message !== undefined && Array.isArray(message.content)) {
-            const blocks = [];
-            for (const block of message.content) {
-                const b = asRecord(block);
-                if (b?.type === "text" && typeof b.text === "string") {
-                    blocks.push({ type: "text", text: b.text });
-                }
-                else if (b?.type === "thinking" && typeof b.thinking === "string") {
-                    const t = { type: "thinking", thinking: b.thinking };
-                    if (typeof b.signature === "string")
-                        t.thinkingSignature = b.signature;
-                    blocks.push(t);
-                }
-                else if (b?.type === "redacted_thinking" && typeof b.data === "string") {
-                    blocks.push({ type: "thinking", thinking: "", thinkingSignature: b.data, redacted: true });
-                }
-                else if (b?.type === "tool_use" && typeof b.id === "string" && typeof b.name === "string") {
-                    toolNames.set(b.id, b.name);
-                    blocks.push({ type: "toolCall", id: b.id, name: b.name, arguments: asRecord(b.input) ?? {} });
-                }
-            }
-            if (blocks.length === 0) {
-                skippedLines += 1;
-                continue;
-            }
-            const { usage, usageMissing } = mapUsage(message.usage);
-            const m = {
-                role: "assistant",
-                content: blocks,
-                api: "anthropic-messages",
-                provider: "claude-code",
-                model: typeof message.model === "string" ? message.model : "unknown",
-                usage,
-                stopReason: mapStopReason(message.stop_reason),
-                timestamp,
-            };
-            if (usageMissing)
-                m.usageMissing = true;
-            messages.push(m);
-            continue;
-        }
-        skippedLines += 1;
-    }
-    return { messages, skippedLines };
-}
-function projectToolResultContent(content) {
-    if (typeof content === "string")
-        return [{ type: "text", text: content }];
-    if (!Array.isArray(content))
-        return [];
-    const out = [];
-    for (const block of content) {
-        const b = asRecord(block);
-        if (b?.type === "text" && typeof b.text === "string")
-            out.push({ type: "text", text: b.text });
-    }
-    return out;
-}
-export function readCcSidecarMessages(handle) {
-    const { lines, malformedLines } = readCcSidecarTranscript(handle.jsonlPath);
-    const projected = ccSidecarToMessages(lines);
-    return { ...projected, malformedLines };
-}

package/dist/stores/cc/task-list-store.d.ts

@@ -1,2 +0,0 @@
-import type { TaskListStore } from "../../tools/task-list.js";
-export declare function createCcFileTaskListStore(listDir: string): TaskListStore;

package/dist/stores/cc/task-list-store.js

@@ -1,125 +0,0 @@
-import { readFileSync, readdirSync, mkdirSync, unlinkSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { assertJsonMetadata, normalizeTaskShape } from "../../tools/task-list.js";
-import { atomicWriteFile } from "../file/fs-atomic.js";
-import { physicalPathOf } from "../../core/physical-path.js";
-import { withCcLock } from "./lockfile.js";
-export function createCcFileTaskListStore(listDir) {
-    const dir = resolve(listDir);
-    mkdirSync(dir, { recursive: true });
-    const hwmPath = join(dir, ".highwatermark");
-    const lockTarget = physicalPathOf(dir);
-    const CC_TASK_ID_RE = /^[A-Za-z0-9_-]+$/;
-    const validId = (id) => CC_TASK_ID_RE.test(id);
-    const taskPath = (id) => {
-        if (!validId(id))
-            throw new Error(`cc task-list store: invalid task id ${JSON.stringify(id)} (CC id charset [A-Za-z0-9_-] required)`);
-        return join(dir, `${id}.json`);
-    };
-    const scanIds = () => readdirSync(dir)
-        .filter((f) => f.endsWith(".json"))
-        .map((f) => f.slice(0, -".json".length))
-        .filter((id) => validId(id));
-    const scanNumericIds = () => scanIds()
-        .map((id) => Number.parseInt(id, 10))
-        .filter((n) => Number.isFinite(n));
-    const orderIds = (ids) => {
-        const num = (id) => (/^\d+$/.test(id) ? Number.parseInt(id, 10) : Number.NaN);
-        return [...ids].sort((a, b) => {
-            const [na, nb] = [num(a), num(b)];
-            if (Number.isFinite(na) && Number.isFinite(nb))
-                return na - nb || a.localeCompare(b);
-            if (Number.isFinite(na))
-                return -1;
-            if (Number.isFinite(nb))
-                return 1;
-            return a.localeCompare(b);
-        });
-    };
-    const readHwm = () => {
-        try {
-            const raw = readFileSync(hwmPath, "utf8").trim();
-            const n = Number.parseInt(raw, 10);
-            return Number.isFinite(n) ? n : 0;
-        }
-        catch {
-            return 0;
-        }
-    };
-    const readTask = (id) => {
-        if (!validId(id))
-            return undefined;
-        try {
-            return JSON.parse(readFileSync(taskPath(id), "utf8"));
-        }
-        catch (err) {
-            if (err.code === "ENOENT")
-                return undefined;
-            throw err;
-        }
-    };
-    const writeTask = (id, item) => {
-        atomicWriteFile(dir, taskPath(id), JSON.stringify(item, null, 2));
-    };
-    const snap = (t) => structuredClone(t);
-    const store = {
-        get: (id) => withCcLock(lockTarget, () => {
-            const t = readTask(id);
-            return t ? snap(t) : undefined;
-        }),
-        set: (id, item) => withCcLock(lockTarget, () => {
-            if (item.metadata)
-                assertJsonMetadata(item.metadata);
-            const prior = readTask(id);
-            writeTask(id, { ...(prior ?? {}), ...normalizeTaskShape(snap(item)) });
-        }),
-        delete: (id) => withCcLock(lockTarget, () => {
-            if (readTask(id) === undefined)
-                return false;
-            unlinkSync(taskPath(id));
-            return true;
-        }),
-        list: () => withCcLock(lockTarget, () => orderIds(scanIds())
-            .map((id) => readTask(id))
-            .filter((t) => t !== undefined)
-            .map(snap)),
-        allocateId: () => withCcLock(lockTarget, () => {
-            const scanned = scanNumericIds();
-            const next = Math.max(readHwm(), scanned.length > 0 ? Math.max(...scanned) : 0) + 1;
-            atomicWriteFile(dir, hwmPath, String(next));
-            return String(next);
-        }),
-        mutate: (fn) => withCcLock(lockTarget, () => {
-            const tx = {
-                get: (id) => {
-                    const t = readTask(id);
-                    return t ? snap(t) : undefined;
-                },
-                set: (id, item) => {
-                    if (item.metadata)
-                        assertJsonMetadata(item.metadata);
-                    const prior = readTask(id);
-                    writeTask(id, { ...(prior ?? {}), ...normalizeTaskShape(snap(item)) });
-                },
-                delete: (id) => {
-                    if (readTask(id) === undefined)
-                        return false;
-                    unlinkSync(taskPath(id));
-                    return true;
-                },
-                list: () => orderIds(scanIds())
-                    .map((id) => readTask(id))
-                    .filter((t) => t !== undefined)
-                    .map(snap),
-                allocateId: () => {
-                    const scanned = scanNumericIds();
-                    const next = Math.max(readHwm(), scanned.length > 0 ? Math.max(...scanned) : 0) + 1;
-                    atomicWriteFile(dir, hwmPath, String(next));
-                    return String(next);
-                },
-            };
-            return fn(tx);
-        }),
-    };
-    return store;
-}