@amoree-code/ocean 0.0.0-stage → 1.1.0

package/node_modules/@ocean/context/dist/context/context-references.js

@@ -0,0 +1,255 @@
+import { realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { validateContextManifest } from "@ocean/core/domain/context/context-validator.js";
+import { oceanRoot } from "@ocean/core/shared/paths.js";
+import { knownTaskPrefixes, projectRules, readProjectManifest, resolveProject, } from "@ocean/core/shared/project-resolution.js";
+import { resolveLadderRung } from "./context-ladder.js";
+import { buildContextPacket } from "./context-packet.js";
+import { classifyIntent } from "./intent-router.js";
+// Lean context for headless runs: the prompt carries references (path + why), never file
+// bodies. The provider is an agentic CLI with file access and reads a reference only if the
+// request needs it. Two sources feed it: the profile's own contextSources and, when profile
+// memory is enabled, the T-198 context packet for a request that names one exact record (a
+// task id). Both go through the same realpath/allowedPaths boundary the old eager reader
+// applied, so a headless prompt never points outside the profile's allowedPaths.
+export const CONTEXT_REFERENCE_MAX_BYTES = 4_096;
+// Within the context-ladder BUDGET_CEILING; the packet itself stats, never reads.
+export const LEAN_PACKET_BUDGET = {
+    maxFiles: 5,
+    maxBytes: 200_000,
+    maxChars: 8_000,
+    maxOperationCost: 5,
+};
+const SECTION_HEADER = "## Context references\nBodies are not inlined; read a file only if the request needs it.";
+async function sizeOf(file) {
+    try {
+        return (await stat(file)).size;
+    }
+    catch {
+        return null;
+    }
+}
+async function canonicalBoundaries(allowedPaths, cwd) {
+    const boundaries = await Promise.all(allowedPaths.map(async (allowedPath) => {
+        try {
+            return await realpath(path.resolve(cwd, allowedPath));
+        }
+        catch {
+            return null;
+        }
+    }));
+    return boundaries.filter((boundary) => boundary !== null);
+}
+// The realpath/allowedPaths boundary carried over verbatim from the former eager context
+// reader: a target that does not resolve, or whose canonical path (symlinks followed) lies
+// outside every canonical allowedPath, is rejected. Returns the canonical path when allowed.
+async function withinAllowedPaths(target, boundaries) {
+    let canonicalPath;
+    try {
+        canonicalPath = await realpath(target);
+    }
+    catch {
+        return null;
+    }
+    const allowed = boundaries.some((boundary) => canonicalPath === boundary ||
+        canonicalPath.startsWith(`${boundary}${path.sep}`));
+    return allowed ? canonicalPath : null;
+}
+// Accepted contextSources entries are stat'd, never read.
+export async function resolveContextSources(profile, cwd) {
+    const references = [];
+    const omitted = [];
+    const boundaries = await canonicalBoundaries(profile.allowedPaths, cwd);
+    for (const relativePath of profile.contextSources) {
+        const canonicalPath = await withinAllowedPaths(path.resolve(cwd, relativePath), boundaries);
+        if (!canonicalPath) {
+            omitted.push(relativePath);
+            continue;
+        }
+        references.push({
+            path: relativePath,
+            base: "cwd",
+            recordType: "context-source",
+            reason: "profile contextSources entry",
+            bytes: await sizeOf(canonicalPath),
+        });
+    }
+    return { references, omitted };
+}
+// References the context packet selects for the request. Only the exact-record rung (a task
+// lookup naming one validated id) is used headlessly: memory/knowledge/decision lookups are
+// keyword-triggered ("memory usage", "lessons", "best practice"), so they would point ordinary
+// engineering prompts at private records. Every selected record must also lie inside the
+// profile's allowedPaths (resolved against cwd); a rejected one goes to `omitted`. Unknown or
+// low-confidence intents select nothing, and any error fails closed to no references, so a
+// headless run never fails on a file it would not have read before.
+export async function selectPacketReferences(prompt, cwd, allowedPaths) {
+    const references = [];
+    const omitted = [];
+    try {
+        const classification = classifyIntent(prompt, await knownTaskPrefixes());
+        if (resolveLadderRung(classification).rung !== "exact-record")
+            return { references, omitted };
+        const packet = await buildContextPacket(classification, LEAN_PACKET_BUDGET, cwd);
+        const boundaries = await canonicalBoundaries(allowedPaths, cwd);
+        for (const reference of packet.selectedReferences) {
+            const canonicalPath = await withinAllowedPaths(path.join(oceanRoot(), reference.sourcePath), boundaries);
+            if (!canonicalPath) {
+                omitted.push(reference.sourcePath);
+                continue;
+            }
+            references.push({
+                path: reference.sourcePath,
+                base: "ocean-root",
+                recordType: reference.recordType,
+                reason: reference.selectionReason,
+                bytes: await sizeOf(canonicalPath),
+            });
+        }
+        return { references, omitted };
+    }
+    catch {
+        return { references: [], omitted: [] };
+    }
+}
+// The absolute file a reference points at (what the provider must be able to read).
+export function referenceTarget(reference, cwd) {
+    return reference.base === "cwd"
+        ? path.resolve(cwd, reference.path)
+        : path.join(oceanRoot(), reference.path);
+}
+function inside(directory, root) {
+    return directory === root || directory.startsWith(`${root}${path.sep}`);
+}
+// The directories a workspace-restricted provider must be granted to open the references.
+// Claude --add-dir and Gemini --include-directories grant a directory recursively, so a
+// reference's canonical parent directory is granted only when that directory itself lies
+// inside the profile's canonical allowedPaths: a single-file allowedPaths entry never widens
+// to its siblings, and a symlinked entry grants its real location, not the link's folder.
+// Directories inside the (canonical) cwd need no grant.
+export async function referenceReadDirectories(references, allowedPaths, cwd) {
+    const boundaries = await canonicalBoundaries(allowedPaths, cwd);
+    let root;
+    try {
+        root = await realpath(cwd);
+    }
+    catch {
+        root = path.resolve(cwd);
+    }
+    const directories = new Set();
+    for (const reference of references) {
+        const canonicalPath = await withinAllowedPaths(referenceTarget(reference, cwd), boundaries);
+        if (!canonicalPath)
+            continue;
+        const directory = path.dirname(canonicalPath);
+        if (inside(directory, root))
+            continue;
+        if (!(await withinAllowedPaths(directory, boundaries)))
+            continue;
+        directories.add(directory);
+    }
+    return [...directories];
+}
+function renderReference(reference) {
+    const target = reference.base === "cwd"
+        ? reference.path
+        : path.join(oceanRoot(), reference.path);
+    const bytes = reference.bytes === null ? "?" : String(reference.bytes);
+    const reason = reference.reason.replace(/\s*\n\s*/g, " ");
+    return `- ${target} (${reference.recordType}, ${bytes} B): ${reason}`;
+}
+function renderProjectRules(rules) {
+    return [
+        `## Project rules (${rules.project})`,
+        ...rules.rules.map((rule) => `- ${rule}`),
+    ].join("\n");
+}
+// A bound project's rules ride in every headless run there, whatever the prompt or the profile's
+// memory setting. Unreadable rules refuse the run (the error is not swallowed): a hard constraint
+// is never silently dropped.
+async function boundProjectRulesBlock(cwd) {
+    // A broken registry leaves no bound project to read rules from (the headless path never
+    // failed on it before); the session-start hook treats it the same way.
+    const resolution = await resolveProject(cwd).catch(() => null);
+    if (resolution?.status !== "bound")
+        return "";
+    const project = resolution.projectId;
+    let rules;
+    try {
+        const manifest = await readProjectManifest(project);
+        rules = manifest ? projectRules(manifest) : [];
+    }
+    catch (error) {
+        throw new Error(`Project rules (${project}) unreadable: ${error instanceof Error ? error.message : String(error)} — fix 04-projects/${project}/project.json`);
+    }
+    return rules.length ? renderProjectRules({ project, rules }) : "";
+}
+export async function buildContextReferences(options) {
+    const { profile, prompt, cwd } = options;
+    const sources = await resolveContextSources(profile, cwd);
+    const packet = profile.memory.enabled
+        ? await selectPacketReferences(prompt, cwd, profile.allowedPaths)
+        : { references: [], omitted: [] };
+    const rulesBlock = await boundProjectRulesBlock(cwd);
+    // The rules come first and are never squeezed out; the references fit in what is left.
+    const referenceBudget = rulesBlock
+        ? CONTEXT_REFERENCE_MAX_BYTES - Buffer.byteLength(rulesBlock) - 2
+        : CONTEXT_REFERENCE_MAX_BYTES;
+    const seen = new Set();
+    const candidates = [...sources.references, ...packet.references].filter((reference) => {
+        const key = `${reference.base}:${reference.path}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    const omitted = [...sources.omitted, ...packet.omitted];
+    const lines = [];
+    const references = [];
+    const overflow = [];
+    for (const reference of candidates) {
+        const line = renderReference(reference);
+        const next = [SECTION_HEADER, ...lines, line].join("\n");
+        if (overflow.length === 0 && Buffer.byteLength(next) <= referenceBudget) {
+            lines.push(line);
+            references.push(reference);
+        }
+        else {
+            overflow.push(reference);
+        }
+    }
+    if (overflow.length) {
+        // Make room for the trailing note by dropping accepted lines if necessary.
+        const note = (count) => `- ... ${count} more references omitted (listed in the context_manifest event)`;
+        while (lines.length &&
+            Buffer.byteLength([SECTION_HEADER, ...lines, note(overflow.length)].join("\n")) > referenceBudget) {
+            lines.pop();
+            const dropped = references.pop();
+            if (dropped)
+                overflow.unshift(dropped);
+        }
+        lines.push(note(overflow.length));
+        omitted.push(...overflow.map((reference) => reference.path));
+    }
+    const referencesBlock = lines.length
+        ? [SECTION_HEADER, ...lines].join("\n")
+        : "";
+    const content = [rulesBlock, referencesBlock].filter(Boolean).join("\n\n");
+    return {
+        content,
+        readDirectories: await referenceReadDirectories(references, profile.allowedPaths, cwd),
+        manifest: validateContextManifest({
+            files: references
+                .filter((reference) => reference.base === "cwd")
+                .map((reference) => reference.path),
+            bytes: Buffer.byteLength(content),
+            compactedSummary: null,
+            lastContextCheckpoint: new Date().toISOString(),
+            maxBytes: CONTEXT_REFERENCE_MAX_BYTES,
+            omitted,
+            compression: null,
+            references,
+        }),
+    };
+}
+//# sourceMappingURL=context-references.js.map

package/node_modules/@ocean/context/dist/context/intent-router.js

@@ -0,0 +1,259 @@
+// Deterministic intent router: pure text classification, no filesystem I/O, no model call,
+// no MCP round trip. Runs before any retrieval so a caller (CLI, shim, hook, or MCP adapter)
+// knows what Ocean operation — if any — a request maps to, without guessing an identifier or
+// a project when the request does not name one clearly. See T-198 slice 4.
+import { extractTaskIds, LEGACY_PREFIX, } from "@ocean/core/domain/tasks/task-id.js";
+function matchesAny(text, patterns) {
+    return patterns.some((pattern) => pattern.test(text));
+}
+const TASK_COMPLETE = [
+    /\b(complete|close|finish|done|archive)\b/i,
+    /خلص|انهي|سكر|أرشف/,
+];
+const TASK_UPDATE = [/\b(update|edit|change)\b/i, /عدل|حدث|غير/];
+const TASK_CONTINUE = [/\b(continue|resume)\b/i, /كمل|استمر/];
+const TASK_CREATE = [
+    /\b(create|new|open)\b[^.\n]*\btask\b/i,
+    /\btask\b[^.\n]*\b(create|new|open)\b/i,
+    /تكت جديدة|انشئ تكت|سوي تكت|افتح تكت/,
+];
+const TASK_CREATE_NAME = /\b(?:called|named|title(?:d)?)(?:\s+is)?\s+["']?(.+?)["']?(?:[.!?]|$)/i;
+const SAVE_VERB = [/\bsave\b/i, /احفظ|خزن|سجل/];
+const REMEMBER_VERB = [/\b(remember|note|capture)\b/i, /تذكر/];
+const REMEMBER_TARGET = [/\b(this|that)\b/i, /هذا|هاي|هذه/];
+const AS_DECISION = [/\bdecision\b/i, /قرار/];
+const AS_KNOWLEDGE = [/\bknowledge\b|\blesson\b/i, /معرفة|درس/];
+const DECISION_LOOKUP = [
+    /\bwhat did we decide\b/i,
+    /\bwhy did we (choose|pick|decide)\b/i,
+    /\bdecision (about|on|for)\b/i,
+    /\bwhat was the decision\b/i,
+    /شنو قررنا|ليش اخترنا|ايش قررنا|القرار\s+(حول|بخصوص)/,
+];
+const WORK_STYLE = [
+    /\bwork[- ]style\b/i,
+    /\bhow (do|should) i (like to )?work\b/i,
+    /\bmy (working )?preferences\b/i,
+    /اسلوب العمل|طريقة (الشغل|العمل)/,
+];
+const PROJECT_CREATE = [
+    /\b(start|create|begin)\b[^.\n]*\b(new )?project\b/i,
+    /\bnew project\b/i,
+    /مشروع جديد|سوي مشروع|انشئ مشروع/,
+];
+const PROJECT_CREATE_NAME = /\b(?:called|named)\s+["']?([\w .-]+?)["']?(?:[.!?]|$)/i;
+const PROJECT_DETECT = [
+    /\b(what|which) project\b/i,
+    /\bcurrent project\b/i,
+    /\bwhere am i\b/i,
+    /شنو المشروع|اي مشروع|وين انا/,
+];
+const KNOWLEDGE_LOOKUP = [
+    /\bknowledge\b/i,
+    /\blesson(s)?\b/i,
+    /\bwhat did we learn\b/i,
+    /\bbest practice\b/i,
+    /معرفة|درس|ايش تعلمنا/,
+];
+const MEMORY_LOOKUP = [
+    /\bremember\b/i,
+    /\brecall\b/i,
+    /\bmemory\b/i,
+    /\bwhat do you know about\b/i,
+    /تتذكر|ذاكرة/,
+];
+// "what tasks we have" / "check the tasks" / "what the next task": a list request with no id.
+// Needs a task noun AND a list cue so "update all tasks" is not read as a list. Includes the
+// typos seen in real requests (taks, tsks) and Arabic/Iraqi wording (شنو عدنه تكتات).
+const TASK_NOUN = [/\b(tasks?|taks|tsks|tasts)\b/i, /تكت|تاسك|مهام|مهمة/];
+const TASK_LIST_CUE = [
+    /\b(what|which|show|list|check|have|next|status|remaining|left|incomplete)\b/i,
+    /شنو|اي |اكو|عدن+ه?|باقي|الجاي|التالي|وين/,
+];
+const EXECUTE = [
+    /\b(run|execute|deploy|launch)\b/i,
+    /\bbuild\b/i,
+    /\bstart (the )?(server|service|app|build)\b/i,
+    /شغل|نفذ|ابني|شغّل/,
+];
+function safeResult(ambiguityReason) {
+    return {
+        intent: "unknown",
+        entityType: "unknown",
+        identifier: null,
+        action: "unknown",
+        confidence: "low",
+        ambiguityReason,
+    };
+}
+// taskPrefixes: the registered per-project prefixes, so "OL-001" is an id but "UTF-8" is not.
+// The caller supplies them (the router stays pure and sync); the default is the legacy T.
+export function classifyIntent(rawText, taskPrefixes = [LEGACY_PREFIX]) {
+    const text = (rawText ?? "").trim();
+    if (!text)
+        return safeResult("empty request");
+    const taskIds = extractTaskIds(text, taskPrefixes);
+    if (taskIds.length > 1) {
+        return safeResult(`multiple task identifiers found (${taskIds.join(", ")}); specify exactly one`);
+    }
+    if (taskIds.length === 1) {
+        const action = matchesAny(text, TASK_COMPLETE)
+            ? "complete"
+            : matchesAny(text, TASK_UPDATE)
+                ? "update"
+                : matchesAny(text, TASK_CONTINUE)
+                    ? "continue"
+                    : "get";
+        return {
+            intent: "task-lookup",
+            entityType: "task",
+            identifier: taskIds[0],
+            action,
+            confidence: "high",
+            ambiguityReason: null,
+        };
+    }
+    if (matchesAny(text, TASK_CREATE)) {
+        const titleMatch = TASK_CREATE_NAME.exec(text);
+        const identifier = titleMatch?.[1]?.trim() || null;
+        return {
+            intent: "task-create",
+            entityType: "task",
+            identifier,
+            action: "create",
+            confidence: identifier ? "high" : "medium",
+            ambiguityReason: identifier
+                ? null
+                : "no task title captured ('called <title>' / 'named <title>')",
+        };
+    }
+    const hasSaveVerb = matchesAny(text, SAVE_VERB);
+    const hasRememberVerb = matchesAny(text, REMEMBER_VERB);
+    const hasTarget = matchesAny(text, REMEMBER_TARGET) ||
+        matchesAny(text, AS_DECISION) ||
+        matchesAny(text, AS_KNOWLEDGE);
+    // "remember"/"note" only count as a save command when they have an explicit target
+    // ("this", "that", "as a decision", ...); bare "remember" (e.g. "what do you remember
+    // about X") is a recall question, handled below by MEMORY_LOOKUP instead.
+    if (hasSaveVerb || (hasRememberVerb && hasTarget)) {
+        const entityType = matchesAny(text, AS_DECISION)
+            ? "decision"
+            : matchesAny(text, AS_KNOWLEDGE)
+                ? "knowledge"
+                : "memory";
+        return {
+            intent: "remember",
+            entityType,
+            identifier: null,
+            action: "remember",
+            confidence: hasTarget ? "high" : "medium",
+            ambiguityReason: hasTarget
+                ? null
+                : "no explicit content target ('this'/'that') named for the save",
+        };
+    }
+    if (matchesAny(text, DECISION_LOOKUP)) {
+        return {
+            intent: "decision-lookup",
+            entityType: "decision",
+            identifier: null,
+            action: "lookup",
+            confidence: "high",
+            ambiguityReason: null,
+        };
+    }
+    if (matchesAny(text, WORK_STYLE)) {
+        return {
+            intent: "work-style-lookup",
+            entityType: "work-style",
+            identifier: null,
+            action: "lookup",
+            confidence: "high",
+            ambiguityReason: null,
+        };
+    }
+    if (matchesAny(text, PROJECT_CREATE)) {
+        const nameMatch = PROJECT_CREATE_NAME.exec(text);
+        const identifier = nameMatch ? nameMatch[1].trim() : null;
+        return {
+            intent: "project-create",
+            entityType: "project",
+            identifier,
+            action: "create",
+            confidence: identifier ? "high" : "medium",
+            ambiguityReason: identifier
+                ? null
+                : "no project name captured ('called <name>' / 'named <name>')",
+        };
+    }
+    if (matchesAny(text, PROJECT_DETECT)) {
+        return {
+            intent: "project-detect",
+            entityType: "project",
+            identifier: null,
+            action: "lookup",
+            confidence: "high",
+            ambiguityReason: null,
+        };
+    }
+    if (matchesAny(text, KNOWLEDGE_LOOKUP)) {
+        return {
+            intent: "knowledge-lookup",
+            entityType: "knowledge",
+            identifier: null,
+            action: "search",
+            confidence: "high",
+            ambiguityReason: null,
+        };
+    }
+    if (matchesAny(text, MEMORY_LOOKUP)) {
+        return {
+            intent: "memory-lookup",
+            entityType: "memory",
+            identifier: null,
+            action: "search",
+            confidence: "high",
+            ambiguityReason: null,
+        };
+    }
+    // No digit anywhere: "show me task 123" / "show TASK-123" name a malformed id, and the
+    // fail-closed rule says never to turn that into a list.
+    if (!/\d/.test(text) &&
+        matchesAny(text, TASK_NOUN) &&
+        matchesAny(text, TASK_LIST_CUE)) {
+        return {
+            intent: "task-lookup",
+            entityType: "task",
+            identifier: null,
+            action: "list",
+            confidence: "medium",
+            ambiguityReason: "task list request without an explicit task id; list the project's tasks, do not guess one",
+        };
+    }
+    // "continue"/"resume" is checked before the execute verbs on purpose: in Arabic "شغل" is
+    // both the noun "work" and the verb "run", so "كمل شغل اللوكين" ("continue the login
+    // work") would otherwise be read as an execution request. Continue wording wins and the
+    // result stays medium-confidence and ambiguous, which is the fail-closed direction.
+    if (matchesAny(text, TASK_CONTINUE)) {
+        return {
+            intent: "task-lookup",
+            entityType: "task",
+            identifier: null,
+            action: "continue",
+            confidence: "medium",
+            ambiguityReason: "'continue'/'resume' matched without an explicit task id or resolved project; could be a task or a project — confirm before retrieval",
+        };
+    }
+    if (matchesAny(text, EXECUTE)) {
+        return {
+            intent: "execute",
+            entityType: "execution",
+            identifier: null,
+            action: "execute",
+            confidence: "high",
+            ambiguityReason: null,
+        };
+    }
+    return safeResult("no recognizable entity, verb, or identifier matched in the request");
+}
+//# sourceMappingURL=intent-router.js.map

package/node_modules/@ocean/context/dist/context/resource-injection.js

@@ -0,0 +1,36 @@
+import { oceanEnvPair } from "@ocean/core/shared/paths.js";
+// This module used to read Ocean files (memory, knowledge, inbox, README, governance rules)
+// and inject their full content into every provider launch. That bulk injection is removed
+// per T-198: providers get a tiny identity/bootstrap signal only, never Ocean file contents.
+// On-demand reads happen through explicit Ocean operations (tasks, memory, knowledge, …),
+// not through what gets stuffed into a launch argument or env var at startup.
+export const OCEAN_BOOTSTRAP_MAX_BYTES = 256;
+const SUPPORTED_OPERATIONS = "context,tasks,memory-search,knowledge-search";
+function projectTag(project) {
+    if (project.status === "bound")
+        return project.projectId;
+    return project.status;
+}
+// Bounded, client-neutral: identifies Ocean as canonical and the resolved project (or its
+// absence), and names the on-demand operations a client can call. Never Ocean file content.
+export function buildOceanBootstrap(project, extra = {}) {
+    const rules = extra.rules && extra.rules > 0 ? ` rules=${extra.rules}` : "";
+    const content = `ocean=1 project=${projectTag(project)} confidence=${project.confidence}${rules} ops=${SUPPORTED_OPERATIONS}`;
+    const bytes = Buffer.byteLength(content, "utf8");
+    if (bytes > OCEAN_BOOTSTRAP_MAX_BYTES) {
+        throw new Error(`Ocean bootstrap exceeds the ${OCEAN_BOOTSTRAP_MAX_BYTES}-byte budget (${bytes} bytes): ${content}`);
+    }
+    return {
+        content,
+        manifest: { bytes, source: "ocean", transport: "bootstrap-env" },
+    };
+}
+// Delivered as environment variables only — never written into provider argv or a
+// provider-owned context file, and never a second source of truth for provider memory.
+export function bootstrapEnvironment(bootstrap) {
+    return {
+        ...oceanEnvPair("BOOTSTRAP", bootstrap.content),
+        ...oceanEnvPair("BOOTSTRAP_BYTES", String(bootstrap.manifest.bytes)),
+    };
+}
+//# sourceMappingURL=resource-injection.js.map

package/node_modules/@ocean/context/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@ocean/context",
+  "version": "1.1.0",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "./*.js": {
+      "import": "./dist/*.js"
+    }
+  }
+}

package/node_modules/@ocean/core/dist/domain/brain/brain-record.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+// Canonical brain-record schema (T-228): the frontmatter shape every markdown record under
+// brain/02-personal and brain/05-knowledge normalizes into. Types + zod only, no I/O — the
+// markdown layer (application/brain/brain-markdown.ts) is what actually reads legacy
+// frontmatter and maps it onto this shape.
+export const brainRecordSchema = z.object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    summary: z.string().default(""),
+    tags: z.array(z.string()).default([]),
+    type: z.string().default("unknown"),
+    confidence: z.string().default("unknown"),
+    created: z.string().nullable().default(null),
+    updated: z.string().nullable().default(null),
+    lastConfirmedAt: z.string().nullable().default(null),
+    // Normalized by domain/brain/record-scope.ts: "global", "project:<id>" or "invalid".
+    scope: z.string().default("global"),
+});
+export function validateBrainRecord(input) {
+    return brainRecordSchema.parse(input);
+}
+//# sourceMappingURL=brain-record.js.map

package/node_modules/@ocean/core/dist/domain/brain/record-scope.js

@@ -0,0 +1,22 @@
+import { isValidProjectId } from "../context/project-id.js";
+export function normalizeScope(raw) {
+    const value = (raw ?? "").trim();
+    if (value === "")
+        return { scope: "global", state: "defaulted" };
+    if (value === "global")
+        return { scope: "global", state: "declared" };
+    if (value.startsWith("project:")) {
+        const id = value.slice("project:".length);
+        if (isValidProjectId(id))
+            return { scope: `project:${id}`, state: "declared" };
+    }
+    return { scope: "invalid", state: "invalid" };
+}
+// Bound to P → global + project:P; unbound or ambiguous (null) → global only.
+export function visibleScopes(project) {
+    return project ? ["global", `project:${project}`] : ["global"];
+}
+export function scopeVisible(scope, project) {
+    return visibleScopes(project).includes(scope);
+}
+//# sourceMappingURL=record-scope.js.map

package/node_modules/@ocean/core/dist/domain/capabilities/browser-contract.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { capabilityContractSchema, } from "./capability-contract.js";
+const browserOperationSchema = z.enum([
+    "open",
+    "close",
+    "approve",
+    "navigate",
+    "read",
+    "observe",
+    "extract",
+    "click",
+    "type",
+    "replace-text",
+    "select",
+    "scroll",
+    "wait",
+    "upload",
+    "download",
+    "submit",
+]);
+// "required" always needs owner approval before execution; "conditional" needs it only
+// when the application layer determines the specific call crosses a trust boundary
+// (navigate: only when the destination origin differs from the session's current origin).
+const browserApprovalSchema = z.enum(["none", "required", "conditional"]);
+const browserCapabilityContractSchema = capabilityContractSchema.extend({
+    capability: z.literal("browser"),
+    operation: browserOperationSchema,
+    approval: browserApprovalSchema,
+});
+function define(operation, authority, idempotency, approval, verification) {
+    return browserCapabilityContractSchema.parse({
+        capability: "browser",
+        operation,
+        authority,
+        idempotency,
+        approval,
+        verification,
+    });
+}
+// authority/idempotency/approval mirror the retired Python prototype's per-operation
+// authority (observe/execute/execute-with-approval) and idempotent flag, translated onto
+// this codebase's authority scopes (profile/session/owner) plus an orthogonal approval
+// gate. Every read-only operation stays session-scoped and safe; state-changing
+// operations are session-scoped and non-repeatable; upload/download/submit and
+// cross-origin navigation require owner approval.
+export const browserContracts = {
+    open: define("open", "session", "non-repeatable", "none", "session record reaches status running with a live CDP endpoint"),
+    close: define("close", "session", "repeatable", "none", "session record reaches a terminal status and the browser process has exited"),
+    approve: define("approve", "owner", "repeatable", "required", "session approval is persisted and expires when the browser session closes"),
+    navigate: define("navigate", "session", "repeatable", "conditional", "live page URL matches the requested destination"),
+    read: define("read", "session", "safe", "none", "returned text is re-read from the live page, not cached"),
+    observe: define("observe", "session", "safe", "none", "returned elements are re-read from the live page, not cached"),
+    extract: define("extract", "session", "safe", "none", "returned values are re-read from the live page via the given selector"),
+    click: define("click", "session", "non-repeatable", "none", "the caller's expected outcome (navigation, staying on the page, or a selector's live element count) is re-checked against live state after the click"),
+    type: define("type", "session", "non-repeatable", "none", "live input value is re-read from the target element after typing"),
+    "replace-text": define("replace-text", "session", "non-repeatable", "none", "the live editor value contains the requested replacement and the selected occurrence was unique or explicit"),
+    select: define("select", "session", "non-repeatable", "none", "live input value is re-read from the target element after selecting"),
+    scroll: define("scroll", "session", "repeatable", "none", "live scroll position is re-read after scrolling"),
+    wait: define("wait", "session", "safe", "none", "the awaited selector or URL pattern is confirmed present on the live page"),
+    upload: define("upload", "owner", "non-repeatable", "required", "live file input reports the attached file names"),
+    download: define("download", "owner", "non-repeatable", "required", "downloaded file exists on disk with a non-zero size at the reported path"),
+    submit: define("submit", "owner", "non-repeatable", "required", "live page URL and load state are re-read after submission"),
+};
+//# sourceMappingURL=browser-contract.js.map