@backburner/cli 0.1.0

package/dist/src/agents/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/agents/wave-assessment-feedback.js

@@ -0,0 +1,69 @@
+import { Task } from "../tasks/task.js";
+export class GitHubWaveAssessmentPublisher {
+    gitHubGateway;
+    logger;
+    reposById;
+    constructor(gitHubGateway, repos, logger) {
+        this.gitHubGateway = gitHubGateway;
+        this.logger = logger;
+        this.reposById = new Map(repos.map((repo) => [repo.id, repo]));
+    }
+    async publishWaveAssessment(task, execution) {
+        if ((task.kind !== "wave_plan_assessment" && task.kind !== "wave_plan_replanning") ||
+            execution.taskStatus !== "completed") {
+            return undefined;
+        }
+        const assessment = execution.result?.waveAssessment;
+        if (!assessment) {
+            this.logger?.warn(`Completed ${task.kind} task ${task.id} did not return a structured assessment result.`);
+            return undefined;
+        }
+        const repo = this.reposById.get(task.repoId);
+        const pullRequestNumber = Task.from(task).owningPullRequestNumber();
+        if (!repo || pullRequestNumber === undefined) {
+            this.logger?.warn(`Could not resolve repo or parent PR number for wave assessment task ${task.id}.`);
+            return undefined;
+        }
+        const comment = await this.gitHubGateway.postIssueComment({
+            owner: repo.owner,
+            name: repo.name,
+            issueNumber: pullRequestNumber,
+            body: renderWaveAssessmentComment(assessment)
+        });
+        return String(comment.id);
+    }
+}
+export function renderWaveAssessmentComment(assessment) {
+    const { identity } = assessment.checkpoint;
+    const lines = [
+        "🤖 **Wave Plan Assessment Report**",
+        "",
+        `- **Wave**: ${identity.waveId}`,
+        `- **Decision**: ${assessment.decision}`,
+        `- **Assessed Parent Head SHA**: \`${identity.parentHeadSha}\``,
+        `- **Plan Revision**: \`${identity.planRevision}\``,
+        `- **Assessment Session**: \`${assessment.sessionId}\``,
+        "",
+        "## Summary",
+        "",
+        assessment.summary,
+        "",
+        "## Findings",
+        ""
+    ];
+    if (assessment.findings.length === 0) {
+        lines.push("- None");
+    }
+    else {
+        for (const finding of assessment.findings) {
+            const affected = finding.affectedPlanNodeIds.length > 0
+                ? finding.affectedPlanNodeIds.join(", ")
+                : "none";
+            lines.push(`- **[${finding.category}]** ${finding.summary} (Affected plan nodes: ${affected})`);
+            if (finding.details.trim()) {
+                lines.push(`  ${finding.details.replace(/\s+/g, " ").trim()}`);
+            }
+        }
+    }
+    return lines.join("\n").trim();
+}

package/dist/src/attention/derive.js

