@chengchenccc/oh-my-agent 0.1.1-rc.1

package/dist/core/session/session-file.d.ts.map

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

package/dist/core/session/session-file.js

@@ -0,0 +1,392 @@
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** The oma's own session store (ADR 0003 decision 6): parentId-
+ *  chained JSONL, same shape family as pi/omp. The CLI owns its session;
+ *  the product stores only the session id (branch.cliSessionRef).
+ *
+ *  Typing: the wire contract (agent-backend transport) deliberately models
+ *  messages as `Record<string, unknown>` - the durable file keeps that same
+ *  wire-loose shape. Strict `Message` typing is the runtime's job, applied
+ *  where the loop consumes them, so this module performs no type bypass. */
+/** Oma agent root (pi's getAgentDir): ~/.oma by default, overridable with
+ *  OMA_CODING_AGENT_DIR (pi's PI_CODING_AGENT_DIR). Everything under it —
+ *  sessions today — follows the override. */
+export function agentDir() {
+    return process.env.OMA_CODING_AGENT_DIR ?? join(homedir(), ".oma");
+}
+/** Sessions root: <agentDir>/sessions. */
+export function sessionsRoot() {
+    return join(agentDir(), "sessions");
+}
+/** Session directory for a specific workspace root (pi's per-cwd dir). */
+export function sessionDirFor(workspaceRoot) {
+    const safePath = `--${workspaceRoot.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+    return join(sessionsRoot(), safePath);
+}
+/** Default session store, isolated per workspace (pi's model): sessions
+ *  live under <agentDir>/sessions/--<cwd-encoded>--/ so different
+ *  workspaces never see each other's sessions. OMA_SESSION_DIR overrides
+ *  the WHOLE store as a flat directory (pi's PI_CODING_AGENT_SESSION_DIR). */
+export function sessionDir() {
+    return process.env.OMA_SESSION_DIR ?? sessionDirFor(process.cwd());
+}
+export function sessionPath(id) {
+    return join(sessionDir(), `${id}.jsonl`);
+}
+export function newSessionId() {
+    return crypto.randomUUID();
+}
+/** Load the transcript messages of a session file (wire-loose shape).
+ *  Missing/corrupt files yield [] (the caller falls back to a fresh
+ *  session). A compaction event REPLACES everything recorded before it:
+ *  the summary becomes one context message, later turns stay live — so a
+ *  resumed session does not re-inflate the context it already compacted. */
+export function loadSessionMessages(id, dir = sessionDir()) {
+    const path = join(dir, `${id}.jsonl`);
+    if (!existsSync(path))
+        return [];
+    const messages = [];
+    for (const line of readFileSync(path, "utf8").split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            // The one unavoidable boundary: JSON.parse yields unknown; the typed
+            // cast pins OUR durable format's event shape.
+            const evt = JSON.parse(line);
+            if (evt.type === "message" && evt.message?.role)
+                messages.push(evt.message);
+            else if (evt.type === "compaction" && typeof evt.summary === "string") {
+                messages.length = 0;
+                messages.push({
+                    role: "user",
+                    text: `<previous_session_summary>\n${evt.summary}\n</previous_session_summary>`,
+                });
+            }
+        }
+        catch {
+            /* skip malformed line */
+        }
+    }
+    return messages;
+}
+/** Scan one session directory (all *.jsonl) into summaries. */
+function scanSessionDir(dir, workspace) {
+    if (!existsSync(dir))
+        return [];
+    const summaries = [];
+    for (const entry of readdirSync(dir)) {
+        if (!entry.endsWith(".jsonl"))
+            continue;
+        const id = entry.slice(0, -".jsonl".length);
+        const path = join(dir, entry);
+        let preview = "";
+        let title;
+        let headerCwd;
+        let forkOf;
+        try {
+            for (const line of readFileSync(path, "utf8").split("\n")) {
+                if (!line.trim())
+                    continue;
+                // Durable-format boundary: JSON lines are our own event shape.
+                const evt = JSON.parse(line);
+                if (evt.type === "session" && typeof evt.cwd === "string") {
+                    headerCwd = evt.cwd;
+                    continue;
+                }
+                if (evt.type === "title" && typeof evt.title === "string") {
+                    title = evt.title;
+                    continue;
+                }
+                if (evt.type === "fork_of" && typeof evt.parentId === "string") {
+                    forkOf = evt.parentId;
+                    continue;
+                }
+                if (!preview && evt.type === "message" && evt.message?.role === "user") {
+                    preview = String(evt.message.text ?? "")
+                        .replace(/\s+/g, " ")
+                        .slice(0, 60);
+                }
+            }
+        }
+        catch {
+            /* corrupt file: listed with an empty preview */
+        }
+        const summary = { id, modifiedAt: statSync(path).mtimeMs, preview };
+        if (title !== undefined)
+            summary.title = title;
+        if (workspace !== undefined)
+            summary.workspace = workspace;
+        else if (headerCwd !== undefined)
+            summary.workspace = headerCwd;
+        if (forkOf !== undefined)
+            summary.forkOf = forkOf;
+        summaries.push(summary);
+    }
+    return summaries;
+}
+/** Session files of the current workspace, newest first. */
+export function listSessions() {
+    return scanSessionDir(sessionDir());
+}
+/** Session files across EVERY workspace, newest first. Covers both the
+ *  default layout (<agentDir>/sessions/--<cwd>--/*.jsonl) and an explicit
+ *  flat OMA_SESSION_DIR. Each summary carries the workspace it belongs to
+ *  (pi's session selector "all" scope). */
+export function listAllSessions() {
+    // Explicit flat OMA_SESSION_DIR: sessions live at the root itself.
+    if (process.env.OMA_SESSION_DIR)
+        return scanSessionDir(process.env.OMA_SESSION_DIR);
+    const root = sessionsRoot();
+    if (!existsSync(root))
+        return [];
+    const summaries = [];
+    for (const entry of readdirSync(root)) {
+        if (!entry.startsWith("--"))
+            continue; // per-workspace dirs only
+        summaries.push(...scanSessionDir(join(root, entry)));
+    }
+    return summaries.sort((a, b) => b.modifiedAt - a.modifiedAt);
+}
+/** Append a title event: the session's display title, auto-generated by the
+ *  loop after each completed run. Last one wins in listings. Also the
+ *  primitive for /rename: appending a new title overrides the display. */
+export function appendSessionTitle(id, title, dir = sessionDir()) {
+    const path = join(dir, `${id}.jsonl`);
+    if (!existsSync(path))
+        return;
+    appendFileSync(path, `${JSON.stringify({
+        type: "title",
+        timestamp: new Date().toISOString(),
+        title,
+    })}\n`);
+}
+/** Delete a session file. Returns false when it did not exist. */
+export function deleteSession(id, dir = sessionDir()) {
+    const path = join(dir, `${id}.jsonl`);
+    if (!existsSync(path))
+        return false;
+    rmSync(path, { force: true });
+    return true;
+}
+/** Rename a session's display title (last-wins title event). Returns false
+ *  when the session file does not exist. */
+export function renameSession(id, title, dir = sessionDir()) {
+    const path = join(dir, `${id}.jsonl`);
+    if (!existsSync(path))
+        return false;
+    appendSessionTitle(id, title, dir);
+    return true;
+}
+/** Append a compaction event: records that the run compacted everything
+ *  recorded so far in this file into `summary`. Must be called AFTER the
+ *  turn's messages are appended. */
+export function appendSessionCompaction(id, summary, dir = sessionDir()) {
+    const path = join(dir, `${id}.jsonl`);
+    if (!existsSync(path))
+        return;
+    appendFileSync(path, `${JSON.stringify({
+        type: "compaction",
+        timestamp: new Date().toISOString(),
+        summary,
+    })}\n`);
+}
+/** Read the durable event tree of one session as parentId-chained message
+ *  nodes (used by the TUI branch-tree fork overlay). Only message events
+ *  carry an id; corrupt lines are skipped. */
+export function loadSessionBranchNodes(id, dir = sessionDir()) {
+    const path = join(dir, `${id}.jsonl`);
+    if (!existsSync(path))
+        return [];
+    const lines = readFileSync(path, "utf8")
+        .split("\n")
+        .filter((l) => l.trim());
+    const parents = new Map();
+    const nodes = [];
+    let userOrdinal = 0;
+    for (const line of lines) {
+        let evt;
+        try {
+            evt = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (evt.type !== "message" || !evt.id || !evt.message?.role)
+            continue;
+        const role = evt.message.role;
+        const parentId = evt.parentId ?? null;
+        parents.set(evt.id, parentId);
+        if (role === "user")
+            userOrdinal += 1;
+        const node = {
+            id: evt.id,
+            parentId,
+            role,
+            text: typeof evt.message.text === "string" ? evt.message.text : "",
+        };
+        if (role === "user")
+            node.ordinal = userOrdinal;
+        nodes.push(node);
+    }
+    const depthOf = (id) => {
+        let depth = 0;
+        let cur = id;
+        const seen = new Set();
+        while (cur) {
+            if (seen.has(cur))
+                break;
+            seen.add(cur);
+            const parent = parents.get(cur) ?? null;
+            if (parent === null)
+                break;
+            depth += 1;
+            cur = parent;
+        }
+        return depth;
+    };
+    return nodes.map((n) => ({ ...n, depth: depthOf(n.id) }));
+}
+/** Copy a session file through the line at `cutIndex` into a NEW file with a
+ *  fork_of marker. Shared by the ordinal and event-id fork paths. */
+function copySessionThrough(id, cutIndex, dir, markerFields) {
+    const path = join(dir, `${id}.jsonl`);
+    if (!existsSync(path))
+        return null;
+    const lines = readFileSync(path, "utf8")
+        .split("\n")
+        .filter((l) => l.trim());
+    if (cutIndex < 0 || cutIndex >= lines.length)
+        return null;
+    const newId = newSessionId();
+    const kept = lines.slice(0, cutIndex + 1);
+    // Rewrite the copied header's id so the new file is self-consistent.
+    try {
+        const header = JSON.parse(kept[0]);
+        if (header.type === "session") {
+            header.id = newId;
+            kept[0] = JSON.stringify(header);
+        }
+    }
+    catch {
+        /* keep the original header line */
+    }
+    const marker = JSON.stringify({ type: "fork_of", parentId: id, ...markerFields });
+    writeFileSync(join(dir, `${newId}.jsonl`), `${[...kept, marker].join("\n")}\n`);
+    return newId;
+}
+/** Fork a session at the Nth user message (1-based) — the existing /fork
+ *  semantics. */
+export function forkSession(id, ordinal, dir = sessionDir()) {
+    const path = join(dir, `${id}.jsonl`);
+    if (!existsSync(path))
+        return null;
+    const lines = readFileSync(path, "utf8")
+        .split("\n")
+        .filter((l) => l.trim());
+    let seen = 0;
+    let cutIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+        let evt;
+        try {
+            evt = JSON.parse(lines[i]);
+        }
+        catch {
+            continue; // corrupt line: not a fork anchor
+        }
+        if (evt.type === "message" && evt.message?.role === "user") {
+            seen += 1;
+            if (seen === ordinal) {
+                cutIndex = i;
+                break;
+            }
+        }
+    }
+    if (cutIndex === -1)
+        return null;
+    return copySessionThrough(id, cutIndex, dir, { atMessage: ordinal });
+}
+/** Fork a session through a specific branch node (message event id). The new
+ *  session contains every event up to and INCLUDING that node. */
+export function forkSessionAtEvent(id, eventId, dir = sessionDir()) {
+    const path = join(dir, `${id}.jsonl`);
+    if (!existsSync(path))
+        return null;
+    const lines = readFileSync(path, "utf8")
+        .split("\n")
+        .filter((l) => l.trim());
+    let cutIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+        let evt;
+        try {
+            evt = JSON.parse(lines[i]);
+        }
+        catch {
+            continue;
+        }
+        if (evt.id === eventId) {
+            cutIndex = i;
+            break;
+        }
+    }
+    if (cutIndex === -1)
+        return null;
+    return copySessionThrough(id, cutIndex, dir, { atEvent: eventId });
+}
+/** Append message events to the session file (header written on create;
+ *  parentId chains to the file's last message id). The tail scan keeps a
+ *  per-process lastId cache — resume reads the file once, steady-state
+ *  appends are O(1) instead of re-reading the whole transcript. */
+const lastIdBySession = new Map();
+function readLastMessageId(path) {
+    let prevId = null;
+    for (const line of readFileSync(path, "utf8").split("\n").reverse()) {
+        if (!line.trim())
+            continue;
+        try {
+            const evt = JSON.parse(line);
+            if (evt.type === "message" && evt.id) {
+                prevId = evt.id;
+                break;
+            }
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return prevId;
+}
+export function appendSessionMessages(id, cwd, messages, dir = sessionDir()) {
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, `${id}.jsonl`);
+    const cacheKey = `${dir}:${id}`;
+    if (!existsSync(path)) {
+        writeFileSync(path, `${JSON.stringify({
+            type: "session",
+            version: 3,
+            id,
+            timestamp: new Date().toISOString(),
+            cwd,
+        })}\n`);
+    }
+    // First append this process: scan the tail once. Later appends reuse the
+    // cached leaf id (one Runtime appends at most once per turn, sequentially).
+    if (!lastIdBySession.has(cacheKey)) {
+        lastIdBySession.set(cacheKey, readLastMessageId(path));
+    }
+    let prevId = lastIdBySession.get(cacheKey) ?? null;
+    const lines = [];
+    for (const message of messages) {
+        const eventId = crypto.randomUUID();
+        lines.push(JSON.stringify({
+            type: "message",
+            id: eventId,
+            parentId: prevId,
+            timestamp: new Date().toISOString(),
+            message,
+        }));
+        prevId = eventId;
+    }
+    lastIdBySession.set(cacheKey, prevId);
+    appendFileSync(path, `${lines.join("\n")}\n`);
+}

package/dist/core/session/session-loop.d.ts

@@ -0,0 +1,33 @@
+import type { OmaRuntime } from "../runtime/create-runtime.js";
+/** Shared session persistence for the interactive CLI modes (TUI) and the
+ *  one-shot modes (print). Mirrors the RPC mode's session semantics
+ *  (ADR 0003 decision 6): the CLI owns its session file; the product
+ *  stores only the session id. A completed turn (input + assistant/tool
+ *  messages + compaction summaries) is appended after the run. */
+/** Finalize a turn in the session file: writes compaction summaries and the
+ *  auto title. Conversational messages are written in REAL TIME via
+ *  createOmaRuntime's onPersistMessages (pi appendMessage) when the caller
+ *  wires it; `messages` is the fallback batch for one-shot modes (print)
+ *  that do not use real-time persistence. */
+export declare function persistSessionTurn(opts: {
+    sessionId: string;
+    cwd: string;
+    runtime: OmaRuntime;
+    /** Messages not already written by the real-time hook (print mode). */
+    messages?: readonly unknown[];
+    /** The run's auto-generated title (outcome.title), when present. */
+    title?: string;
+    /** Session directory; defaults to the current workspace. Cross-workspace
+     *  resumes pass the source workspace's dir so new turns append there. */
+    dir?: string;
+}): Promise<void>;
+/** Resolve the session for a new TUI turn: a --session id resumes that
+ *  file (missing/corrupt file degrades to fresh); otherwise a new id.
+ *  `dir` is the session directory the file lives in (current workspace by
+ *  default; cross-workspace resumes pass their own workspace dir). */
+export declare function resolveSession(sessionId?: string, dir?: string): {
+    sessionId: string;
+    messages: Record<string, unknown>[];
+    dir: string;
+};
+//# sourceMappingURL=session-loop.d.ts.map

package/dist/core/session/session-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-loop.d.ts","sourceRoot":"","sources":["../../../src/core/session/session-loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAU/D;;;;kEAIkE;AAElE;;;;6CAI6C;AAC7C,wBAAsB,kBAAkB,CAAC,IAAI,EAAE;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,UAAU,CAAC;IACpB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC9B,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;6EACyE;IACzE,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,IAAI,CAAC,CAQhB;AAED;;;sEAGsE;AACtE,wBAAgB,cAAc,CAC5B,SAAS,CAAC,EAAE,MAAM,EAClB,GAAG,CAAC,EAAE,MAAM,GACX;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACpC,GAAG,EAAE,MAAM,CAAC;CACb,CAIA"}

package/dist/core/session/session-loop.js

@@ -0,0 +1,30 @@
+import { appendSessionCompaction, appendSessionMessages, appendSessionTitle, loadSessionMessages, newSessionId, sessionDir, } from "./session-file.js";
+/** Shared session persistence for the interactive CLI modes (TUI) and the
+ *  one-shot modes (print). Mirrors the RPC mode's session semantics
+ *  (ADR 0003 decision 6): the CLI owns its session file; the product
+ *  stores only the session id. A completed turn (input + assistant/tool
+ *  messages + compaction summaries) is appended after the run. */
+/** Finalize a turn in the session file: writes compaction summaries and the
+ *  auto title. Conversational messages are written in REAL TIME via
+ *  createOmaRuntime's onPersistMessages (pi appendMessage) when the caller
+ *  wires it; `messages` is the fallback batch for one-shot modes (print)
+ *  that do not use real-time persistence. */
+export async function persistSessionTurn(opts) {
+    if (opts.messages && opts.messages.length > 0) {
+        appendSessionMessages(opts.sessionId, opts.cwd, opts.messages, opts.dir);
+    }
+    for (const summary of await opts.runtime.compactions()) {
+        appendSessionCompaction(opts.sessionId, summary, opts.dir);
+    }
+    if (opts.title)
+        appendSessionTitle(opts.sessionId, opts.title, opts.dir);
+}
+/** Resolve the session for a new TUI turn: a --session id resumes that
+ *  file (missing/corrupt file degrades to fresh); otherwise a new id.
+ *  `dir` is the session directory the file lives in (current workspace by
+ *  default; cross-workspace resumes pass their own workspace dir). */
+export function resolveSession(sessionId, dir) {
+    const id = sessionId ?? newSessionId();
+    const resolvedDir = dir ?? sessionDir();
+    return { sessionId: id, messages: loadSessionMessages(id, resolvedDir), dir: resolvedDir };
+}

package/dist/core/settings/project-settings.d.ts

@@ -0,0 +1,46 @@
+/** Project-level oma settings (`.oma/settings.json` in the workspace root).
+ *  Standalone TUI-only. The product backend keeps agent.yml as its model
+ *  truth and can be overridden per-run by the run parameter, so this file
+ *  never conflicts with agent.yml in the backend->oma chain. */
+export interface ProjectSettings {
+    /** Canonical `<provider>/<model>` id chosen in the TUI. */
+    model?: string;
+    /** Configured skill root dirs (absolute, or relative to the workspace
+     *  root). When present, overrides the default project/global discovery;
+     *  empty/absent falls back to defaults. */
+    skills?: string[];
+    /** Read Claude Code skill dirs (`.claude/skills` + `~/.claude/skills`). */
+    enableClaude?: boolean;
+    /** Read Codex CLI skill dirs (`.codex/skills` + `~/.codex/skills`). */
+    enableCodex?: boolean;
+    /** Read agent skill dirs (`.agent/skills` / `.agents/skills` + home). */
+    enableAgents?: boolean;
+    /** Loop step cap (env OMA_MAX_STEPS). */
+    maxSteps?: number;
+    /** Single model-call timeout ms (env OMA_MODEL_TIMEOUT_MS). */
+    modelTimeoutMs?: number;
+    /** MCP call timeout ms (env OMA_MCP_TIMEOUT_MS). */
+    mcpTimeoutMs?: number;
+    /** Disable web tools (env OMA_DISABLE_WEB=1). */
+    disableWeb?: boolean;
+    /** Generate auto titles (env OMA_TITLE_ENABLED=0 disables). */
+    titleEnabled?: boolean;
+    /** Run autonomous memory extraction (env OMA_MEMORY_EXTRACT=0 disables). */
+    memoryExtract?: boolean;
+    /** Memory extraction model (env OMA_MEMORY_MODEL). */
+    memoryModel?: string;
+    /** Default bash tool timeout ms (env OMA_BASH_TIMEOUT_MS). */
+    bashTimeoutMs?: number;
+    /** Global cap for any per-tool timeout ms; 0 = no limit (omp tools.maxTimeout). */
+    maxToolTimeoutMs?: number;
+}
+/** Read project settings. Missing/corrupt file degrades to `{}`. */
+export declare function loadProjectSettings(root: string): ProjectSettings;
+/** Persist a full settings object to `.oma/settings.json`, preserving any
+ *  unknown keys already present in the file. */
+export declare function saveProjectSettings(root: string, settings: ProjectSettings): void;
+/** Persist a TUI model choice to `.oma/settings.json`, preserving other keys. */
+export declare function saveProjectModel(root: string, modelId: string): void;
+/** True when the file exists (used by tests to assert a write happened). */
+export declare function hasProjectSettings(root: string): boolean;
+//# sourceMappingURL=project-settings.d.ts.map

package/dist/core/settings/project-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-settings.d.ts","sourceRoot":"","sources":["../../../src/core/settings/project-settings.ts"],"names":[],"mappings":"AAGA;;;gEAGgE;AAChE,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;+CAE2C;IAC3C,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,uEAAuE;IACvE,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,yEAAyE;IACzE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oDAAoD;IACpD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iDAAiD;IACjD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,+DAA+D;IAC/D,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,4EAA4E;IAC5E,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,sDAAsD;IACtD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8DAA8D;IAC9D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mFAAmF;IACnF,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAMD,oEAAoE;AACpE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAiDjE;AAED;gDACgD;AAChD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,IAAI,CAWjF;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAGpE;AAED,4EAA4E;AAC5E,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD"}

package/dist/core/settings/project-settings.js

@@ -0,0 +1,85 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+function settingsPath(root) {
+    return join(root, ".oma", "settings.json");
+}
+/** Read project settings. Missing/corrupt file degrades to `{}`. */
+export function loadProjectSettings(root) {
+    try {
+        const parsed = JSON.parse(readFileSync(settingsPath(root), "utf8"));
+        if (typeof parsed !== "object" || parsed === null)
+            return {};
+        const result = {};
+        if ("model" in parsed && typeof parsed.model === "string")
+            result.model = parsed.model;
+        if ("skills" in parsed && Array.isArray(parsed.skills)) {
+            const skills = parsed.skills;
+            if (skills.every((s) => typeof s === "string"))
+                result.skills = skills;
+        }
+        if ("enableClaude" in parsed && typeof parsed.enableClaude === "boolean") {
+            result.enableClaude = parsed.enableClaude;
+        }
+        if ("enableCodex" in parsed && typeof parsed.enableCodex === "boolean") {
+            result.enableCodex = parsed.enableCodex;
+        }
+        if ("enableAgents" in parsed && typeof parsed.enableAgents === "boolean") {
+            result.enableAgents = parsed.enableAgents;
+        }
+        if ("maxSteps" in parsed && typeof parsed.maxSteps === "number")
+            result.maxSteps = parsed.maxSteps;
+        if ("modelTimeoutMs" in parsed && typeof parsed.modelTimeoutMs === "number") {
+            result.modelTimeoutMs = parsed.modelTimeoutMs;
+        }
+        if ("mcpTimeoutMs" in parsed && typeof parsed.mcpTimeoutMs === "number") {
+            result.mcpTimeoutMs = parsed.mcpTimeoutMs;
+        }
+        if ("disableWeb" in parsed && typeof parsed.disableWeb === "boolean") {
+            result.disableWeb = parsed.disableWeb;
+        }
+        if ("titleEnabled" in parsed && typeof parsed.titleEnabled === "boolean") {
+            result.titleEnabled = parsed.titleEnabled;
+        }
+        if ("memoryExtract" in parsed && typeof parsed.memoryExtract === "boolean") {
+            result.memoryExtract = parsed.memoryExtract;
+        }
+        if ("memoryModel" in parsed && typeof parsed.memoryModel === "string") {
+            result.memoryModel = parsed.memoryModel;
+        }
+        if ("bashTimeoutMs" in parsed && typeof parsed.bashTimeoutMs === "number") {
+            result.bashTimeoutMs = parsed.bashTimeoutMs;
+        }
+        if ("maxToolTimeoutMs" in parsed && typeof parsed.maxToolTimeoutMs === "number") {
+            result.maxToolTimeoutMs = parsed.maxToolTimeoutMs;
+        }
+        return result;
+    }
+    catch {
+        return {};
+    }
+}
+/** Persist a full settings object to `.oma/settings.json`, preserving any
+ *  unknown keys already present in the file. */
+export function saveProjectSettings(root, settings) {
+    const path = settingsPath(root);
+    let existing = {};
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        if (typeof raw === "object" && raw !== null)
+            existing = raw;
+    }
+    catch {
+        /* no existing file */
+    }
+    mkdirSync(join(root, ".oma"), { recursive: true });
+    writeFileSync(path, `${JSON.stringify({ ...existing, ...settings }, null, 2)}\n`, "utf8");
+}
+/** Persist a TUI model choice to `.oma/settings.json`, preserving other keys. */
+export function saveProjectModel(root, modelId) {
+    const current = loadProjectSettings(root);
+    saveProjectSettings(root, { ...current, model: modelId });
+}
+/** True when the file exists (used by tests to assert a write happened). */
+export function hasProjectSettings(root) {
+    return existsSync(settingsPath(root));
+}

package/dist/core/settings/workspace-context.d.ts

@@ -0,0 +1,10 @@
+/** The system prompt = AGENTS.md (instructions) + SOUL.md (identity) +
+ *  USER.md (user context) + the knowledge index (ADR 0022: the bridge
+ *  generates knowledge/index.md; it is reference material, appended
+ *  verbatim). */
+export declare function readWorkspaceSystemPrompt(cwd: string): string | undefined;
+/** Skill roots = every directory under .oma/skills (symlinked packs via
+ *  the workspace bridge). Each is scanned for SKILL.md by the progressive
+ *  skill plugin. */
+export declare function scanWorkspaceSkillRoots(cwd: string): string[];
+//# sourceMappingURL=workspace-context.d.ts.map

package/dist/core/settings/workspace-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-context.d.ts","sourceRoot":"","sources":["../../../src/core/settings/workspace-context.ts"],"names":[],"mappings":"AAgBA;;;iBAGiB;AACjB,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CASzE;AAED;;oBAEoB;AACpB,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAa7D"}

package/dist/core/settings/workspace-context.js

@@ -0,0 +1,48 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+/** cwd-based workspace context (ADR 0003 decision 6): the oma's
+ *  meta lives in workspace files, read natively — no run-input injection.
+ *  Only used as the FALLBACK when the run input does not carry explicit
+ *  values (Loop scopes still pass their own LOOP.md config). */
+function readTextOrNull(path) {
+    try {
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+/** The system prompt = AGENTS.md (instructions) + SOUL.md (identity) +
+ *  USER.md (user context) + the knowledge index (ADR 0022: the bridge
+ *  generates knowledge/index.md; it is reference material, appended
+ *  verbatim). */
+export function readWorkspaceSystemPrompt(cwd) {
+    const parts = ["AGENTS.md", "SOUL.md", "USER.md"]
+        .map((f) => readTextOrNull(join(cwd, f)))
+        .filter((t) => t !== null && t.trim() !== "");
+    const knowledgeIndex = readTextOrNull(join(cwd, "knowledge", "index.md"));
+    if (knowledgeIndex && knowledgeIndex.trim() !== "") {
+        parts.push(`<available_knowledge>\n${knowledgeIndex.trim()}\n</available_knowledge>`);
+    }
+    return parts.length > 0 ? parts.join("\n\n") : undefined;
+}
+/** Skill roots = every directory under .oma/skills (symlinked packs via
+ *  the workspace bridge). Each is scanned for SKILL.md by the progressive
+ *  skill plugin. */
+export function scanWorkspaceSkillRoots(cwd) {
+    const skillsDir = join(cwd, ".oma", "skills");
+    if (!existsSync(skillsDir))
+        return [];
+    const roots = [];
+    for (const entry of readdirSync(skillsDir)) {
+        const p = join(skillsDir, entry);
+        try {
+            if (statSync(p).isDirectory())
+                roots.push(p);
+        }
+        catch {
+            /* dangling symlink or race: skip */
+        }
+    }
+    return roots;
+}