@tangle-network/agent-profile-materialize 1.1.6 → 1.1.8

package/dist/hooks.js

@@ -1,250 +0,0 @@
-export function materializeHooks(h, hooks, add, unsupported, plan) {
-    switch (h) {
-        case "claude-code": {
-            // Claude settings hooks{} — each event → [{matcher, hooks:[{type:command,command}]}].
-            const settingsHooks = {};
-            for (const [event, cmds] of Object.entries(hooks)) {
-                if (!hookEventSupported("claude-code", event)) {
-                    unsupported("hooks", `claude-code: unsupported hook event "${event}"`);
-                    continue;
-                }
-                settingsHooks[event] = cmds.map((c) => ({
-                    matcher: c.matcher ?? "*",
-                    hooks: [
-                        {
-                            type: "command",
-                            command: materializedHookCommand(event, c, add, plan),
-                            ...(c.timeoutMs ? { timeout: timeoutSeconds(c.timeoutMs) } : {}),
-                            ...(c.blocking === false ? { async: true } : {}),
-                        },
-                    ],
-                }));
-            }
-            add(CLAUDE_SETTINGS_PATH, serializeWorkspacePlanJson({ hooks: settingsHooks }));
-            registerClaudeSettings(plan);
-            break;
-        }
-        case "nanoclaw":
-            unsupported("hooks", "nanoclaw's chat bridge does not expose Claude Code hook settings to the spawned agent");
-            break;
-        case "gemini": {
-            const settingsHooks = {};
-            for (const [event, cmds] of Object.entries(hooks)) {
-                if (!hookEventSupported("gemini", event)) {
-                    unsupported("hooks", `gemini: unsupported hook event "${event}"`);
-                    continue;
-                }
-                if (cmds.some((command) => command.blocking === false)) {
-                    unsupported("hooks", `gemini: hook event "${event}" does not support non-blocking commands`);
-                }
-                settingsHooks[event] = cmds.map((c) => ({
-                    matcher: c.matcher ?? "*",
-                    hooks: [
-                        {
-                            type: "command",
-                            command: materializedHookCommand(event, c, add, plan),
-                            ...(c.timeoutMs ? { timeout: c.timeoutMs } : {}),
-                        },
-                    ],
-                }));
-            }
-            add(".gemini/settings.json", serializeWorkspacePlanJson({ hooks: settingsHooks }));
-            break;
-        }
-        case "codex": {
-            for (const [event, cmds] of Object.entries(hooks).sort(([left], [right]) => compareStrings(left, right))) {
-                if (!hookEventSupported("codex", event)) {
-                    unsupported("hooks", `codex: unsupported hook event "${event}"`);
-                    continue;
-                }
-                if (cmds.some((command) => command.blocking === false)) {
-                    unsupported("hooks", `codex: hook event "${event}" cannot execute asynchronous commands`);
-                    continue;
-                }
-                const entries = cmds.map((command) => {
-                    const handler = [
-                        `type = ${tomlStr("command")}`,
-                        `command = ${tomlStr(materializedHookCommand(event, command, add, plan))}`,
-                        ...(command.timeoutMs
-                            ? [`timeout = ${timeoutSeconds(command.timeoutMs)}`]
-                            : []),
-                    ];
-                    return `{ matcher = ${tomlStr(command.matcher ?? "*")}, hooks = [{ ${handler.join(", ")} }] }`;
-                });
-                plan.flags.push("-c", `hooks.${event}=[${entries.join(", ")}]`);
-            }
-            break;
-        }
-        case "opencode":
-            unsupported("hooks", "opencode hooks require executable JS/TS plugins; command hooks cannot be translated exactly");
-            break;
-        case "kimi-code":
-            unsupported("hooks", "kimi hooks are [[hooks]] in the config TOML loaded via --config-file, not cwd — pass --config-file");
-            break;
-        case "pi":
-            unsupported("hooks", "pi hooks are TS extensions (.pi/extensions/*.ts) — build an extension");
-            break;
-        case "prime":
-            unsupported("hooks", "prime hooks are TS extensions (fork core/extensions), not command hooks — build an extension");
-            break;
-        case "hermes":
-            unsupported("hooks", "hermes project plugins do not expose an exact command-hook mapping");
-            break;
-        case "openclaw":
-            unsupported("hooks", "openclaw hooks are DISABLED by default — enable in ~/.openclaw/openclaw.json; cwd hooks/ alone is a no-op");
-            break;
-    }
-}
-export function registerClaudeSettings(plan) {
-    for (let index = 0; index < plan.flags.length - 1; index += 1) {
-        if (plan.flags[index] === "--settings" &&
-            plan.flags[index + 1] === CLAUDE_SETTINGS_PATH) {
-            return;
-        }
-    }
-    plan.flags.push("--settings", CLAUDE_SETTINGS_PATH);
-}
-const CLAUDE_HOOK_EVENTS = new Set([
-    "ConfigChange",
-    "CwdChanged",
-    "Elicitation",
-    "ElicitationResult",
-    "FileChanged",
-    "InstructionsLoaded",
-    "MessageDisplay",
-    "Notification",
-    "PermissionDenied",
-    "PermissionRequest",
-    "PostCompact",
-    "PostToolBatch",
-    "PostToolUse",
-    "PostToolUseFailure",
-    "PreCompact",
-    "PreToolUse",
-    "SessionEnd",
-    "SessionStart",
-    "Setup",
-    "Stop",
-    "StopFailure",
-    "SubagentStart",
-    "SubagentStop",
-    "TaskCompleted",
-    "TaskCreated",
-    "TeammateIdle",
-    "UserPromptExpansion",
-    "UserPromptSubmit",
-    "WorktreeCreate",
-    "WorktreeRemove",
-]);
-const CODEX_HOOK_EVENTS = new Set([
-    "PermissionRequest",
-    "PostCompact",
-    "PostToolUse",
-    "PreCompact",
-    "PreToolUse",
-    "SessionStart",
-    "Stop",
-    "SubagentStart",
-    "SubagentStop",
-    "UserPromptSubmit",
-]);
-const GEMINI_HOOK_EVENTS = new Set([
-    "AfterAgent",
-    "AfterModel",
-    "AfterTool",
-    "BeforeAgent",
-    "BeforeModel",
-    "BeforeTool",
-    "BeforeToolSelection",
-    "Notification",
-    "PreCompress",
-    "SessionEnd",
-    "SessionStart",
-]);
-function hookEventSupported(harness, event) {
-    switch (harness) {
-        case "claude-code":
-            return CLAUDE_HOOK_EVENTS.has(event);
-        case "codex":
-            return CODEX_HOOK_EVENTS.has(event);
-        case "gemini":
-            return GEMINI_HOOK_EVENTS.has(event);
-        default:
-            return false;
-    }
-}
-function timeoutSeconds(timeoutMs) {
-    return Math.max(1, Math.ceil(timeoutMs / 1000));
-}
-function materializedHookCommand(event, command, add, plan) {
-    if (!command.env || Object.keys(command.env).length === 0) {
-        return command.command;
-    }
-    const wrapperId = canonicalCandidateDigest({
-        event,
-        command: command.command,
-        env: Object.fromEntries(Object.entries(command.env).sort(([left], [right]) => compareStrings(left, right))),
-    }).slice("sha256:".length);
-    const path = `.tangle/profile-hooks/${wrapperId}.mjs`;
-    const envSources = Object.fromEntries(Object.entries(command.env)
-        .sort(([left], [right]) => compareStrings(left, right))
-        .map(([name, value]) => {
-        const sourceName = `TANGLE_PROFILE_HOOK_${sha256(`${wrapperId}\0${name}`)
-            .slice(0, 24)
-            .toUpperCase()}`;
-        setPlanEnvironment(plan, sourceName, value);
-        return [name, sourceName];
-    }));
-    add(path, hookWrapperSource("/bin/sh", ["-c", command.command], {}, envSources));
-    return `node ${path}`;
-}
-// Classic plan env accepts string | AgentProfileConfigValue (public | secretRef)
-// in profile-plan.ts: keep resolved secrets out of workspace files by carrying
-// source names and resolving at runtime, failing closed with 127 when missing.
-// candidatePublicString rejects non-public values, so candidates inline them
-// to keep sealed bundles self-contained without a runtime environment channel.
-export function hookWrapperSource(executable, args, extraEnv, envSources) {
-    if (envSources !== undefined && Object.keys(extraEnv).length > 0) {
-        throw new Error("Hook wrapper cannot mix inline environment values and sources");
-    }
-    return [
-        'import { spawnSync } from "node:child_process"',
-        `const executable = ${JSON.stringify(executable)}`,
-        `const args = ${JSON.stringify(args)}`,
-        ...(envSources === undefined
-            ? [`const extraEnv = ${JSON.stringify(extraEnv)}`]
-            : [
-                `const envSources = ${JSON.stringify(envSources)}`,
-                "const extraEnv = {}",
-                "for (const [name, source] of Object.entries(envSources)) {",
-                "  const value = process.env[source]",
-                "  if (value === undefined) {",
-                '    console.error("missing materialized hook environment " + source)',
-                "    process.exit(127)",
-                "  }",
-                "  extraEnv[name] = value",
-                "}",
-            ]),
-        "const result = spawnSync(executable, args, {",
-        '  stdio: "inherit",',
-        "  env: { ...process.env, ...extraEnv },",
-        "  shell: false,",
-        "})",
-        "if (result.error) {",
-        "  console.error(result.error.message)",
-        "  process.exit(127)",
-        "}",
-        "if (result.signal) {",
-        '  console.error("hook terminated by " + result.signal)',
-        "  process.exit(1)",
-        "}",
-        "process.exit(result.status ?? 1)",
-        "",
-    ].join("\n");
-}
-import { canonicalCandidateDigest } from "@tangle-network/agent-interface";
-import { CLAUDE_SETTINGS_PATH } from "./harness.js";
-import { sha256 } from "./plan-digest.js";
-import { serializeWorkspacePlanJson, tomlStr } from "./plan-json.js";
-import { setPlanEnvironment } from "./profile-plan.js";
-import { compareStrings } from "./workspace-files.js";

