@amoree-code/ocean 0.0.0-stage → 1.2.0

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

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export const capabilityContractSchema = z.object({
+    capability: z.string().min(1),
+    operation: z.string().min(1),
+    authority: z.enum(["profile", "session", "owner"]),
+    idempotency: z.enum(["safe", "repeatable", "non-repeatable"]),
+    verification: z.string().min(1),
+});
+export const workspaceReadContract = capabilityContractSchema.parse({
+    capability: "workspace",
+    operation: "read",
+    authority: "profile",
+    idempotency: "safe",
+    verification: "sha256 content hash",
+});
+//# sourceMappingURL=capability-contract.js.map

package/node_modules/@ocean/core/dist/domain/capabilities/capability-manifest.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+// The `ocean.capability.json` envelope (T-229). It is kind-agnostic on purpose: `kind` is an
+// open string and `spec` is opaque here, so a new kind is added by registering an adapter in
+// `@ocean/market`, never by editing this file.
+const sha256 = z
+    .string()
+    .regex(/^[0-9a-f]{64}$/, "expected a lowercase sha256 hex digest");
+export const semverPattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+export const capabilityKindSchema = z
+    .string()
+    .regex(/^[a-z][a-z0-9-]{0,31}$/, "expected a lowercase kind such as `skill` or `mcp`");
+// Reverse-DNS, optionally followed by `/<name>` the way the official MCP registry names servers
+// (`io.github.owner/server`).
+export const capabilityNameSchema = z
+    .string()
+    .max(200)
+    .regex(/^[a-z0-9-]+(\.[a-z0-9-]+)+(\/[a-z0-9._-]+)?$/, "expected a reverse-DNS name such as `dev.ocean.skills.ship`");
+const relativePath = z
+    .string()
+    .min(1)
+    .refine((value) => !/^([\\/]|[A-Za-z]:)/.test(value) && !value.split(/[\\/]/).includes(".."), "expected a relative path that stays inside the index");
+export const capabilitySourceSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("path"), path: relativePath }).strict(),
+    z
+        .object({ type: z.literal("url"), url: z.url({ protocol: /^https$/ }) })
+        .strict(),
+]);
+const permissionList = z.array(z.string().min(1)).default([]);
+// Declared up front so install can ask for consent and the runtime can refuse anything else.
+export const capabilityPermissionsSchema = z
+    .object({
+    filesystem: z
+        .object({ read: permissionList, write: permissionList })
+        .strict()
+        .default({ read: [], write: [] }),
+    network: permissionList,
+    env: permissionList,
+    exec: permissionList,
+})
+    .strict();
+export const capabilityManifestSchema = z
+    .object({
+    kind: capabilityKindSchema,
+    name: capabilityNameSchema,
+    version: z.string().regex(semverPattern, "expected a semver version"),
+    description: z.string().max(1000).optional(),
+    engines: z.object({ ocean: z.string().min(1) }).strict(),
+    source: capabilitySourceSchema,
+    integrity: z.object({ sha256 }).strict(),
+    provenance: z
+        .object({ type: z.literal("sigstore"), bundle: z.string().min(1) })
+        .strict()
+        .optional(),
+    permissions: capabilityPermissionsSchema.default({
+        filesystem: { read: [], write: [] },
+        network: [],
+        env: [],
+        exec: [],
+    }),
+    spec: z.unknown(),
+})
+    .strict();
+// `ocean-marketplace.json`: one index, many manifests. Several indexes (local, cached, the
+// official MCP registry) are merged by the catalog in `@ocean/market`.
+export const marketplaceIndexSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    name: z.string().min(1),
+    capabilities: z.array(capabilityManifestSchema),
+})
+    .strict();
+//# sourceMappingURL=capability-manifest.js.map

package/node_modules/@ocean/core/dist/domain/context/context-validator.js

