@bbigbang/agent-node 0.1.0

package/dist/nativeMissionRunner.js

@@ -0,0 +1,461 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { log } from '@bbigbang/runtime-acp';
+import { NativeWorkerHost } from './nativeWorkerHost.js';
+import { NativeMissionAgentDispatch, } from './nativeMissionAgentDispatch.js';
+import { resolveExistingMissionDir, resolveMissionDir } from './droidMissionRunner.js';
+const OUTPUT_LIMIT = 8_000;
+const NATIVE_OUTPUT_DIR = 'native-output';
+export function runNativeMission(msg, send, hooks, executor) {
+    if (!msg.featureId) {
+        handleNativeMissionHandshake(msg, send);
+        return;
+    }
+    runNativeFeatureWorker(msg, send, hooks, executor);
+}
+function handleNativeMissionHandshake(msg, send) {
+    const workspaceRoot = resolveExistingDirectory(msg.workspaceRoot);
+    const missionDir = resolveExistingMissionDir(workspaceRoot, msg.missionDir);
+    send({
+        type: 'mission.run.accepted',
+        requestId: msg.requestId,
+        missionId: msg.missionId,
+        missionDir,
+        runtimeProvider: 'bigbang_native',
+        pid: null,
+    });
+}
+function runNativeFeatureWorker(msg, send, hooks, executor) {
+    const featureId = msg.featureId;
+    if (!msg.featureDescription) {
+        throw new Error('Native mission run request is missing featureDescription.');
+    }
+    if (!msg.milestone) {
+        throw new Error('Native mission run request is missing milestone.');
+    }
+    const workspaceRoot = resolveExistingDirectory(msg.workspaceRoot);
+    const missionDir = resolveMissionDir(workspaceRoot, msg.missionDir);
+    const outputDir = path.join(missionDir, NATIVE_OUTPUT_DIR);
+    mkdirSync(outputDir, { recursive: true });
+    const workerScriptPath = resolveNativeWorkerScriptPath();
+    const context = {
+        featureId,
+        featureDescription: msg.featureDescription,
+        milestone: msg.milestone,
+        expectedBehavior: msg.expectedBehavior,
+        title: msg.title,
+        prompt: msg.prompt,
+        missionId: msg.missionId,
+        workspaceRoot,
+        missionDir,
+        modelMode: msg.modelMode,
+        orchestratorModel: msg.orchestratorModel,
+        workerModel: msg.workerModel,
+        validatorModel: msg.validatorModel,
+        priorHandoffs: msg.priorHandoffs,
+        preconditions: msg.preconditions,
+        validationContract: msg.validationContract,
+        workspaceFiles: msg.workspaceFiles,
+        useAgentDispatch: msg.useAgentDispatch,
+    };
+    if (msg.useAgentDispatch && executor) {
+        log.info('[agent-node] dispatching native feature via platform agent', {
+            requestId: msg.requestId,
+            missionId: msg.missionId,
+            featureId,
+            modelMode: msg.modelMode,
+            workerModel: msg.workerModel,
+        });
+        const dispatch = new NativeMissionAgentDispatch(context, send, executor, msg.requestId);
+        hooks?.onDispatchCreated?.(dispatch);
+        void dispatch
+            .dispatch()
+            .catch((error) => {
+            log.warn('[agent-node] native agent dispatch failed', {
+                requestId: msg.requestId,
+                missionId: msg.missionId,
+                featureId,
+                error: String(error?.message ?? error),
+            });
+        })
+            .finally(() => {
+            hooks?.onDispatchFinished?.(dispatch);
+        });
+        return;
+    }
+    const runtimeConfigForLog = {
+        modelMode: msg.modelMode,
+        orchestratorModel: msg.orchestratorModel ?? null,
+        workerModel: msg.workerModel ?? null,
+        validatorModel: msg.validatorModel ?? null,
+        providerBaseUrl: redactUrlCredentials(process.env.OPENAI_API_BASE ?? 'https://api.openai.com/v1'),
+        apiKeyConfigured: Boolean(process.env.OPENAI_API_KEY),
+        workerTimeoutMs: Number(process.env.NATIVE_WORKER_TIMEOUT_MS ?? 300_000),
+        workerGracePeriodMs: Number(process.env.NATIVE_WORKER_GRACE_PERIOD_MS ?? 5_000),
+    };
+    log.info('[agent-node] spawning native worker', {
+        requestId: msg.requestId,
+        missionId: msg.missionId,
+        featureId,
+        workerScriptPath,
+        ...runtimeConfigForLog,
+    });
+    const host = new NativeWorkerHost({
+        command: process.execPath,
+        args: [workerScriptPath],
+        cwd: missionDir,
+        env: {
+            ...process.env,
+            NATIVE_WORKER_CONTEXT: JSON.stringify(context),
+            NATIVE_WORKER_FEATURE_ID: featureId,
+            NATIVE_WORKER_MISSION_DIR: missionDir,
+            NATIVE_WORKER_WORKSPACE_ROOT: workspaceRoot,
+        },
+        timeoutMs: Number(process.env.NATIVE_WORKER_TIMEOUT_MS ?? 300_000),
+        gracePeriodMs: Number(process.env.NATIVE_WORKER_GRACE_PERIOD_MS ?? 5_000),
+        onStdout: (text) => {
+            sendOutputEvent(send, msg.requestId, msg.missionId, featureId, 'stdout', text);
+        },
+        onStderr: (text) => {
+            sendOutputEvent(send, msg.requestId, msg.missionId, featureId, 'stderr', text);
+        },
+        onExit: (result) => {
+            hooks?.onHostExit?.();
+            const validation = readNativeWorkerOutput(outputDir, featureId);
+            const output = validation.output;
+            const outputError = validation.ok ? undefined : validation.error;
+            const outputReason = validation.ok ? undefined : validation.reason;
+            const outputFailed = output.status === 'failed' || outputError || Boolean(result.error);
+            const endExitCode = result.exitCode || (outputFailed ? 1 : 0);
+            const endError = result.error ?? outputError;
+            // A crash (segfault, OOM, external kill) is indicated by a non-null
+            // signal and no host-initiated timeout/cancel error. Host-initiated
+            // kills already carry their own descriptive error.
+            const crashed = result.signal != null && !result.error;
+            const reason = crashed ? 'process_crashed' : outputReason;
+            const endMsg = {
+                type: 'mission.run.end',
+                requestId: msg.requestId,
+                missionId: msg.missionId,
+                missionDir,
+                runtimeProvider: 'bigbang_native',
+                featureId,
+                exitCode: endExitCode,
+                signal: result.signal,
+                reason,
+                output,
+                handoff: output.handoff,
+                ...(endError ? { error: endError } : {}),
+            };
+            send(endMsg);
+        },
+    });
+    hooks?.onHostCreated?.(host);
+    host.spawn();
+    send({
+        type: 'mission.run.accepted',
+        requestId: msg.requestId,
+        missionId: msg.missionId,
+        missionDir,
+        runtimeProvider: 'bigbang_native',
+        featureId,
+        pid: host.pid,
+    });
+}
+function resolveExistingDirectory(value) {
+    const resolved = path.resolve(value);
+    if (!existsSync(resolved)) {
+        throw new Error(`Directory does not exist: ${value}`);
+    }
+    return realpathSync(resolved);
+}
+function resolveNativeWorkerScriptPath() {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.join(moduleDir, 'native-worker', 'native-worker.mjs'),
+        path.join(moduleDir, 'native-worker', 'native-worker.js'),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    throw new Error('Native worker script not found.');
+}
+function redactUrlCredentials(value) {
+    if (!value)
+        return '';
+    try {
+        const url = new URL(value);
+        url.username = '';
+        url.password = '';
+        return url.toString().replace(/\/$/, '');
+    }
+    catch {
+        return value;
+    }
+}
+function buildDiscoveredIssues(messages) {
+    return messages.map((description) => ({
+        id: randomUUID(),
+        severity: 'non-blocking',
+        description,
+    }));
+}
+function buildFailedHandoff(summary, issueDescriptions) {
+    return {
+        schemaVersion: '2.0.0',
+        salientSummary: summary,
+        whatWasImplemented: [],
+        whatWasLeftUndone: '',
+        verification: { commandsRun: [], interactiveChecks: [] },
+        tests: { added: [] },
+        discoveredIssues: buildDiscoveredIssues(issueDescriptions),
+        successState: 'failure',
+        returnToOrchestrator: true,
+        workerSessionId: 'unknown',
+    };
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function isCommandRunEntry(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.command === 'string' &&
+        typeof value.exitCode === 'number' &&
+        typeof value.observation === 'string');
+}
+function isDiscoveredIssue(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.id === 'string' &&
+        (value.severity === 'blocking' || value.severity === 'non-blocking') &&
+        typeof value.description === 'string' &&
+        (value.suggestion === undefined || typeof value.suggestion === 'string'));
+}
+function validateNativeMissionHandoff(value) {
+    if (!isRecord(value))
+        return null;
+    if (value.schemaVersion !== '2.0.0')
+        return null;
+    if (typeof value.salientSummary !== 'string')
+        return null;
+    if (!isStringArray(value.whatWasImplemented))
+        return null;
+    if (typeof value.whatWasLeftUndone !== 'string')
+        return null;
+    const verification = value.verification;
+    if (!isRecord(verification))
+        return null;
+    const commandsRun = verification.commandsRun;
+    const interactiveChecks = verification.interactiveChecks;
+    if (!Array.isArray(commandsRun) || !commandsRun.every(isCommandRunEntry))
+        return null;
+    if (!Array.isArray(interactiveChecks))
+        return null;
+    if (interactiveChecks.some((item) => !isRecord(item) || typeof item.action !== 'string' || typeof item.observed !== 'string')) {
+        return null;
+    }
+    const tests = value.tests;
+    if (!isRecord(tests))
+        return null;
+    const added = tests.added;
+    if (!Array.isArray(added))
+        return null;
+    for (const entry of added) {
+        if (!isRecord(entry))
+            return null;
+        if (typeof entry.file !== 'string')
+            return null;
+        if (!Array.isArray(entry.cases))
+            return null;
+        for (const c of entry.cases) {
+            if (!isRecord(c) || typeof c.name !== 'string' || typeof c.description !== 'string')
+                return null;
+        }
+    }
+    const discoveredIssues = value.discoveredIssues;
+    if (!Array.isArray(discoveredIssues) || !discoveredIssues.every(isDiscoveredIssue))
+        return null;
+    if (value.successState !== 'success' &&
+        value.successState !== 'partial' &&
+        value.successState !== 'failure') {
+        return null;
+    }
+    if (typeof value.returnToOrchestrator !== 'boolean')
+        return null;
+    if (typeof value.workerSessionId !== 'string')
+        return null;
+    return value;
+}
+const VALID_OUTPUT_STATUSES = ['completed', 'failed', 'skipped'];
+function readNativeWorkerOutput(outputDir, featureId) {
+    const outputPath = path.join(outputDir, `${featureId}.json`);
+    if (!existsSync(outputPath)) {
+        const error = `Native worker did not write output file: ${outputPath}`;
+        const output = {
+            schemaVersion: 'unknown',
+            featureId,
+            status: 'failed',
+            exitCode: 1,
+            implementedFiles: [],
+            fileOperations: [],
+            runtimeConfig: buildPlaceholderRuntimeConfig(),
+            handoff: buildFailedHandoff('Native worker did not produce a structured output file.', [
+                `Output file not found: ${outputPath}`,
+            ]),
+            error,
+        };
+        return { ok: false, output, error, reason: 'invalid_output' };
+    }
+    let raw;
+    try {
+        raw = readFileSync(outputPath, 'utf8');
+    }
+    catch (err) {
+        const error = String(err?.message ?? err);
+        const output = {
+            schemaVersion: 'unknown',
+            featureId,
+            status: 'failed',
+            exitCode: 1,
+            implementedFiles: [],
+            fileOperations: [],
+            runtimeConfig: buildPlaceholderRuntimeConfig(),
+            handoff: buildFailedHandoff('Native worker output file could not be read.', [error]),
+            error,
+        };
+        return { ok: false, output, error };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        const error = `Invalid worker output JSON: ${String(err?.message ?? err)}`;
+        const output = {
+            schemaVersion: 'unknown',
+            featureId,
+            status: 'failed',
+            exitCode: 1,
+            implementedFiles: [],
+            fileOperations: [],
+            runtimeConfig: buildPlaceholderRuntimeConfig(),
+            handoff: buildFailedHandoff('Native worker output could not be parsed as JSON.', [
+                String(err?.message ?? err),
+            ]),
+            stdout: raw.slice(0, OUTPUT_LIMIT),
+            rawOutput: raw,
+            error,
+        };
+        return { ok: false, output, error, reason: 'invalid_output' };
+    }
+    if (!isRecord(parsed) || typeof parsed.featureId !== 'string' || parsed.featureId.trim() !== featureId) {
+        const error = 'Worker output featureId mismatch or missing';
+        const output = {
+            schemaVersion: 'unknown',
+            featureId,
+            status: 'failed',
+            exitCode: 1,
+            implementedFiles: [],
+            fileOperations: [],
+            runtimeConfig: buildPlaceholderRuntimeConfig(),
+            handoff: buildFailedHandoff('Native worker output has an invalid or missing featureId.', [
+                `Expected featureId "${featureId}", got ${isRecord(parsed) ? JSON.stringify(parsed.featureId) : typeof parsed}`,
+            ]),
+            stdout: raw.slice(0, OUTPUT_LIMIT),
+            rawOutput: raw,
+            error,
+        };
+        return { ok: false, output, error, reason: 'invalid_output' };
+    }
+    const status = typeof parsed.status === 'string' ? parsed.status : undefined;
+    const statusValid = status !== undefined && VALID_OUTPUT_STATUSES.includes(status);
+    const implementedFiles = Array.isArray(parsed.implementedFiles) && parsed.implementedFiles.every((item) => typeof item === 'string')
+        ? parsed.implementedFiles
+        : undefined;
+    const handoff = validateNativeMissionHandoff(parsed.handoff);
+    const fileOperations = Array.isArray(parsed.fileOperations) ? parsed.fileOperations : undefined;
+    const runtimeConfig = isRecord(parsed.runtimeConfig)
+        ? parsed.runtimeConfig
+        : undefined;
+    const missingFields = [];
+    if (!statusValid)
+        missingFields.push('status');
+    if (implementedFiles === undefined)
+        missingFields.push('implementedFiles');
+    if (handoff === null)
+        missingFields.push('handoff');
+    if (missingFields.length > 0) {
+        const error = `Worker output missing required fields: ${missingFields.join(', ')}`;
+        const output = {
+            schemaVersion: typeof parsed.schemaVersion === 'string' ? parsed.schemaVersion : 'unknown',
+            featureId,
+            status: 'failed',
+            exitCode: typeof parsed.exitCode === 'number' ? parsed.exitCode : 1,
+            implementedFiles: implementedFiles ?? [],
+            fileOperations: fileOperations ?? [],
+            runtimeConfig: runtimeConfig ?? buildPlaceholderRuntimeConfig(),
+            handoff: handoff ??
+                buildFailedHandoff('Native worker output is missing required fields.', [
+                    `Missing or invalid fields: ${missingFields.join(', ')}`,
+                ]),
+            stdout: typeof parsed.stdout === 'string' ? parsed.stdout : raw.slice(0, OUTPUT_LIMIT),
+            rawOutput: raw,
+            error,
+        };
+        return { ok: false, output, error, reason: 'invalid_output' };
+    }
+    const output = {
+        schemaVersion: typeof parsed.schemaVersion === 'string' ? parsed.schemaVersion : 'unknown',
+        featureId,
+        status: status,
+        implementedFiles: implementedFiles,
+        fileOperations: fileOperations ?? [],
+        runtimeConfig: runtimeConfig ?? buildPlaceholderRuntimeConfig(),
+        handoff: handoff,
+        stdout: typeof parsed.stdout === 'string' ? parsed.stdout : undefined,
+        stderr: typeof parsed.stderr === 'string' ? parsed.stderr : undefined,
+        exitCode: typeof parsed.exitCode === 'number' ? parsed.exitCode : 0,
+        errorClassification: isRecord(parsed.errorClassification)
+            ? parsed.errorClassification
+            : undefined,
+    };
+    return { ok: true, output };
+}
+function buildPlaceholderRuntimeConfig() {
+    return {
+        model: 'unknown',
+        modelMode: 'unknown',
+        orchestratorModel: null,
+        workerModel: null,
+        validatorModel: null,
+        providerBaseUrl: 'unknown',
+        apiKeyConfigured: false,
+        workerTimeoutMs: 0,
+        workerGracePeriodMs: 0,
+        platform: process.platform,
+        nodeVersion: process.version,
+    };
+}
+function sendOutputEvent(send, requestId, missionId, featureId, stream, text) {
+    send({
+        type: 'mission.run.event',
+        requestId,
+        missionId,
+        runtimeProvider: 'bigbang_native',
+        eventType: `mission_${stream}`,
+        source: 'bigbang_native',
+        eventTime: Date.now(),
+        featureId,
+        payload: {
+            stream,
+            text: text.length > OUTPUT_LIMIT ? `${text.slice(0, OUTPUT_LIMIT)}\n[truncated]` : text,
+        },
+    });
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/nativeSkillMounts.js

@@ -0,0 +1,204 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { BUILTIN_LIBRARY_DOCUMENTS_SKILL_ROOT_SENTINEL, BUILTIN_UI_PANEL_SKILL_ROOT_SENTINEL, BUILTIN_WORKSPACE_TOOL_SKILL_ROOT_SENTINEL, } from '@bbigbang/protocol';
+import { expandSkillRoot } from './builtinSkillRoots.js';
+const MANIFEST_FILENAME = '.bigbang-managed-links.json';
+const BUILTIN_SKILL_ROOT_SENTINELS = new Map([
+    [BUILTIN_LIBRARY_DOCUMENTS_SKILL_ROOT_SENTINEL, 'library-documents'],
+    [BUILTIN_UI_PANEL_SKILL_ROOT_SENTINEL, 'ui-panel'],
+    [BUILTIN_WORKSPACE_TOOL_SKILL_ROOT_SENTINEL, 'workspace-tool-builder'],
+]);
+export function ensureNativeSkillMounts(params) {
+    const mountRoot = resolveMountRoot(params);
+    if (!mountRoot)
+        return;
+    const normalizedEnabledSkillPaths = normalizeEnabledSkillPaths(params.enabledSkillPaths ?? []);
+    const normalizedRoots = normalizeRoots(params.skillRoots ?? [], normalizedEnabledSkillPaths.length > 0);
+    fs.mkdirSync(mountRoot, { recursive: true });
+    const manifestPath = path.join(mountRoot, MANIFEST_FILENAME);
+    const previousEntries = readManifestEntries(manifestPath);
+    for (const entryName of previousEntries) {
+        removeManagedEntry(path.join(mountRoot, entryName));
+    }
+    const managedEntries = [];
+    for (const candidate of collectSkillCandidates(normalizedRoots, normalizedEnabledSkillPaths)) {
+        const destinationPath = path.join(mountRoot, candidate.name);
+        if (fs.existsSync(destinationPath)) {
+            continue;
+        }
+        fs.symlinkSync(candidate.targetPath, destinationPath, 'dir');
+        managedEntries.push(candidate.name);
+    }
+    fs.writeFileSync(manifestPath, `${JSON.stringify({ entries: managedEntries }, null, 2)}\n`, 'utf8');
+}
+function resolveMountRoot(params) {
+    if (params.agentType === 'codex_acp') {
+        return path.join(path.resolve(params.workspaceRoot), '.agents', 'skills');
+    }
+    if (params.agentType === 'codex_app_server') {
+        return path.join(path.resolve(params.workspaceRoot), '.agents', 'skills');
+    }
+    if (params.agentType === 'claude_acp' || params.agentType === 'claude_sdk') {
+        return path.join(path.resolve(params.workspaceRoot), '.claude', 'skills');
+    }
+    return null;
+}
+function normalizeRoots(skillRoots, explicitSelectionMode) {
+    const roots = [];
+    const seen = new Set();
+    for (const rawValue of skillRoots) {
+        const trimmed = rawValue.trim();
+        if (!trimmed)
+            continue;
+        const managedSkillName = BUILTIN_SKILL_ROOT_SENTINELS.get(trimmed) ?? null;
+        const rootPath = expandSkillRoot(trimmed);
+        if (seen.has(rootPath))
+            continue;
+        if (!(fs.statSync(rootPath, { throwIfNoEntry: false })?.isDirectory() ?? false))
+            continue;
+        const managedSkillPath = managedSkillName ? path.join(rootPath, managedSkillName) : null;
+        const managedSkillRealPath = managedSkillPath && fs.statSync(managedSkillPath, { throwIfNoEntry: false })?.isDirectory()
+            ? fs.realpathSync(managedSkillPath)
+            : null;
+        roots.push({
+            path: rootPath,
+            realPath: fs.realpathSync(rootPath),
+            autoMount: !explicitSelectionMode || Boolean(managedSkillName),
+            managedSkillName,
+            managedSkillRealPath,
+        });
+        seen.add(rootPath);
+    }
+    return roots;
+}
+function normalizeEnabledSkillPaths(enabledSkillPaths) {
+    return enabledSkillPaths
+        .map((value) => path.resolve(value.trim()))
+        .filter(Boolean)
+        .filter((value, index, list) => list.indexOf(value) === index)
+        .filter((value) => path.basename(value) === 'SKILL.md');
+}
+function collectSkillCandidates(skillRoots, enabledSkillPaths) {
+    const seen = new Set();
+    const results = [];
+    for (const root of skillRoots) {
+        if (!root.autoMount)
+            continue;
+        const entries = safeReadDir(root);
+        for (const entry of entries) {
+            if (root.managedSkillName && entry.name !== root.managedSkillName)
+                continue;
+            if (!entry.isDirectory() && !(root.managedSkillName && entry.isSymbolicLink()))
+                continue;
+            if (seen.has(entry.name))
+                continue;
+            const targetPath = path.join(root.path, entry.name);
+            const skillFile = path.join(targetPath, 'SKILL.md');
+            if (!isMountableSkillFile(skillFile, root))
+                continue;
+            seen.add(entry.name);
+            results.push({ name: entry.name, targetPath });
+        }
+    }
+    for (const skillPath of enabledSkillPaths) {
+        if (!isMountableExplicitSkillFile(skillPath, skillRoots))
+            continue;
+        const targetPath = path.dirname(skillPath);
+        const name = path.basename(targetPath);
+        if (!name || seen.has(name))
+            continue;
+        seen.add(name);
+        results.push({ name, targetPath });
+    }
+    return results.sort((a, b) => a.name.localeCompare(b.name));
+}
+function safeReadDir(root) {
+    try {
+        return fs.readdirSync(root.path, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+function isMountableSkillFile(skillPath, root) {
+    const stat = fs.lstatSync(skillPath, { throwIfNoEntry: false });
+    if (!stat)
+        return false;
+    if (!root.managedSkillName && stat.isSymbolicLink())
+        return false;
+    if (!(fs.statSync(skillPath, { throwIfNoEntry: false })?.isFile() ?? false))
+        return false;
+    if (root.managedSkillName) {
+        if (!root.managedSkillRealPath)
+            return false;
+        const skillDirectoryRealPath = fs.realpathSync(path.dirname(skillPath));
+        return skillDirectoryRealPath === root.managedSkillRealPath;
+    }
+    const realPath = fs.realpathSync(skillPath);
+    const relative = path.relative(root.realPath, realPath);
+    return relative === 'SKILL.md' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function isMountableExplicitSkillFile(skillPath, roots) {
+    const stat = fs.lstatSync(skillPath, { throwIfNoEntry: false });
+    if (!stat || stat.isSymbolicLink())
+        return false;
+    if (!(fs.statSync(skillPath, { throwIfNoEntry: false })?.isFile() ?? false))
+        return false;
+    const realPath = fs.realpathSync(skillPath);
+    if (roots.length === 0) {
+        return !pathHasSymlinkAncestor(skillPath);
+    }
+    return roots.some((root) => {
+        const relative = path.relative(root.realPath, realPath);
+        return (relative === 'SKILL.md' || (!relative.startsWith('..') && !path.isAbsolute(relative)))
+            && !pathHasSymlinkDescendant(root.path, skillPath);
+    });
+}
+function pathHasSymlinkAncestor(filePath) {
+    const parsed = path.parse(filePath);
+    let current = parsed.root;
+    const parts = path.relative(parsed.root, filePath).split(path.sep).filter(Boolean);
+    for (const part of parts) {
+        current = path.join(current, part);
+        const stat = fs.lstatSync(current, { throwIfNoEntry: false });
+        if (stat?.isSymbolicLink())
+            return true;
+    }
+    return false;
+}
+function pathHasSymlinkDescendant(rootPath, filePath) {
+    const relative = path.relative(rootPath, filePath);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative))
+        return false;
+    let current = rootPath;
+    const parts = relative.split(path.sep).filter(Boolean);
+    for (const part of parts.slice(0, -1)) {
+        current = path.join(current, part);
+        const stat = fs.lstatSync(current, { throwIfNoEntry: false });
+        if (stat?.isSymbolicLink())
+            return true;
+    }
+    return false;
+}
+function readManifestEntries(manifestPath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        if (!Array.isArray(parsed.entries))
+            return [];
+        return parsed.entries.filter((value) => typeof value === 'string');
+    }
+    catch {
+        return [];
+    }
+}
+function removeManagedEntry(entryPath) {
+    try {
+        const stat = fs.lstatSync(entryPath);
+        if (stat.isSymbolicLink()) {
+            fs.unlinkSync(entryPath);
+        }
+    }
+    catch {
+        // Ignore stale manifest entries and continue rebuilding managed links.
+    }
+}