package/dist/managed-workspace-bind.d.ts

@@ -1,4 +0,0 @@
-import type { WorkspacePlan, WorkspacePlanApplication } from "./plan-types.js";
-export declare function bindConcurrentLaunch(plan: WorkspacePlan, application: WorkspacePlanApplication, revisionWorkspaceDir: string, options?: {
-    readonly secretOpenCodeRevision?: boolean;
-}): WorkspacePlanApplication["spawn"];

package/dist/managed-workspace-bind.js

@@ -1,112 +0,0 @@
-import { dirname, join } from "node:path";
-import { CODEX_SYSTEM_PROMPT_FILE } from "./harness.js";
-import { bindWorkspaceLaunchFlags } from "./workspace-launch.js";
-/**
- * Paths a secret OpenCode revision serves from its own immutable tree:
- * read-only profile content under `reference/`, skills, and OpenCode's
- * standard agent and command definitions (OpenCode reads
- * `.opencode/{agent,agents}/**\/*.md` and `.opencode/{command,commands}/**\/*.md`).
- */
-const SECRET_REVISION_NATIVE_PATH = /^(?:reference\/|\.opencode\/skills\/|\.opencode\/(?:agents?|commands?)\/(?:[^./][^/]*\/)*[^./][^/]*\.md$)/u;
-export function bindConcurrentLaunch(plan, application, revisionWorkspaceDir, options = {}) {
-    if (plan.requires?.length) {
-        throw new Error(`Concurrent ${plan.harness} profile needs a native extension that this launcher cannot attest`);
-    }
-    if (application.spawn.systemPromptBinding) {
-        throw new Error(`Concurrent ${plan.harness} profile has an unbound system prompt control`);
-    }
-    const flags = bindWorkspaceLaunchFlags(plan, application.spawn.flags, revisionWorkspaceDir);
-    const env = { ...application.spawn.env };
-    const supportedFiles = new Set();
-    const bindFlagFile = (flag, relPath) => {
-        const index = flags.findIndex((value, at) => value === flag && flags[at + 1] === relPath);
-        if (index < 0)
-            throw new Error(`Concurrent ${plan.harness} profile lacks ${flag} for ${relPath}`);
-        flags[index + 1] = join(revisionWorkspaceDir, relPath);
-        supportedFiles.add(relPath);
-    };
-    switch (plan.harness) {
-        case "claude-code":
-            for (const relPath of [
-                ".tangle/claude-mcp.json",
-                ".tangle/claude-settings.json",
-            ]) {
-                if (plan.files.some((file) => file.relPath === relPath)) {
-                    bindFlagFile(relPath.endsWith("mcp.json") ? "--mcp-config" : "--settings", relPath);
-                }
-            }
-            break;
-        case "codex":
-            if (plan.files.some((file) => file.relPath === CODEX_SYSTEM_PROMPT_FILE)) {
-                if (!plan.flags.some((value, at) => value === `model_instructions_file=${CODEX_SYSTEM_PROMPT_FILE}` &&
-                    plan.flags[at - 1] === "-c"))
-                    throw new Error("Concurrent codex profile lacks model_instructions_file binding");
-                supportedFiles.add(CODEX_SYSTEM_PROMPT_FILE);
-            }
-            break;
-        // kimi-code has no case: kimi-code 2.x discovers MCP only from
-        // <cwd>/.kimi-code/mcp.json and has no launch flag that rebinds it to the
-        // revision, so a concurrent kimi-code plan carrying one fails closed in
-        // the redirect check below.
-        case "opencode": {
-            const runtimeConfig = application.runtimeOnlyFiles["opencode.json"];
-            if (runtimeConfig !== undefined)
-                env.OPENCODE_CONFIG_CONTENT = runtimeConfig;
-            const configFile = plan.files.find((file) => file.relPath === "opencode.json");
-            if (configFile) {
-                env.OPENCODE_CONFIG = join(revisionWorkspaceDir, "opencode.json");
-                env.TANGLE_PROFILE_REVISION_WORKSPACE = revisionWorkspaceDir;
-                supportedFiles.add("opencode.json");
-                const config = JSON.parse(configFile.content);
-                if (Array.isArray(config.instructions)) {
-                    for (const entry of config.instructions) {
-                        const prefix = "{env:TANGLE_PROFILE_REVISION_WORKSPACE}/";
-                        if (typeof entry !== "string" || !entry.startsWith(prefix)) {
-                            throw new Error("Concurrent OpenCode instruction lacks an explicit revision binding");
-                        }
-                        supportedFiles.add(entry.slice(prefix.length));
-                    }
-                }
-            }
-            break;
-        }
-    }
-    // A declared executable reference/ tool runs from the immutable revision:
-    // its directory, absolute in that revision, joins the launch PATH.
-    const toolBinDirs = [];
-    for (const file of plan.files) {
-        // Secret OpenCode launches from its immutable revision workspace, with
-        // that revision's .opencode as config directory. These relative native
-        // resources therefore read the revision, never the shared workspace.
-        if (options.secretOpenCodeRevision === true &&
-            plan.harness === "opencode" &&
-            (file.root ?? "workspace") === "workspace" &&
-            SECRET_REVISION_NATIVE_PATH.test(file.relPath)) {
-            if (file.relPath.startsWith("reference/") &&
-                ((file.mode ?? 0) & 0o111) !== 0) {
-                const dir = join(revisionWorkspaceDir, dirname(file.relPath));
-                if (!toolBinDirs.includes(dir))
-                    toolBinDirs.push(dir);
-            }
-            continue;
-        }
-        if (file.source !== "generated") {
-            throw new Error(`Concurrent ${plan.harness} profile resource ${file.relPath} needs a shared-workspace collision-safe copy`);
-        }
-        if ((file.root ?? "workspace") !== "workspace" ||
-            !supportedFiles.has(file.relPath)) {
-            throw new Error(`Concurrent ${plan.harness} profile cannot redirect native file ${file.relPath}; use a verified launch control`);
-        }
-    }
-    for (const name of Object.keys(application.runtimeOnlyFiles)) {
-        if (plan.harness !== "opencode" || name !== "opencode.json") {
-            throw new Error(`Concurrent ${plan.harness} profile cannot bind runtime-only file ${name}`);
-        }
-    }
-    return {
-        ...application.spawn,
-        flags,
-        env,
-        ...(toolBinDirs.length > 0 ? { toolBinDirs } : {}),
-    };
-}

