@voybio/ace-swarm 0.1.0

package/dist/tools-scheduler.js

@@ -0,0 +1,228 @@
+/**
+ * Job scheduler tool registrations.
+ */
+import { z } from "zod";
+import { acknowledgeJob, completeJob, dispatchJobNow, dispatchJobs, enqueueJob, getJobLockTablePath, getJobQueuePath, getSchedulerLeasePath, readJobQueue, readJobLockTable, readSchedulerLease, } from "./job-scheduler.js";
+// Event emission handled in core job-scheduler.ts — no wrapper duplication.
+const PRIORITY_BAND_ENUM = z.enum(["P0", "P1", "P2", "P3"]);
+const JOB_STATUS_ENUM = z.enum([
+    "pending",
+    "accepted",
+    "blocked",
+    "ready",
+    "running",
+    "done",
+    "failed",
+    "failed_terminal",
+    "canceled",
+    "unknown_recovery",
+]);
+const DEPENDENCY_KIND_ENUM = z.enum(["gate", "handoff", "todo", "time"]);
+function asJsonBlock(value) {
+    return `\`\`\`json\n${JSON.stringify(value, null, 2)}\n\`\`\``;
+}
+export function registerSchedulerTools(server) {
+    server.tool("enqueue_job", "Add a handoff job to the scheduler queue with priority/dependency/resource metadata", {
+        kind: z.string().describe("Job kind/type identifier"),
+        payload: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe("Arbitrary JSON payload for the worker"),
+        priority: PRIORITY_BAND_ENUM.optional().describe("Priority band P0..P3"),
+        dependencies: z
+            .array(z.object({
+            kind: DEPENDENCY_KIND_ENUM,
+            ref: z.string(),
+            expected: z.string().optional(),
+        }))
+            .optional()
+            .describe("Optional dependency gates/todos/handoffs/time markers"),
+        resource_requirements: z
+            .array(z.string())
+            .optional()
+            .describe("Shared resources that must remain collision-free while a job is running"),
+        run_after: z.string().optional().describe("ISO timestamp to defer execution until"),
+        max_attempts: z.number().int().min(1).max(25).optional(),
+        backoff_ms: z.number().int().min(1000).max(86_400_000).optional(),
+        job_id: z.string().optional().describe("Optional caller-provided job id"),
+    }, async (input) => {
+        const result = await enqueueJob(input);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.ok
+                        ? [
+                            "✅ Job enqueued",
+                            `Queue: ${result.path}`,
+                            `Job: ${result.ack?.job_id ?? "n/a"}`,
+                            asJsonBlock(result),
+                        ].join("\n")
+                        : [
+                            "❌ enqueue_job rejected",
+                            `Queue: ${result.path}`,
+                            result.nack
+                                ? `${result.nack.reason_code}: ${result.nack.reason}`
+                                : "Unknown enqueue error",
+                            asJsonBlock(result),
+                        ].join("\n"),
+                },
+            ],
+        };
+    });
+    server.tool("list_jobs", "List scheduler jobs and lock table snapshot", {
+        status: JOB_STATUS_ENUM.optional().describe("Optional status filter"),
+        include_locks: z
+            .boolean()
+            .optional()
+            .describe("Include lock table payload (default true)"),
+        limit: z.number().int().min(1).max(1000).optional().describe("Max jobs returned"),
+    }, async ({ status, include_locks, limit }) => {
+        const queue = readJobQueue();
+        const filtered = queue.jobs.filter((job) => (status ? job.status === status : true));
+        const clipped = typeof limit === "number" ? filtered.slice(0, limit) : filtered;
+        const lockTable = readJobLockTable();
+        const lease = readSchedulerLease();
+        const payload = {
+            queue_path: getJobQueuePath(),
+            lock_path: getJobLockTablePath(),
+            lease_path: getSchedulerLeasePath(),
+            total_jobs: queue.jobs.length,
+            returned_jobs: clipped.length,
+            jobs: clipped,
+            lease,
+        };
+        if (include_locks !== false) {
+            payload.locks = lockTable;
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: ["# Scheduler Queue", "", asJsonBlock(payload)].join("\n"),
+                },
+            ],
+        };
+    });
+    server.tool("ack_job", "Acknowledge or update scheduler job lifecycle (accept/reject/cancel/resume)", {
+        job_id: z.string(),
+        action: z.enum(["accept", "reject", "cancel", "resume"]),
+        reason: z.string().optional(),
+    }, async ({ job_id, action, reason }) => {
+        const result = await acknowledgeJob({ job_id, action, reason });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.ok
+                        ? [
+                            "✅ Job acknowledgement applied",
+                            `Queue: ${result.path}`,
+                            `Transition: ${result.from ?? "unknown"} -> ${result.to ?? "unknown"}`,
+                            asJsonBlock(result),
+                        ].join("\n")
+                        : [
+                            "❌ ack_job failed",
+                            result.error ?? "Unknown ack error",
+                            asJsonBlock(result),
+                        ].join("\n"),
+                },
+            ],
+        };
+    });
+    server.tool("dispatch_jobs", "Dispatch runnable jobs immediately with priority-aware collision-free resource locks", {
+        owner: z.string().optional().describe("Lease owner identity"),
+        lease_ttl_seconds: z.number().int().min(5).max(3600).optional(),
+        now_iso: z.string().optional().describe("Optional deterministic clock override"),
+    }, async (input) => {
+        const result = await dispatchJobs(input);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        result.ok ? "✅ Scheduler dispatch completed" : "⚠️ Scheduler lease not acquired",
+                        `Owner: ${result.owner}`,
+                        `Lease acquired: ${result.lease_acquired}`,
+                        `Queue: ${result.queue_path}`,
+                        `Locks: ${result.lock_path}`,
+                        asJsonBlock(result),
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
+    server.tool("dispatch_job_now", "Immediately start a single ready job if its dependencies are clear and resources are free", {
+        job_id: z.string(),
+        owner: z.string().optional(),
+        now_iso: z.string().optional(),
+    }, async ({ job_id, owner, now_iso }) => {
+        const result = await dispatchJobNow({ job_id, owner, now_iso });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.ok
+                        ? ["✅ Job started", asJsonBlock(result)].join("\n")
+                        : ["❌ dispatch_job_now failed", result.error ?? "Unknown error", asJsonBlock(result)].join("\n"),
+                },
+            ],
+        };
+    });
+    server.tool("complete_job", "Finalize a running job, recording success/failure and retry scheduling", {
+        job_id: z.string(),
+        owner: z.string().optional().describe("Lease owner identity (defaults to capability-ops)"),
+        success: z.boolean().optional(),
+        evidence_ref: z.string().optional(),
+        error: z.string().optional(),
+        now_iso: z.string().optional(),
+    }, async ({ job_id, owner, success, evidence_ref, error, now_iso }) => {
+        const result = await completeJob({
+            job_id,
+            owner,
+            success,
+            evidence_ref,
+            error,
+            now_iso,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.ok
+                        ? ["✅ Job completion recorded", asJsonBlock(result)].join("\n")
+                        : ["❌ complete_job failed", result.error ?? "Unknown error", asJsonBlock(result)].join("\n"),
+                },
+            ],
+        };
+    });
+    server.tool("get_lock_table", "Read the scheduler lock table", {}, async () => ({
+        content: [
+            {
+                type: "text",
+                text: [
+                    "# Lock Table",
+                    "",
+                    `Path: ${getJobLockTablePath()}`,
+                    "",
+                    asJsonBlock(readJobLockTable()),
+                ].join("\n"),
+            },
+        ],
+    }));
+    server.tool("get_scheduler_lease", "Read the scheduler lease owner and expiry", {}, async () => ({
+        content: [
+            {
+                type: "text",
+                text: [
+                    "# Scheduler Lease",
+                    "",
+                    `Path: ${getSchedulerLeasePath()}`,
+                    "",
+                    asJsonBlock(readSchedulerLease() ?? null),
+                ].join("\n"),
+            },
+        ],
+    }));
+}
+//# sourceMappingURL=tools-scheduler.js.map

