@amoree-code/ocean 0.0.0-stage → 1.2.0

package/node_modules/@ocean/loop/dist/operations/record-operations.js

@@ -0,0 +1,45 @@
+import { KNOWLEDGE_DIR, PERSONAL_DIR } from "@ocean/core/shared/paths.js";
+import { searchRecords, writeRecord } from "./memory-knowledge-operations.js";
+import { gateOperation, operationResult, } from "./operation-contract.js";
+import { projectCreate, projectDetect, projectUpdate, } from "./project-operations.js";
+import { taskCompleteOperation, taskCreate, taskGet, taskList, taskUpdate, } from "./task-operations.js";
+// Table-driven dispatch over the focused operation modules (task/memory/knowledge/project).
+// This module is the sole public entry point — see operation-scope.ts, record-io.ts,
+// task-operations.ts, memory-knowledge-operations.ts, and project-operations.ts for the
+// implementations.
+export async function runOperation(operation, classification, budget, options = {}) {
+    const gate = gateOperation(operation, classification, budget, options.approval);
+    if (!gate.ok)
+        return operationResult(operation, gate.reason);
+    const bounded = budget;
+    const cwd = options.cwd ?? process.cwd();
+    switch (operation) {
+        case "task.get":
+            return taskGet(classification, bounded, options, cwd);
+        case "task.list":
+            return taskList(classification, bounded, options, cwd);
+        case "task.update":
+            return taskUpdate(classification, bounded, options, cwd);
+        case "task.complete":
+            return taskCompleteOperation(classification, bounded, options, cwd);
+        case "task.create":
+            return taskCreate(classification, options, cwd);
+        case "memory.search":
+            return searchRecords("memory.search", "memory", [PERSONAL_DIR], classification, bounded, options);
+        case "knowledge.search":
+            return searchRecords("knowledge.search", "knowledge", [KNOWLEDGE_DIR], classification, bounded, options);
+        case "memory.write":
+            return writeRecord("memory.write", options, bounded);
+        case "knowledge.write":
+            return writeRecord("knowledge.write", options, bounded);
+        case "project.detect":
+            return projectDetect(classification, cwd);
+        case "project.create":
+            return projectCreate(classification, options);
+        case "project.update":
+            return projectUpdate(classification, options, cwd);
+        default:
+            return operationResult(operation, `unsupported operation '${operation}'`);
+    }
+}
+//# sourceMappingURL=record-operations.js.map

package/node_modules/@ocean/loop/dist/operations/task-linker.js

@@ -0,0 +1,40 @@
+import { sameProject } from "@ocean/core/shared/paths.js";
+// Metadata-first task linking. No body reads, embeddings, or fuzzy guesses. A candidate
+// only gains points from explicit metadata supplied by the caller, then stable recency.
+export function rankTaskCandidates(candidates, request) {
+    const wantedKeywords = new Set((request.keywords ?? []).map((value) => value.toLowerCase()));
+    const wantedRelationships = new Set(request.relationshipIds ?? []);
+    const now = Date.now();
+    const scored = candidates.map((candidate) => {
+        const reasons = [];
+        let score = 0;
+        if (request.projectId &&
+            sameProject(candidate.projectId, request.projectId)) {
+            score += 100;
+            reasons.push("project match");
+        }
+        if (request.state && candidate.state === request.state) {
+            score += 30;
+            reasons.push("state match");
+        }
+        const relationshipMatches = candidate.relationships.filter((id) => wantedRelationships.has(id));
+        if (relationshipMatches.length) {
+            score += 80 * relationshipMatches.length;
+            reasons.push("explicit relationship match");
+        }
+        const keywordMatches = candidate.keywords.filter((keyword) => wantedKeywords.has(keyword.toLowerCase()));
+        if (keywordMatches.length) {
+            score += 10 * keywordMatches.length;
+            reasons.push("keyword match");
+        }
+        const ageDays = Math.max(0, (now - Date.parse(candidate.updatedAt)) / 86_400_000);
+        if (Number.isFinite(ageDays)) {
+            score += Math.max(0, 5 - Math.floor(ageDays / 7));
+            reasons.push("recency considered");
+        }
+        return { ...candidate, score, reasons };
+    });
+    scored.sort((left, right) => right.score - left.score || left.id.localeCompare(right.id));
+    return scored.slice(0, Math.max(1, Math.min(20, request.limit ?? 20)));
+}
+//# sourceMappingURL=task-linker.js.map