package/dist/managed-workspace-stage.d.ts

@@ -1,25 +0,0 @@
-import { lstatSync } from "node:fs";
-import type { AgentProfileSecretProvider } from "@tangle-network/agent-interface";
-import type { ManagedWorkspaceManifest } from "./managed-workspace-types.js";
-import type { ApplyWorkspacePlanOptions, WorkspacePlan, WorkspacePlanApplication } from "./plan-types.js";
-interface PreparedManagedWorkspace {
-    /** Entire profile-owned tree. The caller owns its lifetime through the turn. */
-    root: string;
-    /** Use as the native harness cwd only inside an isolated workspace view. */
-    workspaceDir: string;
-    agentDir: string;
-    manifest: ManagedWorkspaceManifest;
-    application: WorkspacePlanApplication;
-    dispose(): void;
-}
-export declare function assertPrivateManagedRoot(root: string): void;
-/**
- * Stage one complete plan under an executor-owned reserved root. The ordinary
- * materializer still resolves secrets and validates/writes every native file;
- * only its destination changes. A failed stage removes its private files.
- * The caller must keep the returned tree while an admitted turn uses it and
- * dispose it after that turn, so a later binding cannot expose old secrets.
- */
-export declare function prepareManagedWorkspacePlan(plan: WorkspacePlan, managedRoot: string, sharedWorkspaceDir: string, secretProvider: AgentProfileSecretProvider, options?: Pick<ApplyWorkspacePlanOptions, "ownership" | "runtimeOnlyFiles" | "secretFileSlotReferences">): Promise<PreparedManagedWorkspace>;
-export declare function lstatIfPresent(path: string): ReturnType<typeof lstatSync> | null;
-export {};