@@ -0,0 +1,5 @@
+import { contextManifestSchema } from "./context.js";
+export function validateContextManifest(input) {
+    return contextManifestSchema.parse(input);
+}
+//# sourceMappingURL=context-validator.js.map

package/node_modules/@ocean/core/dist/domain/context/context.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+// A file the prompt points at instead of inlining. `path` is always relative: to the run cwd
+// for a profile contextSources entry, to the Ocean root for a context-packet record.
+export const contextReferenceSchema = z.object({
+    path: z.string().min(1),
+    base: z.enum(["cwd", "ocean-root"]),
+    recordType: z.string().min(1),
+    reason: z.string().min(1),
+    bytes: z.number().int().nonnegative().nullable(),
+});
+export const contextManifestSchema = z.object({
+    files: z.array(z.string()),
+    bytes: z.number().int().nonnegative(),
+    compactedSummary: z.string().nullable(),
+    lastContextCheckpoint: z.string().min(1),
+    maxBytes: z.number().int().positive().default(32_000),
+    omitted: z.array(z.string()).default([]),
+    compression: z
+        .object({
+        sourceId: z.string().min(1),
+        sourceHash: z.string().min(1),
+        originalBytes: z.number().int().nonnegative(),
+        compressedBytes: z.number().int().nonnegative(),
+        method: z.string().min(1),
+        budget: z.number().int().positive(),
+        omittedSections: z.array(z.string()),
+        recoveryRef: z.string().min(1),
+        safeToUse: z.boolean(),
+    })
+        .nullable()
+        .default(null),
+    references: z.array(contextReferenceSchema).default([]),
+});
+//# sourceMappingURL=context.js.map

package/node_modules/@ocean/core/dist/domain/context/project-id.js

@@ -0,0 +1,30 @@
+// A project id names a folder under 04-projects, so it must be one plain path segment. It is
+// lowercase because folders are case-insensitive on macOS and Windows: `Ocean-Language` and
+// `ocean-language` would be two ids for one folder, and one write would clobber the other.
+export const PROJECT_ID = /^[a-z0-9][a-z0-9._-]*$/;
+// Who a project belongs to (T-311). A project lives in the folder of its category,
+// 04-projects/<category>/<id>/; a new one lands in UNCATEGORIZED until it is moved.
+export const PROJECT_CATEGORIES = [
+    "company",
+    "personal",
+    "freelance",
+    "former-company",
+    "vendor",
+];
+export const UNCATEGORIZED = "uncategorized";
+// The folders directly under 04-projects that hold projects instead of being one.
+export const PROJECT_CATEGORY_FOLDERS = [
+    ...PROJECT_CATEGORIES,
+    UNCATEGORIZED,
+];
+export function isProjectCategory(value) {
+    return PROJECT_CATEGORIES.includes(value);
+}
+// A category folder name is never an id, so a flat folder and a category folder cannot be
+// confused while both layouts are read.
+export function isValidProjectId(value) {
+    return (PROJECT_ID.test(value) &&
+        !value.includes("..") &&
+        !PROJECT_CATEGORY_FOLDERS.includes(value));
+}
+//# sourceMappingURL=project-id.js.map

package/node_modules/@ocean/core/dist/domain/evidence/evidence.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+const evidenceResultSchema = z.enum(["proven", "not_proven", "limitation"]);
+export const evidenceSchema = z.object({
+    evidenceId: z.string().min(1),
+    sessionId: z.string().min(1),
+    type: z.string().min(1),
+    source: z.string().min(1),
+    observedAt: z.string().datetime(),
+    result: evidenceResultSchema,
+    criterion: z.string().min(1).nullable(),
+    payload: z.string().max(64_000),
+});
+export function validateEvidence(input) {
+    return evidenceSchema.parse(input);
+}
+//# sourceMappingURL=evidence.js.map

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

