@pinet/slack-bridge 0.2.4 → 0.2.7

package/dist/deploy-manifest.d.ts

@@ -23,10 +23,16 @@ export interface DeployResult {
     appId: string;
     scopeChanges: ManifestScopeChanges;
 }
-export declare function diffManifestScopes(beforeManifest: Record<string, unknown> | null | undefined, afterManifest: Record<string, unknown> | null | undefined): ManifestScopeChanges;
+type SlackManifestPrimitive = string | number | boolean | null;
+export type SlackManifestValue = SlackManifestPrimitive | SlackManifestObject | SlackManifestValue[];
+export interface SlackManifestObject {
+    [key: string]: SlackManifestValue;
+}
+export declare function diffManifestScopes(beforeManifest: SlackManifestObject | null | undefined, afterManifest: SlackManifestObject | null | undefined): ManifestScopeChanges;
 export declare function formatScopeChangeSummary(changes: ManifestScopeChanges): string[];
 export declare function resolveDeployConfig(settings: SlackBridgeSettings, env: NodeJS.ProcessEnv, cwd?: string): ResolvedDeployConfig;
 export declare function getDeployConfigError(config: ResolvedDeployConfig): string | null;
-export declare function applyConfiguredSlashCommands(manifest: Record<string, unknown>, settings: SlackBridgeSettings): Record<string, unknown>;
+export declare function applyConfiguredSlashCommands(manifest: SlackManifestObject, settings: SlackBridgeSettings): SlackManifestObject;
 export declare function deploySlackManifest(config: ResolvedDeployConfig): Promise<DeployResult>;
 export declare function run(): Promise<void>;
+export {};

package/dist/deploy-manifest.js

@@ -56,12 +56,14 @@ function buildSlackRequest(method, token, body) {
         },
     };
 }