package/dist/managed-workspace-stage.js

@@ -1,199 +0,0 @@
-import { createHash } from "node:crypto";
-import { copyFileSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync, } from "node:fs";
-import { basename, dirname, extname, join, resolve, sep } from "node:path";
-import { applyWorkspacePlanWithSecretProvider } from "./plan-application.js";
-import { hashWorkspacePlan } from "./plan-digest.js";
-import { normalizeWorkspaceRelativePath } from "./workspace-files.js";
-import { bindWorkspaceLaunchFlags } from "./workspace-launch.js";
-export function assertPrivateManagedRoot(root) {
-    if (!root || resolve(root) !== root) {
-        throw new Error("Managed workspace root must be an absolute path");
-    }
-    const rootStat = lstatSync(root);
-    if (!rootStat.isDirectory() ||
-        realpathSync(root) !== root ||
-        (rootStat.mode & 0o077) !== 0 ||
-        rootStat.uid !== process.getuid?.()) {
-        throw new Error("Managed workspace root must be a private real directory");
-    }
-}
-/**
- * Stage one complete plan under an executor-owned reserved root. The ordinary
- * materializer still resolves secrets and validates/writes every native file;
- * only its destination changes. A failed stage removes its private files.
- * The caller must keep the returned tree while an admitted turn uses it and
- * dispose it after that turn, so a later binding cannot expose old secrets.
- */
-export async function prepareManagedWorkspacePlan(plan, managedRoot, sharedWorkspaceDir, secretProvider, options = {}) {
-    assertPrivateManagedRoot(managedRoot);
-    assertSharedWorkspaceRoot(sharedWorkspaceDir);
-    const planDigest = hashWorkspacePlan(plan);
-    const stage = mkdtempSync(join(managedRoot, `plan-${planDigest.slice(7)}-`));
-    const workspaceDir = join(stage, "workspace");
-    const agentDir = join(stage, "agent");
-    try {
-        mkdirSync(workspaceDir);
-        mkdirSync(agentDir);
-        const application = await applyWorkspacePlanWithSecretProvider(plan, workspaceDir, secretProvider, { ...options, agentDir, existingFiles: "reject" });
-        const files = application.receipt.writtenFiles.map((written) => {
-            const path = join(written.root === "agent" ? agentDir : workspaceDir, written.relPath);
-            const stat = lstatSync(path);
-            if (!stat.isFile() || stat.isSymbolicLink()) {
-                throw new Error(`Managed workspace file is not regular: ${written.relPath}`);
-            }
-            const bytes = readFileSync(path);
-            const authored = plan.files.find((file) => (file.root ?? "workspace") === written.root &&
-                normalizeWorkspaceRelativePath(file.relPath) === written.relPath);
-            return {
-                ...written,
-                source: authored?.source,
-                ownership: authored?.ownership,
-                size: bytes.length,
-                mode: stat.mode & 0o777,
-                visible: true,
-                sha256: createHash("sha256").update(bytes).digest("hex"),
-            };
-        });
-        const conflicts = [];
-        for (const file of [...files]) {
-            if (file.root !== "workspace")
-                continue;
-            const reason = sharedPathCollision(sharedWorkspaceDir, file.relPath);
-            if (!reason)
-                continue;
-            const copyRelPath = sideCopyPath(sharedWorkspaceDir, workspaceDir, file.relPath, planDigest, reason);
-            const copyPath = join(workspaceDir, copyRelPath);
-            mkdirSync(dirname(copyPath), { recursive: true });
-            copyFileSync(join(workspaceDir, file.relPath), copyPath);
-            const copyStat = lstatSync(copyPath);
-            const copyBytes = readFileSync(copyPath);
-            file.visible = false;
-            files.push({
-                ...file,
-                relPath: copyRelPath,
-                relocatedFrom: file.relPath,
-                size: copyBytes.length,
-                mode: copyStat.mode & 0o777,
-                visible: true,
-                sha256: createHash("sha256").update(copyBytes).digest("hex"),
-            });
-            conflicts.push({ relPath: file.relPath, copyRelPath, reason });
-        }
-        files.sort((left, right) => `${left.root}:${left.relPath}`.localeCompare(`${right.root}:${right.relPath}`));
-        conflicts.sort((left, right) => left.relPath.localeCompare(right.relPath));
-        const runtimeOnlyFiles = Object.entries(application.runtimeOnlyFiles)
-            .sort(([left], [right]) => left.localeCompare(right))
-            .map(([name, content]) => ({
-            name,
-            size: Buffer.byteLength(content),
-            sha256: createHash("sha256").update(content).digest("hex"),
-        }));
-        const spawnDigest = createHash("sha256")
-            .update(JSON.stringify({
-            ...application.spawn,
-            flags: bindWorkspaceLaunchFlags(plan, application.spawn.flags),
-        }))
-            .digest("hex");
-        const materializedDigest = `sha256:${createHash("sha256")
-            .update(JSON.stringify({
-            planDigest,
-            files,
-            conflicts,
-            runtimeOnlyFiles,
-            spawnDigest,
-        }))
-            .digest("hex")}`;
-        const manifest = {
-            workspacePlanDigest: planDigest,
-            materializedDigest,
-            files,
-            conflicts,
-            runtimeOnlyFiles,
-            spawnDigest,
-        };
-        writeFileSync(join(stage, "manifest.json"), JSON.stringify(manifest), {
-            mode: 0o600,
-            flag: "wx",
-        });
-        return {
-            root: stage,
-            workspaceDir,
-            agentDir,
-            manifest,
-            application,
-            dispose: () => rmSync(stage, { recursive: true, force: true }),
-        };
-    }
-    catch (error) {
-        rmSync(stage, { recursive: true, force: true });
-        throw error;
-    }
-}
-export function lstatIfPresent(path) {
-    try {
-        return lstatSync(path);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        throw error;
-    }
-}
-function assertSharedWorkspaceRoot(root) {
-    if (!root ||
-        resolve(root) !== root ||
-        !lstatSync(root).isDirectory() ||
-        realpathSync(root) !== root) {
-        throw new Error("Shared workspace must be an absolute real directory");
-    }
-}
-function sharedPathCollision(root, relPath) {
-    const target = resolve(root, relPath);
-    if (target !== root && !target.startsWith(`${root}${sep}`)) {
-        throw new Error(`Profile path escapes shared workspace: ${relPath}`);
-    }
-    let cursor = root;
-    const segments = relPath.split(/[\\/]+/);
-    for (const [index, segment] of segments.entries()) {
-        cursor = join(cursor, segment);
-        const stat = lstatIfPresent(cursor);
-        if (!stat)
-            return null;
-        if (stat.isSymbolicLink())
-            return "symlink";
-        if (index < segments.length - 1 && !stat.isDirectory())
-            return "existing";
-    }
-    return "existing";
-}
-function sideCopyPath(sharedRoot, stagedRoot, relPath, planDigest, reason) {
-    const ancestor = reason === "symlink" ? firstSymlinkAncestor(sharedRoot, relPath) : null;
-    const neighbor = ancestor
-        ? join(dirname(ancestor), `${basename(ancestor)}.${relPath.slice(ancestor.length + 1).replace(/[\\/]+/g, ".")}`)
-        : relPath;
-    const name = basename(neighbor);
-    const extension = extname(name);
-    const stem = name.slice(0, name.length - extension.length);
-    for (let attempt = 0; attempt < 100; attempt++) {
-        const suffix = attempt ? `-${attempt}` : "";
-        const candidate = join(dirname(neighbor), `${stem}.profile-${planDigest.slice(7, 19)}${suffix}${extension}`);
-        if (!lstatIfPresent(join(stagedRoot, candidate)) &&
-            !sharedPathCollision(sharedRoot, candidate)) {
-            return candidate;
-        }
-    }
-    throw new Error(`No unused profile copy path beside ${relPath}`);
-}
-function firstSymlinkAncestor(root, relPath) {
-    const segments = relPath.split(/[\\/]+/);
-    let cursor = root;
-    for (const [index, segment] of segments.entries()) {
-        if (index === segments.length - 1)
-            break;
-        cursor = join(cursor, segment);
-        if (lstatIfPresent(cursor)?.isSymbolicLink()) {
-            return segments.slice(0, index + 1).join(sep);
-        }
-    }
-    return null;
-}

