@voybio/ace-swarm 0.2.5 → 2.4.1

package/dist/helpers/store-resolution.js

@@ -0,0 +1,305 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute } from "node:path";
+import { isInside, normalizeRelPath } from "../shared.js";
+import { getWorkspaceStorePath, listStoreKeysSync, parseVirtualStorePath, readStoreBlobSync, readVirtualStorePathSync, toVirtualStorePath, } from "../store/store-snapshot.js";
+import { isOperationalArtifactPath, operationalArtifactKey, writeOperationalArtifactQueued, writeStoreBlobQueued, writeStoreBlobSync, } from "../store/store-artifacts.js";
+import { withStoreWriteCoordinatorSync } from "../store/write-coordinator.js";
+import { ACE_ROOT_REL, ACE_SCRIPTS_ROOT_REL, ACE_SKILLS_ROOT_REL, ACE_TASKS_ROOT_REL, AGENT_FILES, AGENT_MANIFEST_FILES, DEFAULTS_ROOT, KERNEL_FILES, STORE_AGENT_FILES, STORE_KERNEL_FILES, STORE_TASK_FILES, TASK_FILES, } from "./constants.js";
+import { currentWorkspaceRoot, isProjectedAceWorkspacePath, mapAceWorkspaceRelativePath, resolveWorkspaceReadPath, resolveWorkspaceWritePath, } from "./path-utils.js";
+const STORE_ONLY_AGENT_STATE_FILES = new Set([
+    "agent-state/AST_GREP_INDEX.json",
+    "agent-state/AST_GREP_INDEX.md",
+    "agent-state/EVIDENCE_LOG.md",
+    "agent-state/STATUS_EVENTS.ndjson",
+    "agent-state/STATUS_EVENTS-archive.ndjson",
+    "agent-state/index-fingerprints.json",
+    "agent-state/index.json",
+    "agent-state/job-locks.json",
+    "agent-state/job-queue.json",
+    "agent-state/scheduler-lease.json",
+]);
+export function formatStorePath(key) {
+    return toVirtualStorePath(getWorkspaceStorePath(currentWorkspaceRoot()), key);
+}
+export function readStoreText(keys) {
+    const root = currentWorkspaceRoot();
+    for (const key of keys) {
+        const text = readStoreBlobSync(root, key);
+        if (typeof text === "string") {
+            return { key, path: formatStorePath(key), text };
+        }
+    }
+    return undefined;
+}
+export function listStoreSkillReferences() {
+    const root = currentWorkspaceRoot();
+    const names = new Set();
+    for (const key of listStoreKeysSync(root, "knowledge/skills/")) {
+        const parts = key.split("/");
+        if (parts[2])
+            names.add(parts[2]);
+    }
+    return [...names]
+        .sort((a, b) => a.localeCompare(b))
+        .map((name) => ({
+        name,
+        path: formatStorePath(`knowledge/skills/${name}/SKILL.md`),
+        source: "store",
+    }));
+}
+function resolveStoreFallbackKeys(filePath) {
+    const normalized = normalizeRelPath(filePath);
+    if (!normalized)
+        return [];
+    const canonical = mapAceWorkspaceRelativePath(normalized);
+    const keys = new Set();
+    const logicalAgentStatePath = normalized.startsWith("agent-state/")
+        ? normalized
+        : canonical.startsWith(`${ACE_ROOT_REL}/agent-state/`)
+            ? canonical.slice(`${ACE_ROOT_REL}/`.length)
+            : undefined;
+    if (logicalAgentStatePath && isOperationalArtifactPath(logicalAgentStatePath)) {
+        keys.add(operationalArtifactKey(logicalAgentStatePath));
+    }
+    if (normalized === "agent-state/ACE_WORKFLOW.md" || canonical === `${ACE_ROOT_REL}/agent-state/ACE_WORKFLOW.md`) {
+        keys.add("knowledge/runtime/ACE_WORKFLOW.md");
+    }
+    const gatePrefix = "agent-state/MODULES/gates/";
+    if (logicalAgentStatePath?.startsWith(gatePrefix)) {
+        const file = logicalAgentStatePath.slice(gatePrefix.length);
+        if (file)
+            keys.add(`knowledge/gates/${file}`);
+    }
+    const rolePrefix = "agent-state/MODULES/roles/";
+    if (logicalAgentStatePath?.startsWith(rolePrefix)) {
+        const file = logicalAgentStatePath.slice(rolePrefix.length);
+        if (file)
+            keys.add(`knowledge/roles/${file}`);
+    }
+    const schemaPrefix = "agent-state/MODULES/schemas/";
+    if (logicalAgentStatePath?.startsWith(schemaPrefix)) {
+        const file = logicalAgentStatePath.slice(schemaPrefix.length);
+        if (file)
+            keys.add(`knowledge/schemas/${file}`);
+    }
+    const staticAgentState = new Set([
+        "ACE_WORKFLOW.md",
+        "ARTIFACT_MANIFEST.json",
+        "AST_GREP_COMMANDS.md",
+        "AST_GREP_INDEX.json",
+        "AST_GREP_INDEX.md",
+        "DECISIONS.md",
+        "EVIDENCE_LOG.md",
+        "HANDOFF.json",
+        "INTERFACE_REGISTRY.md",
+        "PROVENANCE_LOG.md",
+        "QUALITY_GATES.md",
+        "RISKS.md",
+        "SCOPE.md",
+        "SKILL_CATALOG.md",
+        "STATUS.md",
+        "STATUS_EVENTS.ndjson",
+        "TASK.md",
+        "TEAL_CONFIG.md",
+        "MODULES/registry.json",
+        "handoff-registry.json",
+        "index-fingerprints.json",
+        "index.json",
+        "run-ledger.json",
+        "runtime-executor-sessions.json",
+        "runtime-tool-specs.json",
+        "runtime-workspaces.json",
+        "todo-state.json",
+        "tracker-snapshot.json",
+        "vericify/ace-bridge.json",
+        "vericify/process-posts.json",
+    ]);
+    if (logicalAgentStatePath?.startsWith("agent-state/")) {
+        const rel = logicalAgentStatePath.slice("agent-state/".length);
+        if (!rel.startsWith("context-snapshots/")) {
+            keys.add(`state/artifacts/agent-state/${rel}`);
+        }
+        const runtimeProjectionKey = {
+            "job-queue.json": "state/artifacts/agent-state/job-queue.json",
+            "job-locks.json": "state/artifacts/agent-state/job-locks.json",
+            "scheduler-lease.json": "state/artifacts/agent-state/scheduler-lease.json",
+        }[rel];
+        if (runtimeProjectionKey)
+            keys.add(runtimeProjectionKey);
+        if (staticAgentState.has(rel)) {
+            keys.add(`knowledge/agent-state/${rel}`);
+        }
+    }
+    const contextSnapshotPrefix = "agent-state/context-snapshots/";
+    if (logicalAgentStatePath?.startsWith(contextSnapshotPrefix)) {
+        const rel = logicalAgentStatePath.slice(contextSnapshotPrefix.length);
+        if (rel)
+            keys.add(`state/memory/context_snapshots/${rel}`);
+    }
+    const skillsPrefix = `${ACE_SKILLS_ROOT_REL}/`;
+    if (canonical.startsWith(skillsPrefix)) {
+        keys.add(`knowledge/skills/${canonical.slice(skillsPrefix.length)}`);
+    }
+    const tasksPrefix = `${ACE_TASKS_ROOT_REL}/`;
+    if (canonical.startsWith(tasksPrefix)) {
+        keys.add(`knowledge/tasks/${canonical.slice(tasksPrefix.length)}`);
+    }
+    const scriptsPrefix = `${ACE_SCRIPTS_ROOT_REL}/`;
+    if (canonical.startsWith(scriptsPrefix)) {
+        keys.add(`knowledge/scripts/${canonical.slice(scriptsPrefix.length)}`);
+    }
+    for (const [key, candidates] of Object.entries(TASK_FILES)) {
+        if (candidates.includes(canonical)) {
+            keys.add(STORE_TASK_FILES[key]);
+        }
+    }
+    for (const [key, candidates] of Object.entries(KERNEL_FILES)) {
+        if (candidates.includes(canonical)) {
+            for (const storeKey of STORE_KERNEL_FILES[key])
+                keys.add(storeKey);
+        }
+    }
+    for (const [role, candidates] of Object.entries(AGENT_FILES)) {
+        if (candidates.includes(canonical)) {
+            for (const file of STORE_AGENT_FILES[role].instructions) {
+                keys.add(`knowledge/agents/${STORE_AGENT_FILES[role].agent}/${file}`);
+            }
+        }
+    }
+    for (const [role, candidates] of Object.entries(AGENT_MANIFEST_FILES)) {
+        if (candidates.includes(canonical)) {
+            for (const file of STORE_AGENT_FILES[role].manifests) {
+                keys.add(`knowledge/agents/${STORE_AGENT_FILES[role].agent}/${file}`);
+            }
+        }
+    }
+    return [...keys];
+}
+export function resolveStoreFallbackKeysForPath(filePath) {
+    return resolveStoreFallbackKeys(filePath);
+}
+export function classifyPathSource(path) {
+    if (!path)
+        return "missing";
+    const root = currentWorkspaceRoot();
+    if (path.includes(".ace#"))
+        return "store";
+    if (isInside(root, path))
+        return "workspace";
+    if (isInside(DEFAULTS_ROOT, path))
+        return "package-defaults";
+    return "missing";
+}
+export function safeRead(filePath) {
+    try {
+        if (parseVirtualStorePath(filePath)) {
+            const direct = readVirtualStorePathSync(filePath);
+            return typeof direct === "string" ? direct : `[FILE NOT FOUND] ${filePath}`;
+        }
+        const abs = resolveWorkspaceReadPath(filePath);
+        if (!existsSync(abs)) {
+            const store = readStoreText(resolveStoreFallbackKeys(filePath));
+            if (store)
+                return store.text;
+            return `[FILE NOT FOUND] ${abs}`;
+        }
+        return readFileSyncUtf8(abs);
+    }
+    catch (err) {
+        return `[ACCESS DENIED] ${String(err)}`;
+    }
+}
+export function safeWrite(filePath, content) {
+    const normalized = normalizeRelPath(filePath);
+    const canonical = mapAceWorkspaceRelativePath(normalized);
+    const logicalAgentStatePath = normalized.startsWith("agent-state/")
+        ? normalized
+        : canonical.startsWith(`${ACE_ROOT_REL}/agent-state/`)
+            ? canonical.slice(`${ACE_ROOT_REL}/`.length)
+            : undefined;
+    const root = currentWorkspaceRoot();
+    let storeVirtualPath;
+    const storeKeys = resolveStoreFallbackKeys(filePath);
+    if (storeKeys.length > 0 && existsSync(getWorkspaceStorePath(root))) {
+        storeVirtualPath = withStoreWriteCoordinatorSync(getWorkspaceStorePath(root), () => writeStoreBlobSync(root, storeKeys[0], content), { operation_label: "safeWrite" });
+        const isAcePath = canonical === ACE_ROOT_REL || canonical.startsWith(`${ACE_ROOT_REL}/`);
+        const isStoreOnlyProjection = canonical === `${ACE_ROOT_REL}/ace-hook-context.json` ||
+            logicalAgentStatePath?.startsWith("agent-state/context-snapshots/") ||
+            STORE_ONLY_AGENT_STATE_FILES.has(logicalAgentStatePath ?? "");
+        if (isAcePath && !isProjectedAceWorkspacePath(canonical)) {
+            return storeVirtualPath;
+        }
+        if (isStoreOnlyProjection) {
+            return storeVirtualPath;
+        }
+    }
+    const abs = isAbsolute(filePath) && isInside(root, filePath)
+        ? filePath
+        : resolveWorkspaceWritePath(filePath, root);
+    mkdirSync(dirname(abs), { recursive: true });
+    const tmpPath = `${abs}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmpPath, content, "utf-8");
+    renameSync(tmpPath, abs);
+    return abs;
+}
+export async function safeWriteAsync(filePath, content) {
+    const normalized = normalizeRelPath(filePath);
+    const canonical = mapAceWorkspaceRelativePath(normalized);
+    const logicalAgentStatePath = normalized.startsWith("agent-state/")
+        ? normalized
+        : canonical.startsWith(`${ACE_ROOT_REL}/agent-state/`)
+            ? canonical.slice(`${ACE_ROOT_REL}/`.length)
+            : undefined;
+    const root = currentWorkspaceRoot();
+    let storeVirtualPath;
+    const storeKeys = resolveStoreFallbackKeys(filePath);
+    if (storeKeys.length > 0 && existsSync(getWorkspaceStorePath(root))) {
+        const storeKey = storeKeys[0];
+        if (logicalAgentStatePath && isOperationalArtifactPath(logicalAgentStatePath)) {
+            storeVirtualPath = await writeOperationalArtifactQueued(root, logicalAgentStatePath, content, { operation_label: "safeWriteAsync" });
+        }
+        else {
+            storeVirtualPath = await writeStoreBlobQueued(root, storeKey, content, { operation_label: "safeWriteAsync" });
+        }
+        const isAcePath = canonical === ACE_ROOT_REL || canonical.startsWith(`${ACE_ROOT_REL}/`);
+        const isStoreOnlyProjection = canonical === `${ACE_ROOT_REL}/ace-hook-context.json` ||
+            logicalAgentStatePath?.startsWith("agent-state/context-snapshots/") ||
+            STORE_ONLY_AGENT_STATE_FILES.has(logicalAgentStatePath ?? "");
+        if (isAcePath && !isProjectedAceWorkspacePath(canonical)) {
+            return storeVirtualPath;
+        }
+        if (isStoreOnlyProjection) {
+            return storeVirtualPath;
+        }
+    }
+    const abs = isAbsolute(filePath) && isInside(root, filePath)
+        ? filePath
+        : resolveWorkspaceWritePath(filePath, root);
+    await mkdir(dirname(abs), { recursive: true });
+    const tmpPath = `${abs}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tmpPath, content, "utf-8");
+    await rename(tmpPath, abs);
+    return abs;
+}
+const _fileLocks = new Map();
+export async function withFileLock(path, fn) {
+    const key = resolveWorkspaceWritePath(path);
+    const prev = _fileLocks.get(key) ?? Promise.resolve();
+    let releaseLock;
+    const next = new Promise((r) => { releaseLock = r; });
+    _fileLocks.set(key, next);
+    await prev;
+    try {
+        return await fn();
+    }
+    finally {
+        releaseLock();
+        if (_fileLocks.get(key) === next)
+            _fileLocks.delete(key);
+    }
+}
+function readFileSyncUtf8(path) {
+    return readFileSync(path, "utf-8");
+}
+//# sourceMappingURL=store-resolution.js.map

