@voybio/ace-swarm 0.1.0

package/dist/semantic-hash.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Semantic hashing engine — pure algorithms, zero I/O.
+ *
+ * Ported from the Jups.tr notebook diff UI: the "golden logic" of
+ * shingling + MinHash + Jaccard + DP alignment + surgical token diff,
+ * hardened for server-side use with deterministic seeds.
+ *
+ * Design decisions:
+ *   • Deterministic PRNG for MinHash permutations — same seed always
+ *     produces the same signature, safe for cross-cycle cache comparison.
+ *   • Section-aware chunking so markdown files get per-heading signatures.
+ *   • Surgical token diff only fires on *modified* pairs (never on
+ *     unchanged or added/deleted) to keep cost proportional to change.
+ */
+export interface DiffOp {
+    /** -1 = deletion, 0 = equal, 1 = insertion */
+    type: -1 | 0 | 1;
+    text: string;
+}
+export interface MarkdownSection {
+    heading: string;
+    /** 0-based inclusive */
+    lineStart: number;
+    /** 0-based inclusive */
+    lineEnd: number;
+    content: string;
+}
+export interface AlignedPair {
+    type: "MATCH" | "MODIFIED" | "INSERT" | "DELETE";
+    left: MarkdownSection | null;
+    right: MarkdownSection | null;
+    similarity: number;
+}
+/**
+ * Character k-shingles for approximate set similarity.
+ * Normalises whitespace so formatting changes don't dominate.
+ */
+export declare function getShingles(text: string, k?: number): Set<string>;
+export declare function calculateJaccard(setA: Set<string>, setB: Set<string>): number;
+export declare class MinHash {
+    readonly numPermutations: number;
+    private readonly prime;
+    private readonly maxHash;
+    private readonly permuteFuncs;
+    /**
+     * @param numPermutations Hash function count (default 128)
+     * @param seed            Deterministic seed — MUST be constant across runs
+     *                        for cached signatures to remain comparable.
+     */
+    constructor(numPermutations?: number, seed?: number);
+    /** djb2 string → uint32 */
+    private hashString;
+    /** Compute a MinHash signature for a set of shingles. */
+    computeSignature(shingles: Set<string>): number[];
+    /** Estimate Jaccard similarity from two signatures. */
+    estimateSimilarity(sigA: number[], sigB: number[]): number;
+}
+/**
+ * Split a markdown document into sections at heading boundaries.
+ * A section runs from one heading to the next (or EOF).
+ * Content before the first heading is labelled "(preamble)".
+ */
+export declare function splitMarkdownSections(text: string): MarkdownSection[];
+/**
+ * Align two ordered sequences of sections using similarity-based DP.
+ * Uses MinHash estimated similarity with a configurable threshold
+ * (default 0.4 for sections which are more granular than whole files).
+ *
+ * Returns an ordered list of aligned pairs.
+ */
+export declare function alignSections(leftSections: MarkdownSection[], rightSections: MarkdownSection[], mh: MinHash, similarityThreshold?: number, shingleSize?: number): AlignedPair[];
+/**
+ * Tokenize preserving whitespace and punctuation boundaries,
+ * then LCS-align tokens for a precise word-level diff.
+ * Only call on MODIFIED pairs — unnecessary for MATCH/INSERT/DELETE.
+ */
+export declare function surgicalTokenDiff(text1: string, text2: string): DiffOp[];
+/**
+ * Render a DiffOp[] into a compact text summary suitable for agent
+ * consumption: lines prefixed with ` `, `+`, `-`.
+ */
+export declare function renderDiffSummary(ops: DiffOp[]): string;
+//# sourceMappingURL=semantic-hash.d.ts.map

package/dist/semantic-hash.js

