@pinet/slack-bridge 0.1.0

package/dist/pinet-commands.js

@@ -0,0 +1,402 @@
+import { parseScheduledWakeupDelay } from "@pinet/pinet-core/scheduled-wakeups";
+import { generateAgentName, agentOwnsThread, describeSlackUserAccess, formatFollowerRuntimeDiagnosticHealth, formatFollowerRuntimeDiagnosticNextStep, resolveAllowAllWorkspaceUsers, } from "./helpers.js";
+import { formatRecentActivityLogEntries } from "./activity-log.js";
+import { formatRuntimeGuardrailsPosture } from "./guardrails.js";
+import { formatSlackScopeDiagnosticsStatus, } from "./slack-scope-diagnostics.js";
+const PINET_PRIMARY_COMMANDS = [
+    { action: "start", args: "", description: "Start as the mesh broker" },
+    { action: "follow", args: "", description: "Connect as a follower worker" },
+    { action: "unfollow", args: "", description: "Disconnect from the broker" },
+    { action: "reload", args: "<agent>", description: "Ask another agent to reload" },
+    { action: "exit", args: "<agent>", description: "Ask another agent to exit" },
+    { action: "free", args: "", description: "Mark this agent as idle" },
+    { action: "snooze", args: "[duration|off|status]", description: "Quiet empty RALPH cycles" },
+];
+const PINET_SECONDARY_COMMANDS = [
+    { action: "status", args: "", description: "Show Pinet status" },
+    { action: "logs", args: "", description: "Show recent broker activity logs" },
+    { action: "rename", args: "[name]", description: "Rename this Pinet agent" },
+];
+// ─── Registration ────────────────────────────────────────
+function abortCurrentTurnBeforeBrokerReload(ctx) {
+    if (ctx.isIdle?.() ?? true) {
+        return;
+    }
+    try {
+        ctx.abort?.();
+    }
+    catch {
+        /* best effort */
+    }
+}
+export function formatPinetCommandHelp() {
+    const lines = [
+        "Usage: /pinet <action> [args]",
+        "",
+        "Primary actions:",
+        ...PINET_PRIMARY_COMMANDS.map((command) => formatPinetCommandHelpLine(command.action, command.args, command.description)),
+        "",
+        "Other actions:",
+        ...PINET_SECONDARY_COMMANDS.map((command) => formatPinetCommandHelpLine(command.action, command.args, command.description)),
+    ];
+    return lines.join("\n");
+}
+function formatPinetCommandHelpLine(action, args, description) {
+    const command = args ? `/pinet ${action} ${args}` : `/pinet ${action}`;
+    return `• ${command} — ${description}`;
+}
+function parsePinetCommandAction(args) {
+    const trimmed = args.trim();
+    if (!trimmed || trimmed === "?" || trimmed === "-h" || trimmed === "--help") {
+        return null;
+    }
+    const [rawAction = "", ...rest] = trimmed.split(/\s+/);
+    const action = normalizePinetCommandAction(rawAction);
+    if (!action) {
+        return null;
+    }
+    return {
+        action,
+        args: rest.join(" ").trim(),
+    };
+}
+function normalizePinetCommandAction(rawAction) {
+    const normalized = rawAction.trim().replace(/^\//, "").toLowerCase();
+    switch (normalized) {
+        case "start":
+        case "broker":
+            return "start";
+        case "follow":
+        case "worker":
+            return "follow";
+        case "unfollow":
+        case "disconnect":
+            return "unfollow";
+        case "reload":
+            return "reload";
+        case "exit":
+            return "exit";
+        case "free":
+        case "idle":
+            return "free";
+        case "status":
+            return "status";
+        case "logs":
+        case "log":
+            return "logs";
+        case "rename":
+            return "rename";
+        case "snooze":
+        case "quiet":
+            return "snooze";
+        case "help":
+            return null;
+        default:
+            return null;
+    }
+}
+export async function runPinetCommandAction(deps, action, args, ctx, usageCommand = `/pinet ${action}`) {
+    switch (action) {
+        case "start":
+            await runPinetStart(deps, ctx);
+            return;
+        case "follow":
+            await runPinetFollow(deps, ctx);
+            return;
+        case "unfollow":
+            await runPinetUnfollow(deps, ctx);
+            return;
+        case "reload":
+            await runPinetReload(deps, args, ctx, usageCommand);
+            return;
+        case "exit":
+            await runPinetExit(deps, args, ctx, usageCommand);
+            return;
+        case "free":
+            await runPinetFree(deps, ctx);
+            return;
+        case "status":
+            runPinetStatus(deps, ctx);
+            return;
+        case "logs":
+            runPinetLogs(deps, ctx);
+            return;
+        case "rename":
+            runPinetRename(deps, args, ctx);
+            return;
+        case "snooze":
+            runPinetSnooze(deps, args, ctx);
+            return;
+    }
+}
+export function registerPinetCommands(pi, deps) {
+    pi.registerCommand("pinet", {
+        description: "Unified Pinet command surface: start, follow, unfollow, reload, exit, free, snooze, status, logs, rename",
+        handler: async (args, ctx) => {
+            const parsed = parsePinetCommandAction(args);
+            if (!parsed) {
+                const trimmed = args.trim();
+                const tone = trimmed && !["help", "?", "-h", "--help"].includes(trimmed.toLowerCase())
+                    ? "warning"
+                    : "info";
+                const prefix = tone === "warning" ? `Unknown Pinet action: ${trimmed}\n\n` : "";
+                ctx.ui.notify(`${prefix}${formatPinetCommandHelp()}`, tone);
+                return;
+            }
+            await runPinetCommandAction(deps, parsed.action, parsed.args, ctx);
+        },
+    });
+}
+async function runPinetStart(deps, ctx) {
+    if (deps.pinetRegistrationBlocked()) {
+        ctx.ui.notify(deps.getPinetRegistrationBlockReason(), "warning");
+        return;
+    }
+    deps.setExtCtx(ctx);
+    if (deps.runtimeMode() === "broker") {
+        try {
+            abortCurrentTurnBeforeBrokerReload(ctx);
+            ctx.ui.notify("Pinet broker already running — reloading current runtime", "info");
+            await deps.reloadPinetRuntime(ctx);
+        }
+        catch (err) {
+            ctx.ui.notify(`Pinet broker reload failed: ${errorMsg(err)}`, "error");
+            deps.setExtStatus(ctx, "error");
+        }
+        return;
+    }
+    try {
+        await deps.connectAsBroker(ctx);
+    }
+    catch (err) {
+        ctx.ui.notify(`Pinet broker failed: ${errorMsg(err)}`, "error");
+        deps.setExtStatus(ctx, "error");
+    }
+}
+async function runPinetFollow(deps, ctx) {
+    if (deps.pinetRegistrationBlocked()) {
+        ctx.ui.notify(deps.getPinetRegistrationBlockReason(), "warning");
+        return;
+    }
+    if (deps.runtimeMode() === "follower") {
+        ctx.ui.notify("Pinet already running (follower)", "info");
+        return;
+    }
+    deps.setExtCtx(ctx);
+    try {
+        await deps.connectAsFollower(ctx);
+        ctx.ui.notify(`${deps.agentEmoji()} ${deps.agentName()} — following broker`, "info");
+    }
+    catch (err) {
+        ctx.ui.notify(`Pinet follow failed: ${errorMsg(err)}`, "error");
+        deps.setExtStatus(ctx, "error");
+    }
+}
+async function runPinetUnfollow(deps, ctx) {
+    if (deps.runtimeMode() !== "follower" || deps.brokerRole() == null) {
+        ctx.ui.notify("Pinet is not running as a follower.", "info");
+        return;
+    }
+    if (deps.brokerRole() !== "follower") {
+        ctx.ui.notify("Pinet is running as broker; /pinet unfollow only applies to followers.", "warning");
+        return;
+    }
+    const { unregisterError } = await deps.disconnectFollower(ctx);
+    if (unregisterError) {
+        ctx.ui.notify(`Pinet follower disconnected locally, but broker deregistration failed: ${unregisterError}`, "warning");
+        return;
+    }
+    ctx.ui.notify(`${deps.agentEmoji()} ${deps.agentName()} — disconnected from broker; local session still running`, "info");
+}
+async function runPinetReload(deps, args, ctx, usageCommand) {
+    const target = args.trim();
+    if (!target) {
+        ctx.ui.notify(`Usage: ${usageCommand} <agent-name-or-id>`, "warning");
+        return;
+    }
+    try {
+        const result = await deps.sendPinetAgentMessage(target, "/reload");
+        ctx.ui.notify(`Sent /reload to ${result.target}`, "info");
+    }
+    catch (err) {
+        ctx.ui.notify(`Pinet reload failed: ${errorMsg(err)}`, "error");
+    }
+}
+async function runPinetExit(deps, args, ctx, usageCommand) {
+    const target = args.trim();
+    if (!target) {
+        ctx.ui.notify(`Usage: ${usageCommand} <agent-name-or-id>`, "warning");
+        return;
+    }
+    try {
+        const result = await deps.sendPinetAgentMessage(target, "/exit");
+        ctx.ui.notify(`Sent /exit to ${result.target}`, "info");
+    }
+    catch (err) {
+        ctx.ui.notify(`Pinet exit failed: ${errorMsg(err)}`, "error");
+    }
+}
+function formatDurationMs(ms) {
+    if (ms <= 0)
+        return "0s";
+    const totalSeconds = Math.ceil(ms / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [
+        hours > 0 ? `${hours}h` : null,
+        minutes > 0 ? `${minutes}m` : null,
+        seconds > 0 && hours === 0 ? `${seconds}s` : null,
+    ].filter((part) => part !== null);
+    return parts.join(" ") || "0s";
+}
+function formatRalphSnoozeStatus(status) {
+    if (!status) {
+        return "RALPH snooze: unavailable outside broker mode";
+    }
+    if (!status.active) {
+        return `RALPH snooze: off (${status.emptyCycleCount} empty cycle${status.emptyCycleCount === 1 ? "" : "s"})`;
+    }
+    return [
+        `RALPH snooze: active for ${formatDurationMs(status.remainingMs)}`,
+        `Until: ${status.until ?? "unknown"}`,
+        `Source: ${status.source ?? "unknown"}`,
+        `Reason: ${status.reason ?? "none"}`,
+        `Empty cycles: ${status.emptyCycleCount}`,
+    ].join("\n");
+}
+async function runPinetFree(deps, ctx) {
+    if (!deps.pinetEnabled()) {
+        ctx.ui.notify("Pinet mesh runtime is not active. Use /pinet start or /pinet follow.", "info");
+        return;
+    }
+    try {
+        const result = await deps.signalAgentFree(ctx, { requirePinet: true });
+        const suffix = result.drainedQueuedInbox
+            ? ` Processing ${result.queuedInboxCount} queued inbox item${result.queuedInboxCount === 1 ? "" : "s"} now.`
+            : result.queuedInboxCount > 0
+                ? ` ${result.queuedInboxCount} queued inbox item${result.queuedInboxCount === 1 ? " remains" : "s remain"}.`
+                : "";
+        ctx.ui.notify(`Marked ${deps.agentEmoji()} ${deps.agentName()} idle/free for new work.${suffix}`, "info");
+    }
+    catch (err) {
+        ctx.ui.notify(`Pinet free failed: ${errorMsg(err)}`, "error");
+    }
+}
+function runPinetSnooze(deps, args, ctx) {
+    if (deps.runtimeMode() !== "broker") {
+        ctx.ui.notify("RALPH snooze is only available while running as the Pinet broker.", "warning");
+        return;
+    }
+    const trimmed = args.trim();
+    const normalized = trimmed.toLowerCase();
+    if (!trimmed || normalized === "status") {
+        ctx.ui.notify(formatRalphSnoozeStatus(deps.ralphSnoozeStatus?.() ?? null), "info");
+        return;
+    }
+    if (["off", "clear", "wake", "resume", "cancel"].includes(normalized)) {
+        if (!deps.clearRalphSnooze) {
+            ctx.ui.notify("RALPH snooze is unavailable in this runtime.", "warning");
+            return;
+        }
+        ctx.ui.notify(formatRalphSnoozeStatus(deps.clearRalphSnooze()), "info");
+        return;
+    }
+    const [durationToken = "", ...reasonParts] = trimmed.split(/\s+/);
+    const durationMs = parseScheduledWakeupDelay(durationToken);
+    if (durationMs == null) {
+        ctx.ui.notify("Usage: /pinet snooze <duration|off|status> [reason]. Example: /pinet snooze 30m no work available", "warning");
+        return;
+    }
+    if (!deps.snoozeRalphLoop) {
+        ctx.ui.notify("RALPH snooze is unavailable in this runtime.", "warning");
+        return;
+    }
+    const status = deps.snoozeRalphLoop({
+        durationMs,
+        reason: reasonParts.join(" ").trim() || "manual command",
+    });
+    ctx.ui.notify(formatRalphSnoozeStatus(status), "info");
+}
+function runPinetStatus(deps, ctx) {
+    const mode = deps.runtimeMode();
+    const ownedCount = [...deps.threads().values()].filter((t) => agentOwnsThread(t.owner, deps.agentName(), deps.agentAliases(), deps.agentOwnerToken())).length;
+    const users = deps.allowedUsers();
+    const s = deps.settings();
+    const allowlistInfo = describeSlackUserAccess(users, {
+        allowAllWorkspaceUsers: resolveAllowAllWorkspaceUsers(s, process.env.SLACK_ALLOW_ALL_WORKSPACE_USERS),
+    });
+    const defaultChInfo = s.defaultChannel
+        ? `Default channel: ${s.defaultChannel}`
+        : "Default channel: none";
+    const activityLogInfo = s.logChannel
+        ? `Activity log: ${s.logChannel} (${s.logLevel ?? "actions"})`
+        : "Activity log: disabled";
+    const guardrailsInfo = `Guardrails: ${formatRuntimeGuardrailsPosture(s.security ?? {})}`;
+    const runtimeDiagnostic = deps.followerRuntimeDiagnostic();
+    const runtimeHealthInfo = `Runtime health: ${formatFollowerRuntimeDiagnosticHealth(runtimeDiagnostic)}`;
+    const runtimeNextStepInfo = `Next step: ${formatFollowerRuntimeDiagnosticNextStep(runtimeDiagnostic)}`;
+    const slackToolHealthInfo = `Slack tool health: ${formatSlackScopeDiagnosticsStatus(deps.slackScopeDiagnostics())}`;
+    const lbm = deps.lastBrokerMaintenance();
+    const brokerHealthInfo = mode === "broker" && lbm
+        ? [
+            `Pending backlog: ${lbm.pendingBacklogCount}`,
+            `Last maintenance: assigned ${lbm.assignedBacklogCount}, reaped ${lbm.reapedAgentIds.length}, repaired ${lbm.repairedThreadClaims}`,
+            ...(lbm.anomalies.length > 0 ? [`Health: ${lbm.anomalies.join("; ")}`] : []),
+        ]
+        : [];
+    const ralphSnoozeInfo = mode === "broker" ? [formatRalphSnoozeStatus(deps.ralphSnoozeStatus?.() ?? null)] : [];
+    const brokerHomeTabInfo = mode === "broker"
+        ? [
+            `Home tab viewers: ${deps.getBrokerControlPlaneHomeTabViewerIds().length}`,
+            ...(deps.lastBrokerControlPlaneHomeTabRefreshAt()
+                ? [`Home tab refreshed: ${deps.lastBrokerControlPlaneHomeTabRefreshAt()}`]
+                : []),
+            ...(deps.lastBrokerControlPlaneHomeTabError()
+                ? [`Home tab status: ${deps.lastBrokerControlPlaneHomeTabError()}`]
+                : []),
+        ]
+        : [];
+    ctx.ui.notify([
+        `Mode: ${mode}`,
+        `Agent: ${deps.agentEmoji()} ${deps.agentName()}`,
+        `Bot: ${deps.botUserId() ?? "unknown"}`,
+        `Connection: ${deps.runtimeConnected() ? "connected" : "disconnected"}`,
+        runtimeHealthInfo,
+        runtimeNextStepInfo,
+        `Skin: ${deps.activeSkinTheme() ?? "(legacy/manual)"}`,
+        ...(deps.agentPersonality() ? [`Persona: ${deps.agentPersonality()}`] : []),
+        `Threads: ${deps.threads().size} (${ownedCount} owned by ${deps.agentName()})`,
+        `DM channel: ${deps.lastDmChannel() ?? "none yet"}`,
+        allowlistInfo,
+        guardrailsInfo,
+        defaultChInfo,
+        activityLogInfo,
+        slackToolHealthInfo,
+        ...brokerHealthInfo,
+        ...ralphSnoozeInfo,
+        ...brokerHomeTabInfo,
+    ].join("\n"), "info");
+}
+function runPinetLogs(deps, ctx) {
+    const s = deps.settings();
+    const channelInfo = s.logChannel ? `${s.logChannel} (${s.logLevel ?? "actions"})` : "disabled";
+    ctx.ui.notify([
+        `Activity log channel: ${channelInfo}`,
+        formatRecentActivityLogEntries(deps.recentActivityLogEntries(10)),
+    ].join("\n\n"), s.logChannel ? "info" : "warning");
+}
+function runPinetRename(deps, args, ctx) {
+    const newName = args.trim();
+    if (!newName) {
+        const fresh = generateAgentName(undefined, deps.runtimeMode() === "broker" ? "broker" : "worker");
+        deps.applyLocalAgentIdentity(fresh.name, fresh.emoji, deps.agentPersonality());
+    }
+    else {
+        deps.applyLocalAgentIdentity(newName, deps.agentEmoji(), deps.agentPersonality());
+    }
+    ctx.ui.notify(`${deps.agentEmoji()} Agent renamed to: ${deps.agentName()}`, "info");
+}
+function errorMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/pinet-confirmation-replies.d.ts

@@ -0,0 +1,7 @@
+import type { PinetReadResult } from "@pinet/pinet-core/pinet-read-formatting";
+export type ConsumePinetConfirmationReply = (threadTs: string, text: string, options?: {
+    receivedAt?: string | number | Date;
+}) => {
+    approved: boolean;
+} | null;
+export declare function consumePinetReadConfirmationReplies(result: PinetReadResult, consumeReply: ConsumePinetConfirmationReply): PinetReadResult;

package/dist/pinet-confirmation-replies.js

@@ -0,0 +1,30 @@
+export function consumePinetReadConfirmationReplies(result, consumeReply) {
+    if (result.markedReadIds.length === 0)
+        return result;
+    const markedReadIds = new Set(result.markedReadIds);
+    return {
+        ...result,
+        messages: result.messages.map((item) => {
+            if (!markedReadIds.has(item.inboxId) ||
+                item.message.source !== "slack" ||
+                item.message.direction !== "inbound") {
+                return item;
+            }
+            const confirmationResult = consumeReply(item.message.threadId, item.message.body, {
+                receivedAt: item.message.createdAt,
+            });
+            if (confirmationResult === null)
+                return item;
+            const suffix = confirmationResult.approved
+                ? "✅ User approved security confirmation request in this thread."
+                : "❌ User denied security confirmation request in this thread.";
+            return {
+                ...item,
+                message: {
+                    ...item.message,
+                    body: `${item.message.body}\n\n${suffix}`,
+                },
+            };
+        }),
+    };
+}

package/dist/pinet-control-plane-dashboard.d.ts

@@ -0,0 +1,34 @@
+import { type RalphLoopAgentWorkload } from "./helpers.js";
+import type { BrokerMaintenanceResult } from "./broker/maintenance.js";
+import type { RalphSnoozeStatus } from "./ralph-loop.js";
+import type { PinetLaneInfo, TaskAssignmentInfo } from "./broker/types.js";
+import { type BrokerControlPlaneDashboardSnapshot, type BrokerControlPlaneRecentCycle } from "./broker/control-plane-dashboard.js";
+export type PinetControlPlaneDashboardAgentRecord = Omit<RalphLoopAgentWorkload, "pendingInboxCount" | "ownedThreadCount">;
+export interface PinetControlPlaneDashboardMessageRecord {
+    id: number;
+    body: string;
+}
+export interface PinetControlPlaneDashboardBrokerDbPort {
+    getAllAgents: () => PinetControlPlaneDashboardAgentRecord[];
+    getPendingInboxCount: (agentId: string) => number;
+    getOwnedThreadCount: (agentId: string) => number;
+    getBacklogCount: (status: "pending") => number;
+    listTaskAssignments: () => TaskAssignmentInfo[];
+    listPinetLanes: (options?: {
+        includeDone?: boolean;
+    }) => PinetLaneInfo[];
+    getMessagesByIds: (ids: number[]) => PinetControlPlaneDashboardMessageRecord[];
+    getRecentRalphCycles: (limit: number) => BrokerControlPlaneRecentCycle[];
+}
+export interface PinetControlPlaneDashboardDeps {
+    getActiveBrokerDb: () => PinetControlPlaneDashboardBrokerDbPort | null;
+    getActiveBrokerSelfId: () => string | null;
+    heartbeatTimerActive: () => boolean;
+    maintenanceTimerActive: () => boolean;
+    getLastMaintenance: () => BrokerMaintenanceResult | null;
+    getRalphSnoozeStatus?: () => RalphSnoozeStatus | null;
+}
+export interface PinetControlPlaneDashboard {
+    buildCurrentBrokerControlPlaneDashboardSnapshot: (cycleStartedAt?: string) => Promise<BrokerControlPlaneDashboardSnapshot | null>;
+}
+export declare function createPinetControlPlaneDashboard(deps: PinetControlPlaneDashboardDeps): PinetControlPlaneDashboard;

package/dist/pinet-control-plane-dashboard.js

@@ -0,0 +1,86 @@
+import * as os from "node:os";
+import { probeGitBranch } from "./git-metadata.js";
+import { DEFAULT_RALPH_LOOP_STUCK_WORKING_THRESHOLD_MS, filterAgentsForMeshVisibility, evaluateRalphLoopCycle, } from "./helpers.js";
+import { DEFAULT_HEARTBEAT_TIMEOUT_MS } from "./broker/socket-server.js";
+import { HEARTBEAT_INTERVAL_MS } from "./broker/client.js";
+import { buildBrokerControlPlaneDashboardSnapshot, } from "./broker/control-plane-dashboard.js";
+import { normalizeTrackedTaskAssignments, resolveTaskAssignments, } from "./task-assignments.js";
+export function createPinetControlPlaneDashboard(deps) {
+    async function buildCurrentBrokerControlPlaneDashboardSnapshot(cycleStartedAt = new Date().toISOString()) {
+        const db = deps.getActiveBrokerDb();
+        if (!db) {
+            return null;
+        }
+        const currentBranch = (await probeGitBranch(process.cwd())) ?? null;
+        const nowMs = Date.now();
+        const recentGhostWindowMs = DEFAULT_HEARTBEAT_TIMEOUT_MS * 2;
+        const workloads = filterAgentsForMeshVisibility(db.getAllAgents(), {
+            now: nowMs,
+            includeGhosts: true,
+            recentDisconnectWindowMs: recentGhostWindowMs,
+        }).map((agent) => ({
+            ...agent,
+            pendingInboxCount: db.getPendingInboxCount(agent.id),
+            ownedThreadCount: db.getOwnedThreadCount(agent.id),
+        }));
+        const pendingBacklogCount = db.getBacklogCount("pending");
+        const evaluationOptions = {
+            now: nowMs,
+            heartbeatTimeoutMs: DEFAULT_HEARTBEAT_TIMEOUT_MS,
+            heartbeatIntervalMs: HEARTBEAT_INTERVAL_MS,
+            stuckWorkingThresholdMs: DEFAULT_RALPH_LOOP_STUCK_WORKING_THRESHOLD_MS,
+            pendingBacklogCount,
+            currentBranch,
+            brokerHeartbeatActive: deps.heartbeatTimerActive(),
+            brokerMaintenanceActive: deps.maintenanceTimerActive(),
+            brokerAgentId: deps.getActiveBrokerSelfId() ?? undefined,
+        };
+        const evaluation = evaluateRalphLoopCycle(workloads, evaluationOptions);
+        const rawTrackedAssignments = db.listTaskAssignments();
+        const trackedAssignmentSourceIds = [
+            ...new Set(rawTrackedAssignments
+                .map((assignment) => assignment.sourceMessageId)
+                .filter((messageId) => messageId != null)),
+        ];
+        const trackedAssignments = normalizeTrackedTaskAssignments(rawTrackedAssignments, new Map(db
+            .getMessagesByIds(trackedAssignmentSourceIds)
+            .map((message) => [message.id, message.body])));
+        let projectedAssignments = [];
+        if (trackedAssignments.length > 0) {
+            const resolvedAssignments = await resolveTaskAssignments(trackedAssignments, process.cwd());
+            projectedAssignments = resolvedAssignments.map((assignment) => ({
+                ...assignment,
+                status: assignment.nextStatus,
+                prNumber: assignment.nextPrNumber,
+            }));
+        }
+        const recentRalphCycles = db.getRecentRalphCycles(5).map((cycle) => ({
+            startedAt: cycle.startedAt,
+            completedAt: cycle.completedAt,
+            durationMs: cycle.durationMs,
+            ghostAgentIds: cycle.ghostAgentIds,
+            stuckAgentIds: cycle.stuckAgentIds,
+            anomalies: cycle.anomalies,
+            followUpDelivered: cycle.followUpDelivered,
+            agentCount: cycle.agentCount,
+            backlogCount: cycle.backlogCount,
+        }));
+        return buildBrokerControlPlaneDashboardSnapshot({
+            workloads,
+            evaluation,
+            evaluationOptions,
+            maintenance: deps.getLastMaintenance(),
+            assignments: projectedAssignments,
+            lanes: db.listPinetLanes({ includeDone: true }),
+            recentCycles: recentRalphCycles,
+            cycleStartedAt,
+            cycleDurationMs: 0,
+            currentBranch,
+            homedir: os.homedir(),
+            snooze: deps.getRalphSnoozeStatus?.() ?? null,
+        });
+    }
+    return {
+        buildCurrentBrokerControlPlaneDashboardSnapshot,
+    };
+}

package/dist/pinet-home-tabs.d.ts

@@ -0,0 +1,36 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { BrokerControlPlaneDashboardSnapshot } from "./broker/control-plane-dashboard.js";
+import { type PublishSlackHomeTabInput } from "./home-tab.js";
+import type { SlackBridgeRuntimeMode } from "./runtime-mode.js";
+export interface PinetHomeTabsBrokerPort {
+    isConnected: () => boolean;
+    publishCurrentHomeTabSafely: (userId: string, ctx: ExtensionContext, openedAt?: string) => Promise<boolean>;
+    getHomeTabViewerIds: () => string[];
+    getLastHomeTabError: () => string | null;
+    setLastHomeTabSnapshot: (snapshot: BrokerControlPlaneDashboardSnapshot | null) => void;
+    setLastHomeTabRefreshAt: (value: string | null) => void;
+    setLastHomeTabError: (value: string | null) => void;
+}
+export interface PinetHomeTabsDeps {
+    slack: PublishSlackHomeTabInput["slack"];
+    getBotToken: () => string | undefined;
+    formatError: (error: unknown) => string;
+    getAgentName: () => string;
+    getAgentEmoji: () => string;
+    getBrokerRole: () => "broker" | "follower" | null;
+    getRuntimeMode: () => SlackBridgeRuntimeMode;
+    isFollowerConnected: () => boolean;
+    isSinglePlayerConnected: () => boolean;
+    getActiveThreads: () => number;
+    getPendingInboxCount: () => number;
+    getDefaultChannel: () => string | null | undefined;
+    getBrokerHomeTabs: () => PinetHomeTabsBrokerPort;
+    getCurrentBranch?: () => Promise<string | null>;
+}
+export interface PinetHomeTabs {
+    refreshBrokerControlPlaneHomeTabs: (ctx: ExtensionContext, snapshot: BrokerControlPlaneDashboardSnapshot, refreshedAt: string, userIds?: string[]) => Promise<void>;
+    reportHomeTabPublishFailure: (ctx: ExtensionContext, err: unknown) => void;
+    publishCurrentPinetHomeTab: (userId: string, ctx: ExtensionContext, openedAt?: string) => Promise<void>;
+    publishCurrentPinetHomeTabSafely: (userId: string, ctx: ExtensionContext, openedAt?: string) => Promise<void>;
+}
+export declare function createPinetHomeTabs(deps: PinetHomeTabsDeps): PinetHomeTabs;