@pinet/slack-bridge 0.2.1 → 0.2.4

package/dist/pinet-session-formatting.js

@@ -0,0 +1,80 @@
+import * as crypto from "node:crypto";
+import * as path from "node:path";
+function stableIdDigest(stableId) {
+    return crypto.createHash("sha256").update(stableId).digest("hex").slice(0, 12);
+}
+export function parsePinetStableId(stableId) {
+    const value = stableId?.trim();
+    if (!value)
+        return null;
+    const firstColon = value.indexOf(":");
+    const secondColon = firstColon >= 0 ? value.indexOf(":", firstColon + 1) : -1;
+    if (firstColon < 0 || secondColon < 0) {
+        return { host: null, kind: "unknown", locator: value, hasPath: false };
+    }
+    const host = value.slice(0, firstColon) || null;
+    const rawKind = value.slice(firstColon + 1, secondColon);
+    const locator = value.slice(secondColon + 1);
+    const kind = rawKind === "session" || rawKind === "leaf" || rawKind === "cwd" || rawKind === "broker"
+        ? rawKind
+        : "unknown";
+    return {
+        host,
+        kind,
+        locator,
+        hasPath: locator.startsWith("/") && (kind === "session" || kind === "cwd" || kind === "broker"),
+    };
+}
+export function summarizePinetStableId(stableId) {
+    const value = stableId?.trim();
+    if (!value)
+        return null;
+    const parsed = parsePinetStableId(value);
+    const kind = parsed?.kind ?? "unknown";
+    return {
+        kind,
+        ref: `${kind}:${stableIdDigest(value)}`,
+        host: parsed?.host ?? null,
+        hasPath: parsed?.hasPath ?? false,
+    };
+}
+export function getPinetSessionPath(stableId) {
+    const parsed = parsePinetStableId(stableId);
+    if (!parsed?.hasPath)
+        return null;
+    return parsed.locator;
+}
+export function getPinetSessionFilename(stableId) {
+    const sessionPath = getPinetSessionPath(stableId);
+    return sessionPath ? path.basename(sessionPath) : null;
+}
+export function buildPinetSessionFullDetails(session) {
+    const summary = summarizePinetStableId(session.stableId);
+    const sessionPath = getPinetSessionPath(session.stableId);
+    return {
+        ...session,
+        session: summary,
+        ...(sessionPath ? { jsonlPath: sessionPath } : {}),
+    };
+}
+export function buildPinetSessionCompactDetails(session) {
+    const summary = summarizePinetStableId(session.stableId);
+    return {
+        agentId: session.agentId,
+        agentName: session.agentName,
+        emoji: session.emoji,
+        pid: session.pid,
+        status: session.status,
+        health: session.disconnectedAt ? "disconnected" : "live",
+        session: summary?.ref ?? null,
+        sessionKind: summary?.kind ?? null,
+        host: summary?.host ?? null,
+        repo: session.repo,
+        branch: session.branch,
+        tmuxSession: session.tmuxSession,
+        lastSeen: session.lastSeen,
+        disconnectedAt: session.disconnectedAt,
+        relatedThreadIds: session.relatedThreadIds.slice(0, 5),
+        matchedBy: session.matchedBy,
+    };
+}

package/dist/pinet-tools.d.ts

@@ -1,12 +1,14 @@
 import { type PinetReadOptions, type PinetReadResult } from "@pinet/pinet-core/pinet-read-formatting";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { RalphSnoozeStatus } from "./ralph-loop.js";