package/dist/tools-skills.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerSkillTools(server: McpServer): void;
+//# sourceMappingURL=tools-skills.d.ts.map

package/dist/tools-skills.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+import { auditSkillCatalog, writeSkillAuditReport, } from "./skill-auditor.js";
+import { triageProblemRequest, writeProblemTriageReport, } from "./problem-triage.js";
+import { listSkillCatalogEntries, summarizeSkillCatalog, } from "./skill-catalog.js";
+export function registerSkillTools(server) {
+    server.tool("skill_catalog_summary", "Summarize discoverable ACE skills and current readiness gaps", {}, async () => {
+        const entries = listSkillCatalogEntries();
+        const summary = summarizeSkillCatalog(entries);
+        const lines = [
+            "# Skill Catalog Summary",
+            "",
+            `- total skills: ${summary.total_skills}`,
+            `- portable-contract-ready skills: ${summary.portable_contract_ready_skills}`,
+            `- skills with frontmatter: ${summary.with_frontmatter}`,
+            `- trigger-aware descriptions: ${summary.trigger_aware_descriptions}`,
+            `- skills with validation surface: ${summary.with_validation_surface}`,
+            `- skills with portability notes: ${summary.with_portability_notes}`,
+            `- skills with optional adapters: ${summary.with_adapter_overlays}`,
+            `- adapter clients observed: ${summary.adapter_clients.length > 0 ? summary.adapter_clients.join(", ") : "none"}`,
+            `- legacy openai overlays observed: ${summary.with_openai_yaml}`,
+            `- long skills (>500 lines): ${summary.long_skills.length > 0
+                ? summary.long_skills.map((entry) => `${entry.name} (${entry.line_count})`).join(", ")
+                : "none"}`,
+            "",
+            "## Skills",
+            ...entries.map((entry) => `- ${entry.name} (${entry.source}) — adapters=${entry.adapter_overlay_clients.length > 0
+                ? entry.adapter_overlay_clients.join("/")
+                : "none"}, sections=${[
+                entry.has_inputs_section ? "inputs" : "",
+                entry.has_workflow_section ? "workflow" : "",
+                entry.has_outputs_section ? "outputs" : "",
+                entry.has_failure_policy ? "failure" : "",
+            ]
+                .filter(Boolean)
+                .join("/") || "missing core sections"}, validation=${entry.has_validation_surface ? "yes" : "no"}, portability=${entry.has_portability_notes ? "yes" : "no"}`),
+        ];
+        return {
+            content: [{ type: "text", text: lines.join("\n") }],
+        };
+    });
+    server.tool("skill_audit", "Audit discoverable ACE skills against the portable skill contract and write SKILL_AUDIT_REPORT.md", {
+        write_artifact: z
+            .boolean()
+            .optional()
+            .describe("Write agent-state/SKILL_AUDIT_REPORT.md (default: true)"),
+        artifact_path: z
+            .string()
+            .optional()
+            .describe("Optional workspace-relative path for the audit report"),
+    }, async ({ write_artifact, artifact_path }) => {
+        const result = auditSkillCatalog();
+        const writtenPath = write_artifact === false
+            ? undefined
+            : writeSkillAuditReport(result, artifact_path || "agent-state/SKILL_AUDIT_REPORT.md");
+        const failCount = result.entries.filter((entry) => entry.status === "fail").length;
+        const warnCount = result.entries.filter((entry) => entry.status === "warn").length;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `Portable-contract-ready skills: ${result.summary.portable_contract_ready_skills}/${result.summary.total_skills}`,
+                        `Fail/Warn: ${failCount}/${warnCount}`,
+                        ...(result.rollout_backlog.slice(0, 5).map((line) => `- ${line}`)),
+                        ...(writtenPath ? [`- Artifact written: ${writtenPath}`] : []),
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
+    server.tool("problem_triage", "Classify whether a request fits an existing skill, needs a skill patch, warrants a new skill, or should stay one-off", {
+        request: z.string().describe("The request or workflow to triage"),
+        write_artifact: z
+            .boolean()
+            .optional()
+            .describe("Write agent-state/PROBLEM_TRIAGE.md (default: true)"),
+        artifact_path: z
+            .string()
+            .optional()
+            .describe("Optional workspace-relative path for the triage report"),
+    }, async ({ request, write_artifact, artifact_path }) => {
+        const result = triageProblemRequest(request);
+        const writtenPath = write_artifact === false
+            ? undefined
+            : writeProblemTriageReport(result, artifact_path || "agent-state/PROBLEM_TRIAGE.md");
+        const reportLines = [
+            ...result.rationale,
+            ...(writtenPath ? [`Artifact written: ${writtenPath}`] : []),
+        ];
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `Route: ${result.route}`,
+                        `Confidence: ${result.confidence.toFixed(2)}`,
+                        ...reportLines.map((line) => `- ${line}`),
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
+}
+//# sourceMappingURL=tools-skills.js.map

package/dist/tools-todo.d.ts

@@ -0,0 +1,6 @@
+/**
+ * TODO, task management, and run-ledger tool registrations.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerTodoTools(server: McpServer): void;
+//# sourceMappingURL=tools-todo.d.ts.map

package/dist/tools-todo.js

@@ -0,0 +1,154 @@
+/**
+ * TODO, task management, and run-ledger tool registrations.
+ */
+import { z } from "zod";
+import { ACE_TASKS_ROOT_REL, readTaskArtifact, resolveWritableTaskPath, safeWrite, } from "./helpers.js";
+import { TODO_STATUS_ENUM } from "./shared.js";
+import { getTodoStatePath, readTodoState, syncTodoStateSafe, transitionTodoNodeSafe, } from "./todo-state.js";
+import { appendRunLedgerEntrySafe, getRunLedgerPath, readRunLedger, } from "./run-ledger.js";
+import { refreshKanbanArtifacts } from "./kanban.js";
+export function registerTodoTools(server) {
+    server.tool("get_todo", "Read the current swarm TODO execution board", {}, async () => ({
+        content: [{ type: "text", text: readTaskArtifact("todo") }],
+    }));
+    server.tool("get_todo_state", "Read synced TODO node state with dependencies and explicit statuses", {}, async () => ({
+        content: [
+            {
+                type: "text",
+                text: `# TODO State\n\nPath: ${getTodoStatePath()}\n\n\`\`\`json\n${JSON.stringify(readTodoState(), null, 2)}\n\`\`\``,
+            },
+        ],
+    }));
+    server.tool("update_todo", "Replace TODO board content or transition a TODO node status with gate validation", {
+        new_content: z
+            .string()
+            .optional()
+            .describe("Full updated TODO markdown content (full replace mode)"),
+        node_id: z
+            .string()
+            .optional()
+            .describe("Todo node id to transition (transition mode)"),
+        status: TODO_STATUS_ENUM.optional().describe("Target status for transition mode"),
+        note: z.string().optional().describe("Optional transition context note"),
+    }, async ({ new_content, node_id, status, note }) => {
+        if (typeof new_content === "string") {
+            const path = safeWrite(resolveWritableTaskPath("todo"), new_content);
+            const synced = await syncTodoStateSafe(new_content);
+            const runLedger = await appendRunLedgerEntrySafe({
+                tool: "update_todo",
+                category: "major_update",
+                message: "Replaced TODO markdown board content",
+                artifacts: [`${ACE_TASKS_ROOT_REL}/todo.md`, "agent-state/todo-state.json"],
+                metadata: {
+                    mode: "replace",
+                    node_count: synced.state.order.length,
+                },
+            });
+            const kanban = refreshKanbanArtifacts("tool:update_todo");
+            const counts = kanban.counts;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [
+                            `✅ TODO updated: ${path}`,
+                            `TODO state synced: ${synced.path}`,
+                            `Run ledger: ${runLedger.path} (${runLedger.entry.id})`,
+                            `Kanban updated: ${kanban.html_path}`,
+                            `Kanban counts: backlog=${counts.backlog}, blocked=${counts.blocked}, in_progress=${counts.in_progress}, gated=${counts.gated}, done=${counts.done}`,
+                        ].join("\n"),
+                    },
+                ],
+            };
+        }
+        if (node_id && status) {
+            const transition = await transitionTodoNodeSafe(node_id, status);
+            if (!transition.ok) {
+                const detailLines = [
+                    transition.error
+                        ? `❌ ${transition.error}`
+                        : "❌ TODO transition failed.",
+                    transition.node_id ? `Node: ${transition.node_id}` : "",
+                    transition.from && transition.to
+                        ? `Attempted: ${transition.from} -> ${transition.to}`
+                        : "",
+                    transition.allowed?.length
+                        ? `Allowed next states: ${transition.allowed.join(", ")}`
+                        : "",
+                    transition.unresolved_dependencies?.length
+                        ? `Unresolved dependencies: ${transition.unresolved_dependencies.join(", ")}`
+                        : "",
+                ].filter(Boolean);
+                return {
+                    content: [{ type: "text", text: detailLines.join("\n") }],
+                };
+            }
+            const previous = transition.from ?? status;
+            const category = previous === "done" && status !== "done"
+                ? "regression"
+                : "major_update";
+            const runLedger = await appendRunLedgerEntrySafe({
+                tool: "update_todo",
+                category,
+                message: `Transitioned TODO node ${node_id}: ${previous} -> ${status}`,
+                artifacts: [`${ACE_TASKS_ROOT_REL}/todo.md`, "agent-state/todo-state.json"],
+                metadata: {
+                    mode: "transition",
+                    node_id,
+                    from: previous,
+                    to: status,
+                    note: note ?? "",
+                },
+            });
+            const kanban = refreshKanbanArtifacts("tool:update_todo");
+            const counts = kanban.counts;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [
+                            `✅ TODO transition applied: ${node_id}`,
+                            `Transition: ${previous} -> ${status}`,
+                            `TODO state: ${transition.path}`,
+                            `TODO markdown: ${transition.todo_path}`,
+                            `Run ledger: ${runLedger.path} (${runLedger.entry.id})`,
+                            `Kanban updated: ${kanban.html_path}`,
+                            `Kanban counts: backlog=${counts.backlog}, blocked=${counts.blocked}, in_progress=${counts.in_progress}, gated=${counts.gated}, done=${counts.done}`,
+                        ].join("\n"),
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "❌ Provide either `new_content` (full replace) or `node_id` + `status` (transition mode).",
+                },
+            ],
+        };
+    });
+    server.tool("get_run_ledger", "Read run-ledger milestone/regression history", {
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(500)
+            .optional()
+            .describe("Optional number of most recent entries to return"),
+    }, async ({ limit }) => {
+        const ledger = readRunLedger();
+        const entries = typeof limit === "number"
+            ? ledger.entries.slice(Math.max(ledger.entries.length - limit, 0))
+            : ledger.entries;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `# Run Ledger\n\nPath: ${getRunLedgerPath()}\n\n\`\`\`json\n${JSON.stringify({ ...ledger, entries }, null, 2)}\n\`\`\``,
+                },
+            ],
+        };
+    });
+}
+//# sourceMappingURL=tools-todo.js.map