package/dist/helpers/workspace-root.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveWorkspaceRoot(): string;
+export declare const WORKSPACE_ROOT: string;
+//# sourceMappingURL=workspace-root.d.ts.map

package/dist/helpers/workspace-root.js

@@ -0,0 +1,80 @@
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+function normalizeWorkspaceRootCandidate(candidate) {
+    const trimmed = candidate?.trim();
+    if (!trimmed)
+        return undefined;
+    return resolve(trimmed);
+}
+function isFilesystemRoot(path) {
+    return dirname(path) === path;
+}
+function normalizeWorkspaceRootLikePath(candidate) {
+    const resolvedCandidate = resolve(candidate);
+    if (resolvedCandidate.endsWith(join("agent-state", "ace-state.ace"))) {
+        return dirname(dirname(resolvedCandidate));
+    }
+    if (resolvedCandidate.endsWith(join(".agents", "ACE", "ace-state.ace"))) {
+        return dirname(dirname(dirname(resolvedCandidate)));
+    }
+    if (resolvedCandidate.endsWith(join(".agents", "ACE"))) {
+        return dirname(dirname(resolvedCandidate));
+    }
+    if (resolvedCandidate.endsWith(join(".agents"))) {
+        return dirname(resolvedCandidate);
+    }
+    return resolvedCandidate;
+}
+function hasInitiatedAceWorkspace(root) {
+    return (existsSync(resolve(root, "agent-state", "ace-state.ace")) ||
+        existsSync(resolve(root, ".agents", "ACE", "ace-state.ace")) ||
+        existsSync(resolve(root, ".agents", "ACE")) ||
+        existsSync(resolve(root, "agent-state", "TASK.md")) ||
+        existsSync(resolve(root, "agent-state", "STATUS.md")));
+}
+function findNearestInitiatedWorkspaceRoot(candidate) {
+    let cursor = normalizeWorkspaceRootLikePath(candidate);
+    while (true) {
+        if (existsSync(cursor) && hasInitiatedAceWorkspace(cursor)) {
+            return cursor;
+        }
+        const parent = dirname(cursor);
+        if (parent === cursor)
+            break;
+        cursor = parent;
+    }
+    return undefined;
+}
+function pinWorkspaceRoot(root) {
+    const normalized = normalizeWorkspaceRootLikePath(root);
+    process.env.ACE_WORKSPACE_ROOT = normalized;
+    return normalized;
+}
+export function resolveWorkspaceRoot() {
+    const explicit = normalizeWorkspaceRootCandidate(process.env.ACE_WORKSPACE_ROOT);
+    if (explicit)
+        return pinWorkspaceRoot(findNearestInitiatedWorkspaceRoot(explicit) ?? explicit);
+    const ordered = [
+        process.env.ACE_TUI_WORKSPACE_ROOT,
+        process.env.INIT_CWD,
+        process.env.PWD,
+        process.cwd(),
+    ]
+        .map(normalizeWorkspaceRootCandidate)
+        .filter((candidate) => Boolean(candidate));
+    const candidates = [...new Set(ordered)];
+    for (const candidate of candidates) {
+        const initiated = findNearestInitiatedWorkspaceRoot(candidate);
+        if (initiated)
+            return pinWorkspaceRoot(initiated);
+    }
+    const firstExistingNonRoot = candidates.find((candidate) => existsSync(candidate) && !isFilesystemRoot(candidate));
+    if (firstExistingNonRoot)
+        return pinWorkspaceRoot(firstExistingNonRoot);
+    const firstExisting = candidates.find((candidate) => existsSync(candidate));
+    if (firstExisting)
+        return pinWorkspaceRoot(firstExisting);
+    return pinWorkspaceRoot(candidates[0] ?? resolve(process.cwd()));
+}
+export const WORKSPACE_ROOT = resolveWorkspaceRoot();
+//# sourceMappingURL=workspace-root.js.map