@@ -0,0 +1,337 @@
+import { extractRetryCommentId } from "../tasks/retry.js";
+import { extractMcpSkipCommand } from "../tasks/mcp-skip.js";
+import { hasGeneratedPlanBreakdown, isParentSyncNeededBeforeNextWave } from "../workstreams/packet-plan.js";
+import { collectPacketPullRequestCommentProjections, collectPacketPullRequestProjections } from "../workstreams/packet-projections.js";
+export function deriveAttentionRecords(input) {
+    const reposById = new Map(input.repos.map((repo) => [repo.id, repo]));
+    const currentIssuesById = new Map(input.currentIssues.map((issue) => [issue.id, issue]));
+    const currentPrsById = new Map(input.currentPullRequests.map((pr) => [pr.id, pr]));
+    const previousIssuesById = new Map(input.previousState.issues.map((issue) => [issue.id, issue]));
+    const previousPrsById = new Map(input.previousState.prs.map((pr) => [pr.id, pr]));
+    const previousCommentsById = new Map(input.previousState.comments.map((comment) => [comment.id, comment]));
+    const previousAttentionByWorkstreamId = new Map(input.previousState.attention.map((record) => [record.workstreamId, record]));
+    const issueWorkstreamByKey = new Map();
+    const prWorkstreamByKey = new Map();
+    const handledReviewHeadShaByPrId = buildHandledReviewHeadShaByPrId(input.previousState, input.currentPullRequests, input.tasks);
+    for (const workstream of input.workstreams) {
+        if (workstream.origin.type === "issue" && workstream.linkedIssueNumber !== undefined) {
+            issueWorkstreamByKey.set(buildIssueKey(workstream.repoKey, workstream.linkedIssueNumber), workstream);
+        }
+        for (const pr of workstream.linkedPrs) {
+            prWorkstreamByKey.set(buildPrKey(workstream.repoKey, pr.number), workstream);
+        }
+        if (workstream.origin.type === "pr") {
+            prWorkstreamByKey.set(buildPrKey(workstream.repoKey, workstream.origin.number), workstream);
+        }
+    }
+    const worktrees = input.worktrees ?? input.previousState.worktrees;
+    const packetPullRequestProjections = collectPacketPullRequestProjections({
+        pullRequests: input.currentPullRequests,
+        workstreams: input.workstreams,
+        worktrees
+    });
+    const packetCommentProjectionByCommentId = new Map(collectPacketPullRequestCommentProjections({
+        comments: input.currentComments,
+        packetPullRequestProjections
+    }).map((projection) => [projection.comment.id, projection]));
+    const attentionByWorkstreamId = new Map();
+    for (const workstream of input.workstreams) {
+        const currentIssue = workstream.origin.type === "issue"
+            ? currentIssuesById.get(buildEntityId("issue", workstream.repoKey, workstream.origin.number))
+            : undefined;
+        const previousAttention = previousAttentionByWorkstreamId.get(workstream.id);
+        const accumulator = getAccumulator(attentionByWorkstreamId, workstream.id);
+        if (currentIssue) {
+            accumulator.issueNumber = currentIssue.number;
+            if (!previousIssuesById.has(currentIssue.id)) {
+                accumulator.reasons.add("new_issue");
+            }
+        }
+        else if (workstream.linkedIssueNumber !== undefined) {
+            accumulator.issueNumber = workstream.linkedIssueNumber;
+        }
+        const currentLinkedPrs = resolveCurrentLinkedPullRequests(workstream, currentPrsById);
+        const currentOpenLinkedPrs = currentLinkedPrs.filter((pr) => pr.state === "open");
+        const repo = currentIssue?.repoId !== undefined
+            ? reposById.get(currentIssue.repoId)
+            : currentLinkedPrs[0]
+                ? reposById.get(currentLinkedPrs[0].repoId)
+                : undefined;
+        for (const pr of currentLinkedPrs) {
+            accumulator.pullRequestNumbers.add(pr.number);
+            if (!previousPrsById.has(pr.id)) {
+                accumulator.reasons.add("new_pr");
+            }
+        }
+        if (workstream.origin.type === "pr" && currentLinkedPrs.length > 0) {
+            accumulator.reasons.add("workstream_unlinked_pr");
+        }
+        if (repo) {
+            for (const pr of currentOpenLinkedPrs) {
+                if (!pr.labels.includes(repo.labels.agentReview)) {
+                    continue;
+                }
+                accumulator.reasons.add("pr_review_requested");
+                accumulator.currentPullRequestHeadSha = pr.headSha;
+                const handledHeadSha = handledReviewHeadShaByPrId.get(pr.id) ?? previousAttention?.lastHandledReviewHeadSha;
+                if (handledHeadSha) {
+                    accumulator.lastHandledReviewHeadSha = handledHeadSha;
+                    if (handledHeadSha !== pr.headSha) {
+                        accumulator.reasons.add("pr_head_changed_since_last_review");
+                    }
+                }
+                else {
+                    accumulator.gaps.add("Review handling is inferred from persisted state; external or unlabeled reviews are not tracked yet.");
+                }
+            }
+            if (currentOpenLinkedPrs.some((pr) => pr.labels.includes(repo.labels.agentPlanApproved))) {
+                accumulator.reasons.add("plan_approved");
+            }
+            if (currentIssue?.labels.includes(repo.labels.agentProductApproved)) {
+                accumulator.reasons.add("product_approval_observed");
+            }
+            const planBreakdownAlreadyProduced = hasGeneratedPlanBreakdown(workstream);
+            if (!planBreakdownAlreadyProduced && currentIssue?.labels.includes(repo.labels.planBreakdownNeeded)) {
+                accumulator.reasons.add("plan_breakdown_requested");
+            }
+            if (!planBreakdownAlreadyProduced &&
+                currentOpenLinkedPrs.some((pr) => pr.labels.includes(repo.labels.planBreakdownNeeded))) {
+                accumulator.reasons.add("plan_breakdown_requested");
+            }
+            if (currentOpenLinkedPrs.some((pr) => pr.labels.includes(repo.labels.prepareForMerge))) {
+                accumulator.reasons.add("prepare_for_merge_requested");
+            }
+        }
+        if (workstream.origin.type === "issue" &&
+            workstream.packetPlan &&
+            isParentSyncNeededBeforeNextWave(workstream.packetPlan)) {
+            accumulator.reasons.add("packet_wave_complete_sync_needed");
+        }
+        if (previousAttention?.issueNumber !== undefined && accumulator.issueNumber === undefined) {
+            accumulator.issueNumber = previousAttention.issueNumber;
+        }
+    }
+    for (const comment of [...input.currentComments].sort(compareComments)) {
+        if (isAgentAuthoredComment(comment.body)) {
+            continue;
+        }
+        const previousComment = previousCommentsById.get(comment.id);
+        const isNew = previousComment === undefined;
+        const isEdited = previousComment !== undefined &&
+            (previousComment.updatedAt !== comment.updatedAt || previousComment.body !== comment.body);
+        if (!isNew && !isEdited) {
+            continue;
+        }
+        let workstream = comment.parentType === "issue"
+            ? issueWorkstreamByKey.get(buildIssueKey(comment.repoKey, comment.parentNumber))
+            : prWorkstreamByKey.get(buildPrKey(comment.repoKey, comment.parentNumber));
+        if (!workstream && comment.parentType === "pull_request") {
+            const packetProjection = packetCommentProjectionByCommentId.get(comment.id);
+            if (packetProjection) {
+                workstream = packetProjection.packetProjection.parentWorkstream;
+            }
+        }
+        if (!workstream) {
+            continue;
+        }
+        const accumulator = getAccumulator(attentionByWorkstreamId, workstream.id);
+        accumulator.commentIds.add(comment.id);
+        if (comment.parentType === "issue") {
+            accumulator.issueNumber ??= comment.parentNumber;
+            accumulator.reasons.add(isNew ? "issue_comment_added" : "issue_comment_edited");
+            const issueRetryCommentId = extractRetryCommentId(comment.body);
+            if (issueRetryCommentId !== undefined) {
+                accumulator.reasons.add("retry_requested");
+                accumulator.retryTargetCommentId ??= issueRetryCommentId;
+            }
+            if (isCancelRequest(comment.body)) {
+                accumulator.reasons.add("cancel_requested");
+            }
+            const mcpSkipCommand = extractMcpSkipCommand(comment.body);
+            if (mcpSkipCommand !== undefined) {
+                const matchingBlocker = findMatchingMcpBlocker(workstream, mcpSkipCommand.taskId, mcpSkipCommand.mcpHandle);
+                const isStale = matchingBlocker !== undefined && comment.createdAt < matchingBlocker.createdAt;
+                if (!isStale) {
+                    accumulator.reasons.add("mcp_skip_requested");
+                    accumulator.mcpSkipTargetTaskId ??= mcpSkipCommand.taskId;
+                    accumulator.mcpSkipMcpHandle ??= mcpSkipCommand.mcpHandle;
+                }
+            }
+            continue;
+        }
+        accumulator.pullRequestNumbers.add(comment.parentNumber);
+        accumulator.reasons.add(isNew ? "pr_comment_added" : "pr_comment_edited");
+        const retryCommentId = extractRetryCommentId(comment.body);
+        if (retryCommentId !== undefined) {
+            accumulator.reasons.add("retry_requested");
+            accumulator.retryTargetCommentId ??= retryCommentId;
+        }
+        if (isCancelRequest(comment.body)) {
+            accumulator.reasons.add("cancel_requested");
+        }
+        const mcpSkipCommand = extractMcpSkipCommand(comment.body);
+        if (mcpSkipCommand !== undefined) {
+            const matchingBlocker = findMatchingMcpBlocker(workstream, mcpSkipCommand.taskId, mcpSkipCommand.mcpHandle);
+            const isStale = matchingBlocker !== undefined && comment.createdAt < matchingBlocker.createdAt;
+            if (!isStale) {
+                accumulator.reasons.add("mcp_skip_requested");
+                accumulator.mcpSkipTargetTaskId ??= mcpSkipCommand.taskId;
+                accumulator.mcpSkipMcpHandle ??= mcpSkipCommand.mcpHandle;
+            }
+        }
+    }
+    return [...input.workstreams]
+        .sort((left, right) => left.id.localeCompare(right.id))
+        .map((workstream) => {
+        const accumulator = attentionByWorkstreamId.get(workstream.id) ?? {
+            reasons: new Set(),
+            pullRequestNumbers: new Set(),
+            commentIds: new Set(),
+            gaps: new Set()
+        };
+        const previous = previousAttentionByWorkstreamId.get(workstream.id);
+        const reasons = [...accumulator.reasons].sort((left, right) => left.localeCompare(right));
+        const needsAction = workstream.status === "open" &&
+            evaluateNeedsAction(reasons, accumulator.lastHandledReviewHeadSha, accumulator.currentPullRequestHeadSha);
+        return {
+            workstreamId: workstream.id,
+            repoKey: workstream.repoKey,
+            needsAction,
+            reasons,
+            ...(accumulator.issueNumber !== undefined ? { issueNumber: accumulator.issueNumber } : {}),
+            ...(accumulator.pullRequestNumbers.size > 0
+                ? {
+                    pullRequestNumbers: [...accumulator.pullRequestNumbers].sort((left, right) => left - right)
+                }
+                : {}),
+            ...(accumulator.commentIds.size > 0
+                ? { commentIds: [...accumulator.commentIds].sort((left, right) => left.localeCompare(right)) }
+                : {}),
+            ...(accumulator.retryTargetCommentId !== undefined
+                ? { retryTargetCommentId: accumulator.retryTargetCommentId }
+                : {}),
+            ...(accumulator.mcpSkipTargetTaskId !== undefined
+                ? { mcpSkipTargetTaskId: accumulator.mcpSkipTargetTaskId }
+                : {}),
+            ...(accumulator.mcpSkipMcpHandle !== undefined
+                ? { mcpSkipMcpHandle: accumulator.mcpSkipMcpHandle }
+                : {}),
+            lastObservedAt: input.now,
+            ...(previous?.lastHandledAt ? { lastHandledAt: previous.lastHandledAt } : {}),
+            ...(accumulator.currentPullRequestHeadSha
+                ? { currentPullRequestHeadSha: accumulator.currentPullRequestHeadSha }
+                : {}),
+            ...(accumulator.lastHandledReviewHeadSha
+                ? { lastHandledReviewHeadSha: accumulator.lastHandledReviewHeadSha }
+                : {}),
+            ...(accumulator.gaps.size > 0
+                ? { gaps: [...accumulator.gaps].sort((left, right) => left.localeCompare(right)) }
+                : {})
+        };
+    });
+}
+function buildHandledReviewHeadShaByPrId(previousState, currentPullRequests, tasks) {
+    const handledByPrId = new Map();
+    const previousPrsById = new Map(previousState.prs.map((pr) => [pr.id, pr]));
+    const currentPrsById = new Map(currentPullRequests.map((pr) => [pr.id, pr]));
+    for (const task of previousState.tasks) {
+        if (task.kind !== "review_pr" || task.status !== "completed") {
+            continue;
+        }
+        const previousPr = previousPrsById.get(task.sourceId);
+        if (previousPr) {
+            handledByPrId.set(task.sourceId, previousPr.headSha);
+        }
+    }
+    for (const task of tasks) {
+        if (task.kind !== "review_pr" || task.status !== "completed") {
+            continue;
+        }
+        const wasAlreadyCompleted = previousState.tasks.some((t) => t.id === task.id && t.status === "completed");
+        if (wasAlreadyCompleted) {
+            continue;
+        }
+        const currentPr = currentPrsById.get(task.sourceId);
+        if (currentPr) {
+            handledByPrId.set(task.sourceId, currentPr.headSha);
+        }
+    }
+    return handledByPrId;
+}
+function resolveCurrentLinkedPullRequests(workstream, currentPrsById) {
+    const prIds = new Set();
+    if (workstream.origin.type === "pr") {
+        prIds.add(buildEntityId("pull_request", workstream.repoKey, workstream.origin.number));
+    }
+    for (const linkedPr of workstream.linkedPrs) {
+        prIds.add(buildEntityId("pull_request", workstream.repoKey, linkedPr.number));
+    }
+    return [...prIds]
+        .map((id) => currentPrsById.get(id))
+        .filter((pr) => pr !== undefined)
+        .sort((left, right) => left.number - right.number);
+}
+function getAccumulator(attentionByWorkstreamId, workstreamId) {
+    const existing = attentionByWorkstreamId.get(workstreamId);
+    if (existing) {
+        return existing;
+    }
+    const created = {
+        reasons: new Set(),
+        pullRequestNumbers: new Set(),
+        commentIds: new Set(),
+        gaps: new Set()
+    };
+    attentionByWorkstreamId.set(workstreamId, created);
+    return created;
+}
+function evaluateNeedsAction(reasons, lastHandledReviewHeadSha, currentPullRequestHeadSha) {
+    return reasons.some((reason) => reason === "new_issue" ||
+        reason === "issue_comment_added" ||
+        reason === "issue_comment_edited" ||
+        reason === "new_pr" ||
+        reason === "pr_comment_added" ||
+        reason === "pr_comment_edited" ||
+        reason === "pr_head_changed_since_last_review" ||
+        reason === "product_approval_observed" ||
+        reason === "plan_approved" ||
+        reason === "plan_breakdown_requested" ||
+        reason === "packet_wave_complete_sync_needed" ||
+        reason === "prepare_for_merge_requested" ||
+        reason === "retry_requested" ||
+        reason === "cancel_requested" ||
+        reason === "mcp_skip_requested" ||
+        reason === "workstream_unlinked_pr" ||
+        reason === "unknown_phase_needs_attention" ||
+        (reason === "pr_review_requested" &&
+            (!lastHandledReviewHeadSha ||
+                (currentPullRequestHeadSha !== undefined && currentPullRequestHeadSha !== lastHandledReviewHeadSha))));
+}
+function isAgentAuthoredComment(body) {
+    return body.trimStart().startsWith("🤖");
+}
+function isCancelRequest(body) {
+    return /\bcancel\b/i.test(body) || /\babandon\b/i.test(body);
+}
+function findMatchingMcpBlocker(workstream, taskId, mcpHandle) {
+    return (workstream.mcpBlockers ?? []).find((blocker) => blocker.blockedTaskId === taskId && blocker.mcpHandle === mcpHandle);
+}
+function buildIssueKey(repoKey, number) {
+    return `${repoKey}:issue:${number}`;
+}
+function buildPrKey(repoKey, number) {
+    return `${repoKey}:pr:${number}`;
+}
+function buildEntityId(kind, repoKey, number) {
+    return `${kind}:${repoKey}:${number}`;
+}
+function compareComments(left, right) {
+    const repoComparison = left.repoSlug.localeCompare(right.repoSlug);
+    if (repoComparison !== 0) {
+        return repoComparison;
+    }
+    if (left.parentNumber !== right.parentNumber) {
+        return left.parentNumber - right.parentNumber;
+    }
+    return left.id.localeCompare(right.id);
+}