package/dist/tools.d.ts

@@ -0,0 +1,9 @@
+/**
+ * MCP Tools - thin hub that delegates to domain-specific tool modules.
+ *
+ * Each module exports a registerXxxTools(server) function.
+ * This keeps the registration entry-point small and each domain testable.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerTools(server: McpServer): void;
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.js

@@ -0,0 +1,33 @@
+/**
+ * MCP Tools - thin hub that delegates to domain-specific tool modules.
+ *
+ * Each module exports a registerXxxTools(server) function.
+ * This keeps the registration entry-point small and each domain testable.
+ */
+import { registerAgentTools } from "./tools-agent.js";
+import { registerHandoffTools } from "./tools-handoff.js";
+import { registerTodoTools } from "./tools-todo.js";
+import { registerDiscoveryTools } from "./tools-discovery.js";
+import { registerLifecycleTools } from "./tools-lifecycle.js";
+import { registerFileTools } from "./tools-files.js";
+import { registerFrameworkTools } from "./tools-framework.js";
+import { registerGitTools } from "./tools-git.js";
+import { registerMemoryTools } from "./tools-memory.js";
+import { registerDriftTools } from "./tools-drift.js";
+import { registerSchedulerTools } from "./tools-scheduler.js";
+import { registerSkillTools } from "./tools-skills.js";
+export function registerTools(server) {
+    registerAgentTools(server);
+    registerHandoffTools(server);
+    registerTodoTools(server);
+    registerDiscoveryTools(server);
+    registerLifecycleTools(server);
+    registerFileTools(server);
+    registerFrameworkTools(server);
+    registerGitTools(server);
+    registerMemoryTools(server);
+    registerDriftTools(server);
+    registerSchedulerTools(server);
+    registerSkillTools(server);
+}
+//# sourceMappingURL=tools.js.map