package/node_modules/@ocean/loop/dist/operations/task-operations.js

@@ -0,0 +1,279 @@
+import { mkdir, readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { TASK_ID } from "@ocean/core/domain/tasks/task-id.js";
+import { atomicWrite, FRONTMATTER_READ_BYTES, } from "@ocean/core/shared/fs-utils.js";
+import { localDate } from "@ocean/core/shared/local-date.js";
+import { oceanPath, PROJECTS_DIR, projectSubdir, } from "@ocean/core/shared/paths.js";
+import { withNextTaskId } from "@ocean/core/shared/project-resolution.js";
+import { resolveTaskReference, } from "@ocean/core/shared/task-reference.js";
+import { completeTask } from "../tasks/archive-tasks.js";
+import { taskRecord, validTaskTitle } from "../tasks/new-task.js";
+import { approvalMatchesTarget, operationResult, selectFields, shapeRecords, validateTaskIdentifier, validateWriteTarget, } from "./operation-contract.js";
+import { crossProjectGuard, taskRoot, } from "./operation-scope.js";
+import { freshnessFor, readFrontmatterFile, relativeToOcean, requireAbsentTarget, } from "./record-io.js";
+const TASK_FIELDS = ["id", "title", "state", "goal", "priority", "updated_at"];
+const MUTABLE_TASK_FIELDS = [
+    "state",
+    "goal",
+    "priority",
+    "updated_at",
+    "next_action",
+];
+export async function taskGet(classification, budget, options, cwd) {
+    const identifier = validateTaskIdentifier(classification.identifier);
+    if (!identifier.valid)
+        return operationResult("task.get", identifier.reason);
+    const project = await crossProjectGuard(options, cwd);
+    if (!project.ok)
+        return operationResult("task.get", project.reason);
+    const resolved = await activeTask(identifier.value, project.projectId);
+    if (!resolved.ok)
+        return operationResult("task.get", resolved.reason);
+    const file = resolved.location.file;
+    const record = await readFrontmatterFile(file);
+    if (!record)
+        return operationResult("task.get", `task ${identifier.value} was not found in project '${project.projectId}'`);
+    if (record.size > budget.maxBytes) {
+        return operationResult("task.get", `task ${identifier.value} is ${record.size} bytes, budget.maxBytes allows ${budget.maxBytes} — refusing to silently truncate`, { violations: ["max-bytes-exceeded"] });
+    }
+    const shaped = {
+        identifier: identifier.value,
+        recordType: "task",
+        provenance: "task",
+        sourcePath: relativeToOcean(file),
+        freshness: freshnessFor(record.mtimeMs),
+        confidence: classification.confidence,
+        selectionReason: `exact task record requested by identifier ${identifier.value}`,
+        fields: selectFields(record.fields, TASK_FIELDS),
+    };
+    return {
+        operation: "task.get",
+        ok: true,
+        reason: `task ${identifier.value} selected`,
+        records: [shaped],
+        violations: [],
+        written: null,
+        packet: null,
+    };
+}
+export async function taskList(classification, budget, options, cwd) {
+    const project = await crossProjectGuard(options, cwd);
+    if (!project.ok)
+        return operationResult("task.list", project.reason);
+    const root = taskRoot(project.projectId);
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return operationResult("task.list", `no task directory for project '${project.projectId}'`);
+    }
+    const records = [];
+    const violations = [];
+    let bytes = 0;
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === "archive")
+            continue;
+        if (!TASK_ID.test(entry.name))
+            continue;
+        const file = path.join(root, entry.name, "task.md");
+        const record = await readFrontmatterFile(file);
+        if (!record)
+            continue;
+        bytes += Math.min(record.size, FRONTMATTER_READ_BYTES);
+        if (bytes > budget.maxBytes) {
+            violations.push(`max-bytes-exceeded: stopped listing at ${bytes} bytes (budget ${budget.maxBytes})`);
+            break;
+        }
+        records.push({
+            identifier: record.fields.id ?? entry.name,
+            recordType: "task",
+            provenance: "task",
+            sourcePath: relativeToOcean(file),
+            freshness: freshnessFor(record.mtimeMs),
+            confidence: classification.confidence,
+            selectionReason: `live task in project '${project.projectId}'`,
+            fields: selectFields(record.fields, TASK_FIELDS),
+        });
+    }
+    const shaped = shapeRecords(records, budget.maxFiles);
+    return {
+        operation: "task.list",
+        ok: true,
+        reason: `${shaped.records.length} task(s) listed for project '${project.projectId}'`,
+        records: shaped.records,
+        violations: [...violations, ...shaped.violations],
+        written: null,
+        packet: null,
+    };
+}
+// Resolves the task inside the active project only. A prefix that belongs to another project
+// gets the same refusal as any cross-project request.
+async function activeTask(id, projectId) {
+    try {
+        return {
+            ok: true,
+            location: await resolveTaskReference(id, {
+                projectId,
+                acrossProjects: false,
+            }),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const foreign = /^\S+ belongs to (\S+),/.exec(message);
+        if (foreign)
+            return {
+                ok: false,
+                reason: `cross-project request refused: active project is '${projectId}', request targeted '${foreign[1]}'`,
+            };
+        return {
+            ok: false,
+            reason: /is not a task in|no project uses prefix/.test(message)
+                ? `task ${id} was not found in project '${projectId}'`
+                : message,
+        };
+    }
+}
+export async function taskCreate(classification, options, cwd) {
+    const project = await crossProjectGuard(options, cwd);
+    if (!project.ok)
+        return operationResult("task.create", project.reason);
+    const title = classification.identifier?.trim();
+    if (!validTaskTitle(title))
+        return operationResult("task.create", "write refused: an explicit single-line task title is required");
+    // Resolve the folder once so the id and the write target can never disagree.
+    const folder = projectSubdir(oceanPath(PROJECTS_DIR), project.projectId);
+    const today = localDate();
+    const objective = (options.content ?? title).trim().replace(/[\r\n]+/g, " ");
+    // The approval is bound to the path of the id that was predicted when it was granted. The id
+    // is issued under the projects lock, so a creator that lost the race is refused (and consumes
+    // nothing) instead of writing under an id nobody approved.
+    return withNextTaskId(project.projectId, async (id) => {
+        const target = validateWriteTarget(PROJECTS_DIR, folder, "tasks", id, "task.md");
+        if (!target.valid)
+            return operationResult("task.create", target.reason);
+        const approvalCheck = approvalMatchesTarget(options.approval, target.value);
+        if (!approvalCheck.ok)
+            return operationResult("task.create", `write refused: the next id is now ${id}; the approval covered ${options.approval?.target} — request a new approval`);
+        const absent = await requireAbsentTarget(target.value);
+        if (!absent.ok)
+            return operationResult("task.create", absent.reason);
+        const source = taskRecord({
+            id,
+            title,
+            project: project.projectId,
+            objective,
+            today,
+        });
+        try {
+            await mkdir(path.dirname(target.value), { recursive: true });
+            const bytes = await atomicWrite(target.value, source);
+            return {
+                operation: "task.create",
+                ok: true,
+                reason: `${id} created for project '${project.projectId}'`,
+                records: [],
+                violations: [],
+                written: { sourcePath: relativeToOcean(target.value), bytes },
+                packet: null,
+            };
+        }
+        catch (error) {
+            return operationResult("task.create", `task creation failed atomically, no partial content left: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+}
+export async function taskUpdate(classification, budget, options, cwd) {
+    const identifier = validateTaskIdentifier(classification.identifier);
+    if (!identifier.valid)
+        return operationResult("task.update", identifier.reason);
+    const project = await crossProjectGuard(options, cwd);
+    if (!project.ok)
+        return operationResult("task.update", project.reason);
+    const patch = options.patch ?? {};
+    const patchKeys = Object.keys(patch);
+    if (patchKeys.length === 0)
+        return operationResult("task.update", "write refused: no explicit field patch supplied");
+    const unknownField = patchKeys.find((key) => !MUTABLE_TASK_FIELDS.includes(key));
+    if (unknownField)
+        return operationResult("task.update", `write refused: field '${unknownField}' is not an updatable task field`);
+    const resolved = await activeTask(identifier.value, project.projectId);
+    if (!resolved.ok || resolved.location.archived)
+        return operationResult("task.update", resolved.ok
+            ? `task ${identifier.value} was not found in project '${project.projectId}'`
+            : resolved.reason);
+    const target = validateWriteTarget(PROJECTS_DIR, projectSubdir(oceanPath(PROJECTS_DIR), project.projectId), "tasks", resolved.location.id, "task.md");
+    if (!target.valid)
+        return operationResult("task.update", target.reason);
+    const approvalCheck = approvalMatchesTarget(options.approval, target.value);
+    if (!approvalCheck.ok)
+        return operationResult("task.update", approvalCheck.reason);
+    let source;
+    try {
+        source = await readFile(target.value, "utf8");
+    }
+    catch {
+        return operationResult("task.update", `task ${identifier.value} was not found in project '${project.projectId}'`);
+    }
+    if (Buffer.byteLength(source, "utf8") > budget.maxBytes) {
+        return operationResult("task.update", `task ${identifier.value} exceeds budget.maxBytes (${budget.maxBytes}) — refusing to rewrite a record it cannot fully read`, { violations: ["max-bytes-exceeded"] });
+    }
+    let updated = source;
+    for (const [key, value] of Object.entries(patch)) {
+        if (value.includes("\n"))
+            return operationResult("task.update", `write refused: value for '${key}' must be a single line`);
+        const pattern = new RegExp(`^${key}:.*$`, "m");
+        updated = pattern.test(updated)
+            ? updated.replace(pattern, `${key}: ${value}`)
+            : updated;
+    }
+    if (updated === source)
+        return operationResult("task.update", "write refused: patch did not match any existing frontmatter field");
+    const bytes = await atomicWrite(target.value, updated);
+    return {
+        operation: "task.update",
+        ok: true,
+        reason: `task ${identifier.value} updated (${patchKeys.join(", ")})`,
+        records: [],
+        violations: [],
+        written: { sourcePath: relativeToOcean(target.value), bytes },
+        packet: null,
+    };
+}
+export async function taskCompleteOperation(classification, _budget, options, cwd) {
+    const identifier = validateTaskIdentifier(classification.identifier);
+    if (!identifier.valid)
+        return operationResult("task.complete", identifier.reason);
+    const project = await crossProjectGuard(options, cwd);
+    if (!project.ok)
+        return operationResult("task.complete", project.reason);
+    const resolved = await activeTask(identifier.value, project.projectId);
+    if (!resolved.ok || resolved.location.archived)
+        return operationResult("task.complete", resolved.ok
+            ? `task ${identifier.value} was not found in project '${project.projectId}'`
+            : resolved.reason);
+    const target = validateWriteTarget(PROJECTS_DIR, projectSubdir(oceanPath(PROJECTS_DIR), project.projectId), "tasks", resolved.location.id, "task.md");
+    if (!target.valid)
+        return operationResult("task.complete", target.reason);
+    const approvalCheck = approvalMatchesTarget(options.approval, target.value);
+    if (!approvalCheck.ok)
+        return operationResult("task.complete", approvalCheck.reason);
+    try {
+        // Reuses the existing governed completion path: it refuses a task with unchecked work.
+        const result = await completeTask(resolved.location.id, taskRoot(project.projectId));
+        return {
+            operation: "task.complete",
+            ok: true,
+            reason: `task ${identifier.value} completed (state: ${result.state})`,
+            records: [],
+            violations: [],
+            written: { sourcePath: relativeToOcean(target.value), bytes: 0 },
+            packet: null,
+        };
+    }
+    catch (error) {
+        return operationResult("task.complete", error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=task-operations.js.map

package/node_modules/@ocean/loop/dist/operations/write-guard.js

@@ -0,0 +1,157 @@
+import { createHash, randomUUID } from "node:crypto";
+import path from "node:path";
+import { validateBudget } from "@ocean/context/context/context-ladder.js";
+import { engineRoot, oceanRoot, resolveWithin, } from "@ocean/core/shared/paths.js";
+import { OPERATION_KIND, } from "./operation-contract.js";
+const DEFAULT_GRANT_TTL_MS = 15 * 60 * 1000;
+// A grant is bound to the exact scope it was granted for. Any change to the action, the
+// resolved target, the record identifier, or the project produces a different hash, so a
+// reused grant cannot silently cover a different write.
+export function computeScopeHash(scope) {
+    const canonical = JSON.stringify({
+        action: scope.action,
+        target: path.resolve(scope.target),
+        identifier: scope.identifier ?? null,
+        projectId: scope.projectId ?? null,
+    });
+    return createHash("sha256").update(canonical).digest("hex").slice(0, 32);
+}
+export function createGrant(sessionId, scope, options = {}) {
+    const now = options.now ?? Date.now();
+    return {
+        grantId: randomUUID(),
+        sessionId,
+        action: scope.action,
+        target: path.resolve(scope.target),
+        scopeHash: computeScopeHash(scope),
+        grantedAt: new Date(now).toISOString(),
+        expiresAt: new Date(now + (options.ttlMs ?? DEFAULT_GRANT_TTL_MS)).toISOString(),
+        revokedAt: null,
+        consumed: false,
+    };
+}
+export function revokeGrant(grant, now = Date.now()) {
+    return { ...grant, revokedAt: new Date(now).toISOString() };
+}
+export function consentStateOf(grant, now = Date.now()) {
+    if (!grant)
+        return "none";
+    if (grant.revokedAt)
+        return "revoked";
+    if (Date.parse(grant.expiresAt) <= now)
+        return "expired";
+    return "granted";
+}
+function decision(request, code, reason, consent, scopeHash, approval = null) {
+    return {
+        allowed: code === "allowed",
+        code,
+        reason,
+        consent,
+        approval,
+        audit: {
+            action: request.scope.action,
+            target: path.resolve(request.scope.target),
+            sessionId: request.sessionId,
+            scopeHash,
+            intent: request.classification.intent,
+            confidence: request.classification.confidence,
+            code,
+            decidedAt: new Date(request.now ?? Date.now()).toISOString(),
+        },
+    };
+}
+// The one decision function. Read operations pass straight through (they are bounded
+// elsewhere); every write, execution, and provider invocation is evaluated here.
+export function evaluateGuard(request) {
+    const now = request.now ?? Date.now();
+    const scopeHash = computeScopeHash(request.scope);
+    const consent = consentStateOf(request.grant, now);
+    const budgetCheck = validateBudget(request.budget);
+    if (!budgetCheck.valid)
+        return decision(request, "invalid-budget", `denied: ${budgetCheck.reason}`, consent, scopeHash);
+    const isRecordOperation = request.scope.action in OPERATION_KIND;
+    const needsApproval = !isRecordOperation ||
+        OPERATION_KIND[request.scope.action] === "write";
+    if (!needsApproval) {
+        return decision(request, "allowed", "read operation: no approval required", consent, scopeHash, null);
+    }
+    if (request.classification.intent === "unknown") {
+        return decision(request, "unknown-intent", "denied: unknown intent may never write, execute, or invoke a provider", consent, scopeHash);
+    }
+    if (request.classification.ambiguityReason) {
+        return decision(request, "ambiguous-intent", `denied: ambiguous intent may never write, execute, or invoke a provider (${request.classification.ambiguityReason})`, consent, scopeHash);
+    }
+    if (request.classification.confidence !== "high") {
+        return decision(request, "low-confidence", `denied: confidence '${request.classification.confidence}' is below the required 'high'`, consent, scopeHash);
+    }
+    if (request.scope.target.includes("\0")) {
+        return decision(request, "invalid-target", "denied: target contains a null byte", consent, scopeHash);
+    }
+    // A record write must resolve inside the private Ocean root and never inside the public
+    // engine package, whatever path the caller passed. resolveWithin (paths.js) rejects both a
+    // lexical escape and a symlink that resolves outside the given root, so a symlink planted
+    // inside the Ocean root pointing outside it can't be used to land a write elsewhere.
+    if (isRecordOperation) {
+        const resolved = path.resolve(request.scope.target);
+        try {
+            resolveWithin(oceanRoot(), resolved);
+        }
+        catch {
+            return decision(request, "invalid-target", "denied: target escapes the Ocean root", consent, scopeHash);
+        }
+        let insideEngine = true;
+        try {
+            resolveWithin(engineRoot(), resolved);
+        }
+        catch {
+            insideEngine = false;
+        }
+        if (insideEngine) {
+            return decision(request, "invalid-target", "denied: refusing to write private Ocean content inside the public engine package", consent, scopeHash);
+        }
+    }
+    if (consent === "none")
+        return decision(request, "no-consent", "denied: no explicit approval grant was supplied — approval is never inferred from wording", consent, scopeHash);
+    if (consent === "revoked")
+        return decision(request, "consent-revoked", "denied: the approval grant was revoked", consent, scopeHash);
+    if (consent === "expired")
+        return decision(request, "consent-expired", "denied: the approval grant has expired", consent, scopeHash);
+    const grant = request.grant;
+    if (grant.consumed)
+        return decision(request, "consent-consumed", "denied: the approval grant was already used and is not reusable", consent, scopeHash);
+    if (grant.sessionId !== request.sessionId) {
+        return decision(request, "wrong-session", `denied: the approval grant belongs to session ${grant.sessionId}, not ${request.sessionId} — approval is never inherited`, consent, scopeHash);
+    }
+    if (grant.action !== request.scope.action) {
+        return decision(request, "wrong-action", `denied: the approval grant covers '${grant.action}', not '${request.scope.action}'`, consent, scopeHash);
+    }
+    if (path.resolve(grant.target) !== path.resolve(request.scope.target)) {
+        return decision(request, "wrong-target", `denied: the approval grant covers a different target`, consent, scopeHash);
+    }
+    if (grant.scopeHash !== scopeHash) {
+        return decision(request, "scope-changed", "denied: the request scope changed after the approval was granted", consent, scopeHash);
+    }
+    const approval = isRecordOperation
+        ? {
+            approved: true,
+            operation: request.scope.action,
+            target: path.resolve(request.scope.target),
+        }
+        : null;
+    return decision(request, "allowed", `approved: grant ${grant.grantId} covers this exact action, target, and scope`, consent, scopeHash, approval);
+}
+// Marks a grant used. A grant is single-use, so an approved write cannot be replayed.
+export function consumeGrant(grant) {
+    return { ...grant, consumed: true };
+}
+// The single sanctioned write path: guard first, operation second. A caller that skips this
+// still hits slice 7's own approval check, which only accepts the approval object the guard
+// produces — there is no path to a durable write that bypasses both.
+export async function guardedRunOperation(request, run) {
+    const verdict = evaluateGuard(request);
+    if (!verdict.allowed)
+        return { decision: verdict, result: null };
+    return { decision: verdict, result: await run(verdict.approval) };
+}
+//# sourceMappingURL=write-guard.js.map

package/node_modules/@ocean/loop/dist/runs/prompt-assembly.js

@@ -0,0 +1,112 @@
+import path from "node:path";
+import { redactRuntimeText } from "@ocean/core/domain/redaction/redaction.js";
+import { truncateUtf8 } from "@ocean/core/shared/fs-utils.js";
+// Pure formatting for the headless runAgent prompt: every section is text built from data
+// the caller already loaded, and each section's byte size is measured so the context_cost
+// event can report where the bytes went. No I/O here.
+export const PROMPT_SECTIONS = [
+    "request",
+    "profile",
+    "instructions",
+    "skills",
+    "facts",
+    "handoff",
+    "context",
+];
+export const PROMOTED_SKILL_MAX_BYTES = 4_096;
+export const SKILL_DESCRIPTION_MAX_BYTES = 300;
+const SEPARATOR = "\n\n";
+// Joins the non-empty sections in PROMPT_SECTIONS order. `separators` counts the join bytes,
+// so the breakdown always sums exactly to `bytes`.
+export function assemblePrompt(sections) {
+    const breakdown = {};
+    const present = [];
+    for (const name of PROMPT_SECTIONS) {
+        const text = sections[name];
+        breakdown[name] = text ? Buffer.byteLength(text) : 0;
+        if (text)
+            present.push(text);
+    }
+    breakdown.separators = present.length
+        ? Buffer.byteLength(SEPARATOR) * (present.length - 1)
+        : 0;
+    const prompt = present.join(SEPARATOR);
+    return { prompt, bytes: Buffer.byteLength(prompt), breakdown };
+}
+const collapse = (value) => value.replace(/\s*\n\s*/g, " ").trim();
+const list = (values) => JSON.stringify(values);
+// The effective profile as compact `key: value` lines, omitting empty and default fields.
+// writePolicy is always emitted: it is a safety statement even at its default.
+export function formatProfileContract(profile, run) {
+    const lines = [
+        `profile: ${collapse(profile.name)}`,
+        `role: ${collapse(profile.role)}`,
+        `provider: ${profile.provider}`,
+    ];
+    if (profile.model !== "provider-managed")
+        lines.push(`model: ${collapse(profile.model)}`);
+    const client = profile.clients[profile.provider];
+    if (client) {
+        if (client.capabilities.length)
+            lines.push(`client.capabilities: ${list(client.capabilities)}`);
+        if (client.limitations.length)
+            lines.push(`client.limitations: ${list(client.limitations)}`);
+        if (client.model)
+            lines.push(`client.model: ${collapse(client.model)}`);
+        if (client.profile)
+            lines.push(`client.profile: ${collapse(client.profile)}`);
+        if (client.mode)
+            lines.push(`client.mode: ${collapse(client.mode)}`);
+    }
+    lines.push(`writePolicy: ${profile.writePolicy}`);
+    if (profile.allowedPaths.length)
+        lines.push(`allowedPaths: ${list(profile.allowedPaths)}`);
+    if (profile.allowedCommands.length)
+        lines.push(`allowedCommands: ${list(profile.allowedCommands)}`);
+    if (profile.verification.commands.length)
+        lines.push(`verification: ${list(profile.verification.commands)}`);
+    if (profile.governance?.approvalRequired)
+        lines.push("approvalRequired: true");
+    if (!profile.memory.enabled)
+        lines.push("memoryScope: disabled");
+    else if (profile.memory.scope !== "profile")
+        lines.push(`memoryScope: ${collapse(profile.memory.scope)}`);
+    if (run.taskId)
+        lines.push(`taskId: ${collapse(run.taskId)}`);
+    if (run.handoffId)
+        lines.push(`handoffId: ${collapse(run.handoffId)}`);
+    return `## Effective Ocean profile\n${lines.join("\n")}`;
+}
+// One line per skill: name, one-line description, and the SKILL.md path the provider reads
+// before applying it (progressive disclosure: bodies are never inlined).
+export function formatSkillIndex(entries) {
+    if (!entries.length)
+        return "";
+    const lines = entries.map((entry) => `- ${entry.name}: ${truncateUtf8(entry.description.replace(/\s+/g, " ").trim(), SKILL_DESCRIPTION_MAX_BYTES)} (${entry.path})`);
+    return `## Ocean skills\nSkill bodies are not inlined; read a skill's SKILL.md at the path shown before applying it.\n${lines.join("\n")}`;
+}
+// Lessons have no SKILL.md, so their (budget-bounded) text stays inline.
+export function formatActiveLessons(lessons) {
+    return lessons
+        .map((lesson) => `## Lesson: ${redactRuntimeText(lesson.title)} [${lesson.id}]\n${redactRuntimeText(lesson.body)}`)
+        .join("\n\n");
+}
+// The directories of referenced files that lie outside cwd, deduped in order. The prompt
+// points the provider at these files (skill folders, context references), so a provider
+// whose file tools are confined to its workspace must be granted them explicitly.
+export function readDirectoriesOutside(cwd, files) {
+    const root = path.resolve(cwd);
+    const directories = new Set();
+    for (const file of files) {
+        const directory = path.dirname(path.resolve(root, file));
+        const relative = path.relative(root, directory);
+        const inside = relative === "" ||
+            (relative !== ".." &&
+                !relative.startsWith(`..${path.sep}`) &&
+                !path.isAbsolute(relative));
+        if (!inside)
+            directories.add(directory);
+    }
+    return [...directories];
+}
+//# sourceMappingURL=prompt-assembly.js.map