package/dist/src/capabilities/index.js

@@ -0,0 +1,2 @@
+export { validateCapabilities } from "./validator.js";
+export { applySkippedCapabilityProjection, deriveProjectedCapabilityToolNames, projectCapabilities } from "./projection.js";

package/dist/src/capabilities/projection.js

@@ -0,0 +1,183 @@
+import { validateCapabilities } from "./validator.js";
+export const SENSOR_TOOL_MAP = {
+    "issues-and-prs": ["get_issue", "get_issue_comments", "get_pr", "get_pr_comments"],
+    "package-docs": ["resolve-library-id", "get-library-docs", "query-docs"],
+    "repository-context": ["search_code"],
+};
+export const CONTROLLER_TOOL_MAP = {
+    "comment-on-prs": ["post_issue_comment"],
+    "comment-on-issues": ["post_issue_comment"],
+    "open-issues": [],
+    "edit-issue-labels": [],
+};
+export function projectCapabilities(input) {
+    void input.taskKind;
+    const validation = validateCapabilities(input.capabilities, input.declaredMcps, input.mcpStatuses);
+    const sensorsByName = new Map(input.capabilities.sensors.map((sensor) => [sensor.name, sensor]));
+    const controllersByName = new Map(input.capabilities.controllers.map((controller) => [controller.name, controller]));
+    const registeredPublicBrokerToolNames = uniqueStrings(input.registeredPublicBrokerToolNames);
+    const providerRunAllowList = uniqueStrings(input.providerRunAllowList);
+    const declaredMcpHandles = new Set(input.declaredMcps.map((mcp) => mcp.handle));
+    const skippedCapabilityNames = input.skippedCapabilityNames ?? new Set();
+    const blocked = validation.blocked.map((capability) => skippedCapabilityNames.has(capability.name)
+        ? skippedCapability(capability.kind, capability.name, capability.uses)
+        : capability);
+    const sensors = [];
+    const controllers = [];
+    for (const capability of validation.valid) {
+        if (skippedCapabilityNames.has(capability.name)) {
+            blocked.push(skippedCapability(capability.kind, capability.name, capability.uses));
+            continue;
+        }
+        if (capability.kind === "sensor") {
+            const sensor = sensorsByName.get(capability.name);
+            if (!sensor) {
+                continue;
+            }
+            const tools = projectToolsForCapability(SENSOR_TOOL_MAP[sensor.observes], registeredPublicBrokerToolNames, providerRunAllowList, sensor.uses, declaredMcpHandles);
+            if (tools.length === 0) {
+                blocked.push(blockedCapability(capability.kind, sensor.name, sensor.uses, toolsBlockedReason(SENSOR_TOOL_MAP[sensor.observes], registeredPublicBrokerToolNames, sensor.uses, declaredMcpHandles)));
+                continue;
+            }
+            sensors.push(buildVisibleSensor(sensor, tools));
+            continue;
+        }
+        const controller = controllersByName.get(capability.name);
+        if (!controller) {
+            continue;
+        }
+        const mappedTools = capabilityToolsForController(controller.grants);
+        const tools = projectToolsForCapability(mappedTools, registeredPublicBrokerToolNames, providerRunAllowList, controller.uses, declaredMcpHandles);
+        if (tools.length === 0) {
+            blocked.push(blockedCapability(capability.kind, controller.name, controller.uses, toolsBlockedReason(mappedTools, registeredPublicBrokerToolNames, controller.uses, declaredMcpHandles)));
+            continue;
+        }
+        controllers.push(buildVisibleController(controller, tools));
+    }
+    return { sensors, controllers, blocked };
+}
+export function applySkippedCapabilityProjection(capabilities, skippedCapabilityNames) {
+    if (skippedCapabilityNames.size === 0) {
+        return capabilities;
+    }
+    const skippedFromSensors = capabilities.sensors
+        .filter((sensor) => skippedCapabilityNames.has(sensor.name))
+        .map((sensor) => skippedCapability("sensor", sensor.name, sensor.uses));
+    const skippedFromControllers = capabilities.controllers
+        .filter((controller) => skippedCapabilityNames.has(controller.name))
+        .map((controller) => skippedCapability("controller", controller.name, controller.uses));
+    const blocked = capabilities.blocked.map((capability) => skippedCapabilityNames.has(capability.name)
+        ? skippedCapability(capability.kind, capability.name, capability.uses)
+        : capability);
+    const blockedNames = new Set(blocked.map((capability) => capability.name));
+    for (const capability of [...skippedFromSensors, ...skippedFromControllers]) {
+        if (!blockedNames.has(capability.name)) {
+            blocked.push(capability);
+            blockedNames.add(capability.name);
+        }
+    }
+    return {
+        sensors: capabilities.sensors.filter((sensor) => !skippedCapabilityNames.has(sensor.name)),
+        controllers: capabilities.controllers.filter((controller) => !skippedCapabilityNames.has(controller.name)),
+        blocked
+    };
+}
+function buildVisibleSensor(sensor, tools) {
+    return {
+        name: sensor.name,
+        uses: sensor.uses,
+        observes: sensor.observes,
+        ...(sensor.cadence !== undefined ? { cadence: sensor.cadence } : {}),
+        ...(sensor.scope !== undefined ? { scope: sensor.scope } : {}),
+        tools,
+    };
+}
+function buildVisibleController(controller, tools) {
+    return {
+        name: controller.name,
+        uses: controller.uses,
+        grants: [...controller.grants],
+        approval: controller.approval,
+        tools,
+    };
+}
+function projectToolsForCapability(mappedTools, registeredPublicBrokerToolNames, providerRunAllowList, capabilityUses, declaredMcpHandles) {
+    const registeredMatches = registeredPublicBrokerToolNames.filter((publicToolName) => mappedTools.some((mappedTool) => publicToolMatchesMappedCapabilityTool(publicToolName, mappedTool, capabilityUses, declaredMcpHandles)));
+    if (registeredMatches.length === 0) {
+        return [];
+    }
+    return registeredMatches.filter((publicToolName) => providerRunAllowList.some((allowedToolName) => providerToolAllowsPublicTool(publicToolName, allowedToolName)));
+}
+function toolsBlockedReason(mappedTools, registeredPublicBrokerToolNames, capabilityUses, declaredMcpHandles) {
+    const registeredMatches = registeredPublicBrokerToolNames.filter((publicToolName) => mappedTools.some((mappedTool) => publicToolMatchesMappedCapabilityTool(publicToolName, mappedTool, capabilityUses, declaredMcpHandles)));
+    return registeredMatches.length === 0
+        ? "capability_tools_unavailable"
+        : "capability_tools_not_allowed";
+}
+function capabilityToolsForController(grants) {
+    const tools = grants.flatMap((grant) => CONTROLLER_TOOL_MAP[grant] ?? []);
+    return uniqueStrings(tools);
+}
+function blockedCapability(kind, name, uses, reason) {
+    return {
+        name,
+        kind,
+        uses,
+        reason,
+        message: reason === "capability_tools_unavailable"
+            ? "No registered broker tool matches the capability's mapped tool set."
+            : "Mapped capability tools are not in the active provider/run allow-list.",
+    };
+}
+function skippedCapability(kind, name, uses) {
+    return {
+        kind,
+        name,
+        uses,
+        reason: "capability_skipped_by_user",
+        message: "User explicitly skipped this MCP-backed capability for the current task."
+    };
+}
+function publicToolNameMatches(publicToolName, candidateToolName) {
+    if (candidateToolName === "*") {
+        return true;
+    }
+    if (candidateToolName.endsWith(".*")) {
+        return publicToolName.startsWith(candidateToolName.slice(0, -1));
+    }
+    return (publicToolName === candidateToolName ||
+        publicToolName.endsWith(`.${candidateToolName}`) ||
+        candidateToolName.endsWith(`.${publicToolName}`));
+}
+function publicToolMatchesMappedCapabilityTool(publicToolName, mappedToolName, capabilityUses, declaredMcpHandles) {
+    const parsed = splitPublicToolName(publicToolName);
+    if (parsed && declaredMcpHandles.has(parsed.namespace)) {
+        return parsed.namespace === capabilityUses && publicToolNameMatches(parsed.localName, mappedToolName);
+    }
+    return publicToolNameMatches(publicToolName, mappedToolName);
+}
+function splitPublicToolName(publicToolName) {
+    const dotIndex = publicToolName.indexOf(".");
+    if (dotIndex <= 0 || dotIndex === publicToolName.length - 1) {
+        return undefined;
+    }
+    return {
+        namespace: publicToolName.slice(0, dotIndex),
+        localName: publicToolName.slice(dotIndex + 1)
+    };
+}
+function providerToolAllowsPublicTool(publicToolName, allowedToolName) {
+    if (publicToolName.includes(".")) {
+        return allowedToolName === publicToolName;
+    }
+    return publicToolNameMatches(publicToolName, allowedToolName);
+}
+export function deriveProjectedCapabilityToolNames(capabilities) {
+    return uniqueStrings([
+        ...capabilities.sensors.flatMap((sensor) => sensor.tools),
+        ...capabilities.controllers.flatMap((controller) => controller.tools),
+    ]);
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter((value) => value.trim().length > 0)));
+}

package/dist/src/capabilities/types.js

@@ -0,0 +1 @@
+export {};