@pinet/slack-bridge 0.2.4 → 0.2.7

package/dist/helpers.js

@@ -3,6 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { classifyPinetMail, formatPinetMailClassLabel, } from "@pinet/broker-core/mail-classification";
 import { buildCompatibilityInstanceScope, buildCompatibilityWorkspaceScope, buildRuntimeScopeCarrier, } from "@pinet/transport-core";
+import { createAbortError, isAbortError, sleep } from "@pinet/transport-core/async";
 import { buildPinetReadPointer } from "./broker-inbound-persistence.js";
 import { matchesToolPattern } from "./guardrails.js";
 import { getPinetSessionPath, summarizePinetStableId } from "./pinet-session-formatting.js";
@@ -421,6 +422,33 @@ export async function reloadPinetRuntimeSafely(reloader) {
         throw new Error(`Reload failed: ${reloadMessage}. Restored the previous runtime.`);
     }
 }
+export async function reloadPinetRuntimeInPlaceSafely(input) {
+    const snapshot = input.snapshotState();
+    try {
+        input.refreshState();
+        await input.validateRefreshedState();
+    }
+    catch (validationErr) {
+        input.restoreState(snapshot);
+        throw validationErr;
+    }
+    try {
+        await input.reloadRuntime();
+    }
+    catch (reloadErr) {
+        input.restoreState(snapshot);
+        try {
+            await input.reloadRuntime();
+        }
+        catch (rollbackErr) {
+            const reloadMessage = reloadErr instanceof Error ? reloadErr.message : String(reloadErr);
+            const rollbackMessage = rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr);
+            throw new Error(`Reload failed: ${reloadMessage}. Rollback to the previous runtime also failed: ${rollbackMessage}`);
+        }
+        const reloadMessage = reloadErr instanceof Error ? reloadErr.message : String(reloadErr);
+        throw new Error(`Reload failed: ${reloadMessage}. Restored the previous runtime.`);
+    }
+}
 function parsePinetControlEnvelope(value) {
     if (typeof value !== "object" || value === null)
         return null;
@@ -471,6 +499,62 @@ export function normalizeOutgoingPinetControlMessage(body, metadata) {
         },
     };
 }