-function asRecord(value) {
-    return typeof value === "object" && value !== null ? value : null;
+function asManifestObject(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
 }
 function readScopeList(manifest, scopeType) {
-    const oauthConfig = asRecord(manifest?.oauth_config);
-    const scopes = asRecord(oauthConfig?.scopes);
+    const oauthConfig = asManifestObject(manifest?.oauth_config);
+    const scopes = asManifestObject(oauthConfig?.scopes);
     const raw = scopes?.[scopeType];
     if (!Array.isArray(raw)) {
         return [];
@@ -127,9 +129,9 @@ export function getDeployConfigError(config) {
 }
 export function applyConfiguredSlashCommands(manifest, settings) {
     const commandNames = resolveSlackAgentCommandNames(settings);
-    const features = asRecord(manifest.features) ?? {};
-    const oauthConfig = asRecord(manifest.oauth_config) ?? {};
-    const scopes = asRecord(oauthConfig.scopes) ?? {};
+    const features = asManifestObject(manifest.features) ?? {};
+    const oauthConfig = asManifestObject(manifest.oauth_config) ?? {};
+    const scopes = asManifestObject(oauthConfig.scopes) ?? {};
     const botScopes = readScopeList(manifest, "bot");
     const nextBotScopes = botScopes.includes("commands") ? botScopes : [...botScopes, "commands"];
     return {

package/dist/follower-runtime.d.ts

@@ -2,6 +2,7 @@ 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 declare function resolveBrokerSocketPath(): string;
 export type BrokerClientRef = {
     client: BrokerClient;
     pollInterval: ReturnType<typeof setInterval> | null;
@@ -24,12 +25,13 @@ export interface FollowerRuntimeDeps {
     getLastDmChannel: () => string | null;
     setLastDmChannel: (channelId: string | null) => void;
     pushInboxMessages: (messages: InboxMessage[]) => void;
-    getAgentMetadata: (role: "broker" | "worker") => Promise<Record<string, unknown>>;
+    getAgentMetadata: (role: "broker" | "worker", signal?: AbortSignal) => Promise<Record<string, unknown>>;
     applyRegistrationIdentity: (registration: {
         name: string;
         emoji: string;
         metadata?: Record<string, unknown> | null;
     }) => void;
+    onRegistrationIdentityApplied: () => Promise<void>;
     persistState: () => void;
     updateBadge: () => void;
     maybeDrainInboxIfIdle: (ctx: ExtensionContext) => boolean;
@@ -37,6 +39,7 @@ export interface FollowerRuntimeDeps {
     deferControlAck: (command: PinetControlCommand, inboxId: number) => void;
     runRemoteControl: (command: PinetControlCommand, ctx: ExtensionContext) => void;
     deliverFollowUpMessage: (text: string) => boolean;
+    deliverSteeringMessage: (text: string, ctx: ExtensionContext) => boolean;
     setExtStatus: (ctx: ExtensionContext, state: "ok" | "reconnecting" | "error" | "off") => void;
     getRuntimeDiagnostic: () => FollowerRuntimeDiagnostic | null;
     setRuntimeDiagnostic: (diagnostic: FollowerRuntimeDiagnostic | null) => void;
@@ -45,7 +48,7 @@ export interface FollowerRuntimeDeps {
     deliveryState: FollowerDeliveryState;
 }
 export interface FollowerRuntime {
-    connect: (ctx: ExtensionContext) => Promise<BrokerClientRef>;
+    connect: (ctx: ExtensionContext, signal?: AbortSignal) => Promise<BrokerClientRef>;
     disconnect: (ctx: ExtensionContext, options?: {
         releaseIdentity?: boolean;
     }) => Promise<{

package/dist/follower-runtime.js

@@ -1,7 +1,7 @@
-import { buildFollowerRuntimeDiagnostic, buildPinetOwnerToken, extractPinetControlCommand, formatPinetInboxMessages, getFollowerOwnedThreadReclaims, getFollowerReconnectUiUpdate, partitionFollowerInboxEntries, resolvePinetMeshAuth, resolveRuntimeAgentIdentity, syncFollowerInboxEntries, syncTransferredSlackThreadContexts, } from "./helpers.js";
+import { buildFollowerRuntimeDiagnostic, buildPinetOwnerToken, extractPinetSteeringInboxEntry, extractPinetControlCommand, formatPinetInboxMessages, formatPinetSteeringMessage, 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 resolveBrokerSocketPath() {
+export function resolveBrokerSocketPath() {
     const envPath = process.env.PINET_SOCKET_PATH?.trim();
     return envPath && envPath.length > 0 ? envPath : DEFAULT_SOCKET_PATH;
 }
@@ -91,7 +91,8 @@ export function createFollowerRuntime(deps) {
         followerStatusSyncTarget = null;
         resetFollowerDeliveryState(deps.deliveryState);
     }
-    async function connect(ctx) {
+    async function connect(ctx, signal) {
+        signal?.throwIfAborted();
         deps.refreshSettings();
         const meshAuth = resolvePinetMeshAuth(deps.getSettings());
         const client = new BrokerClient({
@@ -99,6 +100,10 @@ export function createFollowerRuntime(deps) {
             ...(meshAuth.meshSecret ? { meshSecret: meshAuth.meshSecret } : {}),
             ...(meshAuth.meshSecretPath ? { meshSecretPath: meshAuth.meshSecretPath } : {}),
         });
+        const abortConnect = () => {
+            client.disconnect();
+        };
+        signal?.addEventListener("abort", abortConnect, { once: true });
         async function registerFollowerRuntime() {
             deps.refreshSettings();
             const settings = deps.getSettings();
@@ -107,8 +112,9 @@ export function createFollowerRuntime(deps) {
             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());
+            const registration = await client.register(hasExplicitIdentityRequest ? workerIdentity.name : "", hasExplicitIdentityRequest ? workerIdentity.emoji : "", await deps.getAgentMetadata("worker", signal), deps.getAgentStableId());
             deps.applyRegistrationIdentity(registration);
+            await deps.onRegistrationIdentityApplied();
             client.setHeartbeatMetadataProvider(() => deps.getAgentMetadata("worker"));
         }
         async function resumeThreadClaims() {
@@ -179,7 +185,29 @@ export function createFollowerRuntime(deps) {
                         }
                         return;
                     }
-                    const { nudges, agentMessages, regular } = partitionFollowerInboxEntries(remainingEntries);
+                    const steeringEntries = [];
+                    const queuedEntries = [];
+                    for (const entry of remainingEntries) {
+                        const steering = extractPinetSteeringInboxEntry(entry);
+                        if (steering) {
+                            steeringEntries.push(steering);
+                            continue;
+                        }
+                        queuedEntries.push(entry);
+                    }
+                    if (steeringEntries.length > 0) {
+                        const deliveredSteeringIds = [];
+                        for (const entry of steeringEntries) {
+                            if (deps.deliverSteeringMessage(formatPinetSteeringMessage(entry), ctx)) {
+                                deliveredSteeringIds.push(entry.inboxId);
+                            }
+                        }
+                        if (deliveredSteeringIds.length > 0) {
+                            markFollowerInboxIdsDelivered(deps.deliveryState, deliveredSteeringIds);
+                            void flushDeliveredAcks();
+                        }
+                    }
+                    const { nudges, agentMessages, regular } = partitionFollowerInboxEntries(queuedEntries);
                     if (nudges.length > 0) {
                         const nudgeText = nudges
                             .map((nudge) => nudge.message.body ?? "")
@@ -233,7 +261,9 @@ export function createFollowerRuntime(deps) {
         }
         try {
             await client.connect();
+            signal?.throwIfAborted();
             await registerFollowerRuntime();
+            signal?.throwIfAborted();
             deps.setRuntimeDiagnostic(null);
             syncedFollowerStatus = "idle";
             clientRef = {
@@ -304,6 +334,7 @@ export function createFollowerRuntime(deps) {
                 void deps.handleTerminalReconnectFailure(ctx, reconnectError);
             });
             await resumeThreadClaims();
+            signal?.throwIfAborted();
             startPolling();
             return clientRef;
         }
@@ -315,6 +346,9 @@ export function createFollowerRuntime(deps) {
             resetFollowerRuntimeState();
             throw error;
         }
+        finally {
+            signal?.removeEventListener("abort", abortConnect);
+        }
     }
     async function disconnect(_ctx, options = {}) {
         const current = clientRef;

package/dist/git-metadata.d.ts

@@ -4,6 +4,8 @@ type ExecFileResult = {
 export type ExecFileAsyncLike = (file: string, args: string[], options: {
     cwd: string;
     encoding: "utf-8";
+    timeout: number;
+    signal?: AbortSignal;
 }) => Promise<ExecFileResult>;
 export interface GitContext {
     cwd: string;
@@ -23,13 +25,7 @@ export interface GitDynamicState {
     /** 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 declare function probeGitBranch(cwd?: string, runner?: ExecFileAsyncLike, signal?: AbortSignal): Promise<string | undefined>;
+export declare function probeGitDynamic(cwd?: string, runner?: ExecFileAsyncLike, signal?: AbortSignal): Promise<GitDynamicState>;
+export declare function probeGitContext(cwd?: string, runner?: ExecFileAsyncLike, signal?: AbortSignal): Promise<GitContext>;
 export {};

package/dist/git-metadata.js

@@ -2,26 +2,34 @@ 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) {
+const GIT_PROBE_TIMEOUT_MS = 2_000;
+async function runGitCommand(args, cwd, runner, signal) {
+    signal?.throwIfAborted();
     try {
-        const result = await runner("git", args, { cwd, encoding: "utf-8" });
+        const result = await runner("git", args, {
+            cwd,
+            encoding: "utf-8",
+            timeout: GIT_PROBE_TIMEOUT_MS,
+            signal,
+        });
         const stdout = typeof result.stdout === "string" ? result.stdout : result.stdout?.toString();
         return { stdout, ok: true };
     }
     catch {
+        signal?.throwIfAborted();
         return { stdout: undefined, ok: false };
     }
 }
-async function readGitTrimmed(args, cwd, runner) {
-    const { stdout, ok } = await runGitCommand(args, cwd, runner);
+async function readGitTrimmed(args, cwd, runner, signal) {
+    const { stdout, ok } = await runGitCommand(args, cwd, runner, signal);
     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;
+export async function probeGitBranch(cwd = process.cwd(), runner = execFileAsync, signal) {
+    return (await readGitTrimmed(["branch", "--show-current"], cwd, runner, signal)).value;
 }
-async function probeGitDirty(cwd, runner) {
-    const { stdout, ok } = await runGitCommand(["status", "--porcelain", "--untracked-files=normal"], cwd, runner);
+async function probeGitDirty(cwd, runner, signal) {
+    const { stdout, ok } = await runGitCommand(["status", "--porcelain", "--untracked-files=normal"], cwd, runner, signal);
     if (!ok) {
         return { ok: false };
     }
@@ -31,9 +39,9 @@ async function probeGitDirty(cwd, runner) {
         .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);
+export async function probeGitDynamic(cwd = process.cwd(), runner = execFileAsync, signal) {
+    const branchProbe = await readGitTrimmed(["branch", "--show-current"], cwd, runner, signal);
+    const dirtyProbe = await probeGitDirty(cwd, runner, signal);
     return {
         ...(branchProbe.value ? { branch: branchProbe.value } : {}),
         ...(typeof dirtyProbe.dirty === "boolean" ? { dirty: dirtyProbe.dirty } : {}),
@@ -43,9 +51,10 @@ export async function probeGitDynamic(cwd = process.cwd(), runner = execFileAsyn
         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);
+export async function probeGitContext(cwd = process.cwd(), runner = execFileAsync, signal) {
+    const repoRoot = (await readGitTrimmed(["rev-parse", "--show-toplevel"], cwd, runner, signal))
+        .value;
+    const dynamic = await probeGitDynamic(cwd, runner, signal);
     const resolvedRepoRoot = repoRoot ?? cwd;
     return {
         cwd,
@@ -58,31 +67,3 @@ export async function probeGitContext(cwd = process.cwd(), runner = execFileAsyn
             : {}),
     };
 }
-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.js

@@ -14,6 +14,7 @@ export const READ_ONLY_TOOLS = new Set([
     "slack:canvas_comments_read",
     "slack:confirm_action",
     "pinet:agents",
+    "pinet:lanes",
     "pinet:read",
     "memory_read",
     "memory_search",
@@ -47,10 +48,14 @@ export const WRITE_TOOLS = new Set([
     "pinet:schedule",
     "pinet:send",
     "pinet:snooze",
+    "pinet:spawn",
+    "pinet:lanes:write",
     "pinet:free",
     "pinet:ports",
     "pinet:reload",
     "pinet:exit",
+    "pinet:hibernate",
+    "pinet:wake",
 ]);
 /**
  * Match a tool name against glob patterns (supports `*` wildcard).

package/dist/helpers.d.ts

@@ -1,4 +1,5 @@
 import { type RuntimeScopeCarrier } from "@pinet/transport-core";
+import { createAbortError, isAbortError } from "@pinet/transport-core/async";
 import type { ReactionCommandSettings } from "./reaction-triggers.js";
 import type { AgentSessionSummary } from "./broker/types.js";
 export interface SlackIngressGuardSettings {
@@ -29,6 +30,8 @@ export interface SlackBridgeSettings {
     }[];
     reactionCommands?: ReactionCommandSettings;
     runtimeMode?: "off" | "single" | "broker" | "follower";
+    /** Runtime backend for newly spawned subtree workers. Defaults to tmux. */
+    subtreeWorkerRuntime?: "tmux" | "herdr";
     brokerPrompt?: string;
     autoConnect?: boolean;
     autoFollow?: boolean;
@@ -42,6 +45,18 @@ export interface SlackBridgeSettings {
     agentEmoji?: string;
     meshSecret?: string;
     meshSecretPath?: string;
+    hibernation?: {
+        /** Master kill switch. Defaults false; waking/draining existing rows remains permitted. */
+        enabled?: boolean;
+        mode?: "observe" | "manual" | "auto";
+        allowedRepos?: string[];
+        graceMs?: number;
+        idleDebounceMs?: number;
+        handshakeTimeoutMs?: number;
+        wakeLeaseMs?: number;
+        maxConcurrentWakes?: number;
+        maxConcurrentWakesPerRepo?: number;
+    };
     imessage?: {
         enabled?: boolean;
     };
@@ -71,6 +86,7 @@ export declare function describeSlackUserAccess(allowlist: Set<string> | null, o
 }): string;
 export declare function getSlackUserAccessWarning(allowlist: Set<string> | null): string | null;
 export declare function isUserAllowed(allowlist: Set<string> | null, userId: string): boolean;
+export type InboxMessageMetadata = Record<string, unknown>;
 export interface InboxMessage {
     channel: string;
     threadTs: string;
@@ -79,7 +95,8 @@ export interface InboxMessage {
     timestamp: string;
     isChannelMention?: boolean;
     brokerInboxId?: number;
-    metadata?: Record<string, unknown> | null;
+    brokerInboxOrigin?: "subtree";
+    metadata?: InboxMessageMetadata | null;
     scope?: RuntimeScopeCarrier | null;
 }
 export interface SqliteJournalModeResult {
@@ -120,36 +137,62 @@ export interface PinetRuntimeReloader<State> {
     startRuntime: (role: "broker" | "follower") => Promise<void>;
 }
 export declare function reloadPinetRuntimeSafely<State>(reloader: PinetRuntimeReloader<State>): Promise<void>;
-export interface PinetControlEnvelope {
+export declare function reloadPinetRuntimeInPlaceSafely<State>(input: {
+    snapshotState: () => State;
+    restoreState: (snapshot: State) => void;
+    refreshState: () => void;
+    validateRefreshedState: () => void | Promise<void>;
+    reloadRuntime: () => Promise<void>;
+}): Promise<void>;
+export type PinetControlMetadata = Record<string, unknown>;
+export interface PinetControlEnvelope extends PinetControlMetadata {
     type: "pinet:control";
     action: PinetControlCommand;
 }
 export declare function getPinetControlCommandFromText(text: string | undefined): PinetControlCommand | null;
 export declare function buildPinetControlMetadata(command: PinetControlCommand): PinetControlEnvelope;
 export declare function buildPinetControlMessage(command: PinetControlCommand): string;
-export declare function normalizeOutgoingPinetControlMessage(body: string, metadata?: Record<string, unknown>): {
+export declare function normalizeOutgoingPinetControlMessage(body: string, metadata?: PinetControlMetadata): {
+    body: string;
+    metadata: PinetControlMetadata;
+} | null;
+export interface PinetSteeringEnvelope extends PinetControlMetadata {
+    type: "pinet:steer";
+    message: string;
+}
+export declare function getPinetSteeringMessageFromText(text: string | undefined): string | null;
+export declare function buildPinetSteeringMetadata(message: string): PinetSteeringEnvelope;
+export declare function buildPinetSteeringMessage(message: string): string;
+export declare function normalizeOutgoingPinetSteeringMessage(body: string, metadata?: PinetControlMetadata): {
     body: string;
-    metadata: Record<string, unknown>;
+    metadata: PinetControlMetadata;
 } | null;
 export type PinetSkinStatusKey = "idle" | "working" | "healthy" | "stale" | "ghost" | "resumable";
 export type PinetSkinStatusVocabulary = Partial<Record<PinetSkinStatusKey, string>>;
-export declare function extractPinetControlCommand(message: {
+export interface PinetControlCommandMessage {
+    threadId?: string;
+    body?: string;
+    metadata?: PinetControlMetadata | null;
+}
+export declare function extractPinetControlCommand(message: PinetControlCommandMessage): PinetControlCommand | null;
+export declare function extractPinetSteeringMessage(message: {
     threadId?: string;
     body?: string;
-    metadata?: Record<string, unknown> | null;
-}): PinetControlCommand | null;
+    metadata?: PinetControlMetadata | null;
+}): string | null;
 export declare const FORM_METHODS: Set<string>;
-export declare function buildSlackRequest(method: string, token: string, body?: Record<string, unknown>): {
+export type SlackRequestBody = Record<string, unknown>;
+export interface SlackApiRequest {
     url: string;
     init: RequestInit;
-};
+}
+export declare function buildSlackRequest(method: string, token: string, body?: SlackRequestBody): SlackApiRequest;
 export interface AbortableOperationTracker {
     run<T>(operation: (signal: AbortSignal) => Promise<T>): Promise<T>;
     abortAndWait(): Promise<void>;
     isAborting(): boolean;
 }
-export declare function createAbortError(message?: string): Error;
-export declare function isAbortError(error: unknown): boolean;
+export { createAbortError, isAbortError };
 export declare function abortableDelay(ms: number, signal: AbortSignal): Promise<void>;
 export declare function createAbortableOperationTracker(): AbortableOperationTracker;
 export declare function stripBotMention(text: string, botUserId: string): string;
@@ -220,6 +263,7 @@ export interface AgentDisplayInfo {
     routingScore?: number;
     routingReasons?: string[];
 }
+export type AgentVisibilityMetadata = Record<string, unknown>;
 export interface AgentVisibilityInput {
     emoji: string;
     name: string;
@@ -228,7 +272,7 @@ export interface AgentVisibilityInput {
     stableId?: string | null;
     session?: AgentSessionSummary | null;
     status: "working" | "idle";
-    metadata?: Record<string, unknown> | null;
+    metadata?: AgentVisibilityMetadata | null;
     lastHeartbeat?: string;
     lastSeen?: string;
     disconnectedAt?: string | null;
@@ -257,7 +301,7 @@ export interface AgentRoutingHint {
     task?: string;
 }
 export declare function shortenPath(p: string, homedir: string): string;
-export declare function extractAgentCapabilities(metadata: Record<string, unknown> | null | undefined): AgentCapabilities;
+export declare function extractAgentCapabilities(metadata: AgentVisibilityMetadata | null | undefined): AgentCapabilities;
 export declare function buildAgentCapabilityTags(capabilities: AgentCapabilities): string[];
 export interface MeshVisibilityOptions {
     includeGhosts?: boolean;
@@ -379,6 +423,7 @@ export interface FollowerThreadState {
     source?: string;
     owner?: string;
 }
+export type FollowerInboxMessageMetadata = Record<string, unknown>;
 export interface FollowerInboxEntry {
     inboxId?: number;
     message: {
@@ -387,7 +432,7 @@ export interface FollowerInboxEntry {
         sender?: string;
         body?: string;
         createdAt?: string;
-        metadata: Record<string, unknown> | null;
+        metadata: FollowerInboxMessageMetadata | null;
     };
 }
 export interface FollowerInboxSyncResult {
@@ -404,13 +449,21 @@ export interface BrokerInboxControlEntry {
     inboxId: number;
     command: PinetControlCommand;
 }
+export interface PinetSteeringInboxEntry {
+    inboxId: number;
+    message: FollowerInboxEntry["message"];
+    steeringText: string;
+}
 export interface BrokerInboxSyncResult {
     controlEntries: BrokerInboxControlEntry[];
+    steeringEntries: PinetSteeringInboxEntry[];
     inboxMessages: InboxMessage[];
 }
 export declare function isDirectMessageChannel(channel: string): boolean;
 export declare function syncTransferredSlackThreadContexts(entries: FollowerInboxEntry[], existingThreads: ReadonlyMap<string, FollowerThreadState>, agentOwner: string): TransferredSlackThreadSyncResult;
 export declare function syncFollowerInboxEntries(entries: FollowerInboxEntry[], existingThreads: ReadonlyMap<string, FollowerThreadState>, agentOwner: string, lastDmChannel: string | null): FollowerInboxSyncResult;
+export declare function extractPinetSteeringInboxEntry(entry: FollowerInboxEntry): PinetSteeringInboxEntry | null;
+export declare function formatPinetSteeringMessage(entry: PinetSteeringInboxEntry): string;
 export declare function syncBrokerInboxEntries(entries: FollowerInboxEntry[]): BrokerInboxSyncResult;
 export interface FollowerThreadChannelResolution {
     channelId: string | null;
@@ -542,24 +595,21 @@ export interface CallSlackAPIOptions {
     signal?: AbortSignal;
     retryCount?: number;
 }
-export declare function callSlackAPI(method: string, token: string, body?: Record<string, unknown>, options?: CallSlackAPIOptions): Promise<SlackResult>;
-export declare function isRalphNudgeEntry(entry: {
+export declare function callSlackAPI(method: string, token: string, body?: SlackRequestBody, options?: CallSlackAPIOptions): Promise<SlackResult>;
+interface FollowerInboxMetadataEntry {
     message: {
-        metadata?: Record<string, unknown> | null;
+        metadata?: FollowerInboxMessageMetadata | null;
     };
-}): boolean;
-export declare function isAgentToAgentEntry(entry: {
-    message: {
-        threadId?: string;
-        metadata?: Record<string, unknown> | null;
-    };
-}): boolean;
-export declare function partitionFollowerInboxEntries<T extends {
+}
+interface FollowerInboxPartitionEntry extends FollowerInboxMetadataEntry {
     message: {
         threadId?: string;
-        metadata?: Record<string, unknown> | null;
+        metadata?: FollowerInboxMessageMetadata | null;
     };
-}>(entries: T[]): {
+}
+export declare function isRalphNudgeEntry(entry: FollowerInboxMetadataEntry): boolean;
+export declare function isAgentToAgentEntry(entry: FollowerInboxPartitionEntry): boolean;
+export declare function partitionFollowerInboxEntries<T extends FollowerInboxPartitionEntry>(entries: T[]): {
     nudges: T[];
     agentMessages: T[];
     regular: T[];