@@ -0,0 +1,346 @@
+/**
+ * Semantic hashing engine — pure algorithms, zero I/O.
+ *
+ * Ported from the Jups.tr notebook diff UI: the "golden logic" of
+ * shingling + MinHash + Jaccard + DP alignment + surgical token diff,
+ * hardened for server-side use with deterministic seeds.
+ *
+ * Design decisions:
+ *   • Deterministic PRNG for MinHash permutations — same seed always
+ *     produces the same signature, safe for cross-cycle cache comparison.
+ *   • Section-aware chunking so markdown files get per-heading signatures.
+ *   • Surgical token diff only fires on *modified* pairs (never on
+ *     unchanged or added/deleted) to keep cost proportional to change.
+ */
+// ────────────────────────────────────────────────────────────────────
+// 1. Shingling
+// ────────────────────────────────────────────────────────────────────
+/**
+ * Character k-shingles for approximate set similarity.
+ * Normalises whitespace so formatting changes don't dominate.
+ */
+export function getShingles(text, k = 3) {
+    const clean = text.replace(/\s+/g, " ").toLowerCase();
+    const shingles = new Set();
+    for (let i = 0; i <= clean.length - k; i++) {
+        shingles.add(clean.substring(i, i + k));
+    }
+    return shingles;
+}
+// ────────────────────────────────────────────────────────────────────
+// 2. Jaccard (exact)
+// ────────────────────────────────────────────────────────────────────
+export function calculateJaccard(setA, setB) {
+    if (setA.size === 0 && setB.size === 0)
+        return 1.0;
+    if (setA.size === 0 || setB.size === 0)
+        return 0.0;
+    let intersection = 0;
+    const smaller = setA.size <= setB.size ? setA : setB;
+    const larger = setA.size <= setB.size ? setB : setA;
+    for (const x of smaller) {
+        if (larger.has(x))
+            intersection++;
+    }
+    const union = setA.size + setB.size - intersection;
+    return intersection / union;
+}
+// ────────────────────────────────────────────────────────────────────
+// 3. Deterministic MinHash
+// ────────────────────────────────────────────────────────────────────
+/**
+ * Simple 32-bit seeded LCG (Numerical Recipes constants).
+ * Produces repeatable sequences for the same seed.
+ */
+function seededRandom(seed) {
+    let s = seed >>> 0;
+    return () => {
+        s = (s * 1664525 + 1013904223) >>> 0;
+        return s;
+    };
+}
+export class MinHash {
+    numPermutations;
+    prime = 4294967311n; // next prime > 2^32
+    maxHash = 4294967295; // 2^32 − 1
+    permuteFuncs;
+    /**
+     * @param numPermutations Hash function count (default 128)
+     * @param seed            Deterministic seed — MUST be constant across runs
+     *                        for cached signatures to remain comparable.
+     */
+    constructor(numPermutations = 128, seed = 42) {
+        this.numPermutations = numPermutations;
+        const rng = seededRandom(seed);
+        this.permuteFuncs = [];
+        for (let i = 0; i < numPermutations; i++) {
+            this.permuteFuncs.push({
+                a: BigInt((rng() % this.maxHash) + 1),
+                b: BigInt((rng() % this.maxHash) + 1),
+            });
+        }
+    }
+    /** djb2 string → uint32 */
+    hashString(str) {
+        let hash = 5381;
+        for (let i = 0; i < str.length; i++) {
+            hash = ((hash << 5) + hash + str.charCodeAt(i)) >>> 0;
+        }
+        return hash;
+    }
+    /** Compute a MinHash signature for a set of shingles. */
+    computeSignature(shingles) {
+        const sig = new Array(this.numPermutations).fill(Infinity);
+        if (shingles.size === 0)
+            return sig.fill(0);
+        for (const shingle of shingles) {
+            const h = BigInt(this.hashString(shingle));
+            for (let i = 0; i < this.numPermutations; i++) {
+                const { a, b } = this.permuteFuncs[i];
+                const ph = Number((a * h + b) % this.prime);
+                if (ph < sig[i])
+                    sig[i] = ph;
+            }
+        }
+        return sig;
+    }
+    /** Estimate Jaccard similarity from two signatures. */
+    estimateSimilarity(sigA, sigB) {
+        if (sigA.length !== sigB.length)
+            return 0;
+        const aEmpty = sigA[0] === 0 && sigA[sigA.length - 1] === 0;
+        const bEmpty = sigB[0] === 0 && sigB[sigB.length - 1] === 0;
+        if (aEmpty && bEmpty)
+            return 1.0;
+        if (aEmpty || bEmpty)
+            return 0.0;
+        let matches = 0;
+        for (let i = 0; i < sigA.length; i++) {
+            if (sigA[i] === sigB[i])
+                matches++;
+        }
+        return matches / sigA.length;
+    }
+}
+// ────────────────────────────────────────────────────────────────────
+// 4. Markdown section splitter
+// ────────────────────────────────────────────────────────────────────
+/**
+ * Split a markdown document into sections at heading boundaries.
+ * A section runs from one heading to the next (or EOF).
+ * Content before the first heading is labelled "(preamble)".
+ */
+export function splitMarkdownSections(text) {
+    const lines = text.split(/\r?\n/);
+    const sections = [];
+    let currentHeading = "(preamble)";
+    let currentStart = 0;
+    let buffer = [];
+    for (let i = 0; i < lines.length; i++) {
+        const headingMatch = lines[i].match(/^(#{1,6})\s+(.+)/);
+        if (headingMatch && buffer.length > 0) {
+            // Close previous section
+            sections.push({
+                heading: currentHeading,
+                lineStart: currentStart,
+                lineEnd: i - 1,
+                content: buffer.join("\n"),
+            });
+            // Start new
+            currentHeading = headingMatch[0].trim();
+            currentStart = i;
+            buffer = [lines[i]];
+        }
+        else if (headingMatch && buffer.length === 0) {
+            currentHeading = headingMatch[0].trim();
+            currentStart = i;
+            buffer = [lines[i]];
+        }
+        else {
+            buffer.push(lines[i]);
+        }
+    }
+    // final section
+    if (buffer.length > 0) {
+        sections.push({
+            heading: currentHeading,
+            lineStart: currentStart,
+            lineEnd: lines.length - 1,
+            content: buffer.join("\n"),
+        });
+    }
+    return sections;
+}
+// ────────────────────────────────────────────────────────────────────
+// 5. DP alignment (LCS-style with similarity threshold)
+// ────────────────────────────────────────────────────────────────────
+/**
+ * Align two ordered sequences of sections using similarity-based DP.
+ * Uses MinHash estimated similarity with a configurable threshold
+ * (default 0.4 for sections which are more granular than whole files).
+ *
+ * Returns an ordered list of aligned pairs.
+ */
+export function alignSections(leftSections, rightSections, mh, similarityThreshold = 0.4, shingleSize = 3) {
+    const n = leftSections.length;
+    const m = rightSections.length;
+    // Pre-compute signatures
+    const sigsLeft = leftSections.map((s) => mh.computeSignature(getShingles(s.content, shingleSize)));
+    const sigsRight = rightSections.map((s) => mh.computeSignature(getShingles(s.content, shingleSize)));
+    // Similarity matrix
+    const simMatrix = Array.from({ length: n }, () => new Array(m).fill(0));
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < m; j++) {
+            simMatrix[i][j] = mh.estimateSimilarity(sigsLeft[i], sigsRight[j]);
+        }
+    }
+    // DP table
+    const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = 1; i <= n; i++) {
+        for (let j = 1; j <= m; j++) {
+            if (simMatrix[i - 1][j - 1] > similarityThreshold) {
+                dp[i][j] = 1 + dp[i - 1][j - 1];
+            }
+            else {
+                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    // Backtrack
+    const alignment = [];
+    let i = n;
+    let j = m;
+    while (i > 0 || j > 0) {
+        if (i > 0 &&
+            j > 0 &&
+            simMatrix[i - 1][j - 1] > similarityThreshold) {
+            const sim = simMatrix[i - 1][j - 1];
+            const isExact = leftSections[i - 1].content === rightSections[j - 1].content;
+            alignment.push({
+                type: isExact ? "MATCH" : "MODIFIED",
+                left: leftSections[i - 1],
+                right: rightSections[j - 1],
+                similarity: sim,
+            });
+            i--;
+            j--;
+        }
+        else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+            alignment.push({
+                type: "INSERT",
+                left: null,
+                right: rightSections[j - 1],
+                similarity: 0,
+            });
+            j--;
+        }
+        else if (i > 0) {
+            alignment.push({
+                type: "DELETE",
+                left: leftSections[i - 1],
+                right: null,
+                similarity: 0,
+            });
+            i--;
+        }
+    }
+    alignment.reverse();
+    return alignment;
+}
+// ────────────────────────────────────────────────────────────────────
+// 6. Surgical token diff (for MODIFIED pairs only)
+// ────────────────────────────────────────────────────────────────────
+/**
+ * Tokenize preserving whitespace and punctuation boundaries,
+ * then LCS-align tokens for a precise word-level diff.
+ * Only call on MODIFIED pairs — unnecessary for MATCH/INSERT/DELETE.
+ */
+export function surgicalTokenDiff(text1, text2) {
+    if (text1 === text2)
+        return [{ type: 0, text: text1 }];
+    const tokenize = (str) => {
+        const tokens = [];
+        let current = "";
+        let inWord = false;
+        for (let i = 0; i < str.length; i++) {
+            const ch = str[i];
+            const isWordChar = /[a-zA-Z0-9_]/.test(ch);
+            if (isWordChar !== inWord && current) {
+                tokens.push(current);
+                current = ch;
+                inWord = isWordChar;
+            }
+            else {
+                current += ch;
+            }
+        }
+        if (current)
+            tokens.push(current);
+        return tokens;
+    };
+    const tokens1 = tokenize(text1);
+    const tokens2 = tokenize(text2);
+    // LCS DP
+    const n = tokens1.length;
+    const m = tokens2.length;
+    const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = 1; i <= n; i++) {
+        for (let j = 1; j <= m; j++) {
+            if (tokens1[i - 1] === tokens2[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            }
+            else {
+                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    // Backtrack
+    const result = [];
+    let ii = n;
+    let jj = m;
+    while (ii > 0 || jj > 0) {
+        if (ii > 0 && jj > 0 && tokens1[ii - 1] === tokens2[jj - 1]) {
+            result.unshift({ type: 0, text: tokens1[ii - 1] });
+            ii--;
+            jj--;
+        }
+        else if (jj > 0 && (ii === 0 || dp[ii][jj - 1] >= dp[ii - 1][jj])) {
+            result.unshift({ type: 1, text: tokens2[jj - 1] });
+            jj--;
+        }
+        else if (ii > 0) {
+            result.unshift({ type: -1, text: tokens1[ii - 1] });
+            ii--;
+        }
+    }
+    // Merge consecutive same-type ops
+    const merged = [];
+    for (const op of result) {
+        const last = merged[merged.length - 1];
+        if (last && last.type === op.type) {
+            last.text += op.text;
+        }
+        else {
+            merged.push({ ...op });
+        }
+    }
+    return merged;
+}
+// ────────────────────────────────────────────────────────────────────
+// 7. Compact diff summary (for MCP output — no UI needed)
+// ────────────────────────────────────────────────────────────────────
+/**
+ * Render a DiffOp[] into a compact text summary suitable for agent
+ * consumption: lines prefixed with ` `, `+`, `-`.
+ */
+export function renderDiffSummary(ops) {
+    const lines = [];
+    for (const op of ops) {
+        const prefix = op.type === 0 ? " " : op.type === 1 ? "+" : "-";
+        for (const line of op.text.split("\n")) {
+            lines.push(`${prefix}${line}`);
+        }
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=semantic-hash.js.map

package/dist/server.d.ts

@@ -0,0 +1,10 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const ACE_MCP_SERVER_NAME = "ace-swarm";
+export declare const ACE_MCP_SERVER_VERSION = "1.1.0";
+export interface CreateAceServerOptions {
+    toolGovernance?: boolean;
+    instructions?: string;
+}
+export declare function createAceServer(options?: CreateAceServerOptions): McpServer;
+export declare function startStdioServer(logStartup?: boolean): Promise<void>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -0,0 +1,46 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { buildServerInstructions, installAceToolGovernance, } from "./ace-server-instructions.js";
+import { resolveWorkspaceRoot } from "./helpers.js";
+import { registerPrompts } from "./prompts.js";
+import { registerResources } from "./resources.js";
+import { registerTools } from "./tools.js";
+import { backfillHandoffsIntoScheduler } from "./tools-handoff.js";
+export const ACE_MCP_SERVER_NAME = "ace-swarm";
+export const ACE_MCP_SERVER_VERSION = "1.1.0";
+export function createAceServer(options = {}) {
+    const workspaceRoot = resolveWorkspaceRoot();
+    const server = new McpServer({
+        name: ACE_MCP_SERVER_NAME,
+        version: ACE_MCP_SERVER_VERSION,
+    }, {
+        instructions: options.instructions ?? buildServerInstructions(workspaceRoot),
+    });
+    if (options.toolGovernance !== false) {
+        installAceToolGovernance(server, workspaceRoot);
+    }
+    registerResources(server);
+    registerPrompts(server);
+    registerTools(server);
+    return server;
+}
+export async function startStdioServer(logStartup = true) {
+    try {
+        const backfill = await backfillHandoffsIntoScheduler();
+        if (logStartup && backfill.scanned > 0) {
+            console.error(`Scheduler backfill: scanned=${backfill.scanned} synced=${backfill.synced} enqueued=${backfill.enqueued} failures=${backfill.failures.length}`);
+        }
+    }
+    catch (error) {
+        if (logStartup) {
+            console.error(`Scheduler backfill warning: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const server = createAceServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    if (logStartup) {
+        console.error(`ACE MCP Server (${ACE_MCP_SERVER_NAME}) running on stdio`);
+    }
+}
+//# sourceMappingURL=server.js.map

package/dist/shared.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Shared utilities – deduplicated common functions and typed constants
+ * used across ace-mcp-server modules.
+ *
+ * This module has NO imports from helpers.ts to prevent circular deps.
+ * Only depends on node built-ins and zod.
+ */
+import { z } from "zod";
+/** Check if a safeRead result indicates file absence or access error. */
+export declare function isReadError(raw: string): boolean;
+/** Check if target path is inside base directory. */
+export declare function isInside(base: string, target: string): boolean;
+/** Normalize path to forward-slash workspace-relative form. */
+export declare function normalizeRelPath(path: string): string;
+/** Create a URL-safe slug from a string (max 48 chars). */
+export declare function slugify(value: string): string;
+/** Test if a normalized path looks like a SWARM_HANDOFF payload file. */
+export declare function looksLikeSwarmHandoffPath(path: string): boolean;
+export declare const ROLE_TITLES: Record<string, string>;
+export declare function getRoleTitle(role: string): string;
+export declare const MCP_CLIENT_ENUM: z.ZodEnum<{
+    claude: "claude";
+    cursor: "cursor";
+    codex: "codex";
+    vscode: "vscode";
+    antigravity: "antigravity";
+}>;
+export declare const ROLE_ENUM: z.ZodEnum<{
+    orchestrator: "orchestrator";
+    vos: "vos";
+    ui: "ui";
+    coders: "coders";
+    astgrep: "astgrep";
+    skeptic: "skeptic";
+    ops: "ops";
+    research: "research";
+    spec: "spec";
+    builder: "builder";
+    qa: "qa";
+    docs: "docs";
+    memory: "memory";
+    security: "security";
+    observability: "observability";
+    eval: "eval";
+    release: "release";
+}>;
+export declare const HANDOFF_VALIDATION_MODE: z.ZodOptional<z.ZodEnum<{
+    auto: "auto";
+    swarm: "swarm";
+    "agent-state": "agent-state";
+}>>;
+export declare const KERNEL_KEY_ENUM: z.ZodEnum<{
+    directive_kernel: "directive_kernel";
+    agent_registry: "agent_registry";
+}>;
+export declare const TODO_STATUS_ENUM: z.ZodEnum<{
+    backlog: "backlog";
+    in_progress: "in_progress";
+    blocked: "blocked";
+    gated: "gated";
+    done: "done";
+}>;
+export declare const HANDOFF_LIFECYCLE_STATUS_ENUM: z.ZodEnum<{
+    blocked: "blocked";
+    open: "open";
+    accepted: "accepted";
+    completed: "completed";
+}>;
+export declare const SOURCE_MODULE: {
+    readonly OPS: "capability-ops";
+    readonly ASTGREP: "capability-astgrep";
+    readonly SAFETY: "capability-safety";
+    readonly GIT: "capability-git";
+    readonly MEMORY: "capability-memory";
+    readonly FRAMEWORK: "capability-framework";
+};
+export declare const EVENT_TYPE: {
+    readonly ADAPTER_LOW_CONFIDENCE: "ADAPTER_LOW_CONFIDENCE";
+    readonly CIRCUIT_BREAKER_OPENED: "CIRCUIT_BREAKER_OPENED";
+    readonly CIRCUIT_BREAKER_CLOSED: "CIRCUIT_BREAKER_CLOSED";
+    readonly CONTEXT_SNAPSHOT: "CONTEXT_SNAPSHOT";
+    readonly DISCOVERY_INDEX_READY: "DISCOVERY_INDEX_READY";
+    readonly DISCOVERY_SCOPE_BLOCKED: "DISCOVERY_SCOPE_BLOCKED";
+    readonly FRAMEWORK_VALIDATED: "FRAMEWORK_VALIDATED";
+    readonly GATES_EXECUTED: "GATES_EXECUTED";
+    readonly GIT_INITIALIZED: "GIT_INITIALIZED";
+    readonly GIT_COMMITTED: "GIT_COMMITTED";
+    readonly HANDOFF_SCHEDULER_SYNCED: "HANDOFF_SCHEDULER_SYNCED";
+    readonly RUNTIME_EXECUTOR_SESSION_BLOCKED: "RUNTIME_EXECUTOR_SESSION_BLOCKED";
+    readonly RUNTIME_EXECUTOR_SESSION_COMPLETED: "RUNTIME_EXECUTOR_SESSION_COMPLETED";
+    readonly RUNTIME_EXECUTOR_SESSION_FAILED: "RUNTIME_EXECUTOR_SESSION_FAILED";
+    readonly RUNTIME_EXECUTOR_SESSION_STARTED: "RUNTIME_EXECUTOR_SESSION_STARTED";
+    readonly RUNTIME_EXECUTOR_SESSION_STOPPED: "RUNTIME_EXECUTOR_SESSION_STOPPED";
+    readonly RUNTIME_EXECUTOR_TURN_COMPLETED: "RUNTIME_EXECUTOR_TURN_COMPLETED";
+    readonly RUNTIME_EXECUTOR_TURN_FAILED: "RUNTIME_EXECUTOR_TURN_FAILED";
+    readonly RUNTIME_EXECUTOR_TURN_STARTED: "RUNTIME_EXECUTOR_TURN_STARTED";
+    readonly RUNTIME_PROFILE_INVALID: "RUNTIME_PROFILE_INVALID";
+    readonly RUNTIME_PROFILE_LOADED: "RUNTIME_PROFILE_LOADED";
+    readonly RUNTIME_PROFILE_RELOADED: "RUNTIME_PROFILE_RELOADED";
+    readonly RUNTIME_TOOL_EXECUTED: "RUNTIME_TOOL_EXECUTED";
+    readonly RUNTIME_TOOL_FAILED: "RUNTIME_TOOL_FAILED";
+    readonly RUNTIME_TOOL_REGISTRY_INVALID: "RUNTIME_TOOL_REGISTRY_INVALID";
+    readonly SAFE_EDIT_COMPLETED: "SAFE_EDIT_COMPLETED";
+    readonly SAFE_EDIT_FAILED: "SAFE_EDIT_FAILED";
+    readonly SCHEDULER_JOB_ACK: "SCHEDULER_JOB_ACK";
+    readonly SCHEDULER_JOB_COMPLETED: "SCHEDULER_JOB_COMPLETED";
+    readonly SCHEDULER_JOB_ENQUEUED: "SCHEDULER_JOB_ENQUEUED";
+    readonly SCHEDULER_JOB_STARTED: "SCHEDULER_JOB_STARTED";
+    readonly SCHEDULER_RECOVERY: "SCHEDULER_RECOVERY";
+    readonly SCHEDULER_TICK: "SCHEDULER_TICK";
+    readonly TESTS_PASSED: "TESTS_PASSED";
+    readonly TESTS_FAILED: "TESTS_FAILED";
+    readonly TRACKER_COMMENT_CREATED: "TRACKER_COMMENT_CREATED";
+    readonly TRACKER_ITEM_STATE_UPDATED: "TRACKER_ITEM_STATE_UPDATED";
+    readonly TRACKER_SNAPSHOT_REFRESHED: "TRACKER_SNAPSHOT_REFRESHED";
+    readonly TRACKER_SNAPSHOT_REFRESH_FAILED: "TRACKER_SNAPSHOT_REFRESH_FAILED";
+    readonly WORKER_INPUT: "WORKER_INPUT";
+    readonly WORKSPACE_HOOK_FAILED: "WORKSPACE_HOOK_FAILED";
+    readonly WORKSPACE_SESSION_CREATED: "WORKSPACE_SESSION_CREATED";
+    readonly WORKSPACE_SESSION_FAILED: "WORKSPACE_SESSION_FAILED";
+    readonly WORKSPACE_SESSION_REMOVED: "WORKSPACE_SESSION_REMOVED";
+};
+export interface DomainKeyword {
+    keyword: string;
+    weight: number;
+}
+export declare const DOMAIN_KEYWORDS: Record<string, DomainKeyword[]>;
+/**
+ * Score a task description against all domain keyword sets.
+ * Returns the domain with the highest weighted score, or "mixed" on tie/zero.
+ */
+export declare function scoreDomains(text: string): {
+    domain: string;
+    scores: Record<string, number>;
+};
+//# sourceMappingURL=shared.d.ts.map