package/dist/managed-workspace-types.d.ts

@@ -1,38 +0,0 @@
-import type { PlanFile, PlanFileRoot } from "./plan-types.js";
-export interface ManagedWorkspaceFileDigest {
-    root: PlanFileRoot;
-    relPath: string;
-    source: PlanFile["source"];
-    ownership: PlanFile["ownership"];
-    size: number;
-    mode: number;
-    /** The host view exposes only visible entries for this pinned turn. */
-    visible: boolean;
-    /** A side copy of this original path, when a user file won the collision. */
-    relocatedFrom?: string;
-    /** Digest of the actual staged bytes, including resolved secret leaves. Private. */
-    sha256: string;
-}
-/** Private executor inventory; never expose hashes of resolved credentials. */
-export interface ManagedWorkspaceManifest {
-    workspacePlanDigest: string;
-    /** Hashes the resolved stage inventory and launch inputs, not only public refs. */
-    materializedDigest: string;
-    files: ManagedWorkspaceFileDigest[];
-    /** User-owned path stays in place; profile bytes are staged beside it. */
-    conflicts: Array<{
-        relPath: string;
-        copyRelPath: string;
-        reason: "existing" | "symlink";
-    }>;
-    /** Resolved for the runtime but intentionally absent from the visible tree. */
-    runtimeOnlyFiles: Array<{
-        name: string;
-        size: number;
-        sha256: string;
-    }>;
-    /** Private digest of resolved spawn controls, including secret-bearing env. */
-    spawnDigest: string;
-    /** Exact native spawn controls after absolute revision paths are bound. */
-    launchDigest?: string;
-}