+function normalizePinetSteeringText(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function parsePinetSteeringEnvelope(value) {
+    if (typeof value !== "object" || value === null)
+        return null;
+    const record = value;
+    if (record.type !== "pinet:steer")
+        return null;
+    return (normalizePinetSteeringText(record.message) ??
+        normalizePinetSteeringText(record.text) ??
+        normalizePinetSteeringText(record.body));
+}
+function parseStructuredPinetSteeringMessageFromText(text) {
+    const trimmed = text?.trim();
+    if (!trimmed)
+        return null;
+    try {
+        return parsePinetSteeringEnvelope(JSON.parse(trimmed));
+    }
+    catch {
+        return null;
+    }
+}
+function parseLegacyPinetSteeringMessageFromText(text) {
+    const trimmed = text?.trim();
+    if (!trimmed?.startsWith("/steer"))
+        return null;
+    const nextChar = trimmed.charAt("/steer".length);
+    if (nextChar && !/\s/.test(nextChar))
+        return null;
+    return normalizePinetSteeringText(trimmed.slice("/steer".length));
+}
+export function getPinetSteeringMessageFromText(text) {
+    return (parseStructuredPinetSteeringMessageFromText(text) ??
+        parseLegacyPinetSteeringMessageFromText(text));
+}
+export function buildPinetSteeringMetadata(message) {
+    return { type: "pinet:steer", message };
+}
+export function buildPinetSteeringMessage(message) {
+    return JSON.stringify(buildPinetSteeringMetadata(message));
+}
+export function normalizeOutgoingPinetSteeringMessage(body, metadata) {
+    const message = getPinetSteeringMessageFromText(body);
+    if (!message)
+        return null;
+    return {
+        body: buildPinetSteeringMessage(message),
+        metadata: {
+            ...(metadata ?? {}),
+            ...buildPinetSteeringMetadata(message),
+            kind: "pinet_steer",
+        },
+    };
+}
 function extractPinetSkinStatusVocabulary(value) {
     const record = asRecord(value);
     if (!record)
@@ -503,6 +587,23 @@ export function extractPinetControlCommand(message) {
     // Backward-compatible fallback for structured JSON or exact slash commands sent over a2a flows.
     return getPinetControlCommandFromText(message.body);
 }
+export function extractPinetSteeringMessage(message) {
+    const metadata = message.metadata ?? {};
+    if (metadata.scheduledWakeup === true)
+        return null;
+    const metadataMessage = parsePinetSteeringEnvelope(metadata) ??
+        (metadata.kind === "pinet_steer" || metadata.kind === "pinet_steering"
+            ? (normalizePinetSteeringText(metadata.message) ??
+                normalizePinetSteeringText(metadata.text) ??
+                normalizePinetSteeringText(metadata.body))
+            : null);
+    if (metadataMessage)
+        return metadataMessage;
+    if (metadata.reactionTrigger === true && metadata.reactionAction === "steer") {
+        return normalizePinetSteeringText(message.body);
+    }
+    return getPinetSteeringMessageFromText(message.body);
+}
 // ─── Slack API encoding ──────────────────────────────────
 export const FORM_METHODS = new Set([
     "auth.test",
@@ -549,30 +650,9 @@ export function buildSlackRequest(method, token, body) {
         },
     };
 }
-export function createAbortError(message = "Operation aborted") {
-    const error = new Error(message);
-    error.name = "AbortError";
-    return error;
-}
-export function isAbortError(error) {
-    return error instanceof Error && error.name === "AbortError";
-}
+export { createAbortError, isAbortError };
 export function abortableDelay(ms, signal) {
-    if (signal.aborted) {
-        return Promise.reject(createAbortError());
-    }
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            signal.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        function onAbort() {
-            clearTimeout(timer);
-            signal.removeEventListener("abort", onAbort);
-            reject(createAbortError());
-        }
-        signal.addEventListener("abort", onAbort, { once: true });
-    });
+    return sleep(ms, { signal });
 }
 export function createAbortableOperationTracker() {
     let aborting = false;
@@ -1266,8 +1346,8 @@ export function buildWorkerPromptGuidelines() {
         "- In PM mode, remain accountable: nominate an implementation lead, delegate implementation, coordinate blockers/status, act as second-pass reviewer, and coordinate merge readiness.",
         "- Before delegating through Pinet, call `pinet action=agents` with the target repo to find a suitable connected worker in the same repo/worktree, then delegate via `pinet action=send`.",
         "- Keep delegation inside the Pinet or Slack thread so ACKs, blockers, status updates, and final results flow back to the original sender.",
-        "- Do not start or delegate extension changes unless the request names a GitHub issue/PR with clear maintainer priority/approval; if missing or unclear, ask first.",
-        "- When delegating, include the workflow (`ack/work/ask/report`), the task, issue/PR numbers, maintainer approval, repo/branch/worktree setup, important files, acceptance criteria, and where to reply.",
+        "- For work in `gugu91/pinet`, do not start or delegate changes unless the request names a GitHub issue/PR with clear maintainer priority/approval; if missing or unclear, ask first. This gate is specific to `gugu91/pinet`; unrelated repositories, including `tmustier/pi-extensions`, follow their own instructions and normal requester authority.",
+        "- When delegating, include the workflow (`ack/work/ask/report`), the task, repo/branch/worktree setup, important files, acceptance criteria, where to reply, and any issue/PR numbers or maintainer approval required by the target repository's instructions.",
         "- Use `pinet action=lanes` to keep PM-mode or complex coordination lane metadata durable when the broker asks you to track lane state/roles.",
     ];
 }