@@ -0,0 +1,36 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+export const mcpToolSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    inputSchema: z.record(z.string(), z.unknown()).optional(),
+    // Hints for the client's own permission UI. They are not enforcement: the server's own
+    // checks (roots, secrets, the writes switch) decide what a call may do.
+    annotations: z
+        .object({
+        readOnlyHint: z.boolean().optional(),
+        destructiveHint: z.boolean().optional(),
+        idempotentHint: z.boolean().optional(),
+    })
+        .optional(),
+});
+export const mcpApprovalSchema = z.object({
+    approved: z.literal(true),
+    fingerprint: z.string().length(64),
+});
+export function actionFingerprint(name, args) {
+    const canonical = (value) => {
+        if (Array.isArray(value))
+            return value.map(canonical);
+        if (value && typeof value === "object")
+            return Object.fromEntries(Object.entries(value)
+                .filter(([key]) => key !== "approval" && key !== "approved")
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([key, item]) => [key, canonical(item)]));
+        return value;
+    };
+    return createHash("sha256")
+        .update(JSON.stringify({ name, arguments: canonical(args) }))
+        .digest("hex");
+}
+//# sourceMappingURL=mcp-contract.js.map

package/node_modules/@ocean/core/dist/domain/mcp/memory-contract.js

@@ -0,0 +1,41 @@
+// The memory contract every MCP client of the `ocean` server receives (T-296). One source:
+// the server sends MEMORY_INSTRUCTIONS in `initialize`, and the memory tools refuse with one of
+// MEMORY_ERROR_CODES so a client can recover deterministically instead of parsing messages.
+export const MEMORY_CONTRACT_VERSION = 1;
+export const MEMORY_INSTRUCTIONS = [
+    "Ocean is this user's single memory and environment; do not keep durable facts only in this client's own memory.",
+    // Only Ocean's server sends this text, so it is true wherever it is read. A record listing
+    // clients that cannot connect is not about this session (T-307: Desktop chat misread it).
+    "If you can call these tools, this client is connected to Ocean.",
+    "Before answering about the user, their projects or past decisions, search with brain_search, read with brain_read or memory_read, and cite the record path.",
+    "Use memory_write only when the user explicitly asks you to remember or change something: search first, then mode create for a new record, or mode update with the current sha256 from memory_read as expectedHash.",
+    "Facts you infer yourself, and anything imported from another tool's memory, go to memory_propose for the user's review, never to memory_write.",
+    "Never store secrets, credentials or temporary state. If a new fact contradicts a record, tell the user instead of overwriting it.",
+    "memory_delete is a soft delete; memory_history and memory_restore undo changes.",
+    "Without a session-start hook, call ocean_context once. Use ocean_handoff_create only when the user asks for a handoff.",
+].join(" ");
+export const MEMORY_ERROR_CODES = [
+    "EXISTS",
+    "EXISTS_SIMILAR",
+    "MISSING",
+    "OUT_OF_ROOT",
+    "PROTECTED",
+    "SYMLINK",
+    "HARDLINK",
+    "SECRET",
+    "CONFLICT",
+    "TOO_LARGE",
+    "INVALID",
+    "WRITES_OFF",
+];
+export class MemoryContractError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.name = "MemoryContractError";
+        this.code = code;
+        this.details = details;
+    }
+}
+//# sourceMappingURL=memory-contract.js.map

package/node_modules/@ocean/core/dist/domain/ports/brain-index-port.js

@@ -0,0 +1,7 @@
+// Port for the brain (T-228) index driver. application/brain/* depends only on this — the
+// concrete node:sqlite + sqlite-vec implementation lives in infrastructure/brain/brain-index.ts
+// and is wired in through composition/runtime.js, never imported directly by application
+// code (enforced by tests/architecture.test.mjs).
+// 2: docs carry a scope. The index is a disposable cache, so a bump means "reindex", not a migration.
+export const BRAIN_INDEX_SCHEMA_VERSION = "2";
+//# sourceMappingURL=brain-index-port.js.map

package/node_modules/@ocean/core/dist/domain/ports/browser-port.js

