@voybio/ace-swarm 0.1.0

package/dist/agent-runtime/role-adapters.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared role adapter engine for worker implementations.
+ *
+ * This module is transport-agnostic so both TUI and non-TUI workers can reuse
+ * the same role-intent planning behavior.
+ */
+export type AdapterDomain = "venture" | "ux" | "engineering" | "mixed" | "research";
+export interface ToolIntent {
+    tool: string;
+    args: Record<string, unknown>;
+}
+export interface HandoffIntent {
+    from: string;
+    to: string;
+    payload: Record<string, unknown>;
+}
+export interface AdapterDecision {
+    toolCalls: ToolIntent[];
+    handoffs: HandoffIntent[];
+    notes: string[];
+    domain: AdapterDomain;
+    confidence: number;
+    confidenceLevel: "low" | "medium" | "high";
+}
+export declare function inferDomain(input: string): AdapterDomain;
+export declare function parseManualHandoffCommand(input: string): HandoffIntent | undefined;
+export declare function parseManualToolCommand(input: string): ToolIntent | undefined;
+export declare function planRoleExecution(roleValue: string, input: string): AdapterDecision;
+//# sourceMappingURL=role-adapters.d.ts.map

package/dist/agent-runtime/role-adapters.js

@@ -0,0 +1,573 @@
+/**
+ * Shared role adapter engine for worker implementations.
+ *
+ * This module is transport-agnostic so both TUI and non-TUI workers can reuse
+ * the same role-intent planning behavior.
+ */
+const KNOWN_ROLES = [
+    "orchestrator",
+    "vos",
+    "ui",
+    "coders",
+    "astgrep",
+    "skeptic",
+    "ops",
+    "research",
+    "spec",
+    "builder",
+    "qa",
+    "docs",
+    "memory",
+    "security",
+    "observability",
+    "eval",
+    "release",
+];
+const KNOWN_ROLE_SET = new Set(KNOWN_ROLES);
+const ROLE_PATTERN = new RegExp(`\\b(?:agent[-\\s]?)?(${KNOWN_ROLES.join("|")})\\b`, "i");
+function canonicalizeRole(input) {
+    const value = input.trim().toLowerCase().replace(/^agent-/, "");
+    return value || "unknown";
+}
+function includeAny(text, needles) {
+    return needles.some((needle) => text.includes(needle));
+}
+function escapeRegex(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function toTokenPattern(input) {
+    return escapeRegex(input.toLowerCase()).replace(/\s+/g, "\\s+");
+}
+function toFlexibleNeedlePattern(input) {
+    const normalized = input.trim().toLowerCase();
+    const base = toTokenPattern(normalized);
+    if (!normalized.includes(" ") && !normalized.endsWith("s")) {
+        return `${base}s?`;
+    }
+    return base;
+}
+function countKeywordHits(text, needles) {
+    let hits = 0;
+    for (const needle of needles) {
+        const pattern = new RegExp(`\\b${toTokenPattern(needle)}\\b`, "i");
+        if (pattern.test(text))
+            hits += 1;
+    }
+    return hits;
+}
+function hasNegatedIntent(text, needles) {
+    const normalized = text.toLowerCase().replace(/[’]/g, "'");
+    const negations = ["no", "not", "never", "without", "skip", "avoid", "don't", "do not"];
+    for (const needle of needles) {
+        const needlePattern = toFlexibleNeedlePattern(needle);
+        for (const negation of negations) {
+            const pattern = new RegExp(`\\b${toTokenPattern(negation)}\\b(?:\\W+\\w+){0,3}\\W+${needlePattern}\\b`, "i");
+            if (pattern.test(normalized))
+                return true;
+        }
+    }
+    return false;
+}
+function intentRequested(text, positiveNeedles, negationNeedles = positiveNeedles) {
+    if (!includeAny(text, positiveNeedles))
+        return false;
+    return !hasNegatedIntent(text, negationNeedles);
+}
+function truncate(input, max) {
+    if (input.length <= max)
+        return input;
+    const clipped = input.slice(0, Math.max(0, max - 3)).trimEnd();
+    return `${clipped}...`;
+}
+export function inferDomain(input) {
+    const score = scoreDomain(input);
+    return score.domain;
+}
+function scoreDomain(input) {
+    const text = input.toLowerCase();
+    const uxHits = countKeywordHits(text, ["ux", "ui", "design", "layout", "visual", "tui"]);
+    const engineeringHits = countKeywordHits(text, [
+        "build",
+        "code",
+        "test",
+        "regression",
+        "debug",
+        "fix",
+        "bug",
+        "compile",
+        "deploy",
+        "engineer",
+    ]);
+    const ventureHits = countKeywordHits(text, [
+        "market",
+        "pricing",
+        "thesis",
+        "growth",
+        "revenue",
+        "venture",
+        "business",
+        "fund",
+    ]);
+    const researchHits = countKeywordHits(text, [
+        "research",
+        "evidence",
+        "source",
+        "hypothesis",
+        "assumption",
+        "unknown",
+        "literature",
+    ]);
+    const rows = [
+        { domain: "ux", hits: uxHits },
+        { domain: "engineering", hits: engineeringHits },
+        { domain: "venture", hits: ventureHits },
+        { domain: "research", hits: researchHits },
+    ].sort((a, b) => b.hits - a.hits);
+    const top = rows[0];
+    const runnerUp = rows[1];
+    const totalHits = uxHits + engineeringHits + ventureHits + researchHits;
+    if (!top || totalHits === 0 || top.hits === 0) {
+        return { domain: "mixed", confidence: 0.2, confidenceLevel: "low", ambiguous: true };
+    }
+    const ambiguous = runnerUp ? top.hits === runnerUp.hits : false;
+    if (ambiguous) {
+        const confidence = Math.max(0.3, top.hits / Math.max(1, totalHits));
+        return {
+            domain: "mixed",
+            confidence,
+            confidenceLevel: confidence >= 0.45 ? "medium" : "low",
+            ambiguous: true,
+        };
+    }
+    const base = top.hits / Math.max(1, totalHits);
+    const spread = Math.max(0, top.hits - (runnerUp?.hits ?? 0));
+    const confidence = Math.min(0.95, base + Math.min(0.25, spread * 0.08));
+    const confidenceLevel = confidence >= 0.7 ? "high" : confidence >= 0.45 ? "medium" : "low";
+    return {
+        domain: top.domain,
+        confidence,
+        confidenceLevel,
+        ambiguous: false,
+    };
+}
+function inferPriority(input) {
+    const text = input.toLowerCase();
+    if (includeAny(text, ["p0", "urgent", "critical", "asap", "immediately"])) {
+        return "P0";
+    }
+    if (includeAny(text, ["p1", "high", "soon", "priority"])) {
+        return "P1";
+    }
+    return "P2";
+}
+function normalizeRoleTarget(input) {
+    if (!input)
+        return undefined;
+    const raw = input.trim().toLowerCase().replace(/^agent-/, "").replace(/[^a-z]/g, "");
+    if (!raw)
+        return undefined;
+    return KNOWN_ROLE_SET.has(raw) ? raw : undefined;
+}
+function extractTargetRole(input) {
+    const text = input.toLowerCase();
+    const explicit = text.match(/\b(?:to|into|for)\s+(?:agent[-\s]?)?([a-z-]+)\b/i)?.[1];
+    const normalizedExplicit = normalizeRoleTarget(explicit);
+    if (normalizedExplicit)
+        return normalizedExplicit;
+    const anyRole = text.match(ROLE_PATTERN)?.[1];
+    return normalizeRoleTarget(anyRole);
+}
+export function parseManualHandoffCommand(input) {
+    if (!input.toLowerCase().startsWith("handoff "))
+        return undefined;
+    const [, fromRaw, toRaw, ...rest] = input.split(/\s+/);
+    const from = normalizeRoleTarget(fromRaw);
+    const to = normalizeRoleTarget(toRaw);
+    if (!from || !to)
+        return undefined;
+    return {
+        from,
+        to,
+        payload: {
+            reason: rest.join(" ") || "manual handoff request from worker input",
+            mode: "manual",
+        },
+    };
+}
+export function parseManualToolCommand(input) {
+    if (!input.toLowerCase().startsWith("tool "))
+        return undefined;
+    const [, tool, ...argsParts] = input.split(/\s+/);
+    if (!tool)
+        return undefined;
+    const rawArg = argsParts.join(" ").trim();
+    if (!rawArg)
+        return { tool, args: {} };
+    if (rawArg.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(rawArg);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                return { tool, args: parsed };
+            }
+        }
+        catch {
+            // Fall through to raw payload.
+        }
+    }
+    return { tool, args: { raw: rawArg } };
+}
+function asHandoffTaskType(domain) {
+    if (domain === "venture" || domain === "ux" || domain === "engineering") {
+        return domain;
+    }
+    return "mixed";
+}
+function dedupeToolIntents(calls) {
+    const seen = new Set();
+    const out = [];
+    for (const call of calls) {
+        const key = `${call.tool}:${JSON.stringify(call.args)}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(call);
+        if (out.length >= 8)
+            break;
+    }
+    return out;
+}
+function dedupeHandoffIntents(handoffs) {
+    const seen = new Set();
+    const out = [];
+    for (const handoff of handoffs) {
+        const key = `${handoff.from}->${handoff.to}:${JSON.stringify(handoff.payload)}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(handoff);
+        if (out.length >= 2)
+            break;
+    }
+    return out;
+}
+function buildCreateHandoffIntent(fromRole, toRole, input) {
+    const from = normalizeRoleTarget(fromRole) ?? "orchestrator";
+    const to = normalizeRoleTarget(toRole) ?? "ops";
+    const domain = inferDomain(input);
+    const taskType = asHandoffTaskType(domain);
+    const priority = inferPriority(input);
+    const summary = truncate(input, 96);
+    return {
+        tool: "create_handoff",
+        args: {
+            from,
+            to,
+            title: `Worker dispatch: ${truncate(summary, 64)}`,
+            task_type: taskType,
+            priority,
+            directive: input,
+            acceptance_criteria: [
+                `Execute delegated objective: ${summary}`,
+                "Return completion status with evidence references.",
+            ],
+        },
+    };
+}
+export function planRoleExecution(roleValue, input) {
+    const normalizedRole = canonicalizeRole(roleValue);
+    const text = input.toLowerCase();
+    const domainScore = scoreDomain(input);
+    const domain = domainScore.domain;
+    const toolCalls = [];
+    const handoffs = [];
+    const notes = [];
+    const dispatchKeywords = [
+        "handoff",
+        "delegate",
+        "route to",
+        "dispatch",
+        "assign to",
+    ];
+    const dispatchRequested = intentRequested(text, dispatchKeywords);
+    if (includeAny(text, dispatchKeywords) && !dispatchRequested) {
+        notes.push("Dispatch keywords were negated; delegation intents suppressed.");
+    }
+    const targetRole = extractTargetRole(input);
+    if (dispatchRequested && !targetRole) {
+        notes.push("Dispatch requested but no valid target role detected; create_handoff suppressed.");
+    }
+    if (domainScore.ambiguous || domainScore.confidenceLevel === "low") {
+        notes.push(`Low-confidence adapter routing (domain=${domain}, confidence=${Math.round(domainScore.confidence * 100)}%).`);
+    }
+    const contradictoryStateRequested = includeAny(text, [
+        "contradict",
+        "conflict",
+        "misalign",
+        "drift",
+        "blocked",
+        "unclear",
+        "ambiguous",
+    ]);
+    const aceStateRequested = countKeywordHits(text, ["task", "scope", "gate", "handoff", "state", "status"]) > 0;
+    switch (normalizedRole) {
+        case "orchestrator": {
+            const preflightRequired = dispatchRequested ||
+                domainScore.ambiguous ||
+                domainScore.confidenceLevel === "low" ||
+                contradictoryStateRequested ||
+                aceStateRequested;
+            toolCalls.push({ tool: "recall_context", args: {} });
+            toolCalls.push({ tool: "validate_framework", args: {} });
+            toolCalls.push({ tool: "get_framework_status", args: {} });
+            toolCalls.push({ tool: "route_task", args: { description: input, domain } });
+            if (preflightRequired) {
+                toolCalls.push({ tool: "execute_gates", args: {} });
+                notes.push("Orchestrator preflight required before dispatch.");
+            }
+            if (intentRequested(text, ["scheduler", "queue", "dispatch", "lock"])) {
+                toolCalls.push({ tool: "dispatch_jobs", args: {} });
+                toolCalls.push({ tool: "list_jobs", args: { limit: 20 } });
+            }
+            if (dispatchRequested && targetRole && targetRole !== normalizedRole && !preflightRequired) {
+                toolCalls.push(buildCreateHandoffIntent(normalizedRole, targetRole, input));
+                handoffs.push({
+                    from: normalizedRole,
+                    to: targetRole,
+                    payload: { reason: truncate(input, 180), mode: "adapter" },
+                });
+            }
+            else if (dispatchRequested && targetRole && targetRole !== normalizedRole && preflightRequired) {
+                notes.push(`Dispatch to ${targetRole} deferred until preflight clears current ACE state.`);
+            }
+            break;
+        }
+        case "vos": {
+            toolCalls.push({ tool: "get_task_pack", args: { role: "vos" } });
+            toolCalls.push({ tool: "route_task", args: { description: input, domain: "venture" } });
+            if (dispatchRequested && targetRole && targetRole !== normalizedRole) {
+                toolCalls.push(buildCreateHandoffIntent(normalizedRole, targetRole, input));
+                handoffs.push({ from: normalizedRole, to: targetRole, payload: { reason: input, mode: "adapter" } });
+            }
+            break;
+        }
+        case "ui": {
+            toolCalls.push({ tool: "get_task_pack", args: { role: "ui" } });
+            toolCalls.push({ tool: "route_task", args: { description: input, domain: "ux" } });
+            if (intentRequested(text, ["test", "qa", "verify"], ["test", "qa", "verify"])) {
+                toolCalls.push({ tool: "run_tests", args: {} });
+            }
+            if (dispatchRequested && targetRole && targetRole !== normalizedRole) {
+                toolCalls.push(buildCreateHandoffIntent(normalizedRole, targetRole, input));
+                handoffs.push({ from: normalizedRole, to: targetRole, payload: { reason: input, mode: "adapter" } });
+            }
+            break;
+        }
+        case "coders": {
+            toolCalls.push({ tool: "get_task_pack", args: { role: "coders" } });
+            if (intentRequested(text, ["test", "regression", "verify", "suite"])) {
+                toolCalls.push({ tool: "run_tests", args: {} });
+            }
+            if (intentRequested(text, ["gate", "criteria", "quality"])) {
+                toolCalls.push({ tool: "execute_gates", args: {} });
+            }
+            if (intentRequested(text, ["diff", "patch", "changes"])) {
+                toolCalls.push({ tool: "git_diff", args: {} });
+            }
+            if (dispatchRequested && targetRole && targetRole !== normalizedRole) {
+                toolCalls.push(buildCreateHandoffIntent(normalizedRole, targetRole, input));
+                handoffs.push({ from: normalizedRole, to: targetRole, payload: { reason: input, mode: "adapter" } });
+            }
+            break;
+        }
+        case "astgrep": {
+            toolCalls.push({ tool: "refresh_astgrep_index", args: {} });
+            if (includeAny(text, ["scan", "delta", "workspace", "changed", "index"])) {
+                toolCalls.push({ tool: "scan_workspace_delta", args: {} });
+            }
+            break;
+        }
+        case "skeptic": {
+            if (intentRequested(text, ["review", "adversarial", "disprove", "audit", "skeptic pass"], [
+                "review",
+                "adversarial",
+                "disprove",
+                "audit",
+                "skeptic pass",
+            ])) {
+                toolCalls.push({
+                    tool: "execute_gates",
+                    args: {
+                        review_mode: "skeptic_adversarial",
+                        review_focus: truncate(input, 160),
+                    },
+                });
+                notes.push("Skeptic adversarial review requested; only confirmed findings should remain actionable.");
+            }
+            else {
+                toolCalls.push({ tool: "execute_gates", args: {} });
+            }
+            if (includeAny(text, ["risk", "blocker", "unsafe", "halt", "critical"])) {
+                toolCalls.push({
+                    tool: "open_circuit_breaker",
+                    args: { reason: `skeptic flagged: ${truncate(input, 160)}` },
+                });
+            }
+            break;
+        }
+        case "ops": {
+            toolCalls.push({ tool: "list_jobs", args: { limit: 20 } });
+            toolCalls.push({
+                tool: "emit_status_event",
+                args: {
+                    source_module: "capability-ops",
+                    event_type: "WORKER_INPUT",
+                    status: "in_progress",
+                    summary: truncate(input, 140),
+                },
+            });
+            if (intentRequested(text, ["dispatch", "schedule", "lock"])) {
+                toolCalls.push({ tool: "dispatch_jobs", args: {} });
+            }
+            if (includeAny(text, ["lease"])) {
+                toolCalls.push({ tool: "get_scheduler_lease", args: {} });
+            }
+            if (includeAny(text, ["todo", "task"])) {
+                toolCalls.push({ tool: "get_todo_state", args: {} });
+            }
+            if (dispatchRequested && targetRole && targetRole !== normalizedRole) {
+                toolCalls.push(buildCreateHandoffIntent(normalizedRole, targetRole, input));
+                handoffs.push({ from: normalizedRole, to: targetRole, payload: { reason: input, mode: "adapter" } });
+            }
+            break;
+        }
+        case "research": {
+            toolCalls.push({ tool: "route_task", args: { description: input, domain: "research" } });
+            if (includeAny(text, ["skill", "pattern", "approach"])) {
+                toolCalls.push({ tool: "list_skills", args: {} });
+            }
+            if (includeAny(text, ["assumption", "hypothesis", "unknown", "gap"])) {
+                toolCalls.push({
+                    tool: "context_snapshot",
+                    args: {
+                        name: `research-${Date.now()}`,
+                        summary: truncate(input, 140),
+                    },
+                });
+            }
+            break;
+        }
+        case "spec": {
+            toolCalls.push({ tool: "get_task_pack", args: { role: "spec" } });
+            if (includeAny(text, ["schema", "contract", "interface", "validate"])) {
+                toolCalls.push({ tool: "validate_framework", args: {} });
+            }
+            if (includeAny(text, ["handoff", "payload"])) {
+                toolCalls.push({ tool: "get_handoff_template", args: {} });
+            }
+            break;
+        }
+        case "builder": {
+            toolCalls.push({ tool: "get_task_pack", args: { role: "builder" } });
+            if (intentRequested(text, ["build", "implement", "fix", "test"])) {
+                toolCalls.push({ tool: "run_tests", args: {} });
+            }
+            if (intentRequested(text, ["diff", "changes", "patch"])) {
+                toolCalls.push({ tool: "git_diff", args: {} });
+            }
+            break;
+        }
+        case "qa": {
+            toolCalls.push({ tool: "run_tests", args: {} });
+            toolCalls.push({ tool: "execute_gates", args: {} });
+            if (includeAny(text, ["status", "trace", "event", "regression"])) {
+                toolCalls.push({ tool: "list_status_events", args: { limit: 25 } });
+            }
+            break;
+        }
+        case "docs": {
+            toolCalls.push({ tool: "get_task_pack", args: { role: "docs" } });
+            if (includeAny(text, ["kanban", "board"])) {
+                toolCalls.push({ tool: "generate_kanban_ui", args: {} });
+            }
+            if (includeAny(text, ["readme", "docs", "guide", "documentation"])) {
+                toolCalls.push({ tool: "get_run_ledger", args: {} });
+            }
+            break;
+        }
+        case "memory": {
+            toolCalls.push({ tool: "recall_context", args: {} });
+            if (includeAny(text, ["snapshot", "remember", "save", "capture", "context"])) {
+                toolCalls.push({
+                    tool: "context_snapshot",
+                    args: {
+                        name: `memory-${Date.now()}`,
+                        summary: truncate(input, 140),
+                    },
+                });
+            }
+            if (includeAny(text, ["lesson", "guardrail", "failure"])) {
+                toolCalls.push({ tool: "get_lessons", args: {} });
+            }
+            break;
+        }
+        case "security": {
+            toolCalls.push({ tool: "execute_gates", args: {} });
+            toolCalls.push({ tool: "validate_framework", args: {} });
+            if (intentRequested(text, ["breach", "vulnerability", "exploit", "critical", "risk"])) {
+                toolCalls.push({
+                    tool: "open_circuit_breaker",
+                    args: { reason: `security escalation: ${truncate(input, 160)}` },
+                });
+            }
+            if (intentRequested(text, ["resolved", "mitigated", "resume", "unblock"])) {
+                toolCalls.push({
+                    tool: "close_circuit_breaker",
+                    args: { reason: `security clear: ${truncate(input, 160)}` },
+                });
+            }
+            break;
+        }
+        case "observability": {
+            toolCalls.push({ tool: "list_status_events", args: { limit: 50 } });
+            if (includeAny(text, ["ledger", "history", "trend"])) {
+                toolCalls.push({ tool: "get_run_ledger", args: {} });
+            }
+            if (includeAny(text, ["scheduler", "lease"])) {
+                toolCalls.push({ tool: "get_scheduler_lease", args: {} });
+            }
+            break;
+        }
+        case "eval": {
+            toolCalls.push({ tool: "run_tests", args: {} });
+            toolCalls.push({ tool: "execute_gates", args: {} });
+            if (includeAny(text, ["framework", "drift", "integrity", "validate"])) {
+                toolCalls.push({ tool: "validate_framework", args: {} });
+            }
+            break;
+        }
+        case "release": {
+            toolCalls.push({ tool: "git_status", args: {} });
+            toolCalls.push({ tool: "execute_gates", args: {} });
+            if (includeAny(text, ["log", "history", "changelog"])) {
+                toolCalls.push({ tool: "git_log", args: { limit: 20 } });
+            }
+            if (includeAny(text, ["validate", "framework", "check"])) {
+                toolCalls.push({ tool: "validate_framework", args: {} });
+            }
+            break;
+        }
+        default: {
+            toolCalls.push({ tool: "route_task", args: { description: input, domain } });
+            notes.push(`No role adapter profile for "${normalizedRole}", defaulted to route_task.`);
+        }
+    }
+    return {
+        toolCalls: dedupeToolIntents(toolCalls),
+        handoffs: dedupeHandoffIntents(handoffs),
+        notes,
+        domain,
+        confidence: domainScore.confidence,
+        confidenceLevel: domainScore.confidenceLevel,
+    };
+}
+//# sourceMappingURL=role-adapters.js.map

package/dist/astgrep-index.d.ts

@@ -0,0 +1,24 @@
+export interface RefreshAstgrepIndexInput {
+    scope?: string;
+    append_evidence?: boolean;
+    emit_event?: boolean;
+    include_rep_corpus?: boolean;
+}
+export interface RefreshAstgrepIndexResult {
+    generated_at: string;
+    scope: string;
+    astgrep_command: string | null;
+    output_md_path: string;
+    output_json_path: string;
+    evidence_appended: boolean;
+    event_path?: string;
+    event_id?: string;
+    stats: {
+        language_profile_entries: number;
+        hotspot_files: number;
+        rep_sources: number;
+        todo_signals: number;
+    };
+}
+export declare function refreshAstgrepIndex(input?: RefreshAstgrepIndexInput): RefreshAstgrepIndexResult;
+//# sourceMappingURL=astgrep-index.d.ts.map