package/dist/helpers.d.ts

@@ -1,128 +1,11 @@
-/**
- * Shared helpers – path resolution, file I/O, artifact discovery, bootstrap.
- */
+import { resolveWorkspaceRoot } from "./helpers/workspace-root.js";
 export { isInside, isReadError, normalizeRelPath, looksLikeSwarmHandoffPath } from "./shared.js";
-export declare const SERVER_ROOT: string;
-export declare const PACKAGE_ROOT: string;
-export declare function resolveWorkspaceRoot(): string;
+export * from "./helpers/constants.js";
+export { resolveWorkspaceRoot };
 export declare const WORKSPACE_ROOT: string;
-export declare const DEFAULTS_ROOT: string;
-export declare const ACE_ROOT_REL = ".agents/ACE";
-export declare const ACE_SKILLS_ROOT_REL = ".agents/ACE/skills";
-export declare const ACE_TASKS_ROOT_REL = ".agents/ACE/tasks";
-export declare const ACE_SCRIPTS_ROOT_REL = ".agents/ACE/scripts/ace";
-export declare const ACE_BUNDLE_ROOT_REL = ".mcp-config";
-export declare const ACE_LLM_ROOT_REL = ".agents/ACE/.ace";
-export declare const ACE_VSCODE_ROOT_REL = ".vscode";
-export declare const ACE_CURSOR_ROOT_REL = ".cursor";
-export declare const ACE_CLAUDE_ROOT_REL = ".claude";
-export declare const ACE_GITHUB_ROOT_REL = ".github";
-export declare const ACE_HOST_AGENTS_REL = "AGENTS.md";
-export declare const ACE_HOST_CLAUDE_REL = "CLAUDE.md";
-export declare const ACE_HOST_CURSOR_RULES_REL = ".cursorrules";
-export declare const ALL_MCP_CLIENTS: readonly ["codex", "vscode", "claude", "cursor", "antigravity"];
-export type McpClient = (typeof ALL_MCP_CLIENTS)[number];
-export declare const ALL_LLM_PROVIDERS: readonly ["ollama", "llama.cpp", "codex", "claude", "gemini", "copilot"];
-export type LlmProvider = (typeof ALL_LLM_PROVIDERS)[number];
-export declare const ALL_AGENTS: readonly ["orchestrator", "vos", "ui", "coders", "astgrep", "skeptic", "ops", "research", "spec", "builder", "qa", "docs", "memory", "security", "observability", "eval", "release"];
-export type AgentRole = (typeof ALL_AGENTS)[number];
-export declare const SWARM_AGENTS: readonly ["orchestrator", "vos", "ui", "coders"];
-export type SwarmAgentRole = (typeof SWARM_AGENTS)[number];
-export declare const COMPOSABLE_AGENTS: readonly ["astgrep", "skeptic", "ops", "research", "spec", "builder", "qa", "docs", "memory", "security", "observability", "eval", "release"];
-export type ComposableAgentRole = (typeof COMPOSABLE_AGENTS)[number];
-export declare const SWARM_SUBAGENT_MAP: Record<SwarmAgentRole, readonly ComposableAgentRole[]>;
-export type TaskKey = "todo" | "role_tasks" | "cli_work_split" | "lessons" | "readme" | "handoff_template" | "handoff_example" | "handoff_example_vos_ui" | "handoff_example_ui_coders";
-export type KernelKey = "directive_kernel" | "agent_registry";
-export declare const AGENT_FILES: Record<AgentRole, string[]>;
-export declare const AGENT_MANIFEST_FILES: Record<AgentRole, string[]>;
-export declare const TASK_FILES: Record<TaskKey, string[]>;
-export declare const KERNEL_FILES: Record<KernelKey, string[]>;
-export type ArtifactSource = "workspace" | "package-defaults" | "store" | "missing";
-export interface SkillReference {
-    name: string;
-    path: string;
-    source: "workspace" | "package-defaults" | "store";
-}
-export interface BootstrapOptions {
-    projectName?: string;
-    force?: boolean;
-    includeMcpConfig?: boolean;
-    includeClientConfigBundle?: boolean;
-    llmProvider?: LlmProvider;
-    llmModel?: string;
-    llmBaseUrl?: string;
-    ollamaModel?: string;
-    ollamaBaseUrl?: string;
-    /**
-     * When true, skip copying store-managed trees (tasks, agent-state, skills,
-     * and the .agents/ACE defaults tree). Pass this when bootstrapStoreWorkspace()
-     * has already run so the store is authoritative for those paths.
-     */
-    skipStoreManaged?: boolean;
-}
-export interface BootstrapResult {
-    created: string[];
-    updated: string[];
-    skipped: string[];
-}
-export declare function mapAceWorkspaceRelativePath(path: string): string;
-export declare function isProjectedAceWorkspacePath(filePath: string): boolean;
-export declare function acePath(...segments: string[]): string;
-export declare function wsPath(...segments: string[]): string;
-/** Normalize a path for validation: workspace-relative, forward slashes. */
-export declare function normalizePathForValidation(path: string): string;
-/** Check if a role is a swarm agent (vs composable). */
-export declare function isSwarmRole(role: string): role is (typeof SWARM_AGENTS)[number];
-/** Atomically write a file via tmp + rename to prevent partial writes. */
-export declare function atomicWrite(filePath: string, content: string): string;
-/** Check if a file exists. Relative paths are workspace-relative. */
-export declare function fileExists(filePath: string): boolean;
-export declare function resolveWorkspaceWritePath(filePath: string): string;
-export declare function resolveWorkspaceReadPath(filePath: string): string;
-export declare function resolveWorkspaceArtifactPath(filePath: string, mode?: "read" | "write"): string;
-export declare function resolveStoreFallbackKeysForPath(filePath: string): string[];
-export declare function classifyPathSource(path?: string): ArtifactSource;
-/** Safely read a workspace file, returning either text or a not-found/access message. */
-export declare function safeRead(filePath: string): string;
-/** Safely write a workspace file atomically (tmp + rename), creating directories if needed. */
-export declare function safeWrite(filePath: string, content: string): string;
-/**
- * Execute `fn` while holding a per-path serialization lock.
- * Prevents concurrent read-modify-write cycles on the same file
- * within a single process. Cross-process safety relies on atomic rename.
- */
-export declare function withFileLock<T>(path: string, fn: () => T | Promise<T>): Promise<T>;
-export declare function getAgentInstructionPath(role: AgentRole): string | undefined;
-export declare function getAgentManifestPath(role: AgentRole): string | undefined;
-export declare function readAgentInstructions(role: AgentRole): string;
-export declare function readAgentManifest(role: AgentRole): string;
-export declare function getTaskArtifactPath(key: TaskKey): string | undefined;
-export declare function readTaskArtifact(key: TaskKey): string;
-export declare function getKernelArtifactPath(key: KernelKey): string | undefined;
-export declare function readKernelArtifact(key: KernelKey): string;
-export declare function resolveWritableTaskPath(key: TaskKey): string;
-export declare function listAvailableSkills(): SkillReference[];
-export declare function getSkillPath(name: string): string | undefined;
-export declare function readSkillInstructions(name: string): string;
-export declare function getMcpClientBundlePath(client: McpClient): string;
-export declare function getMcpClientInstallHint(client: McpClient): string;
-export declare function getMcpServerConfigSnippet(client?: McpClient): string;
-export declare function getAllMcpServerConfigSnippets(): Record<McpClient, string>;
-export declare function bootstrapAceWorkspace(options?: BootstrapOptions): BootstrapResult;
-export interface DriftEntry {
-    asset_path: string;
-    runtime_path: string;
-    status: "match" | "drift" | "missing-runtime" | "missing-asset";
-}
-export interface DriftReport {
-    checked: number;
-    drifted: number;
-    missing_runtime: number;
-    entries: DriftEntry[];
-}
-/**
- * Compare packaged assets against runtime workspace copies.
- * Detects silent divergence between authoritative defaults and live state.
- */
-export declare function detectAssetDrift(): DriftReport;
+export * from "./helpers/path-utils.js";
+export * from "./helpers/store-resolution.js";
+export * from "./helpers/artifacts.js";
+export * from "./helpers/bootstrap.js";
+export * from "./helpers/drift.js";
 //# sourceMappingURL=helpers.d.ts.map