@@ -0,0 +1,8 @@
+// The browser provider boundary. Everything above this file is Ocean: capability,
+// authority, verification, session identity. A provider is the only place a browser
+// engine may be named — see infrastructure/providers/playwright-browser-provider.ts.
+// Every call here returns a plain, JSON-safe value; a provider never decides whether
+// an action was verified, it only reports what it observed. Verification re-reads
+// state separately. These are pure interfaces, so they live in the domain layer.
+export {};
+//# sourceMappingURL=browser-port.js.map

package/node_modules/@ocean/core/dist/domain/ports/embedder-port.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=embedder-port.js.map

package/node_modules/@ocean/core/dist/domain/ports/platform-ports.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=platform-ports.js.map

package/node_modules/@ocean/core/dist/domain/ports/runtime-ports.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=runtime-ports.js.map

package/node_modules/@ocean/core/dist/domain/ports/session-store-port.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session-store-port.js.map

package/node_modules/@ocean/core/dist/domain/process/process-events.js

@@ -0,0 +1,5 @@
+// Pure process I/O contracts. These are the shapes exchanged with a headless
+// child process; they carry no behavior, so they live in the domain layer and
+// infrastructure/process/cli-process.ts re-exports them.
+export {};
+//# sourceMappingURL=process-events.js.map

package/node_modules/@ocean/core/dist/domain/profiles/profile-distribution.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+const profileDistributionSchema = z
+    .object({
+    name: z.string().min(1),
+    version: z.string().min(1),
+    description: z.string().default(""),
+    oceanRequires: z.string().optional(),
+    clients: z.array(z.string().min(1)).default([]),
+    files: z.array(z.string().min(1)).default([]),
+    distributionOwned: z.array(z.string().min(1)).default(["profile.json"]),
+})
+    .transform(({ oceanRequires, ...rest }) => ({
+    ...rest,
+    oceanRequires: oceanRequires ?? "*",
+}));
+export function validateProfileDistribution(input) {
+    return profileDistributionSchema.parse(input);
+}
+//# sourceMappingURL=profile-distribution.js.map

package/node_modules/@ocean/core/dist/domain/profiles/profile-policy.js

@@ -0,0 +1,34 @@
+import path from "node:path";
+import { isApiClient } from "./profile.js";
+const providerCommand = {
+    claude: "claude",
+    codex: "codex",
+    gemini: "gemini",
+    antigravity: "agy",
+    hermes: "hermes",
+    kilo: "kilo",
+    kimi: "kimi",
+};
+export function executionPolicy(profile, cwd) {
+    const command = isApiClient(profile.provider)
+        ? null
+        : providerCommand[profile.provider];
+    if (command !== null &&
+        profile.allowedCommands.length &&
+        !profile.allowedCommands.some((allowed) => command === allowed ||
+            path.basename(command) === path.basename(allowed))) {
+        throw new Error(`Policy denied provider command: ${command}`);
+    }
+    if (profile.writePolicy === "allowed-paths" &&
+        profile.allowedPaths.length === 0) {
+        throw new Error("Policy denied writable run without allowed paths");
+    }
+    if (!path.isAbsolute(cwd))
+        throw new Error("Policy denied non-absolute working directory");
+    return {
+        providerCommand: command,
+        writePolicy: profile.writePolicy,
+        allowedPaths: profile.allowedPaths,
+    };
+}
+//# sourceMappingURL=profile-policy.js.map

package/node_modules/@ocean/core/dist/domain/profiles/profile-selection.js