package/dist/managed-workspace-types.js

@@ -1 +0,0 @@
-export {};

package/dist/managed-workspace.d.ts

@@ -1,37 +0,0 @@
-import type { AgentProfileSecretProvider } from "@tangle-network/agent-interface";
-import type { ManagedWorkspaceManifest } from "./managed-workspace-types.js";
-import type { ApplyWorkspacePlanOptions, WorkspacePlan, WorkspacePlanApplication } from "./plan-types.js";
-export type { ManagedWorkspaceFileDigest, ManagedWorkspaceManifest, } from "./managed-workspace-types.js";
-/** A private, write-once revision and the exact inputs for one native spawn. */
-export interface ConcurrentProfileRevision {
-    directory: string;
-    manifest: ManagedWorkspaceManifest;
-    application: WorkspacePlanApplication;
-}
-/** Create the two executor-owned roots on one filesystem. */
-export declare function ensurePublicConcurrentProfileRoots(base: string): {
-    managedRoot: string;
-    launchRoot: string;
-};
-/**
- * Materialize PUBLIC profile material beside the shared workspace. Processes
- * in one sandbox share a uid and can read each other's revision files and env.
- * Callers must not use this path for confidential profile text or credentials.
- * Only native controls with a verified explicit launch path are admitted.
- * A separate reaper owns removal after no native process reads the revision.
- */
-export declare function preparePublicConcurrentProfileRevision(input: {
-    plan: WorkspacePlan;
-    managedRoot: string;
-    /** Root-owned, agent-traversable publication root on the same filesystem. */
-    launchRoot: string;
-    sharedWorkspaceDir: string;
-    ownerId: string;
-    secretProvider: AgentProfileSecretProvider;
-    options?: Pick<ApplyWorkspacePlanOptions, "ownership" | "runtimeOnlyFiles">;
-}): Promise<ConcurrentProfileRevision>;
-/** Move OpenCode's cwd-discovered primary agent into its explicit JSON config. */
-export declare function prepareExplicitOpenCodePlan(plan: WorkspacePlan): WorkspacePlan;
-export declare function listRevisionFiles(root: string, prefix?: string): string[];
-export declare function assertLaunchRoot(root: string): void;
-export declare function makeStageWritable(root: string): void;