@amoree-code/ocean 0.0.0-stage → 1.1.0

package/dist/application/scheduler/local-scheduler.js

@@ -0,0 +1,210 @@
+import { mkdir, open, readFile, rename, unlink, writeFile, } from "node:fs/promises";
+import path from "node:path";
+import { oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+import { runAgent } from "@ocean/loop/runs/run-agent.js";
+const file = () => oceanPath(SYSTEM_DIR, "schedules.json");
+const running = new Set();
+export async function listSchedules() {
+    try {
+        return JSON.parse(await readFile(file(), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+export async function saveSchedule(schedule) {
+    if (!Number.isFinite(schedule.intervalMs) || schedule.intervalMs < 1_000)
+        throw new Error("Schedule interval must be at least 1000ms");
+    await mutateSchedules((schedules) => [
+        ...schedules.filter((item) => item.id !== schedule.id),
+        schedule,
+    ]);
+}
+export async function setScheduleEnabled(id, enabled) {
+    let updated;
+    await mutateSchedules((schedules) => schedules.map((schedule) => {
+        if (schedule.id !== id)
+            return schedule;
+        updated = { ...schedule, enabled };
+        return updated;
+    }));
+    if (!updated)
+        throw new Error(`Schedule not found: ${id}`);
+    return updated;
+}
+export async function runSchedule(id, cwd, runtime) {
+    const schedule = (await listSchedules()).find((item) => item.id === id);
+    if (!schedule)
+        throw new Error(`Schedule not found: ${id}`);
+    await runAgent({ profileName: schedule.profile, prompt: schedule.prompt, cwd }, runtime);
+}
+export async function runDueSchedules(cwd, runtime) {
+    const now = Date.now();
+    const schedules = await listSchedules();
+    const ran = [];
+    for (const schedule of schedules) {
+        if (!schedule.enabled ||
+            Date.parse(schedule.nextRunAt) > now ||
+            (schedule.retryAt && Date.parse(schedule.retryAt) > now) ||
+            running.has(schedule.id))
+            continue;
+        const lease = await acquireLease(schedule.id);
+        if (!lease)
+            continue;
+        running.add(schedule.id);
+        try {
+            const session = await runAgent({ profileName: schedule.profile, prompt: schedule.prompt, cwd }, runtime);
+            if (session.status !== "completed")
+                throw new Error(`Scheduled run failed: ${session.sessionId}`);
+            schedule.nextRunAt = new Date(now + schedule.intervalMs).toISOString();
+            ran.push(schedule.id);
+        }
+        finally {
+            running.delete(schedule.id);
+            await lease.close();
+            await unlink(leaseFile(schedule.id)).catch(() => undefined);
+        }
+    }
+    for (const id of ran) {
+        const completed = schedules.find((schedule) => schedule.id === id);
+        if (completed)
+            await mutateSchedules((current) => current.map((item) => item.id === id ? { ...item, nextRunAt: completed.nextRunAt } : item));
+    }
+    return ran;
+}
+export async function runSchedulerWorkerOnce(cwd, runtime) {
+    const schedules = await listSchedules();
+    const ran = [];
+    for (const schedule of schedules) {
+        if (!schedule.enabled || Date.parse(schedule.nextRunAt) > Date.now())
+            continue;
+        const lease = leaseFile(schedule.id);
+        const handle = await acquireLease(schedule.id);
+        if (!handle)
+            continue;
+        try {
+            try {
+                const session = await runAgent({ profileName: schedule.profile, prompt: schedule.prompt, cwd }, runtime);
+                if (session.status !== "completed")
+                    throw new Error(`Scheduled run failed: ${session.sessionId}`);
+                schedule.nextRunAt = new Date(Date.now() + schedule.intervalMs).toISOString();
+                schedule.attempts = 0;
+                delete schedule.retryAt;
+                ran.push(schedule.id);
+            }
+            catch {
+                schedule.attempts = (schedule.attempts ?? 0) + 1;
+                const delay = Math.min(schedule.intervalMs * 2 ** Math.min(schedule.attempts, 5), 3_600_000);
+                schedule.retryAt = new Date(Date.now() + delay).toISOString();
+                schedule.nextRunAt = schedule.retryAt;
+            }
+        }
+        finally {
+            await handle.close();
+            await unlink(lease).catch(() => undefined);
+        }
+    }
+    for (const changed of schedules) {
+        if (!ran.includes(changed.id) &&
+            changed.attempts === undefined &&
+            changed.retryAt === undefined)
+            continue;
+        await mutateSchedules((current) => current.map((item) => {
+            if (item.id !== changed.id)
+                return item;
+            const updated = {
+                ...item,
+                nextRunAt: changed.nextRunAt,
+                attempts: changed.attempts,
+            };
+            if (changed.retryAt)
+                updated.retryAt = changed.retryAt;
+            else
+                delete updated.retryAt;
+            return updated;
+        }));
+    }
+    return ran;
+}
+export async function runSchedulerWorker(cwd, runtime, options = {}) {
+    const pollMs = Math.max(1_000, options.pollMs ?? 30_000);
+    while (!options.signal?.aborted) {
+        await runSchedulerWorkerOnce(cwd, runtime);
+        await new Promise((resolve) => {
+            const timer = setTimeout(resolve, pollMs);
+            options.signal?.addEventListener("abort", () => {
+                clearTimeout(timer);
+                resolve();
+            }, { once: true });
+        });
+    }
+}
+function leaseFile(id) {
+    return oceanPath(SYSTEM_DIR, "schedules", `${id}.lease`);
+}
+async function acquireLease(id) {
+    const lease = leaseFile(id);
+    await mkdir(path.dirname(lease), { recursive: true });
+    try {
+        const handle = await open(lease, "wx");
+        await handle.writeFile(`${process.pid}\n`);
+        return handle;
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            const leaseContents = (await readFile(lease, "utf8").catch(() => "")).trim();
+            if (!leaseContents)
+                return null;
+            const owner = Number.parseInt(leaseContents, 10);
+            if (Number.isInteger(owner) && owner > 0 && processIsAlive(owner))
+                return null;
+            await unlink(lease).catch(() => undefined);
+            try {
+                const handle = await open(lease, "wx");
+                await handle.writeFile(`${process.pid}\n`);
+                return handle;
+            }
+            catch (retryError) {
+                if (retryError.code === "EEXIST")
+                    return null;
+                throw retryError;
+            }
+        }
+        throw error;
+    }
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+async function mutateSchedules(update) {
+    let lease = null;
+    for (let attempt = 0; attempt < 100 && !lease; attempt += 1) {
+        lease = await acquireLease("__registry__");
+        if (!lease)
+            await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    if (!lease)
+        throw new Error("Schedule registry remained busy for 1 second");
+    try {
+        const schedules = update(await listSchedules());
+        await mkdir(path.dirname(file()), { recursive: true });
+        const temporary = `${file()}.tmp-${process.pid}-${Date.now()}`;
+        await writeFile(temporary, `${JSON.stringify(schedules, null, 2)}\n`, {
+            mode: 0o600,
+        });
+        await rename(temporary, file());
+    }
+    finally {
+        await lease.close();
+        await unlink(leaseFile("__registry__")).catch(() => undefined);
+    }
+}
+//# sourceMappingURL=local-scheduler.js.map

package/dist/composition/runtime.js

@@ -0,0 +1,64 @@
+// Composition root. This is the one place (besides entry points) allowed to
+// import infrastructure concretes: it wires them to the domain ports that the
+// application layer depends on. Dependencies point inward everywhere else —
+// application → domain ports, never application → infrastructure.
+import { brainIndexPort } from "@ocean/brain/infrastructure/brain/brain-index.js";
+import { selectActiveLessons } from "@ocean/brain/memory/lesson-activation.js";
+import { openSessionStore, SessionStore, } from "@ocean/loop/infrastructure/persistence/session-store.js";
+import { loadProfile } from "../infrastructure/filesystem/profile-loader.js";
+import { loadSkillIndex } from "../infrastructure/filesystem/skill-loader.js";
+import { appendRuntimeLog } from "../infrastructure/observability/runtime-logger.js";
+import { executeAgentTool } from "../infrastructure/process/agent-tool-executor.js";
+import { runHeadless } from "../infrastructure/process/cli-process.js";
+import { runInteractive } from "../infrastructure/process/interactive-process.js";
+import { resolveClientHome } from "../infrastructure/providers/client-home.js";
+import { chatTransport, runCompletion, } from "../infrastructure/providers/openai-compatible.js";
+import { resolveOriginalExecutable } from "../infrastructure/providers/provider-registry.js";
+import { assertProviderSupportsReadOnly, runProvider, } from "../infrastructure/providers/providers.js";
+import { desktopWrapperPath, registerProvider, removeProvider, syncProviderWrappers, wrapperDoctor, } from "../infrastructure/wrappers/wrapper-manager.js";
+/** The concrete session-store factory, as the SessionStoreFactory port. */
+export const defaultSessionStoreFactory = openSessionStore;
+/** Opens a session-store file at an arbitrary path, as the SessionStoreOpener port. */
+export const defaultSessionStoreOpener = (file) => new SessionStore(file);
+/** The concrete brain-index driver (T-228), as the BrainIndexPort. */
+export const defaultBrainIndexPort = brainIndexPort;
+/** The concrete dependency set for `runAgent`/`resumeAgent`. */
+export const defaultAgentRuntime = {
+    openStore: openSessionStore,
+    executeProvider: runProvider,
+    executeCompletion: runCompletion,
+    chat: chatTransport,
+    executeAgentTool,
+    loadProfile,
+    loadSkillIndex,
+    loadActiveLessons: (prompt, maxBytes) => selectActiveLessons(prompt, { maxBytes, indexPort: defaultBrainIndexPort }),
+    resolveClientHome,
+    appendRuntimeLog,
+    assertProviderSupportsReadOnly,
+};
+/**
+ * Build an agent runtime with the real implementations, overriding any subset —
+ * used by tests to inject a fake provider executor while keeping the rest real.
+ */
+export function createAgentRuntime(overrides = {}) {
+    return { ...defaultAgentRuntime, ...overrides };
+}
+/** Shell wrapper management, as the WrapperManagerPort. */
+export const defaultWrapperManager = {
+    syncProviderWrappers,
+    registerProvider,
+    removeProvider,
+    wrapperDoctor,
+    desktopWrapperPath,
+};
+/** The provider registry, as the ProviderRegistryPort. */
+export const defaultProviderRegistry = {
+    resolveOriginalExecutable,
+};
+/** Dependencies for the auth flows. */
+export const defaultAuthDeps = {
+    registry: defaultProviderRegistry,
+    runHeadless,
+    runInteractive,
+};
+//# sourceMappingURL=runtime.js.map

package/dist/engine-root.js

@@ -0,0 +1,9 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+// Publishes the `ocean` package root for @ocean/core's engineRoot() (see
+// core/src/shared/paths.ts). This module sits one directory below that root, whether it
+// runs compiled from dist/ or directly from src/ under tsx. main.ts imports it first, and
+// it must not import core itself, so core's module-level paths already see the root.
+globalThis[Symbol.for("ocean.engineRoot")] =
+    path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+//# sourceMappingURL=engine-root.js.map

package/dist/infrastructure/filesystem/profile-loader.js

@@ -0,0 +1,46 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { assertProfileName, } from "@ocean/core/domain/profiles/profile.js";
+import { validateProfile } from "@ocean/core/domain/profiles/profile-validator.js";
+import { oceanPath, resolveWithin, SYSTEM_DIR, } from "@ocean/core/shared/paths.js";
+function missingAsNull(error) {
+    if (error.code === "ENOENT")
+        return null;
+    throw error;
+}
+// The parser's message quotes the text around the error, which could be part of a secret
+// pasted into the file, so only the file is named.
+function parseProfile(source, file) {
+    try {
+        return JSON.parse(source);
+    }
+    catch {
+        throw new Error(`Invalid profile JSON in ${file}`);
+    }
+}
+// The name inside the file must be the name it was loaded by: the name keys sessions and the
+// profile's memory namespace, so a mismatch would read or write another profile's facts.
+function requireName(profile, name, file) {
+    if (profile.name !== name)
+        throw new Error(`Profile ${file} declares name "${profile.name}", expected "${name}"`);
+    return profile;
+}
+export async function loadProfile(name) {
+    assertProfileName(name);
+    const root = oceanPath(SYSTEM_DIR, "profiles");
+    const file = resolveWithin(root, `${name}.json`);
+    // Only a missing canonical file falls through to the legacy directory form; a file that
+    // exists but cannot be read, parsed or validated is an error, never a silent fallback.
+    const source = await readFile(file, "utf8").catch(missingAsNull);
+    if (source !== null)
+        return requireName(validateProfile(parseProfile(source, file)), name, file);
+    const directory = resolveWithin(root, name);
+    if ((await stat(directory).catch(missingAsNull))?.isDirectory()) {
+        const legacy = path.join(directory, "profile.json");
+        const input = parseProfile(await readFile(legacy, "utf8"), legacy);
+        const instructions = await readFile(path.join(directory, "instructions.md"), "utf8").catch(() => "");
+        return requireName(validateProfile({ ...input, instructions }), name, legacy);
+    }
+    throw new Error(`Profile not found: ${name}`);
+}
+//# sourceMappingURL=profile-loader.js.map

package/dist/infrastructure/filesystem/runtime-config-loader.js

@@ -0,0 +1,29 @@
+import { readFile } from "node:fs/promises";
+import { validateRuntimeConfig, } from "@ocean/core/domain/profiles/runtime-config.js";
+import { oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+export function runtimeConfigFile() {
+    return oceanPath(SYSTEM_DIR, "config", "runtime.json");
+}
+// null only when the file does not exist; a file that exists but is not valid is an error.
+export async function loadRuntimeConfig() {
+    const file = runtimeConfigFile();
+    let source;
+    try {
+        source = await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    let input;
+    try {
+        input = JSON.parse(source);
+    }
+    catch {
+        // The parser's message quotes the file around the error; it is not repeated.
+        throw new Error(`Invalid runtime config JSON in ${file}`);
+    }
+    return validateRuntimeConfig(input);
+}
+//# sourceMappingURL=runtime-config-loader.js.map

package/dist/infrastructure/filesystem/skill-loader.js

@@ -0,0 +1,84 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { PROJECT_CATEGORY_FOLDERS } from "@ocean/core/domain/context/project-id.js";
+import { skillMetadataSchema, } from "@ocean/core/domain/skills/skill.js";
+import { validateSkill } from "@ocean/core/domain/skills/skill-validator.js";
+import { enginePath, oceanPath, oceanRoot, PROJECTS_DIR, SYSTEM_DIR, } from "@ocean/core/shared/paths.js";
+const catalogPath = enginePath("skills", "index.json");
+export async function listSkills() {
+    return readCatalog(catalogPath);
+}
+export async function loadSkill(name) {
+    const { metadata, file } = await resolveSkillFile(name, [
+        enginePath("skills"),
+    ]);
+    return validateSkill({
+        ...metadata,
+        instructions: await readFile(file, "utf8"),
+    });
+}
+// Resolves profile skills to catalog metadata plus their SKILL.md path, in order and
+// deduplicated, without reading any body. The description comes from index.json.
+export async function loadSkillIndex(names, cwd = oceanRoot()) {
+    const roots = skillRoots(cwd);
+    const entries = [];
+    const seen = new Set();
+    for (const name of names) {
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        const { metadata, file } = await resolveSkillFile(name, roots);
+        entries.push({ ...metadata, path: file });
+    }
+    return entries;
+}
+function skillRoots(cwd) {
+    return [
+        enginePath("skills"),
+        oceanPath(SYSTEM_DIR, "integrations", "claude-code", "skills"),
+        projectSkillRoot(cwd),
+    ].filter(Boolean);
+}
+// The first root whose index.json lists the skill and whose SKILL.md exists wins.
+async function resolveSkillFile(name, roots) {
+    for (const root of roots) {
+        const catalog = path.join(root, "index.json");
+        try {
+            const metadata = (await readCatalog(catalog)).find((skill) => skill.name === name);
+            if (!metadata)
+                continue;
+            const file = path.join(root, metadata.category, name, "SKILL.md");
+            await stat(file);
+            return { metadata, file };
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                continue;
+            throw error;
+        }
+    }
+    throw new Error(`Skill not found: ${name}`);
+}
+async function readCatalog(file) {
+    try {
+        return skillMetadataSchema
+            .array()
+            .parse(JSON.parse(await readFile(file, "utf8")));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+function projectSkillRoot(cwd) {
+    const projectsRoot = path.resolve(oceanPath(PROJECTS_DIR));
+    const relative = path.relative(projectsRoot, path.resolve(cwd));
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative))
+        return null;
+    const parts = relative.split(path.sep);
+    const grouped = PROJECT_CATEGORY_FOLDERS.includes(parts[0] ?? "");
+    const projectParts = grouped ? parts.slice(0, 2) : parts.slice(0, 1);
+    return path.join(projectsRoot, ...projectParts, "skills");
+}
+//# sourceMappingURL=skill-loader.js.map

package/dist/infrastructure/filesystem/workspace-capability.js

@@ -0,0 +1,37 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { workspaceReadContract } from "@ocean/core/domain/capabilities/capability-contract.js";
+export async function readWorkspaceFile(root, relativePath, allowedPaths, maxBytes = 32_000, timeoutMs = 5_000) {
+    const absolute = path.resolve(root, relativePath);
+    const allowed = allowedPaths.some((allowedPath) => {
+        const boundary = path.resolve(root, allowedPath);
+        return (absolute === boundary || absolute.startsWith(`${boundary}${path.sep}`));
+    });
+    if (!allowed)
+        throw new Error(`Capability denied outside allowed paths: ${relativePath}`);
+    if (timeoutMs <= 0)
+        throw new Error(`Capability timed out: ${relativePath}`);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    let content;
+    try {
+        content = (await readFile(absolute, { encoding: "utf8", signal: controller.signal })).slice(0, maxBytes);
+    }
+    catch (error) {
+        if (controller.signal.aborted)
+            throw new Error(`Capability timed out: ${relativePath}`);
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    return {
+        contract: workspaceReadContract,
+        path: relativePath,
+        bytes: Buffer.byteLength(content),
+        sha256: createHash("sha256").update(content).digest("hex"),
+        content,
+    };
+}
+//# sourceMappingURL=workspace-capability.js.map

package/dist/infrastructure/observability/runtime-logger.js

@@ -0,0 +1,16 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { redactRuntimeText, redactSecrets, } from "@ocean/core/domain/redaction/redaction.js";
+import { oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+// Redaction is a pure domain transform; re-exported here so existing infrastructure
+// callers keep importing it from the logger without reaching into domain directly.
+export { redactRuntimeText, redactSecrets };
+export async function appendRuntimeLog(log) {
+    const safe = {
+        ...log,
+        payload: log.payload === undefined ? undefined : redactRuntimeText(log.payload),
+    };
+    await mkdir(oceanPath(SYSTEM_DIR, "runtime", "logs"), { recursive: true });
+    await appendFile(path.join(oceanPath(SYSTEM_DIR, "runtime", "logs"), "runtime.jsonl"), `${JSON.stringify(safe)}\n`, "utf8");
+}
+//# sourceMappingURL=runtime-logger.js.map

package/dist/infrastructure/process/agent-tool-executor.js

@@ -0,0 +1,99 @@
+import { mkdir, readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { containsKnownSecret } from "@ocean/core/domain/redaction/redaction.js";
+import { atomicWrite } from "@ocean/core/shared/fs-utils.js";
+import { realDeepestExisting, resolveWithin, } from "@ocean/core/shared/paths.js";
+// Executes one already-validated file tool call for a tool-loop run (T-245 Phase 6).
+// Everything it touches is bounded to the plan's allowed paths under its cwd, judged and
+// operated on by real path, and never a credential-bearing or repository-internal file:
+// what a tool reads is sent to a third-party API.
+export const MAX_READ_BYTES = 64 * 1024;
+const MAX_LIST_ENTRIES = 500;
+// A policy refusal, as opposed to a tool that ran and failed. The loop records it as
+// `tool_denied` by this name.
+export class ToolDenied extends Error {
+    name = "ToolDenied";
+}
+// Case-insensitive: the default macOS volume is, so ".Git" is ".git".
+function isSensitive(relative) {
+    return relative
+        .split(/[\\/]/)
+        .some((segment) => /^\.git$/i.test(segment) ||
+        /^\.env(\..*)?$/i.test(segment) ||
+        /^\.envrc$/i.test(segment) ||
+        /^id_[a-z0-9]+(\.pub)?$/i.test(segment) ||
+        /\.(pem|key|p12|pfx|keystore|jks)$/i.test(segment) ||
+        /^\.(npmrc|netrc|pypirc|htpasswd|pgpass|git-credentials)$/i.test(segment) ||
+        /^(credentials|secrets?)(\.[a-z0-9]+)*$/i.test(segment) ||
+        /\.tfstate(\.backup)?$/i.test(segment) ||
+        /^\.(aws|ssh|gnupg|docker|kube)$/i.test(segment));
+}
+// The real location of a requested path inside one of the plan's allowed paths. Both the
+// requested name and the real location must pass the sensitivity check, so a symlink inside
+// an allowed path cannot lead to .env or .git; resolveWithin rejects lexical escapes and
+// symlinks that leave the root. Callers operate on the returned real path.
+function resolveTarget(plan, requested) {
+    if (path.isAbsolute(requested))
+        throw new ToolDenied("path must be relative to the working directory");
+    if (isSensitive(path.normalize(requested)))
+        throw new ToolDenied("path is a credential or repository-internal file");
+    const target = path.resolve(plan.cwd, requested);
+    for (const allowed of plan.allowedPaths) {
+        let root;
+        try {
+            root = resolveWithin(plan.cwd, allowed);
+        }
+        catch {
+            continue;
+        }
+        const relative = path.relative(root, target);
+        if (relative.startsWith("..") || path.isAbsolute(relative))
+            continue;
+        try {
+            resolveWithin(root, relative);
+        }
+        catch {
+            throw new ToolDenied("path escapes the allowed paths");
+        }
+        const real = realDeepestExisting(target);
+        if (isSensitive(path.relative(realDeepestExisting(root), real)))
+            throw new ToolDenied("path leads to a credential or repository-internal file");
+        return real;
+    }
+    throw new ToolDenied("path is outside the allowed paths");
+}
+export async function executeAgentTool(plan, name, args) {
+    if (name === "read_file") {
+        const target = resolveTarget(plan, args.path);
+        const info = await stat(target);
+        if (!info.isFile())
+            throw new ToolDenied("not a file");
+        if (info.size > MAX_READ_BYTES)
+            throw new ToolDenied(`file exceeds ${MAX_READ_BYTES} bytes`);
+        const content = await readFile(target, "utf8");
+        // Refused, not redacted: a redacted file edited and written back would be corrupted.
+        if (containsKnownSecret(content))
+            throw new ToolDenied("file appears to contain a credential");
+        return content;
+    }
+    if (name === "list_directory") {
+        const target = resolveTarget(plan, args.path);
+        const entries = (await readdir(target, { withFileTypes: true }))
+            .filter((entry) => !isSensitive(entry.name))
+            .map((entry) => (entry.isDirectory() ? `${entry.name}/` : entry.name))
+            .sort();
+        const shown = entries.slice(0, MAX_LIST_ENTRIES);
+        return [
+            ...shown,
+            ...(entries.length > shown.length
+                ? [`[${entries.length - shown.length} more entries not shown]`]
+                : []),
+        ].join("\n");
+    }
+    const { path: requested, content } = args;
+    const target = resolveTarget(plan, requested);
+    await mkdir(path.dirname(target), { recursive: true });
+    await atomicWrite(target, content);
+    return `wrote ${Buffer.byteLength(content)} bytes to ${requested}`;
+}
+//# sourceMappingURL=agent-tool-executor.js.map

package/dist/infrastructure/process/cli-process.js

@@ -0,0 +1,49 @@
+import { spawn } from "node:child_process";
+import { ownsGroup, superviseProcess } from "./process-supervisor.js";
+// Applied whenever a caller doesn't pass an explicit maxOutputBytes, so a headless run
+// without a budget contract can never buffer unbounded output (disk/memory exhaustion,
+// unbounded secret/log capture surface).
+export const DEFAULT_MAX_OUTPUT_BYTES = 64 * 1024 * 1024;
+export async function runHeadless(request) {
+    const events = [];
+    const supervision = superviseProcess({
+        timeoutMs: request.timeoutMs ?? 60_000,
+        maxOutputBytes: request.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES,
+        onLine: (line) => {
+            let event;
+            try {
+                event = { type: "json", data: JSON.parse(line) };
+            }
+            catch {
+                event = { type: "text", data: line };
+            }
+            events.push(event);
+            request.onEvent?.(event);
+        },
+    });
+    try {
+        const child = spawn(request.command, request.args, {
+            cwd: request.cwd,
+            env: { ...process.env, ...request.env },
+            stdio: ["ignore", "pipe", "pipe"],
+            detached: ownsGroup,
+            windowsHide: true,
+        });
+        supervision.attach(child);
+        if (child.pid)
+            request.onSpawn?.(child.pid);
+        await Promise.race([supervision.closed, supervision.released]);
+        if (supervision.spawnError && !supervision.timedOut)
+            throw supervision.spawnError;
+        supervision.flush();
+        return {
+            exitCode: supervision.exitCode(child.exitCode),
+            events,
+            stderr: supervision.stderr + supervision.stopNote,
+        };
+    }
+    finally {
+        supervision.finish();
+    }
+}
+//# sourceMappingURL=cli-process.js.map