@@ -0,0 +1,73 @@
+// Profile suggestion for a task (T-296 §3.10): a fixed rule table over the task record —
+// its `kind`, title and objective, plus `class`/`risk` — picks one installed profile and says
+// why. First matching rule wins; nothing matching, or a profile that is not installed, falls
+// back to `default`. The suggestion never widens anything by itself: `ocean run` uses it only
+// when runtime.json turns `autoProfile` on, and an explicit --profile always wins.
+export const PROFILE_RULES = [
+    {
+        rule: "security",
+        profile: "security-auditor",
+        words: /\b(security|privacy|secrets?|vulnerab\w*|auth(entication|orization)?|permissions?|leaks?)\b/,
+    },
+    {
+        rule: "review",
+        profile: "reviewer",
+        words: /\b(review\w*|audit\w*|inspect\w*)\b/,
+    },
+    {
+        rule: "test",
+        profile: "tester",
+        words: /\b(tests?|testing|regressions?|reproduc\w*|flaky|coverage)\b/,
+    },
+    {
+        rule: "delivery",
+        profile: "devops",
+        words: /\b(deploy\w*|release\w*|ci|pipelines?|docker\w*|infra\w*|runtime|rollout)\b/,
+    },
+    {
+        rule: "research",
+        profile: "researcher",
+        words: /\b(research\w*|investigat\w*|compar\w*|evaluat\w*|spike|explor\w*)\b/,
+    },
+    {
+        rule: "planning",
+        profile: "strategist",
+        words: /\b(plan|planning|design|architecture|strategy|roadmap|proposal|decide)\b/,
+    },
+    {
+        rule: "implementation",
+        profile: "developer",
+        words: /\b(implement\w*|fix\w*|build\w*|add\w*|feat\w*|bugs?|refactor\w*|wire\w*|migrat\w*)\b/,
+    },
+];
+export function suggestProfile(task, installed) {
+    // The kind is a declared signal and is tried alone first; title and objective are prose.
+    const sources = [task.kind ?? "", `${task.title} ${task.objective ?? ""}`];
+    let match;
+    for (const text of sources) {
+        const lower = text.toLowerCase().slice(0, 2_000);
+        match = PROFILE_RULES.find((rule) => rule.words.test(lower));
+        if (match)
+            break;
+    }
+    const highRisk = [task.class, task.risk].some((value) => value?.toLowerCase() === "high");
+    const riskNote = highRisk ? "; high risk — verify before completing" : "";
+    if (!match)
+        return {
+            profile: "default",
+            rule: "fallback",
+            reason: `no rule matched ${task.id}${riskNote}`,
+        };
+    if (!installed.includes(match.profile))
+        return {
+            profile: "default",
+            rule: match.rule,
+            reason: `${match.rule} work suggests ${match.profile}, which is not installed${riskNote}`,
+        };
+    return {
+        profile: match.profile,
+        rule: match.rule,
+        reason: `${match.rule} work in ${task.id}${riskNote}`,
+    };
+}
+//# sourceMappingURL=profile-selection.js.map

package/node_modules/@ocean/core/dist/domain/profiles/profile-upgrade.js

