@pinet/slack-bridge 0.1.0

package/dist/follower-runtime.d.ts

@@ -0,0 +1,61 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type FollowerRuntimeDiagnostic, type FollowerThreadState, type InboxMessage, type PinetControlCommand, type PinetRemoteControlRequestResult, type SlackBridgeSettings } from "./helpers.js";
+import { type FollowerDeliveryState } from "./follower-delivery.js";
+import { BrokerClient } from "./broker/client.js";
+export type BrokerClientRef = {
+    client: BrokerClient;
+    pollInterval: ReturnType<typeof setInterval> | null;
+};
+type SharedFollowerThreadState = Pick<FollowerThreadState, "channelId" | "threadTs" | "userId" | "source" | "owner">;
+export interface FollowerRuntimeDeps {
+    getSettings: () => SlackBridgeSettings;
+    refreshSettings: () => void;
+    getPinetEnabled: () => boolean;
+    getAgentIdentity: () => {
+        name: string;
+        emoji: string;
+    };
+    getAgentStableId: () => string;
+    getAgentOwnerToken: () => string;
+    setAgentOwnerToken: (ownerToken: string) => void;
+    getDesiredAgentStatus: () => "working" | "idle";
+    getAgentAliases: () => Iterable<string>;
+    getThreads: () => Map<string, SharedFollowerThreadState>;
+    getLastDmChannel: () => string | null;
+    setLastDmChannel: (channelId: string | null) => void;
+    pushInboxMessages: (messages: InboxMessage[]) => void;
+    getAgentMetadata: (role: "broker" | "worker") => Promise<Record<string, unknown>>;
+    applyRegistrationIdentity: (registration: {
+        name: string;
+        emoji: string;
+        metadata?: Record<string, unknown> | null;
+    }) => void;
+    persistState: () => void;
+    updateBadge: () => void;
+    maybeDrainInboxIfIdle: (ctx: ExtensionContext) => boolean;
+    requestRemoteControl: (command: PinetControlCommand, ctx: ExtensionContext) => PinetRemoteControlRequestResult;
+    deferControlAck: (command: PinetControlCommand, inboxId: number) => void;
+    runRemoteControl: (command: PinetControlCommand, ctx: ExtensionContext) => void;
+    deliverFollowUpMessage: (text: string) => boolean;
+    setExtStatus: (ctx: ExtensionContext, state: "ok" | "reconnecting" | "error" | "off") => void;
+    getRuntimeDiagnostic: () => FollowerRuntimeDiagnostic | null;
+    setRuntimeDiagnostic: (diagnostic: FollowerRuntimeDiagnostic | null) => void;
+    handleTerminalReconnectFailure: (ctx: ExtensionContext, error: Error) => Promise<void> | void;
+    formatError: (error: unknown) => string;
+    deliveryState: FollowerDeliveryState;
+}
+export interface FollowerRuntime {
+    connect: (ctx: ExtensionContext) => Promise<BrokerClientRef>;
+    disconnect: (ctx: ExtensionContext, options?: {
+        releaseIdentity?: boolean;
+    }) => Promise<{
+        unregisterError: string | null;
+    }>;
+    syncDesiredStatus: (desiredStatus: "working" | "idle", options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    flushDeliveredAcks: () => Promise<void>;
+    getClientRef: () => BrokerClientRef | null;
+}
+export declare function createFollowerRuntime(deps: FollowerRuntimeDeps): FollowerRuntime;
+export {};

package/dist/follower-runtime.js

@@ -0,0 +1,350 @@
+import { buildFollowerRuntimeDiagnostic, buildPinetOwnerToken, extractPinetControlCommand, formatPinetInboxMessages, getFollowerOwnedThreadReclaims, getFollowerReconnectUiUpdate, partitionFollowerInboxEntries, resolvePinetMeshAuth, resolveRuntimeAgentIdentity, syncFollowerInboxEntries, syncTransferredSlackThreadContexts, } from "./helpers.js";
+import { drainFollowerAckBatches, hasDeliveredFollowerInboxIds, isFollowerInboxIdTracked, markFollowerInboxIdsDelivered, queueFollowerInboxIds, resetFollowerDeliveryState, } from "./follower-delivery.js";
+import { BrokerClient, DEFAULT_SOCKET_PATH } from "./broker/client.js";
+function getInboxIds(entries) {
+    return entries.flatMap((entry) => (typeof entry.inboxId === "number" ? [entry.inboxId] : []));
+}
+function mergeFollowerThreadUpdates(threads, updates) {
+    for (const nextThread of updates) {
+        const existing = threads.get(nextThread.threadTs);
+        if (!existing) {
+            threads.set(nextThread.threadTs, { ...nextThread });
+            continue;
+        }
+        existing.channelId = nextThread.channelId;
+        existing.threadTs = nextThread.threadTs;
+        existing.userId = nextThread.userId;
+        existing.owner = nextThread.owner;
+        existing.source = nextThread.source ?? existing.source;
+    }
+}
+export function createFollowerRuntime(deps) {
+    let clientRef = null;
+    let followerPollRunning = false;
+    let wasDisconnected = false;
+    let followerAckPromise = null;
+    let syncedFollowerStatus = null;
+    let followerStatusSyncPromise = null;
+    let followerStatusSyncTarget = null;
+    async function flushDeliveredAcks() {
+        if (followerAckPromise) {
+            await followerAckPromise;
+            return;
+        }
+        if (!clientRef?.client) {
+            return;
+        }
+        const client = clientRef.client;
+        const promise = drainFollowerAckBatches(deps.deliveryState, async (ids) => {
+            await client.ackMessages(ids);
+        }).finally(() => {
+            if (followerAckPromise === promise) {
+                followerAckPromise = null;
+            }
+        });
+        followerAckPromise = promise;
+        await promise;
+    }
+    async function syncDesiredStatus(desiredStatus, options = {}) {
+        if (!clientRef) {
+            return;
+        }
+        if (!options.force && syncedFollowerStatus === desiredStatus) {
+            return;
+        }
+        if (followerStatusSyncPromise && followerStatusSyncTarget === desiredStatus) {
+            await followerStatusSyncPromise;
+            return;
+        }
+        const targetStatus = desiredStatus;
+        const request = clientRef.client.updateStatus(targetStatus).then(() => {
+            syncedFollowerStatus = targetStatus;
+        });
+        followerStatusSyncTarget = targetStatus;
+        const inFlight = request.finally(() => {
+            if (followerStatusSyncPromise === inFlight) {
+                followerStatusSyncPromise = null;
+                followerStatusSyncTarget = null;
+            }
+        });
+        followerStatusSyncPromise = inFlight;
+        await inFlight;
+    }
+    function stopPolling() {
+        if (clientRef?.pollInterval) {
+            clearInterval(clientRef.pollInterval);
+            clientRef.pollInterval = null;
+        }
+        followerPollRunning = false;
+    }
+    function resetFollowerRuntimeState() {
+        clientRef = null;
+        followerPollRunning = false;
+        wasDisconnected = false;
+        followerAckPromise = null;
+        syncedFollowerStatus = null;
+        followerStatusSyncPromise = null;
+        followerStatusSyncTarget = null;
+        resetFollowerDeliveryState(deps.deliveryState);
+    }
+    async function connect(ctx) {
+        deps.refreshSettings();
+        const meshAuth = resolvePinetMeshAuth(deps.getSettings());
+        const client = new BrokerClient({
+            path: DEFAULT_SOCKET_PATH,
+            ...(meshAuth.meshSecret ? { meshSecret: meshAuth.meshSecret } : {}),
+            ...(meshAuth.meshSecretPath ? { meshSecretPath: meshAuth.meshSecretPath } : {}),
+        });
+        async function registerFollowerRuntime() {
+            deps.refreshSettings();
+            const settings = deps.getSettings();
+            const { name, emoji } = deps.getAgentIdentity();
+            const workerIdentity = resolveRuntimeAgentIdentity({ name, emoji }, settings, process.env.PI_NICKNAME, ctx.sessionManager.getSessionFile() ?? deps.getAgentStableId(), "worker");
+            const hasExplicitIdentityRequest = Boolean(settings.agentName?.trim() && settings.agentEmoji?.trim()) ||
+                Boolean(process.env.PI_NICKNAME?.trim());
+            deps.setAgentOwnerToken(buildPinetOwnerToken(deps.getAgentStableId()));
+            const registration = await client.register(hasExplicitIdentityRequest ? workerIdentity.name : "", hasExplicitIdentityRequest ? workerIdentity.emoji : "", await deps.getAgentMetadata("worker"), deps.getAgentStableId());
+            deps.applyRegistrationIdentity(registration);
+            client.setHeartbeatMetadataProvider(() => deps.getAgentMetadata("worker"));
+        }
+        async function resumeThreadClaims() {
+            for (const thread of getFollowerOwnedThreadReclaims(deps.getThreads(), deps.getAgentIdentity().name, deps.getAgentAliases(), deps.getAgentOwnerToken())) {
+                try {
+                    await client.claimThread(thread.threadTs, thread.channelId, thread.source);
+                }
+                catch {
+                    break;
+                }
+            }
+        }
+        function startPolling() {
+            if (!clientRef || clientRef.pollInterval) {
+                return;
+            }
+            clientRef.pollInterval = setInterval(async () => {
+                if (!deps.getPinetEnabled() || followerPollRunning || clientRef?.client !== client) {
+                    return;
+                }
+                followerPollRunning = true;
+                try {
+                    const entries = await client.pollInbox();
+                    if (deps.getRuntimeDiagnostic()?.kind === "poll_failure") {
+                        deps.setRuntimeDiagnostic(null);
+                    }
+                    const newEntries = entries.filter((entry) => !isFollowerInboxIdTracked(deps.deliveryState, entry.inboxId));
+                    if (newEntries.length === 0) {
+                        if (hasDeliveredFollowerInboxIds(deps.deliveryState)) {
+                            void flushDeliveredAcks();
+                        }
+                        return;
+                    }
+                    const controlEntries = [];
+                    const remainingEntries = [];
+                    for (const entry of newEntries) {
+                        const command = extractPinetControlCommand({
+                            threadId: entry.message.threadId,
+                            body: entry.message.body,
+                            metadata: entry.message.metadata,
+                        });
+                        if (command) {
+                            controlEntries.push({ inboxId: entry.inboxId, command });
+                            continue;
+                        }
+                        remainingEntries.push(entry);
+                    }
+                    if (controlEntries.length > 0) {
+                        const immediateAckIds = [];
+                        const commandsToStart = [];
+                        for (const entry of controlEntries) {
+                            const queued = deps.requestRemoteControl(entry.command, ctx);
+                            if (queued.ackDisposition === "immediate") {
+                                immediateAckIds.push(entry.inboxId);
+                            }
+                            else {
+                                deps.deferControlAck(queued.scheduledCommand, entry.inboxId);
+                            }
+                            if (queued.shouldStartNow) {
+                                commandsToStart.push(entry.command);
+                            }
+                        }
+                        if (immediateAckIds.length > 0) {
+                            await client.ackMessages(immediateAckIds);
+                        }
+                        for (const command of commandsToStart) {
+                            deps.runRemoteControl(command, ctx);
+                        }
+                        return;
+                    }
+                    const { nudges, agentMessages, regular } = partitionFollowerInboxEntries(remainingEntries);
+                    if (nudges.length > 0) {
+                        const nudgeText = nudges
+                            .map((nudge) => nudge.message.body ?? "")
+                            .filter(Boolean)
+                            .join("\n");
+                        if (nudgeText && deps.deliverFollowUpMessage(nudgeText)) {
+                            markFollowerInboxIdsDelivered(deps.deliveryState, getInboxIds(nudges));
+                            void flushDeliveredAcks();
+                        }
+                    }
+                    if (agentMessages.length > 0) {
+                        const transferredThreads = syncTransferredSlackThreadContexts(agentMessages, deps.getThreads(), deps.getAgentOwnerToken());
+                        if (transferredThreads.threadUpdates.length > 0) {
+                            mergeFollowerThreadUpdates(deps.getThreads(), transferredThreads.threadUpdates);
+                            if (transferredThreads.changed) {
+                                deps.persistState();
+                            }
+                        }
+                        const pinetPrompt = formatPinetInboxMessages(agentMessages);
+                        if (deps.deliverFollowUpMessage(pinetPrompt)) {
+                            markFollowerInboxIdsDelivered(deps.deliveryState, getInboxIds(agentMessages));
+                            void flushDeliveredAcks();
+                        }
+                    }
+                    if (regular.length > 0) {
+                        const synced = syncFollowerInboxEntries(regular, deps.getThreads(), deps.getAgentOwnerToken(), deps.getLastDmChannel());
+                        mergeFollowerThreadUpdates(deps.getThreads(), synced.threadUpdates);
+                        deps.setLastDmChannel(synced.lastDmChannel);
+                        deps.pushInboxMessages(synced.inboxMessages);
+                        queueFollowerInboxIds(deps.deliveryState, getInboxIds(regular));
+                        if (synced.changed) {
+                            deps.persistState();
+                        }
+                        deps.updateBadge();
+                        deps.maybeDrainInboxIfIdle(ctx);
+                    }
+                }
+                catch (error) {
+                    deps.setRuntimeDiagnostic(buildFollowerRuntimeDiagnostic("poll_failure", {
+                        detail: deps.formatError(error),
+                        connected: client.isConnected(),
+                    }));
+                }
+                finally {
+                    void syncDesiredStatus(deps.getDesiredAgentStatus()).catch(() => {
+                        /* best effort */
+                    });
+                    followerPollRunning = false;
+                }
+            }, 2000);
+        }
+        try {
+            await client.connect();
+            await registerFollowerRuntime();
+            deps.setRuntimeDiagnostic(null);
+            syncedFollowerStatus = "idle";
+            clientRef = {
+                client,
+                pollInterval: null,
+            };
+            followerAckPromise = null;
+            wasDisconnected = false;
+            followerPollRunning = false;
+            resetFollowerDeliveryState(deps.deliveryState);
+            client.onDisconnect(() => {
+                if (clientRef?.client !== client) {
+                    return;
+                }
+                stopPolling();
+                deps.setRuntimeDiagnostic(buildFollowerRuntimeDiagnostic("broker_disconnect"));
+                deps.setExtStatus(ctx, "reconnecting");
+                const uiUpdate = getFollowerReconnectUiUpdate("disconnect", wasDisconnected);
+                wasDisconnected = uiUpdate.nextWasDisconnected;
+                if (uiUpdate.notify) {
+                    ctx.ui.notify(uiUpdate.notify.message, uiUpdate.notify.level);
+                }
+            });
+            client.onReconnect(() => {
+                void (async () => {
+                    if (clientRef?.client !== client) {
+                        return;
+                    }
+                    try {
+                        await registerFollowerRuntime();
+                        deps.setRuntimeDiagnostic(null);
+                    }
+                    catch (error) {
+                        console.error(`[slack-bridge] follower reconnect registration refresh failed: ${deps.formatError(error)}`);
+                        deps.setRuntimeDiagnostic(buildFollowerRuntimeDiagnostic("registration_refresh_failure", {
+                            detail: deps.formatError(error),
+                        }));
+                        const registration = client.getRegisteredIdentity();
+                        if (registration) {
+                            deps.applyRegistrationIdentity(registration);
+                        }
+                    }
+                    await resumeThreadClaims();
+                    syncedFollowerStatus = "idle";
+                    void syncDesiredStatus(deps.getDesiredAgentStatus()).catch(() => {
+                        /* best effort */
+                    });
+                    startPolling();
+                    if (hasDeliveredFollowerInboxIds(deps.deliveryState)) {
+                        void flushDeliveredAcks();
+                    }
+                    deps.setExtStatus(ctx, "ok");
+                    const uiUpdate = getFollowerReconnectUiUpdate("reconnect", wasDisconnected);
+                    wasDisconnected = uiUpdate.nextWasDisconnected;
+                    if (uiUpdate.notify) {
+                        ctx.ui.notify(uiUpdate.notify.message, uiUpdate.notify.level);
+                    }
+                })();
+            });
+            client.onReconnectFailed((error) => {
+                if (clientRef?.client !== client) {
+                    return;
+                }
+                const reconnectError = error instanceof Error ? error : new Error(String(error));
+                deps.setRuntimeDiagnostic(buildFollowerRuntimeDiagnostic("reconnect_stopped", {
+                    detail: deps.formatError(reconnectError),
+                }));
+                void deps.handleTerminalReconnectFailure(ctx, reconnectError);
+            });
+            await resumeThreadClaims();
+            startPolling();
+            return clientRef;
+        }
+        catch (error) {
+            await client.unregister().catch(() => {
+                /* best effort */
+            });
+            client.disconnect();
+            resetFollowerRuntimeState();
+            throw error;
+        }
+    }
+    async function disconnect(_ctx, options = {}) {
+        const current = clientRef;
+        stopPolling();
+        await flushDeliveredAcks().catch(() => {
+            /* best effort */
+        });
+        let unregisterError = null;
+        if (current) {
+            if (options.releaseIdentity === false) {
+                try {
+                    current.client.disconnect();
+                }
+                catch {
+                    /* best effort */
+                }
+            }
+            else {
+                try {
+                    await current.client.disconnectGracefully();
+                }
+                catch (error) {
+                    unregisterError = deps.formatError(error);
+                }
+            }
+        }
+        resetFollowerRuntimeState();
+        return { unregisterError };
+    }
+    return {
+        connect,
+        disconnect,
+        syncDesiredStatus,
+        flushDeliveredAcks,
+        getClientRef: () => clientRef,
+    };
+}

package/dist/git-metadata.d.ts

@@ -0,0 +1,35 @@
+type ExecFileResult = {
+    stdout?: string | Buffer;
+};
+export type ExecFileAsyncLike = (file: string, args: string[], options: {
+    cwd: string;
+    encoding: "utf-8";
+}) => Promise<ExecFileResult>;
+export interface GitContext {
+    cwd: string;
+    repo: string;
+    repoRoot?: string;
+    branch?: string;
+    dirty?: boolean;
+    dirtyFileCount?: number;
+}
+export interface GitDynamicState {
+    /** Current branch, omitted when detached/unknown/not in a repo. */
+    branch?: string;
+    /** Dirty flag, omitted when `git status` could not be read. */
+    dirty?: boolean;
+    /** Number of changed/untracked entries when dirty state is known. */
+    dirtyFileCount?: number;
+    /** True when any git probe failed; callers should treat omitted values as unknown. */
+    probeFailed: boolean;
+}
+export declare function probeGitBranch(cwd?: string, runner?: ExecFileAsyncLike): Promise<string | undefined>;
+export declare function probeGitDynamic(cwd?: string, runner?: ExecFileAsyncLike): Promise<GitDynamicState>;
+export declare function probeGitContext(cwd?: string, runner?: ExecFileAsyncLike): Promise<GitContext>;
+export interface GitContextCache {
+    get(): Promise<GitContext>;
+    peek(): GitContext | null;
+    clear(): void;
+}
+export declare function createGitContextCache(loader: () => Promise<GitContext>): GitContextCache;
+export {};

package/dist/git-metadata.js

@@ -0,0 +1,88 @@
+import { execFile } from "node:child_process";
+import * as path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+async function runGitCommand(args, cwd, runner) {
+    try {
+        const result = await runner("git", args, { cwd, encoding: "utf-8" });
+        const stdout = typeof result.stdout === "string" ? result.stdout : result.stdout?.toString();
+        return { stdout, ok: true };
+    }
+    catch {
+        return { stdout: undefined, ok: false };
+    }
+}
+async function readGitTrimmed(args, cwd, runner) {
+    const { stdout, ok } = await runGitCommand(args, cwd, runner);
+    const trimmed = stdout?.trim();
+    return { value: trimmed ? trimmed : undefined, ok };
+}
+export async function probeGitBranch(cwd = process.cwd(), runner = execFileAsync) {
+    return (await readGitTrimmed(["branch", "--show-current"], cwd, runner)).value;
+}
+async function probeGitDirty(cwd, runner) {
+    const { stdout, ok } = await runGitCommand(["status", "--porcelain", "--untracked-files=normal"], cwd, runner);
+    if (!ok) {
+        return { ok: false };
+    }
+    const dirtyFileCount = (stdout ?? "")
+        .split("\n")
+        .map((line) => line.replace(/\r$/, ""))
+        .filter((line) => line.length > 0).length;
+    return { dirty: dirtyFileCount > 0, dirtyFileCount, ok: true };
+}
+export async function probeGitDynamic(cwd = process.cwd(), runner = execFileAsync) {
+    const branchProbe = await readGitTrimmed(["branch", "--show-current"], cwd, runner);
+    const dirtyProbe = await probeGitDirty(cwd, runner);
+    return {
+        ...(branchProbe.value ? { branch: branchProbe.value } : {}),
+        ...(typeof dirtyProbe.dirty === "boolean" ? { dirty: dirtyProbe.dirty } : {}),
+        ...(typeof dirtyProbe.dirtyFileCount === "number"
+            ? { dirtyFileCount: dirtyProbe.dirtyFileCount }
+            : {}),
+        probeFailed: !branchProbe.ok || !dirtyProbe.ok,
+    };
+}
+export async function probeGitContext(cwd = process.cwd(), runner = execFileAsync) {
+    const repoRoot = (await readGitTrimmed(["rev-parse", "--show-toplevel"], cwd, runner)).value;
+    const dynamic = await probeGitDynamic(cwd, runner);
+    const resolvedRepoRoot = repoRoot ?? cwd;
+    return {
+        cwd,
+        repo: path.basename(resolvedRepoRoot),
+        repoRoot,
+        ...(dynamic.branch ? { branch: dynamic.branch } : {}),
+        ...(typeof dynamic.dirty === "boolean" ? { dirty: dynamic.dirty } : {}),
+        ...(typeof dynamic.dirtyFileCount === "number"
+            ? { dirtyFileCount: dynamic.dirtyFileCount }
+            : {}),
+    };
+}
+export function createGitContextCache(loader) {
+    let cached = null;
+    let inflight = null;
+    return {
+        async get() {
+            if (cached)
+                return cached;
+            if (inflight)
+                return inflight;
+            inflight = loader()
+                .then((result) => {
+                cached = result;
+                return result;
+            })
+                .finally(() => {
+                inflight = null;
+            });
+            return inflight;
+        },
+        peek() {
+            return cached;
+        },
+        clear() {
+            cached = null;
+            inflight = null;
+        },
+    };
+}

package/dist/guardrails.d.ts

@@ -0,0 +1,69 @@
+export interface SecurityGuardrails {
+    readOnly?: boolean;
+    requireConfirmation?: string[];
+    blockedTools?: string[];
+}
+/** Well-known read-only tools that are always safe */
+export declare const READ_ONLY_TOOLS: Set<string>;
+/** Well-known write tools (used when readOnly mode is active) */
+export declare const WRITE_TOOLS: Set<string>;
+/**
+ * Match a tool name against glob patterns (supports `*` wildcard).
+ * Slack and Pinet dispatcher actions use `<namespace>:<action>` names; legacy
+ * `<namespace>_<action>` guardrail patterns still match during migration. Pinet
+ * direct tools are no longer registered, but keeping alias matching prevents old
+ * security configs from silently failing open.
+ * Returns true if the tool name matches any of the patterns.
+ */
+export declare function matchesToolPattern(toolName: string, patterns: string[]): boolean;
+/**
+ * Check if a tool is blocked by the guardrails.
+ * Returns true if:
+ * - tool matches any blockedTools pattern
+ * - guardrails.readOnly is true AND tool is in WRITE_TOOLS
+ */
+export declare function isToolBlocked(toolName: string, guardrails: SecurityGuardrails): boolean;
+/**
+ * Check if a tool needs confirmation.
+ * Returns true if tool matches any requireConfirmation pattern.
+ * Returns false if tool is already blocked (blocked takes priority).
+ */
+export declare function toolNeedsConfirmation(toolName: string, guardrails: SecurityGuardrails): boolean;
+/**
+ * Build security instructions to prepend to Slack-triggered messages.
+ * Returns a clear, structured prompt with active guardrails.
+ * Returns empty string if no guardrails are active.
+ */
+export declare function hasEffectivelyEmptyRuntimeGuardrails(guardrails: SecurityGuardrails | null | undefined): boolean;
+export declare function formatRuntimeGuardrailsPosture(guardrails: SecurityGuardrails | null | undefined): string;
+export declare function getEmptyRuntimeGuardrailsWarning(guardrails: SecurityGuardrails | null | undefined): string | null;
+export declare function buildSecurityPrompt(guardrails: SecurityGuardrails): string;
+/**
+ * Tools that the broker agent must NEVER use.
+ * The broker is infrastructure — it coordinates, not codes.
+ * Spawning local subagents (Agent) is forbidden because they
+ * have no Slack/Pinet connectivity and can't be monitored.
+ * Direct file mutation tools are also blocked so the runtime
+ * enforces the coordination-only role even if prompt guidance drifts.
+ */
+export declare const BROKER_FORBIDDEN_TOOLS: Set<string>;
+/**
+ * Check if a tool is forbidden for the broker role.
+ * Returns true if the broker must not use this tool.
+ */
+export declare function isBrokerForbiddenTool(toolName: string): boolean;
+/**
+ * Build a prompt snippet describing broker tool restrictions.
+ * Injected into the system prompt when the broker role is active.
+ */
+export declare function buildBrokerToolGuardrailsPrompt(): string;
+/**
+ * Parse whether a user message is approving a confirmation request.
+ * Case-insensitive, trimmed.
+ */
+export declare function isConfirmationApproval(text: string): boolean;
+/**
+ * Parse whether a user message is rejecting a confirmation request.
+ * Case-insensitive, trimmed.
+ */
+export declare function isConfirmationRejection(text: string): boolean;