@@ -1517,8 +1597,39 @@ export function syncFollowerInboxEntries(entries, existingThreads, agentOwner, l
         changed,
     };
 }
+export function extractPinetSteeringInboxEntry(entry) {
+    if (entry.inboxId == null)
+        return null;
+    const steeringText = extractPinetSteeringMessage({
+        threadId: entry.message.threadId,
+        body: entry.message.body,
+        metadata: entry.message.metadata,
+    });
+    if (!steeringText)
+        return null;
+    return {
+        inboxId: entry.inboxId,
+        message: entry.message,
+        steeringText,
+    };
+}
+export function formatPinetSteeringMessage(entry) {
+    const threadTs = entry.message.threadId ?? "";
+    const sender = getPinetSenderLabel(entry.message);
+    const transferSuffix = formatPinetThreadTransferSuffix(entry);
+    const pointer = formatPinetInboxPointer(entry);
+    return [
+        "Pinet steering message:",
+        `[thread ${threadTs}] ${sender}: inbox_id=${entry.inboxId}${transferSuffix} ${pointer}`,
+        "",
+        entry.steeringText,
+        "",
+        "This message was sent with explicit steering semantics. Incorporate it now, even if it interrupts the active turn. Reply via pinet action=send when needed.",
+    ].join("\n");
+}
 export function syncBrokerInboxEntries(entries) {
     const controlEntries = [];
+    const steeringEntries = [];
     const inboxMessages = [];
     for (const entry of entries) {
         const meta = entry.message.metadata ?? {};
@@ -1536,6 +1647,11 @@ export function syncBrokerInboxEntries(entries) {
             controlEntries.push({ inboxId, command: control });
             continue;
         }
+        const steering = extractPinetSteeringInboxEntry(entry);
+        if (steering) {
+            steeringEntries.push(steering);
+            continue;
+        }
         const scope = extractRuntimeScopeCarrier(meta.scope);
         inboxMessages.push({
             channel: "",
@@ -1550,6 +1666,7 @@ export function syncBrokerInboxEntries(entries) {
     }
     return {
         controlEntries,
+        steeringEntries,
         inboxMessages,
     };
 }
@@ -2030,7 +2147,7 @@ const MAX_PINET_SKIN_PERSONALITY_LENGTH = 260;
 const MAX_PINET_SKIN_PROMPT_GUIDELINE_LENGTH = 460;
 const PINET_BUILT_IN_SKIN_FILES = ["foundation", "cosmere"];
 let cachedBuiltInPinetSkinDescriptors = null;
-function isRecord(value) {
+function isPinetSkinObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readStringProperty(value, key) {
@@ -2055,13 +2172,13 @@ function validatePinetSkinTheme(value) {
     return null;
 }
 function validatePinetSkinStatusVocabulary(value) {
-    if (!isRecord(value)) {
+    if (!isPinetSkinObject(value)) {
         return null;
     }
     return extractPinetSkinStatusVocabulary(value) ?? {};
 }
 function validateBuiltInPinetSkinCharacter(id, value) {
-    if (!isRecord(value)) {
+    if (!isPinetSkinObject(value)) {
         return null;
     }
     const name = readStringProperty(value, "name");
@@ -2075,7 +2192,7 @@ function validateBuiltInPinetSkinCharacter(id, value) {
     return { id, name, ...(aliases.length > 0 ? { aliases } : {}), emoji, persona, style };
 }
 function validateBuiltInPinetSkinRoleDescriptor(value) {
-    if (!isRecord(value)) {
+    if (!isPinetSkinObject(value)) {
         return null;
     }
     const characterPool = readStringArrayProperty(value, "characterPool");
@@ -2093,7 +2210,7 @@ function validateBuiltInPinetSkinRoleDescriptor(value) {
     };
 }
 function validateBuiltInPinetSkinDescriptor(value) {
-    if (!isRecord(value)) {
+    if (!isPinetSkinObject(value)) {
         throw new Error("Pinet skin descriptor must be an object.");
     }
     const keyValue = readStringProperty(value, "key");
@@ -2105,7 +2222,7 @@ function validateBuiltInPinetSkinDescriptor(value) {
     if (!key || !aliases || !displayName || !intent || !statusVocabulary) {
         throw new Error("Pinet skin descriptor is missing required top-level fields.");
     }
-    if (!isRecord(value.roles)) {
+    if (!isPinetSkinObject(value.roles)) {
         throw new Error(`Pinet skin descriptor ${key} must define roles.`);
     }
     const brokerRole = validateBuiltInPinetSkinRoleDescriptor(value.roles.broker);
@@ -2113,7 +2230,7 @@ function validateBuiltInPinetSkinDescriptor(value) {
     if (!brokerRole || !workerRole) {
         throw new Error(`Pinet skin descriptor ${key} must define broker and worker roles.`);
     }
-    if (!isRecord(value.characters)) {
+    if (!isPinetSkinObject(value.characters)) {
         throw new Error(`Pinet skin descriptor ${key} must define characters.`);
     }
     const characters = {};
@@ -2704,12 +2821,7 @@ export async function callSlackAPI(method, token, body, options = {}) {
             throw new Error(`Slack ${method}: rate limited after ${maxRetries} retries`);
         }
         const wait = Number(res.headers.get("retry-after") ?? "3");
-        if (signal) {
-            await abortableDelay(wait * 1000, signal);
-        }
-        else {
-            await new Promise((resolve) => setTimeout(resolve, wait * 1000));
-        }
+        await sleep(wait * 1000, { signal });
         return callSlackAPI(method, token, body, { signal, retryCount: retryCount + 1 });
     }
     const data = (await res.json());
@@ -2718,7 +2830,6 @@ export async function callSlackAPI(method, token, body, options = {}) {
     }
     return data;
 }
-// ─── Follower inbox partitioning (#102, #175) ───────────
 export function isRalphNudgeEntry(entry) {
     return entry.message.metadata?.kind === "ralph_loop_nudge";
 }

package/dist/hibernation-config.d.ts

@@ -0,0 +1,13 @@
+import type { SlackBridgeSettings } from "./helpers.js";
+export interface ResolvedHibernationSettings {
+    enabled: boolean;
+    mode: "observe" | "manual" | "auto";
+    allowedRepos: string[];
+    graceMs: number;
+    idleDebounceMs: number;
+    handshakeTimeoutMs: number;
+    wakeLeaseMs: number;
+    maxConcurrentWakes: number;
+    maxConcurrentWakesPerRepo: number;
+}
+export declare function resolveHibernationSettings(settings: Pick<SlackBridgeSettings, "hibernation">): ResolvedHibernationSettings;

package/dist/hibernation-config.js

@@ -0,0 +1,14 @@
+export function resolveHibernationSettings(settings) {
+    const value = settings.hibernation;
+    return {
+        enabled: value?.enabled === true,
+        mode: value?.mode ?? "observe",
+        allowedRepos: [...(value?.allowedRepos ?? [])],
+        graceMs: value?.graceMs ?? 60 * 60_000,
+        idleDebounceMs: value?.idleDebounceMs ?? 2 * 60_000,
+        handshakeTimeoutMs: value?.handshakeTimeoutMs ?? 30_000,
+        wakeLeaseMs: value?.wakeLeaseMs ?? 90_000,
+        maxConcurrentWakes: value?.maxConcurrentWakes ?? 2,
+        maxConcurrentWakesPerRepo: value?.maxConcurrentWakesPerRepo ?? 1,
+    };
+}

package/dist/home-tab.d.ts

@@ -1,12 +1,23 @@
 import type { BrokerControlPlaneDashboardSnapshot } from "./broker/control-plane-dashboard.js";
 import type { SlackBridgeRuntimeMode } from "./runtime-mode.js";
 export type SlackBlock = Record<string, unknown>;
+export type SlackSectionAccessory = Record<string, unknown>;
+export type SlackHomeTabPublishResponse = Record<string, unknown>;
+export interface SlackTextObject extends Record<string, unknown> {
+    type: "plain_text" | "mrkdwn";
+    text: string;
+    emoji?: boolean;
+}
 export interface SlackHomeView {
     type: "home";
     blocks: SlackBlock[];
 }
+export interface SlackHomeTabPublishRequest extends Record<string, unknown> {
+    user_id: string;
+    view: SlackHomeView;
+}
 export interface PublishSlackHomeTabInput {
-    slack: (method: string, token: string, body?: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    slack: (method: string, token: string, body?: SlackHomeTabPublishRequest) => Promise<SlackHomeTabPublishResponse>;
     token: string;
     userId: string;
     view: SlackHomeView;
@@ -23,5 +34,5 @@ export interface StandalonePinetHomeTabInput {
 }
 export declare function renderBrokerControlPlaneHomeTabView(snapshot: BrokerControlPlaneDashboardSnapshot): SlackHomeView;
 export declare function renderStandalonePinetHomeTabView(input: StandalonePinetHomeTabInput): SlackHomeView;
-export declare function buildSlackHomeTabPublishRequest(userId: string, view: SlackHomeView): Record<string, unknown>;
+export declare function buildSlackHomeTabPublishRequest(userId: string, view: SlackHomeView): SlackHomeTabPublishRequest;
 export declare function publishSlackHomeTab(input: PublishSlackHomeTabInput): Promise<void>;

package/dist/imessage-tools.d.ts

@@ -1,6 +1,9 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { NormalizedMessageContent } from "@pinet/transport-core";
 import type { Broker } from "./broker/index.js";
+export interface IMessageToolMetadata extends Record<string, unknown> {
+    recipient: string;
+}
 export interface IMessageToolSendInput {
     threadId: string;
     body: string;
@@ -10,7 +13,7 @@ export interface IMessageToolSendInput {
     agentName: string;
     agentEmoji: string;
     agentOwnerToken: string;
-    metadata: Record<string, unknown>;
+    metadata: IMessageToolMetadata;
 }
 export interface IMessageToolSendResult {
     adapter: string;

package/dist/inbox-drain-runtime.d.ts

@@ -19,6 +19,7 @@ export interface InboxDrainRuntimeDeps {
     hasFollowerClient: () => boolean;
     flushFollowerDeliveredAcks: () => Promise<void>;
     markBrokerInboxIdsDelivered: (inboxIds: number[]) => void;
+    markSubtreeInboxIdsDelivered: (inboxIds: number[]) => void;
     getFollowerDeliveryState: () => FollowerDeliveryState;
     maxMessagesPerDrain?: number;
 }

package/dist/inbox-drain-runtime.js

@@ -1,4 +1,4 @@
-import { getBrokerInboxIds } from "./broker-delivery.js";
+import { getBrokerInboxIds, getSubtreeInboxIds } from "./broker-delivery.js";
 import { markFollowerInboxIdsDelivered } from "./follower-delivery.js";
 import { formatInboxMessages } from "./helpers.js";
 const DEFAULT_MAX_MESSAGES_PER_DRAIN = 5;
@@ -31,6 +31,7 @@ export function createInboxDrainRuntime(deps) {
             return;
         }
         const brokerInboxIds = getBrokerInboxIds(pending);
+        const subtreeInboxIds = getSubtreeInboxIds(pending);
         deps.updateBadge();
         void deps.reportStatus("working").catch(() => {
             /* best effort */
@@ -58,6 +59,9 @@ export function createInboxDrainRuntime(deps) {
                     }
                 }
             }
+            if (subtreeInboxIds.length > 0) {
+                deps.markSubtreeInboxIdsDelivered(subtreeInboxIds);
+            }
             return;
         }
         deps.restoreInboxMessages(pending);