@@ -0,0 +1,123 @@
+import { redactSecrets } from "../redaction/redaction.js";
+import { isApiClient, selectProfileClient } from "./profile.js";
+import { validateProfile } from "./profile-validator.js";
+const credentialKey = /api[-_]?key|token|secret|password|credential|bearer/i;
+// Paths only, never values: the report is printed and must not repeat a secret.
+function credentialIssues(value, at) {
+    if (typeof value === "string")
+        return redactSecrets(value).includes("[REDACTED]")
+            ? [`${at}: value looks like a credential`]
+            : [];
+    if (Array.isArray(value))
+        return value.flatMap((item, index) => credentialIssues(item, `${at}[${index}]`));
+    if (value && typeof value === "object")
+        return Object.entries(value).flatMap(([key, item]) => [
+            ...(credentialKey.test(key)
+                ? [`${at}.${key}: credential-like field`]
+                : []),
+            ...credentialIssues(item, `${at}.${key}`),
+        ]);
+    return [];
+}
+const credentialHint = "credentials never belong in a profile; set DEEPSEEK_API_KEY or OPENROUTER_API_KEY in the environment instead";
+function enabledClients(profile) {
+    return Object.entries(profile.clients)
+        .filter(([, binding]) => binding.enabled)
+        .map(([client]) => client);
+}
+// What a run would actually get from a profile, per enabled client. The upgrade must not
+// change any of it.
+function behaviour(profile) {
+    return {
+        defaultClient: profile.defaultClient,
+        clients: Object.fromEntries((enabledClients(profile).length
+            ? enabledClients(profile)
+            : [profile.provider]).map((client) => [client, selectProfileClient(profile, client).model])),
+        allowedPaths: profile.allowedPaths,
+        allowedCommands: profile.allowedCommands,
+        writePolicy: profile.writePolicy,
+        approvalRequired: profile.governance?.approvalRequired ?? false,
+        skills: profile.skills,
+        contextSources: profile.contextSources,
+        instructions: profile.instructions,
+        memoryEnabled: profile.memory.enabled && profile.memory.scope !== "disabled",
+        verification: profile.verification,
+        contextCompression: profile.contextCompression,
+    };
+}
+export function upgradeProfile(raw) {
+    const input = (raw ?? {});
+    const credentials = credentialIssues(raw, "profile");
+    if (credentials.length)
+        return { status: "rejected", issues: [...credentials, credentialHint] };
+    let v1;
+    try {
+        v1 = validateProfile(raw);
+    }
+    catch (error) {
+        return { status: "rejected", issues: [error.message] };
+    }
+    if (v1.schemaVersion === 2)
+        return { status: "current" };
+    const changes = [];
+    const rawClients = (input.clients ?? {});
+    const clientNames = Object.keys(rawClients).length
+        ? Object.keys(rawClients)
+        : [v1.provider];
+    const clients = Object.fromEntries(clientNames.map((client) => {
+        const binding = rawClients[client] ?? { enabled: true };
+        // The model a v1 run of this client gets, made explicit.
+        const model = binding.model ??
+            (client === v1.provider ? v1.model : "provider-managed");
+        if (binding.model === undefined)
+            changes.push(`clients.${client}.model: explicit "${model}"`);
+        return [
+            client,
+            {
+                ...binding,
+                transport: isApiClient(client) ? "openai-compatible-api" : "cli",
+                model,
+            },
+        ];
+    }));
+    const scope = v1.memory.scope === "disabled" ? "disabled" : "profile";
+    if (scope !== v1.memory.scope)
+        changes.push(`memory.scope: "${v1.memory.scope}" -> "${scope}"`);
+    const governance = (input.governance ?? {});
+    const profile = {
+        schemaVersion: 2,
+        name: v1.name,
+        description: v1.description,
+        version: v1.version,
+        role: v1.role,
+        // The raw list: an empty list still means "the role's default skills".
+        skills: Array.isArray(input.skills) ? input.skills : [],
+        contextSources: v1.contextSources,
+        defaultClient: v1.defaultClient,
+        clients,
+        governance: {
+            ...governance,
+            allowedPaths: v1.allowedPaths,
+            allowedCommands: v1.allowedCommands,
+            writePolicy: v1.writePolicy,
+        },
+        memory: { enabled: v1.memory.enabled, scope },
+        verification: v1.verification,
+        contextCompression: v1.contextCompression,
+        instructions: v1.instructions,
+    };
+    let v2;
+    try {
+        v2 = validateProfile(profile);
+    }
+    catch (error) {
+        return { status: "rejected", issues: [error.message] };
+    }
+    if (JSON.stringify(behaviour(v1)) !== JSON.stringify(behaviour(v2)))
+        return {
+            status: "rejected",
+            issues: ["upgrade would change how this profile runs"],
+        };
+    return { status: "upgrade", profile, changes };
+}
+//# sourceMappingURL=profile-upgrade.js.map

package/node_modules/@ocean/core/dist/domain/profiles/profile-validator.js

@@ -0,0 +1,5 @@
+import { profileSchema } from "./profile.js";
+export function validateProfile(input) {
+    return profileSchema.parse(input);
+}
+//# sourceMappingURL=profile-validator.js.map