-import type { PortLeaseAcquireInput, PortLeaseInfo, PortLeaseListOptions, PortLeaseReleaseInput, PortLeaseRenewInput, PinetLaneInfo, PinetLaneListOptions, PinetLaneParticipantInfo, PinetLaneParticipantUpsertInput, PinetLaneUpsertInput } from "./broker/types.js";
+import type { AgentSessionSearchInfo, AgentSessionSearchOptions, AgentSessionSummary, PortLeaseAcquireInput, PortLeaseInfo, PortLeaseListOptions, PortLeaseReleaseInput, PortLeaseRenewInput, PinetLaneInfo, PinetLaneListOptions, PinetLaneParticipantInfo, PinetLaneParticipantUpsertInput, PinetLaneUpsertInput } from "./broker/types.js";
 export interface PinetToolsAgentRecord {
     emoji: string;
     name: string;
     id: string;
     pid?: number;
+    stableId?: string | null;
+    session?: AgentSessionSummary | null;
     status: "working" | "idle";
     metadata: Record<string, unknown> | null;
     lastHeartbeat: string;
@@ -76,6 +78,7 @@ export interface RegisterPinetToolsDeps {
     readPinetInbox: (options: PinetReadOptions) => Promise<PinetReadResult>;
     listBrokerAgents: () => PinetToolsAgentRecord[];
     listFollowerAgents: (includeGhosts: boolean) => Promise<PinetToolsAgentRecord[]>;
+    searchPinetSessions: (options: AgentSessionSearchOptions) => Promise<AgentSessionSearchInfo[]>;
     listSubtreeAgents?: (includeGhosts: boolean) => PinetToolsAgentRecord[] | null;
     getSubtreeSelfAgentId?: () => string | null;
     spawnSubtreeWorker?: (input: PinetSubtreeSpawnInput) => Promise<PinetSubtreeSpawnResult>;

package/dist/pinet-tools.js

@@ -8,6 +8,7 @@ import { buildAgentDisplayInfo, filterAgentsForMeshVisibility, formatAgentList,
 import { isBroadcastChannelTarget } from "./broker/agent-messaging.js";
 import { DEFAULT_HEARTBEAT_TIMEOUT_MS } from "./broker/socket-server.js";
 import { HEARTBEAT_INTERVAL_MS } from "./broker/client.js";
+import { buildPinetSessionCompactDetails, buildPinetSessionFullDetails, getPinetSessionFilename, getPinetSessionPath, summarizePinetStableId, } from "./pinet-session-formatting.js";
 const PINET_DISPATCHER_EXAMPLES = {
     send: [{ action: "send", args: { to: "@worker", message: "Please review PR #123" } }],
     read: [
@@ -29,6 +30,10 @@ const PINET_DISPATCHER_EXAMPLES = {
     ],
     schedule: [{ action: "schedule", args: { delay: "30m", message: "Check queue state" } }],
     agents: [{ action: "agents", args: { repo: "<repo>", role: "worker" } }],
+    sessions: [
+        { action: "sessions", args: { agent_name: "Frozen Hazel Whale" } },
+        { action: "sessions", args: { thread_id: "a2a:<broker>:<worker>", full: true } },
+    ],
     spawn: [
         {
             action: "spawn",
@@ -89,6 +94,7 @@ function normalizeDispatcherAction(value) {
         "snooze",
         "schedule",
         "agents",
+        "sessions",
         "lanes",
         "ports",
         "spawn",
@@ -137,7 +143,8 @@ function classifyPinetError(message) {
         message.includes("ttl_ms") ||
         message.includes("purpose") ||
         message.includes("port") ||
-        message.includes("spawn")) {
+        message.includes("spawn") ||
+        message.includes("sessions op")) {
         return {
             class: "input",
             message,
@@ -803,6 +810,8 @@ function buildCompactAgentDetails(agents, hint) {
                 repo: getAgentRepo(agent) ?? null,
                 branch: getAgentBranch(agent) ?? null,
                 role: getAgentRole(agent) ?? null,
+                session: agent.session?.ref ?? null,
+                sessionKind: agent.session?.kind ?? null,
                 brokerManaged: agent.metadata?.brokerManaged === true,
                 parentAgentId: agent.metadata?.parentAgentId ?? null,
                 treeDepth: agent.metadata?.treeDepth ?? 0,
@@ -1363,6 +1372,123 @@ function runPinetAgentsAction(params, deps, toolName, output) {
         };
     })();
 }
+function buildPinetSessionSearchOptions(params) {
+    return {
+        ...((getMaybeString(params, "agent_name") ?? getMaybeString(params, "name"))
+            ? { agentName: getMaybeString(params, "agent_name") ?? getMaybeString(params, "name") }
+            : {}),
+        ...(getMaybeString(params, "agent_id") ? { agentId: getMaybeString(params, "agent_id") } : {}),
+        ...(getMaybeString(params, "thread_id")
+            ? { threadId: getMaybeString(params, "thread_id") }
+            : {}),
+        ...(getMaybeString(params, "repo") ? { repo: getMaybeString(params, "repo") } : {}),
+        ...(getMaybeString(params, "worktree_path")
+            ? { worktreePath: getMaybeString(params, "worktree_path") }
+            : {}),
+        ...(getMaybeString(params, "tmux_session")
+            ? { tmuxSession: getMaybeString(params, "tmux_session") }
+            : {}),
+        ...(getMaybeString(params, "since") ? { since: getMaybeString(params, "since") } : {}),
+        ...(getMaybeString(params, "until") ? { until: getMaybeString(params, "until") } : {}),
+        ...(getMaybeNumber(params, "limit") ? { limit: getMaybeNumber(params, "limit") } : {}),
+    };
+}
+function formatPinetSessionSearchHeader(sessions, options) {
+    const filters = [
+        options.agentName ? `agent_name=${options.agentName}` : null,
+        options.agentId ? `agent_id=${options.agentId}` : null,
+        options.threadId ? `thread_id=${options.threadId}` : null,
+        options.repo ? `repo=${options.repo}` : null,
+        options.worktreePath ? `worktree=${options.worktreePath}` : null,
+        options.tmuxSession ? `tmux=${options.tmuxSession}` : null,
+        options.since ? `since=${options.since}` : null,
+        options.until ? `until=${options.until}` : null,
+    ].filter((item) => Boolean(item));
+    const filterText = filters.length > 0 ? ` for ${filters.join(" · ")}` : "";
+    return `Pinet sessions: ${sessions.length} match${sessions.length === 1 ? "" : "es"}${filterText}.`;
+}
+function formatPinetSessionLine(session, full) {
+    const summary = summarizePinetStableId(session.stableId);
+    const health = session.disconnectedAt ? "disconnected" : "live";
+    const where = [
+        session.repo ?? null,
+        session.branch ? `branch=${session.branch}` : null,
+        session.tmuxSession ? `tmux=${session.tmuxSession}` : null,
+    ].filter((item) => Boolean(item));
+    const threads = session.relatedThreadIds.slice(0, full ? 10 : 3).join(", ");
+    const suffix = session.relatedThreadIds.length > (full ? 10 : 3) ? " …" : "";
+    const base = [
+        `- ${session.emoji} ${session.agentName} (${session.agentId})`,
+        `${health}`,
+        `pid:${session.pid}`,
+        summary?.ref ? `session:${summary.ref}` : "session:none",
+        `lastSeen:${session.lastSeen}`,
+        where.length > 0 ? where.join(" · ") : null,
+    ].filter((item) => Boolean(item));
+    const lines = [base.join(" — ")];
+    if (threads) {
+        lines.push(`  threads: ${threads}${suffix}`);
+    }
+    if (full) {
+        const sessionPath = getPinetSessionPath(session.stableId);
+        const sessionFilename = getPinetSessionFilename(session.stableId);
+        if (session.stableId)
+            lines.push(`  stableId: ${session.stableId}`);
+        if (sessionPath)
+            lines.push(`  jsonl: ${sessionPath}`);
+        if (sessionFilename)
+            lines.push(`  jsonlFile: ${sessionFilename}`);
+        if (session.cwd)
+            lines.push(`  cwd: ${session.cwd}`);
+        if (session.repoRoot)
+            lines.push(`  repoRoot: ${session.repoRoot}`);
+        if (session.worktreePath)
+            lines.push(`  worktreePath: ${session.worktreePath}`);
+        if (session.brokerManaged) {
+            lines.push(`  managed: source=${session.launchSource ?? "broker"}${session.brokerManagedBy ? ` by=${session.brokerManagedBy}` : ""}`);
+        }
+        lines.push(`  matchedBy: ${session.matchedBy.join(", ")}`);
+    }
+    return lines.join("\n");
+}
+function formatPinetSessionSearch(sessions, options, full) {
+    const header = formatPinetSessionSearchHeader(sessions, options);
+    if (sessions.length === 0)
+        return `${header} Try a broader agent_name, thread_id, or repo filter.`;
+    const body = sessions.map((session) => formatPinetSessionLine(session, full)).join("\n");
+    const fullHint = full ? "" : "\nUse args.full=true for exact stableId/jsonl paths.";
+    return `${header}\n${body}${fullHint}`;
+}
+function runPinetSessionsAction(params, deps, toolName, output) {
+    return (async () => {
+        const op = getMaybeString(params, "op") ?? "search";
+        if (op !== "search") {
+            throw new Error("sessions op must be search");
+        }
+        const options = buildPinetSessionSearchOptions(params);
+        deps.requireToolPolicy(toolName, undefined, `agent_name=${options.agentName ?? ""} | agent_id=${options.agentId ?? ""} | thread_id=${options.threadId ?? ""} | repo=${options.repo ?? ""} | worktree_path=${options.worktreePath ?? ""} | tmux_session=${options.tmuxSession ?? ""} | since=${options.since ?? ""} | until=${options.until ?? ""} | limit=${options.limit ?? ""} | format=${output.format} | full=${output.full}`);
+        if (!deps.pinetEnabled()) {
+            throw new Error("Pinet is not running. Use /pinet start or /pinet follow first.");
+        }
+        const sessions = await deps.searchPinetSessions(options);
+        const text = formatPinetSessionSearch(sessions, options, output.full);
+        return {
+            content: [{ type: "text", text }],
+            details: { count: sessions.length, sessions, options },
+            compactDetails: {
+                count: sessions.length,
+                options,
+                sessions: sessions.map(buildPinetSessionCompactDetails),
+            },
+            fullDetails: {
+                count: sessions.length,
+                options,
+                sessions: sessions.map(buildPinetSessionFullDetails),
+            },
+            expandedText: text,
+        };
+    })();
+}
 export function registerPinetTools(pi, deps) {
     const actionDefinitions = new Map();
     function registerAction(definition) {
@@ -1478,6 +1604,25 @@ export function registerPinetTools(pi, deps) {
         }),
         execute: (_id, params, output) => runPinetAgentsAction(params, deps, "pinet:agents", output),
     });
+    registerAction({
+        name: "sessions",
+        description: "Search live and historical Pinet worker Pi sessions by display name, agent id, thread, repo/worktree, tmux session, or time range.",
+        parameters: Type.Object({
+            op: Type.Optional(Type.String({ description: "Operation: search (default)" })),
+            agent_name: Type.Optional(Type.String({ description: "Worker display name, e.g. Frozen Hazel Whale" })),
+            name: Type.Optional(Type.String({ description: "Alias for agent_name" })),
+            agent_id: Type.Optional(Type.String({ description: "Pinet agent id or id prefix" })),
+            thread_id: Type.Optional(Type.String({ description: "Related Pinet/Slack/A2A thread id" })),
+            repo: Type.Optional(Type.String({ description: "Repo name or path fragment" })),
+            worktree_path: Type.Optional(Type.String({ description: "Worktree/cwd path fragment" })),
+            tmux_session: Type.Optional(Type.String({ description: "Broker-managed tmux session name" })),
+            since: Type.Optional(Type.String({ description: "Only sessions active after this ISO time" })),
+            until: Type.Optional(Type.String({ description: "Only sessions started before this ISO time" })),
+            limit: Type.Optional(Type.Number({ description: "Maximum matches (default 20, max 100)" })),
+            ...PINET_OUTPUT_OPTION_PARAMETERS,
+        }),
+        execute: (_id, params, output) => runPinetSessionsAction(params, deps, "pinet:sessions", output),
+    });
     registerAction({
         name: "ports",
         description: "Acquire, renew, release, inspect, list, or expire durable Pinet local port leases.",
@@ -1549,10 +1694,10 @@ export function registerPinetTools(pi, deps) {
         name: "pinet",
         label: "Pinet Dispatcher",
         description: "Dispatch Pinet operations by action with compact help and schema discovery.",
-        promptSnippet: 'Use this compact dispatcher for Pinet actions: send, read, free, snooze, schedule, agents, lanes, ports, reload, exit, spawn, and help. Use /pinet start, /pinet follow, /pinet unfollow, and /pinet subtree start for TUI lifecycle changes. Defaults to terse CLI text; pass args.format="json" for the compact envelope or args.full=true for verbose/debug detail.',
+        promptSnippet: 'Use this compact dispatcher for Pinet actions: send, read, free, snooze, schedule, agents, sessions, lanes, ports, reload, exit, spawn, and help. Use /pinet start, /pinet follow, /pinet unfollow, and /pinet subtree start for TUI lifecycle changes. Defaults to terse CLI text; pass args.format="json" for the compact envelope or args.full=true for verbose/debug detail.',
         parameters: Type.Object({
             action: Type.String({
-                description: "Action name: help, send, read, free, snooze, schedule, agents, lanes, ports, reload, or exit. Also supports spawn for launching worker-owned subtree children.",
+                description: "Action name: help, send, read, free, snooze, schedule, agents, sessions, lanes, ports, reload, or exit. Also supports spawn for launching worker-owned subtree children.",
             }),
             args: Type.Optional(Type.Record(Type.String(), Type.Unknown(), {
                 description: 'Action arguments. Add format="cli"|"json" (or f/"-f") for presentation, and full=true (or "--full": true) only for verbose/debug details. Default cli and non-full json keep data.details compact.',

package/dist/slack-markdown.d.ts

@@ -0,0 +1 @@
+export declare function renderMarkdownForSlackMrkdwn(text: string): string;

package/dist/slack-markdown.js

@@ -0,0 +1,128 @@
+export function renderMarkdownForSlackMrkdwn(text) {
+    if (!text.includes("**")) {
+        return text;
+    }
+    return transformOutsideBacktickCode(text, convertMarkdownStrongToSlackBold);
+}
+function transformOutsideBacktickCode(text, transform) {
+    let output = "";
+    let segmentStart = 0;
+    let index = 0;
+    while (index < text.length) {
+        if (text[index] !== "`") {
+            index += 1;
+            continue;
+        }
+        const runLength = countRepeated(text, index, "`");
+        const closingIndex = findClosingBacktickRun(text, index + runLength, runLength);
+        if (closingIndex === -1) {
+            index += runLength;
+            continue;
+        }
+        output += transform(text.slice(segmentStart, index));
+        output += text.slice(index, closingIndex + runLength);
+        index = closingIndex + runLength;
+        segmentStart = index;
+    }
+    output += transform(text.slice(segmentStart));
+    return output;
+}
+function convertMarkdownStrongToSlackBold(segment) {
+    let output = "";
+    let index = 0;
+    while (index < segment.length) {
+        if (segment.startsWith("**", index) && isStrongOpeningDelimiter(segment, index)) {
+            const closingIndex = findStrongClosingDelimiter(segment, index + 2);
+            if (closingIndex !== -1) {
+                output += `*${segment.slice(index + 2, closingIndex)}*`;
+                index = closingIndex + 2;
+                continue;
+            }
+        }
+        output += segment[index];
+        index += 1;
+    }
+    return output;
+}
+function findStrongClosingDelimiter(segment, fromIndex) {
+    let index = fromIndex;
+    while (index < segment.length) {
+        const next = segment.indexOf("**", index);
+        if (next === -1) {
+            return -1;
+        }
+        if (isStrongClosingDelimiter(segment, next)) {
+            return next;
+        }
+        index = next + 2;
+    }
+    return -1;
+}
+function isStrongOpeningDelimiter(text, index) {
+    if (isEscaped(text, index)) {
+        return false;
+    }
+    const previous = text[index - 1];
+    const next = text[index + 2];
+    return isSafeOpeningBoundary(previous, next);
+}
+function isStrongClosingDelimiter(text, index) {
+    if (isEscaped(text, index)) {
+        return false;
+    }
+    const previous = text[index - 1];
+    const next = text[index + 2];
+    return isSafeClosingBoundary(previous, next);
+}
+function isSafeOpeningBoundary(previous, next) {
+    if (!next || isWhitespace(next) || next === "*" || next === "/") {
+        return false;
+    }
+    if (previous === "*" || previous === "/") {
+        return false;
+    }
+    return true;
+}
+function isSafeClosingBoundary(previous, next) {
+    if (!previous || isWhitespace(previous) || previous === "*" || previous === "/") {
+        return false;
+    }
+    if (next === "*" || next === "/") {
+        return false;
+    }
+    return true;
+}
+function isWhitespace(value) {
+    return /\s/u.test(value);
+}
+function countRepeated(text, index, char) {
+    let count = 0;
+    while (text[index + count] === char) {
+        count += 1;
+    }
+    return count;
+}
+function findClosingBacktickRun(text, fromIndex, runLength) {
+    let index = fromIndex;
+    while (index < text.length) {
+        const next = text.indexOf("`", index);
+        if (next === -1) {
+            return -1;
+        }
+        const nextRunLength = countRepeated(text, next, "`");
+        if (nextRunLength === runLength) {
+            return next;
+        }
+        index = next + nextRunLength;
+    }
+    return -1;
+}
+function isEscaped(text, index) {
+    let slashCount = 0;
+    let cursor = index - 1;
+    while (cursor >= 0 && text[cursor] === "\\") {
+        slashCount += 1;
+        cursor -= 1;
+    }
+    return slashCount % 2 === 1;
+}

package/dist/slack-pinet-runtime-adapter.js

@@ -61,6 +61,7 @@ export function createSlackPinetRuntimeAdapterFactory(deps) {
             appToken: deps.getAppToken(),
             allowedUsers: allowedUsers ? [...allowedUsers] : undefined,
             allowAllWorkspaceUsers: deps.shouldAllowAllWorkspaceUsers(),
+            ingressGuard: settings.ingressGuard,
             suggestedPrompts: settings.suggestedPrompts,
             reactionCommands: settings.reactionCommands,
             isKnownThread: (threadTs) => shouldRouteKnownSlackThread(broker.db.getThread(threadTs)),
@@ -69,6 +70,12 @@ export function createSlackPinetRuntimeAdapterFactory(deps) {
                 rememberKnownSlackThread(broker, threadTs, channelId, context);
             },
             isReactionThreadAuthorized: (threadTs, channelId) => isAuthorizedReactionThread(broker, threadTs, channelId),
+            isPinetOwnedThread: (threadTs, channelId) => {
+                const thread = broker.db.getThread(threadTs);
+                if (!thread || thread.source !== "slack" || thread.channel !== channelId)
+                    return false;
+                return !!thread.ownerAgent || readStoredSlackThreadContext(thread.metadata) !== null;
+            },
             onAppHomeOpened: async ({ userId }) => {
                 await deps.onAppHomeOpened(userId, ctx);
             },

package/dist/slack-tools.d.ts

@@ -26,6 +26,14 @@ export interface SlackPinetDeliveryResult {
     source: string;
 }
 export interface SlackPinetDeliveryPort {
+    /**
+     * True when Pinet is configured/enabled for this session, regardless of
+     * live broker connectivity. When true, threaded Slack replies MUST route
+     * through the broker; direct Slack fallback is refused even if the broker
+     * is momentarily unavailable, to preserve broker-enforced thread
+     * ownership (see gugu91/extensions#855).
+     */
+    isEnabled: () => boolean;
     isAvailable: () => boolean;
     sendSlackMessage: (input: SlackPinetDeliveryInput) => Promise<SlackPinetDeliveryResult>;
 }

package/dist/slack-tools.js

@@ -180,25 +180,6 @@ function isAbortError(error) {
 function getErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function isPinetDeliveryFallbackError(error) {
-    const lower = getErrorMessage(error).toLowerCase();
-    if (lower.includes("already owned"))
-        return false;
-    return (lower.includes("not running") ||
-        lower.includes("unexpected state") ||
-        lower.includes("unavailable") ||
-        lower.includes("not connected") ||
-        lower.includes("disconnected") ||
-        lower.includes("timeout") ||
-        lower.includes("timed out") ||
-        lower.includes("econn") ||
-        lower.includes("socket") ||
-        lower.includes("no transport source") ||
-        lower.includes("no transport channel") ||
-        lower.includes("only allows local file paths") ||
-        lower.includes("no adapter") ||
-        lower.includes("identity is unavailable"));
-}
 function classifySlackDispatcherError(error) {
     const message = getErrorMessage(error);
     const lower = message.toLowerCase();
@@ -423,6 +404,7 @@ function buildSlackSendPromptGuidelines() {
     return [
         "Use slack_send for replies in the current Slack assistant thread; always reply where the task came from.",
         "For rich Block Kit JSON examples or modal/canvas patterns, load the slack-bridge skill instead of relying on tool schemas.",
+        "If slack_send fails with 'broker is unavailable' or 'already owned by another agent', do NOT retry via post_channel or a different tool \u2014 report the blocker in the same thread (or to the broker) and wait for ownership to be transferred; direct posting would bypass thread ownership (#855).",
     ];
 }
 function getSlackCanvasSummary(markdown) {
@@ -624,32 +606,31 @@ export function registerSlackTools(pi, deps) {
     }
     async function deliverSlackMessage(input) {
         const blocks = input.blocks ? normalizeSlackBlocksInput(input.blocks) : undefined;
-        let fallbackReason;
-        if (input.threadTs && pinetDelivery) {
-            try {
-                if (pinetDelivery.isAvailable()) {
-                    const result = await pinetDelivery.sendSlackMessage({
-                        threadId: input.threadTs,
-                        channel: input.channel,
-                        text: input.text,
-                        ...(blocks ? { blocks } : {}),
-                        ...(input.files ? { files: input.files } : {}),
-                    });
-                    return {
-                        threadTs: input.threadTs,
-                        channel: result.channel,
-                        blocksCount: blocks?.length ?? 0,
-                        delivery: "pinet",
-                        adapter: result.adapter,
-                        messageId: result.messageId,
-                    };
-                }
-            }
-            catch (error) {
-                if (!isPinetDeliveryFallbackError(error))
-                    throw error;
-                fallbackReason = getErrorMessage(error);
-            }
+        // Threaded Slack replies routed through Pinet MUST NOT fall back to direct
+        // Slack when the broker is unavailable or the delivery errors: direct
+        // Slack posting bypasses broker thread-ownership enforcement and lets any
+        // worker with a valid bot token take over a Slack thread it does not own.
+        // See gugu91/extensions#855. Single-player mode (isEnabled === false) and
+        // top-level channel posts (no threadTs) remain unaffected.
+        if (input.threadTs && pinetDelivery?.isEnabled()) {
+            if (!pinetDelivery.isAvailable()) {
+                throw new Error("Cannot post to Slack thread: Pinet broker is unavailable and direct Slack fallback would bypass thread-ownership enforcement. Wait for the broker to reconnect, or ask the broker to transfer this thread.");
+            }
+            const result = await pinetDelivery.sendSlackMessage({
+                threadId: input.threadTs,
+                channel: input.channel,
+                text: input.text,
+                ...(blocks ? { blocks } : {}),
+                ...(input.files ? { files: input.files } : {}),
+            });
+            return {
+                threadTs: input.threadTs,
+                channel: result.channel,
+                blocksCount: blocks?.length ?? 0,
+                delivery: "pinet",
+                adapter: result.adapter,
+                messageId: result.messageId,
+            };
         }
         if (input.files && input.files.length > 0) {
             if (blocks && blocks.length > 0) {
@@ -676,7 +657,6 @@ export function registerSlackTools(pi, deps) {
                 channel: input.channel,
                 blocksCount: blocks?.length ?? 0,
                 delivery: "slack",
-                ...(fallbackReason ? { fallbackReason } : {}),
             };
         }
         const body = {
@@ -700,7 +680,6 @@ export function registerSlackTools(pi, deps) {
             channel: input.channel,
             blocksCount: blocks?.length ?? 0,
             delivery: "slack",
-            ...(fallbackReason ? { fallbackReason } : {}),
         };
     }
     const slackActionRegistry = new Map();
@@ -1479,7 +1458,6 @@ export function registerSlackTools(pi, deps) {
                     filesCount: Array.isArray(params.files) ? params.files.length : 0,
                     ...(delivery.adapter ? { adapter: delivery.adapter } : {}),
                     ...(delivery.messageId ? { messageId: delivery.messageId } : {}),
-                    ...(delivery.fallbackReason ? { fallbackReason: delivery.fallbackReason } : {}),
                 },
             };
         },
@@ -2194,7 +2172,6 @@ export function registerSlackTools(pi, deps) {
                     filesCount: Array.isArray(params.files) ? params.files.length : 0,
                     ...(delivery.adapter ? { adapter: delivery.adapter } : {}),
                     ...(delivery.messageId ? { messageId: delivery.messageId } : {}),
-                    ...(delivery.fallbackReason ? { fallbackReason: delivery.fallbackReason } : {}),
                 },
             };
         },

package/dist/subtree-broker-runtime.d.ts

@@ -1,4 +1,5 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { AgentSessionSummary } from "./broker/types.js";
 import type { PinetReadOptions, PinetReadResult } from "@pinet/pinet-core/pinet-read-formatting";
 import { type InboxMessage, type PinetControlCommand, type PinetRemoteControlRequestResult, type SlackBridgeSettings } from "./helpers.js";
 export interface SubtreeBrokerPaths {
@@ -32,6 +33,8 @@ export interface SubtreeAgentRecord {
     name: string;
     id: string;
     pid?: number;
+    stableId?: string | null;
+    session?: AgentSessionSummary | null;
     status: "working" | "idle";
     metadata: Record<string, unknown> | null;
     lastHeartbeat: string;

package/dist/subtree-broker-runtime.js

@@ -4,6 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
+import { summarizePinetStableId } from "./pinet-session-formatting.js";
 import { dispatchDirectAgentMessage, resolveDirectAgentTarget } from "./broker/agent-messaging.js";
 import { startBroker } from "./broker/index.js";
 import { HEARTBEAT_INTERVAL_MS } from "./broker/client.js";
@@ -174,6 +175,8 @@ function toSubtreeAgentRecord(db, agent) {
         name: agent.name,
         id: agent.id,
         pid: agent.pid,
+        stableId: agent.stableId ?? null,
+        session: summarizePinetStableId(agent.stableId),
         status: agent.status,
         metadata: agent.metadata,
         lastHeartbeat: agent.lastHeartbeat,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinet/slack-bridge",
-  "version": "0.2.1",
+  "version": "0.2.4",
   "type": "module",
   "description": "Pi package for Pinet Slack assistant integration — multi-agent broker, thread routing, and inbox tools",
   "author": "Will Porcellini <5994936+gugu91@users.noreply.github.com>",
@@ -49,10 +49,10 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@pinet/broker-core": "0.2.1",
-    "@pinet/imessage-bridge": "0.2.1",
-    "@pinet/pinet-core": "0.2.1",
-    "@pinet/transport-core": "0.2.1",
+    "@pinet/broker-core": "0.2.4",
+    "@pinet/imessage-bridge": "0.2.4",
+    "@pinet/pinet-core": "0.2.4",
+    "@pinet/transport-core": "0.2.4",
     "@sinclair/typebox": "^0.34.49"
   },
   "types": "./dist/index.d.ts",