package/dist/tracker-adapters.d.ts

@@ -0,0 +1,74 @@
+import { type ArtifactSource } from "./helpers.js";
+import { type ValidationResult } from "./schemas.js";
+export declare const TRACKER_SNAPSHOT_REL_PATH = "agent-state/tracker-snapshot.json";
+export declare const TRACKER_SNAPSHOT_SCHEMA_REL_PATH = "agent-state/MODULES/schemas/TRACKER_SNAPSHOT.schema.json";
+export declare const TRACKER_SNAPSHOT_SCHEMA_NAME = "tracker-snapshot@1.0.0";
+export type TrackerAdapterKind = "none" | "memory" | "external";
+export interface TrackerItem {
+    item_id: string;
+    external_id?: string;
+    title: string;
+    body?: string;
+    state: string;
+    labels: string[];
+    assignee?: string;
+    url?: string;
+    updated_at: string;
+    metadata: Record<string, unknown>;
+}
+export interface TrackerComment {
+    comment_id: string;
+    item_id: string;
+    body: string;
+    author: string;
+    created_at: string;
+    metadata: Record<string, unknown>;
+}
+export interface TrackerSnapshot {
+    version: 1;
+    adapter_kind: TrackerAdapterKind;
+    updated_at: string;
+    items: TrackerItem[];
+    comments: TrackerComment[];
+}
+export interface TrackerHealthCheckResult {
+    ok: boolean;
+    detail?: string;
+}
+export interface TrackerMutationResult {
+    ok: boolean;
+    comment_id?: string;
+    error?: string;
+}
+export interface TrackerSnapshotResult {
+    ok: boolean;
+    schema: typeof TRACKER_SNAPSHOT_SCHEMA_NAME;
+    path: string;
+    source: ArtifactSource;
+    snapshot?: TrackerSnapshot;
+    errors?: string[];
+}
+export interface IssueTrackerAdapter {
+    kind: string;
+    healthCheck?(): Promise<TrackerHealthCheckResult>;
+    listActiveItems?(filter?: Record<string, unknown>): Promise<TrackerItem[]>;
+    getItemsById?(ids: string[]): Promise<TrackerItem[]>;
+    createComment?(itemId: string, body: string): Promise<{
+        ok: boolean;
+        comment_id?: string;
+        error?: string;
+    }>;
+    updateItemState?(itemId: string, state: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+}
+export declare function validateTrackerSnapshotContent(raw: string): ValidationResult;
+export declare function loadTrackerSnapshot(explicitPath?: string): TrackerSnapshotResult;
+export declare function readTrackerSnapshot(): TrackerSnapshot;
+export declare function getTrackerSnapshotPath(): string;
+export declare function writeTrackerSnapshot(snapshot: TrackerSnapshot): string;
+export declare function listTrackerAdapterKinds(): string[];
+export declare function getTrackerAdapter(kind?: string): IssueTrackerAdapter;
+export declare function buildDefaultTrackerSnapshot(kind?: TrackerAdapterKind): TrackerSnapshot;
+//# sourceMappingURL=tracker-adapters.d.ts.map