@pinet/slack-bridge 0.2.11 → 0.2.13

package/dist/code-anchor.d.ts

@@ -0,0 +1,57 @@
+export type ContextJsonValue = string | number | boolean | null | ContextJsonObject | ContextJsonValue[];
+export interface ContextJsonObject {
+    [key: string]: ContextJsonValue | undefined;
+}
+export type CodeAnchorSide = "old" | "new";
+export type CodeAnchorKind = "diff" | "normal";
+export interface CodeRevisionIdentity extends ContextJsonObject {
+    repository: string;
+    worktree: string;
+    path: string;
+    baseOid: string | null;
+    headOid: string;
+    blobOid: string;
+    anchorKind: CodeAnchorKind;
+    side?: CodeAnchorSide;
+    headBlobOid?: string | null;
+    dirty?: boolean;
+}
+export interface CodeAnchor extends CodeRevisionIdentity {
+    startLine: number;
+    endLine: number;
+    selectedTextSha256: string | null;
+    contextSha256: string | null;
+}
+export interface ContextualThreadState extends ContextJsonObject {
+    resolved: boolean;
+    resolvedAt?: string;
+    resolvedBy?: string;
+}
+export interface ContextualThreadMetadata extends ContextJsonObject {
+    pinetKind: "contextual_thread";
+    schemaVersion: 1 | 2;
+    codeAnchor: CodeAnchor;
+    state: ContextualThreadState;
+}
+export declare function sha256Text(text: string): string;
+export declare function buildNvimThreadId(repoSocketHash: string): string;
+export declare function buildContextualThreadMetadata(input: {
+    repository: string;
+    worktree: string;
+    path: string;
+    baseOid?: string | null;
+    headOid: string;
+    blobOid: string;
+    anchorKind?: CodeAnchorKind;
+    side?: CodeAnchorSide;
+    headBlobOid?: string | null;
+    dirty?: boolean;
+    startLine: number;
+    endLine?: number;
+    selectedText?: string | null;
+    contextText?: string | null;
+}): ContextualThreadMetadata;
+export declare function parseContextualThreadMetadata(value: ContextJsonValue | undefined): ContextualThreadMetadata | null;
+export declare function updateContextualThreadResolvedState(metadata: ContextualThreadMetadata, resolved: boolean, actor: string, now?: string): ContextualThreadMetadata;
+export declare function hasSameCodeRevision(anchor: CodeAnchor, candidate: CodeRevisionIdentity): boolean;
+export declare function formatAnchorForMessage(metadata: ContextualThreadMetadata): string;

package/dist/code-anchor.js

@@ -0,0 +1,144 @@
+import { createHash, randomUUID } from "node:crypto";
+export function sha256Text(text) {
+    return createHash("sha256").update(text).digest("hex");
+}
+export function buildNvimThreadId(repoSocketHash) {
+    return `nvim:${repoSocketHash}:${randomUUID()}`;
+}
+export function buildContextualThreadMetadata(input) {
+    const startLine = Math.max(1, Math.floor(input.startLine));
+    const endLine = Math.max(startLine, Math.floor(input.endLine ?? startLine));
+    const anchorKind = input.anchorKind ?? "diff";
+    if (anchorKind === "diff" && !input.side)
+        throw new Error("diff code anchor side is required");
+    return {
+        pinetKind: "contextual_thread",
+        schemaVersion: anchorKind === "normal" ? 2 : 1,
+        codeAnchor: {
+            repository: input.repository,
+            worktree: input.worktree,
+            path: input.path,
+            baseOid: input.baseOid ?? null,
+            headOid: input.headOid,
+            blobOid: input.blobOid,
+            anchorKind,
+            ...(input.side ? { side: input.side } : {}),
+            ...(anchorKind === "normal"
+                ? { headBlobOid: input.headBlobOid ?? null, dirty: input.dirty === true }
+                : {}),
+            startLine,
+            endLine,
+            selectedTextSha256: input.selectedText ? sha256Text(input.selectedText) : null,
+            contextSha256: input.contextText ? sha256Text(input.contextText) : null,
+        },
+        state: { resolved: false },
+    };
+}
+function readRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function readPositiveInteger(record, key) {
+    const value = record[key];
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return null;
+    const integer = Math.floor(value);
+    return integer > 0 ? integer : null;
+}
+export function parseContextualThreadMetadata(value) {
+    const metadata = readRecord(value);
+    if (!metadata ||
+        metadata.pinetKind !== "contextual_thread" ||
+        (metadata.schemaVersion !== 1 && metadata.schemaVersion !== 2)) {
+        return null;
+    }
+    const anchorRecord = readRecord(metadata.codeAnchor);
+    const stateRecord = readRecord(metadata.state);
+    if (!anchorRecord || !stateRecord || typeof stateRecord.resolved !== "boolean")
+        return null;
+    const repository = readString(anchorRecord, "repository");
+    const worktree = readString(anchorRecord, "worktree");
+    const path = readString(anchorRecord, "path");
+    const headOid = readString(anchorRecord, "headOid");
+    const blobOid = readString(anchorRecord, "blobOid");
+    const anchorKind = metadata.schemaVersion === 2 ? anchorRecord.anchorKind : "diff";
+    if (anchorKind !== "diff" && anchorKind !== "normal")
+        return null;
+    const side = anchorRecord.side === "old" || anchorRecord.side === "new" ? anchorRecord.side : null;
+    if (anchorKind === "diff" && !side)
+        return null;
+    if (anchorKind === "normal" && typeof anchorRecord.dirty !== "boolean")
+        return null;
+    const startLine = readPositiveInteger(anchorRecord, "startLine");
+    const endLine = readPositiveInteger(anchorRecord, "endLine");
+    if (!repository ||
+        !worktree ||
+        !path ||
+        !headOid ||
+        !blobOid ||
+        startLine == null ||
+        endLine == null) {
+        return null;
+    }
+    const resolvedAt = readString(stateRecord, "resolvedAt");
+    const resolvedBy = readString(stateRecord, "resolvedBy");
+    return {
+        pinetKind: "contextual_thread",
+        schemaVersion: metadata.schemaVersion,
+        codeAnchor: {
+            repository,
+            worktree,
+            path,
+            baseOid: readString(anchorRecord, "baseOid"),
+            headOid,
+            blobOid,
+            anchorKind,
+            ...(side ? { side } : {}),
+            ...(anchorKind === "normal"
+                ? {
+                    headBlobOid: readString(anchorRecord, "headBlobOid"),
+                    dirty: anchorRecord.dirty === true,
+                }
+                : {}),
+            startLine,
+            endLine,
+            selectedTextSha256: readString(anchorRecord, "selectedTextSha256"),
+            contextSha256: readString(anchorRecord, "contextSha256"),
+        },
+        state: {
+            resolved: stateRecord.resolved,
+            ...(resolvedAt ? { resolvedAt } : {}),
+            ...(resolvedBy ? { resolvedBy } : {}),
+        },
+    };
+}
+export function updateContextualThreadResolvedState(metadata, resolved, actor, now = new Date().toISOString()) {
+    return {
+        ...metadata,
+        state: resolved ? { resolved: true, resolvedAt: now, resolvedBy: actor } : { resolved: false },
+    };
+}
+export function hasSameCodeRevision(anchor, candidate) {
+    return (anchor.repository === candidate.repository &&
+        anchor.worktree === candidate.worktree &&
+        anchor.path === candidate.path &&
+        anchor.baseOid === candidate.baseOid &&
+        anchor.headOid === candidate.headOid &&
+        anchor.blobOid === candidate.blobOid &&
+        anchor.anchorKind === candidate.anchorKind &&
+        anchor.side === candidate.side &&
+        anchor.headBlobOid === candidate.headBlobOid &&
+        anchor.dirty === candidate.dirty);
+}
+export function formatAnchorForMessage(metadata) {
+    const anchor = metadata.codeAnchor;
+    const range = anchor.startLine === anchor.endLine
+        ? `${anchor.path}:${anchor.startLine}`
+        : `${anchor.path}:${anchor.startLine}-${anchor.endLine}`;
+    const base = anchor.baseOid ? ` base=${anchor.baseOid}` : "";
+    const mode = anchor.anchorKind === "diff" ? `side=${anchor.side}` : `mode=normal dirty=${anchor.dirty}`;
+    return `[code-anchor ${range} ${mode} head=${anchor.headOid} blob=${anchor.blobOid}${base}]`;
+}

package/dist/contextual-thread-context.d.ts

@@ -0,0 +1,19 @@
+import { type ContextualThreadMetadata } from "./code-anchor.js";
+import type { ThreadInfo } from "./broker/types.js";
+export interface ContextualThreadContextMessage {
+    sender: string;
+    body: string;
+}
+export interface ContextualThreadContextRepository {
+    repository: string;
+    worktree: string;
+    headOid: string;
+    baseOid: string | null;
+}
+interface OpenContextualThread {
+    thread: ThreadInfo;
+    metadata: ContextualThreadMetadata;
+}
+export declare function selectOpenContextualThreads(threads: readonly ThreadInfo[], repository: ContextualThreadContextRepository, limit?: number): OpenContextualThread[];
+export declare function formatContextualThreadContext(items: readonly OpenContextualThread[], messagesByThread: ReadonlyMap<string, readonly ContextualThreadContextMessage[]>, maxCharacters?: number): string;
+export {};

package/dist/contextual-thread-context.js

@@ -0,0 +1,39 @@
+import { parseContextualThreadMetadata, } from "./code-anchor.js";
+export function selectOpenContextualThreads(threads, repository, limit = 5) {
+    return threads
+        .map((thread) => ({
+        thread,
+        metadata: parseContextualThreadMetadata(thread.metadata),
+    }))
+        .filter((item) => item.metadata !== null &&
+        !item.metadata.state.resolved &&
+        item.metadata.codeAnchor.repository === repository.repository &&
+        item.metadata.codeAnchor.worktree === repository.worktree &&
+        item.metadata.codeAnchor.headOid === repository.headOid &&
+        item.metadata.codeAnchor.baseOid === repository.baseOid)
+        .sort((left, right) => right.thread.updatedAt.localeCompare(left.thread.updatedAt))
+        .slice(0, Math.max(0, limit));
+}
+export function formatContextualThreadContext(items, messagesByThread, maxCharacters = 5000) {
+    if (items.length === 0)
+        return "";
+    const lines = [
+        "Open persisted Pinet code threads relevant to this worktree and revision:",
+        "Reply with `pinet action=reply args.thread_id=<id> args.message=<text>`; resolved threads are omitted.",
+    ];
+    for (const { thread, metadata } of items) {
+        const anchor = metadata.codeAnchor;
+        const range = anchor.startLine === anchor.endLine
+            ? `${anchor.path}:${anchor.startLine}`
+            : `${anchor.path}:${anchor.startLine}-${anchor.endLine}`;
+        lines.push(`- ${thread.threadId} — ${range} (${anchor.side})`);
+        for (const message of (messagesByThread.get(thread.threadId) ?? []).slice(-3)) {
+            const compactBody = message.body.replace(/\s+/g, " ").trim().slice(0, 600);
+            if (compactBody)
+                lines.push(`  ${message.sender}: ${compactBody}`);
+        }
+        if (lines.join("\n").length >= maxCharacters)
+            break;
+    }
+    return lines.join("\n").slice(0, maxCharacters);
+}

package/dist/index.js

@@ -22,6 +22,8 @@ import { createFollowerRuntime, resolveBrokerSocketPath, } from "./follower-runt
 import { createSinglePlayerRuntime, } from "./single-player-runtime.js";
 import { createBrokerRuntime } from "./broker-runtime.js";
 import { createSlackPinetRuntimeAdapterFactory } from "./slack-pinet-runtime-adapter.js";
+import { createNvimPinetRuntimeAdapterFactory, resolveNvimRepositoryContext, } from "./nvim-pinet-adapter.js";
+import { formatContextualThreadContext, selectOpenContextualThreads, } from "./contextual-thread-context.js";
 import { SlackActivityLogger } from "./activity-log.js";
 import { createBrokerDeliveryState, queueBrokerInboxIds } from "./broker-delivery.js";
 import { buildBrokerControlPlaneDashboardSnapshot } from "./broker/control-plane-dashboard.js";
@@ -629,8 +631,22 @@ export default function (pi) {
                     broker.db.queueMessage(decision.agentId, routedMessage);
                     return;
                 }
-                if (decision.action === "deliver" || decision.action === "unrouted") {
-                    const persisted = routedMessage.source === "slack" && routedMessage.threadId
+                if (decision.action === "broadcast") {
+                    const remoteAgentIds = decision.agentIds.filter((agentId) => agentId !== selfId);
+                    if (broker.db.queueMessageToAgents) {
+                        broker.db.queueMessageToAgents(remoteAgentIds, routedMessage);
+                    }
+                    else {
+                        for (const agentId of remoteAgentIds)
+                            broker.db.queueMessage(agentId, routedMessage);
+                    }
+                    if (!decision.agentIds.includes(selfId))
+                        return;
+                }
+                if (decision.action === "deliver" ||
+                    decision.action === "broadcast" ||
+                    decision.action === "unrouted") {
+                    const persisted = routedMessage.threadId
                         ? persistDeliveredInboundMessage(broker.db, selfId, routedMessage)
                         : null;
                     if (persisted && !persisted.result.freshDelivery) {
@@ -688,7 +704,7 @@ export default function (pi) {
         },
         buildControlPlaneDashboardSnapshot: (input) => buildBrokerControlPlaneDashboardSnapshot(input),
         buildCurrentDashboardSnapshot: async (openedAt) => buildCurrentBrokerControlPlaneDashboardSnapshot(openedAt),
-        createAdapterBindings: [slackPinetAdapterFactory],
+        createAdapterBindings: [slackPinetAdapterFactory, createNvimPinetRuntimeAdapterFactory()],
         onAdminShutdownRequested: async (ctx) => {
             // `/pinet start replace` from another local session: stop being the
             // broker but keep this session alive (issue #951).
@@ -1223,6 +1239,30 @@ export default function (pi) {
             requireToolPolicy,
             sendPinetAgentMessage,
             sendPinetBroadcastMessage,
+            replyToPinetThread: async (threadId, body) => {
+                if (brokerRole !== "broker") {
+                    if (!brokerClient?.client)
+                        throw new Error("Pinet is in an unexpected state.");
+                    const result = await brokerClient.client.sendMessage({ threadId, body });
+                    return {
+                        messageId: result.messageId,
+                        threadId: result.threadId,
+                        source: result.source,
+                        channel: result.channel,
+                    };
+                }
+                const broker = getActiveBroker();
+                const selfId = getActiveBrokerSelfId();
+                if (!broker || !selfId)
+                    throw new Error("Broker agent identity is unavailable.");
+                const result = await sendBrokerMessage({ db: broker.db, adapters: broker.adapters }, { threadId, body, senderAgentId: selfId });
+                return {
+                    messageId: result.message.id,
+                    threadId: result.thread.threadId,
+                    source: result.thread.source,
+                    channel: result.thread.channel,
+                };
+            },
             signalAgentFree,
             scheduleBrokerWakeup,
             scheduleFollowerWakeup,
@@ -1603,6 +1643,57 @@ export default function (pi) {
     });
     // ─── Agent event wiring ──────────────────────────────
     agentEventRuntime.register(pi);
+    pi.on("before_agent_start", async (_event, ctx) => {
+        if (!pinetEnabled || !brokerRole)
+            return;
+        const repository = resolveNvimRepositoryContext(ctx.cwd);
+        if (!repository)
+            return;
+        try {
+            const brokerDb = brokerRole === "broker" ? getActiveBrokerDb() : null;
+            const selfId = brokerRole === "broker" ? getActiveBrokerSelfId() : null;
+            const threads = brokerDb && selfId
+                ? brokerDb.getThreads(selfId)
+                : brokerRole === "follower" && brokerClient?.client
+                    ? await brokerClient.client.listThreads()
+                    : [];
+            const selected = selectOpenContextualThreads(threads, repository, 5);
+            if (selected.length === 0)
+                return;
+            const messagesByThread = new Map();
+            for (const item of selected) {
+                if (brokerDb) {
+                    messagesByThread.set(item.thread.threadId, brokerDb
+                        .getMessagesForThread(item.thread.threadId, 6)
+                        .map((message) => ({ sender: message.sender, body: message.body })));
+                    continue;
+                }
+                if (brokerClient?.client) {
+                    const result = await brokerClient.client.readInbox({
+                        threadId: item.thread.threadId,
+                        unreadOnly: false,
+                        markRead: false,
+                        limit: 6,
+                    });
+                    messagesByThread.set(item.thread.threadId, result.messages.map(({ message }) => ({ sender: message.sender, body: message.body })));
+                }
+            }
+            const content = formatContextualThreadContext(selected, messagesByThread);
+            if (!content)
+                return;
+            return {
+                message: {
+                    customType: "pinet-contextual-threads",
+                    content,
+                    display: true,
+                },
+            };
+        }
+        catch (error) {
+            console.error(`[slack-bridge] contextual thread hydration failed: ${msg(error)}`);
+            return;
+        }
+    });
     pi.on("session_before_compact", (event) => {
         compactionGate.begin(event.signal);
     });

package/dist/nvim-pinet-adapter.d.ts

@@ -0,0 +1,83 @@
+import { type CodeRevisionIdentity, type ContextJsonValue } from "./code-anchor.js";
+import type { BrokerMessage, InboundMessage, MessageAdapter, OutboundMessage, ThreadInfo, DocumentInfo } from "./broker/types.js";
+export interface NvimAdapterDbPort {
+    getThread(threadId: string): ThreadInfo | null;
+    getDocument(documentId: string): DocumentInfo | null;
+    getDocumentByAlias(source: string, externalId: string): DocumentInfo | null;
+    upsertDocument(document: Omit<DocumentInfo, "createdAt" | "updatedAt">): DocumentInfo;
+    bindDocumentAlias(source: string, externalId: string, documentId: string, metadata?: Record<string, ContextJsonValue> | null): void;
+    setDocumentOwner(documentId: string, ownerAgent: string | null): DocumentInfo;
+    subscribeDocument(documentId: string, agentId: string): void;
+    unsubscribeDocument(documentId: string, agentId: string): void;
+    listDocumentSubscribers(documentId: string): string[];
+    getDocumentRecipients(documentId: string): string[];
+    createThread(thread: ThreadInfo): ThreadInfo;
+    updateThread(threadId: string, updates: Partial<ThreadInfo>): void;
+    getThreads(ownerAgent?: string): ThreadInfo[];
+    getMessagesForThread(threadId: string, limit?: number): BrokerMessage[];
+    insertMessage(threadId: string, source: string, direction: "inbound" | "outbound", sender: string, body: string, targetAgentIds: string[], metadata?: Record<string, ContextJsonValue>): BrokerMessage;
+    getAgent?(agentId: string): {
+        id: string;
+        name: string;
+    } | null;
+}
+export interface NvimRepositoryContext {
+    repository: string;
+    worktree: string;
+    branch: string;
+    headOid: string;
+    baseOid: string | null;
+}
+export interface NvimPinetAdapterOptions extends NvimRepositoryContext {
+    db: NvimAdapterDbPort;
+    getAgentById: (agentId: string) => {
+        id: string;
+        name: string;
+    } | null;
+}
+export declare function resolveNvimRepositoryContext(cwd: string): NvimRepositoryContext | null;
+export declare function buildGitFileAliasExternalId(anchor: Pick<CodeRevisionIdentity, "repository" | "worktree" | "path">): string;
+export declare function buildGitFileDocumentId(anchor: Pick<CodeRevisionIdentity, "repository" | "worktree" | "path">): string;
+export declare function computeNvimSocketPath(worktree: string, branch: string): string;
+export declare class NvimPinetAdapter implements MessageAdapter {
+    private readonly options;
+    readonly name = "nvim";
+    private readonly repoSocketHash;
+    private readonly socketPath;
+    private server;
+    private inboundHandler;
+    private readonly clients;
+    private readonly editorState;
+    constructor(options: NvimPinetAdapterOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    onInbound(handler: (msg: InboundMessage) => void): void;
+    send(message: OutboundMessage): Promise<void>;
+    private accept;
+    private handleLine;
+    private handleRequest;
+    private resolveGitDocument;
+    private createThread;
+    private replyToThread;
+    private resolveThread;
+    private listThreads;
+    private getThread;
+    private getDocument;
+    private setDocumentOwner;
+    private subscribeDocument;
+    private bindDocumentThread;
+    private emitDocumentEvent;
+    private serializeThread;
+    private emitInbound;
+    private broadcast;
+}
+export declare function createNvimPinetRuntimeAdapterFactory(): (context: {
+    broker: {
+        db: NvimAdapterDbPort;
+    };
+    ctx: {
+        cwd: string;
+    };
+}) => {
+    adapter: MessageAdapter;
+} | [];

package/dist/nvim-pinet-adapter.js

@@ -0,0 +1,663 @@
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as path from "node:path";
+import { buildContextualThreadMetadata, buildNvimThreadId, formatAnchorForMessage, hasSameCodeRevision, parseContextualThreadMetadata, updateContextualThreadResolvedState, } from "./code-anchor.js";
+function git(cwd, ...args) {
+    return execFileSync("git", args, {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+}
+export function resolveNvimRepositoryContext(cwd) {
+    try {
+        const worktree = fs.realpathSync(git(cwd, "rev-parse", "--show-toplevel"));
+        const commonDir = fs.realpathSync(git(cwd, "rev-parse", "--path-format=absolute", "--git-common-dir"));
+        const repository = path.basename(commonDir) === ".git" ? path.dirname(commonDir) : commonDir;
+        const branch = git(cwd, "branch", "--show-current");
+        const headOid = git(cwd, "rev-parse", "HEAD");
+        let baseOid = null;
+        try {
+            baseOid = git(cwd, "merge-base", "HEAD", "@{upstream}");
+        }
+        catch {
+            baseOid = null;
+        }
+        return { repository, worktree, branch, headOid, baseOid };
+    }
+    catch {
+        return null;
+    }
+}
+export function buildGitFileAliasExternalId(anchor) {
+    return `${anchor.repository}\0${anchor.worktree}\0${anchor.path}`;
+}
+export function buildGitFileDocumentId(anchor) {
+    return `doc:git-file:${createHash("sha256").update(buildGitFileAliasExternalId(anchor)).digest("hex")}`;
+}
+function computeRepoSocketHash(worktree, branch) {
+    return createHash("sha256").update(`${worktree}:${branch}`).digest("hex");
+}
+export function computeNvimSocketPath(worktree, branch) {
+    const dir = "/tmp/pi-nvim";
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.chmodSync(dir, 0o700);
+    return path.join(dir, `${computeRepoSocketHash(worktree, branch)}.sock`);
+}
+function getRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function getString(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function getPositiveInteger(record, key, fallback) {
+    const value = record[key];
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    const integer = Math.floor(value);
+    return integer > 0 ? integer : fallback;
+}
+// agent-standards-ignore prefer-inline-single-use-helper: versioned socket envelope parser is a protocol boundary.
+function parseRequest(line) {
+    const parsed = JSON.parse(line);
+    const record = getRecord(parsed);
+    const id = record ? getString(record, "id") : null;
+    const type = record ? getString(record, "type") : null;
+    if (!record || !type)
+        return { id, request: null };
+    return {
+        id,
+        request: {
+            id,
+            type,
+            payload: getRecord(record.payload) ?? record,
+        },
+    };
+}
+function parseAnchor(payload) {
+    const anchor = getRecord(payload.anchor);
+    if (!anchor)
+        return null;
+    const repository = getString(anchor, "repository");
+    const worktree = getString(anchor, "worktree");
+    const anchorPath = getString(anchor, "path");
+    const headOid = getString(anchor, "headOid");
+    const blobOid = getString(anchor, "blobOid");
+    const side = anchor.side === "old" || anchor.side === "new" ? anchor.side : null;
+    const anchorKind = anchor.anchorKind === "normal" || anchor.anchorKind === "diff"
+        ? anchor.anchorKind
+        : side
+            ? "diff"
+            : null;
+    if (!repository || !worktree || !anchorPath || !headOid || !blobOid || !anchorKind)
+        return null;
+    if (anchorKind === "diff" && !side)
+        return null;
+    if (anchorKind === "normal" && typeof anchor.dirty !== "boolean")
+        return null;
+    return {
+        repository,
+        worktree,
+        path: anchorPath,
+        baseOid: getString(anchor, "baseOid"),
+        headOid,
+        blobOid,
+        anchorKind,
+        ...(side ? { side } : {}),
+        ...(anchorKind === "normal"
+            ? { headBlobOid: getString(anchor, "headBlobOid"), dirty: anchor.dirty === true }
+            : {}),
+    };
+}
+// agent-standards-ignore prefer-inline-single-use-helper: create payload parser is a named protocol DTO boundary.
+function parseCreateThreadRequest(payload) {
+    const targetAgentId = getString(payload, "targetAgentId");
+    const body = getString(payload, "body");
+    const anchor = parseAnchor(payload);
+    const startLine = getPositiveInteger(payload, "startLine", null);
+    const endLine = getPositiveInteger(payload, "endLine", startLine);
+    if (!body || !anchor || startLine == null || endLine == null)
+        return null;
+    return {
+        targetAgentId,
+        body,
+        anchor,
+        startLine,
+        endLine,
+        selectedText: getString(payload, "selectedText"),
+        contextText: getString(payload, "contextText"),
+    };
+}
+// agent-standards-ignore prefer-inline-single-use-helper: reply payload parser is a named protocol DTO boundary.
+function parseReplyRequest(payload) {
+    const threadId = getString(payload, "threadId");
+    const body = getString(payload, "body");
+    return threadId && body ? { threadId, body } : null;
+}
+// agent-standards-ignore prefer-inline-single-use-helper: resolution payload parser is a named protocol DTO boundary.
+function parseResolveRequest(payload) {
+    const threadId = getString(payload, "threadId");
+    if (!threadId || typeof payload.resolved !== "boolean")
+        return null;
+    return { threadId, resolved: payload.resolved };
+}
+// agent-standards-ignore prefer-inline-single-use-helper: list payload parser is a named protocol DTO boundary.
+function parseListRequest(payload) {
+    const anchor = parseAnchor(payload);
+    if (!anchor)
+        return null;
+    return {
+        anchor,
+        includeResolved: typeof payload.includeResolved === "boolean" ? payload.includeResolved : false,
+        limit: getPositiveInteger(payload, "limit", 100) ?? 100,
+    };
+}
+// agent-standards-ignore prefer-inline-single-use-helper: document payload parser is a named protocol DTO boundary.
+function parseDocumentRequest(payload) {
+    const anchor = parseAnchor(payload);
+    return anchor ? { anchor } : null;
+}
+function parseBindThreadRequest(payload) {
+    const anchor = parseAnchor(payload);
+    const threadId = getString(payload, "threadId");
+    return anchor && threadId ? { anchor, threadId } : null;
+}
+function parseDocumentAgentRequest(payload) {
+    const anchor = parseAnchor(payload);
+    const agentId = getString(payload, "agentId");
+    return anchor && agentId ? { anchor, agentId } : null;
+}
+function serializeMetadata(metadata) {
+    return JSON.parse(JSON.stringify(metadata));
+}
+function sendJson(socket, payload) {
+    socket.write(`${JSON.stringify(payload)}\n`);
+}
+export class NvimPinetAdapter {
+    options;
+    name = "nvim";
+    repoSocketHash;
+    socketPath;
+    server = null;
+    inboundHandler = null;
+    clients = new Set();
+    editorState = {
+        file: null,
+        line: null,
+        visibleStart: null,
+        visibleEnd: null,
+        selectionStart: null,
+        selectionEnd: null,
+    };
+    constructor(options) {
+        this.options = options;
+        this.repoSocketHash = computeRepoSocketHash(options.worktree, options.branch);
+        this.socketPath = computeNvimSocketPath(options.worktree, options.branch);
+    }
+    async connect() {
+        try {
+            fs.unlinkSync(this.socketPath);
+        }
+        catch {
+            // Missing stale socket is fine.
+        }
+        await new Promise((resolve, reject) => {
+            this.server = net.createServer((socket) => this.accept(socket));
+            this.server.once("error", reject);
+            this.server.listen(this.socketPath, () => {
+                this.server?.off("error", reject);
+                fs.chmodSync(this.socketPath, 0o600);
+                resolve();
+            });
+        });
+    }
+    async disconnect() {
+        for (const client of this.clients)
+            client.destroy();
+        this.clients.clear();
+        await new Promise((resolve) => {
+            if (!this.server)
+                return resolve();
+            this.server.close(() => resolve());
+            this.server = null;
+        });
+        try {
+            fs.unlinkSync(this.socketPath);
+        }
+        catch {
+            // Ignore stale socket cleanup failures.
+        }
+    }
+    onInbound(handler) {
+        this.inboundHandler = handler;
+    }
+    async send(message) {
+        this.broadcast({
+            type: "thread.updated",
+            payload: {
+                threadId: message.threadId,
+                channel: message.channel,
+                body: message.text,
+                sender: message.agentName ?? "agent",
+            },
+        });
+    }
+    accept(socket) {
+        this.clients.add(socket);
+        let buffer = "";
+        socket.on("data", (data) => {
+            buffer += data.toString();
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (line.trim())
+                    this.handleLine(socket, line);
+            }
+        });
+        socket.on("close", () => this.clients.delete(socket));
+        socket.on("error", () => this.clients.delete(socket));
+    }
+    handleLine(socket, line) {
+        let request = null;
+        let requestId = null;
+        try {
+            const parsed = parseRequest(line);
+            request = parsed.request;
+            requestId = parsed.id;
+            if (!request) {
+                sendJson(socket, {
+                    type: "error",
+                    id: requestId ?? "request-error",
+                    error: { code: "invalid_request", message: "type is required" },
+                });
+                return;
+            }
+            const result = this.handleRequest(request);
+            if (request.id)
+                sendJson(socket, { type: "ok", id: request.id, result });
+        }
+        catch (error) {
+            sendJson(socket, {
+                type: "error",
+                id: requestId ?? request?.id ?? "request-error",
+                error: {
+                    code: "request_error",
+                    message: error instanceof Error ? error.message : "nvim request failed",
+                },
+            });
+        }
+    }
+    handleRequest(request) {
+        switch (request.type) {
+            case "buffer_focus": {
+                const file = getString(request.payload, "file");
+                const line = getPositiveInteger(request.payload, "line", null);
+                if (file)
+                    this.editorState.file = file;
+                if (line != null)
+                    this.editorState.line = line;
+                return { status: "ok" };
+            }
+            case "visible_range": {
+                const file = getString(request.payload, "file");
+                if (file)
+                    this.editorState.file = file;
+                this.editorState.visibleStart = getPositiveInteger(request.payload, "start", null);
+                this.editorState.visibleEnd = getPositiveInteger(request.payload, "end", null);
+                return { status: "ok" };
+            }
+            case "selection": {
+                const file = getString(request.payload, "file");
+                if (file)
+                    this.editorState.file = file;
+                this.editorState.selectionStart = getPositiveInteger(request.payload, "start", null);
+                this.editorState.selectionEnd = getPositiveInteger(request.payload, "end", null);
+                return { status: "ok" };
+            }
+            case "editor.context":
+                return { ...this.editorState };
+            case "editor.open": {
+                const file = getString(request.payload, "file");
+                if (!file)
+                    throw new Error("file is required");
+                const line = getPositiveInteger(request.payload, "line", null);
+                this.broadcast({ type: "open_file", file, ...(line ? { line } : {}) });
+                return { delivered: this.clients.size > 1 };
+            }
+            case "pinet.thread.create":
+                return this.createThread(request.payload);
+            case "pinet.thread.reply":
+                return this.replyToThread(request.payload);
+            case "pinet.thread.resolve":
+                return this.resolveThread(request.payload);
+            case "pinet.thread.list":
+                return this.listThreads(request.payload);
+            case "pinet.thread.get":
+                return this.getThread(request.payload);
+            case "pinet.document.get":
+                return this.getDocument(request.payload);
+            case "pinet.document.owner":
+                return this.setDocumentOwner(request.payload);
+            case "pinet.document.subscribe":
+                return this.subscribeDocument(request.payload, true);
+            case "pinet.document.unsubscribe":
+                return this.subscribeDocument(request.payload, false);
+            case "pinet.document.bind_thread":
+                return this.bindDocumentThread(request.payload);
+            default:
+                throw new Error(`Unknown nvim request: ${request.type}`);
+        }
+    }
+    resolveGitDocument(anchor) {
+        return (this.options.db.getDocumentByAlias("nvim", buildGitFileAliasExternalId(anchor)) ??
+            this.options.db.getDocument(buildGitFileDocumentId(anchor)));
+    }
+    createThread(payload) {
+        const parsed = parseCreateThreadRequest(payload);
+        if (!parsed)
+            throw new Error("body, anchor, startLine, and endLine are required");
+        if (parsed.anchor.repository !== this.options.repository ||
+            parsed.anchor.worktree !== this.options.worktree) {
+            throw new Error("code anchor does not belong to this Pinet worktree");
+        }
+        let document = this.resolveGitDocument(parsed.anchor);
+        const documentId = document?.documentId ?? buildGitFileDocumentId(parsed.anchor);
+        const targetAgentId = parsed.targetAgentId ?? document?.ownerAgent ?? null;
+        if (!targetAgentId)
+            throw new Error("targetAgentId is required until this document has an owner");
+        if (!this.options.getAgentById(targetAgentId)) {
+            throw new Error(`Unknown target agent: ${targetAgentId}`);
+        }
+        if (!document) {
+            document = this.options.db.upsertDocument({
+                documentId,
+                kind: "git_file",
+                title: parsed.anchor.path,
+                ownerAgent: targetAgentId,
+                ownerBinding: "explicit",
+                metadata: {
+                    repository: parsed.anchor.repository,
+                    worktree: parsed.anchor.worktree,
+                    path: parsed.anchor.path,
+                },
+            });
+            this.options.db.bindDocumentAlias("nvim", buildGitFileAliasExternalId(parsed.anchor), documentId);
+        }
+        const metadata = buildContextualThreadMetadata({
+            ...parsed.anchor,
+            startLine: parsed.startLine,
+            endLine: parsed.endLine,
+            selectedText: parsed.selectedText,
+            contextText: parsed.contextText,
+        });
+        const threadId = buildNvimThreadId(this.repoSocketHash);
+        const now = new Date().toISOString();
+        this.options.db.createThread({
+            threadId,
+            source: "nvim",
+            channel: this.repoSocketHash,
+            ownerAgent: targetAgentId,
+            ownerBinding: "explicit",
+            metadata: { ...serializeMetadata(metadata), documentId },
+            createdAt: now,
+            updatedAt: now,
+        });
+        this.emitInbound(threadId, targetAgentId, `${formatAnchorForMessage(metadata)}\n\n${parsed.body}`, {
+            pinetKind: "contextual_thread_message",
+            schemaVersion: 1,
+            event: "thread.created",
+            documentId,
+        });
+        return { threadId, metadata: serializeMetadata(metadata) };
+    }
+    replyToThread(payload) {
+        const parsed = parseReplyRequest(payload);
+        if (!parsed)
+            throw new Error("threadId and body are required");
+        const thread = this.options.db.getThread(parsed.threadId);
+        if (!thread)
+            throw new Error(`Unknown thread: ${parsed.threadId}`);
+        const documentId = typeof thread.metadata?.documentId === "string" ? thread.metadata.documentId : null;
+        this.emitInbound(parsed.threadId, thread.ownerAgent ?? "", parsed.body, {
+            pinetKind: "contextual_thread_message",
+            schemaVersion: 1,
+            event: "thread.reply",
+            ...(documentId ? { documentId } : {}),
+        });
+        return { threadId: parsed.threadId };
+    }
+    resolveThread(payload) {
+        const parsed = parseResolveRequest(payload);
+        if (!parsed)
+            throw new Error("threadId and resolved are required");
+        const thread = this.options.db.getThread(parsed.threadId);
+        const metadata = parseContextualThreadMetadata(thread?.metadata);
+        if (!thread || !metadata)
+            throw new Error(`Unknown contextual thread: ${parsed.threadId}`);
+        const updated = updateContextualThreadResolvedState(metadata, parsed.resolved, "nvim");
+        this.options.db.updateThread(parsed.threadId, { metadata: serializeMetadata(updated) });
+        const documentId = typeof thread.metadata?.documentId === "string" ? thread.metadata.documentId : null;
+        this.emitInbound(parsed.threadId, thread.ownerAgent ?? "", parsed.resolved ? "Resolved this thread." : "Reopened this thread.", {
+            pinetKind: "contextual_thread_message",
+            schemaVersion: 1,
+            event: parsed.resolved ? "thread.resolved" : "thread.reopened",
+            ...(documentId ? { documentId } : {}),
+        });
+        this.broadcast({ type: "thread.updated", payload: { threadId: parsed.threadId } });
+        return { threadId: parsed.threadId, metadata: serializeMetadata(updated) };
+    }
+    listThreads(payload) {
+        const parsed = parseListRequest(payload);
+        if (!parsed)
+            throw new Error("revision-aware anchor is required");
+        const threads = this.options.db
+            .getThreads()
+            .map((thread) => ({
+            thread,
+            metadata: parseContextualThreadMetadata(thread.metadata),
+        }))
+            .filter((item) => item.metadata !== null && hasSameCodeRevision(item.metadata.codeAnchor, parsed.anchor))
+            .filter((item) => parsed.includeResolved || !item.metadata.state.resolved)
+            .slice(0, parsed.limit)
+            .map((item) => this.serializeThread(item.thread, item.metadata, 20));
+        return { threads };
+    }
+    getThread(payload) {
+        const threadId = getString(payload, "threadId");
+        if (!threadId)
+            throw new Error("threadId is required");
+        const thread = this.options.db.getThread(threadId);
+        const metadata = parseContextualThreadMetadata(thread?.metadata);
+        if (!thread || !metadata)
+            throw new Error(`Unknown contextual thread: ${threadId}`);
+        return this.serializeThread(thread, metadata, 50);
+    }
+    getDocument(payload) {
+        const parsed = parseDocumentRequest(payload);
+        if (!parsed)
+            throw new Error("revision-aware anchor is required");
+        const document = this.resolveGitDocument(parsed.anchor);
+        const documentId = document?.documentId ?? buildGitFileDocumentId(parsed.anchor);
+        return {
+            documentId,
+            ownerAgentId: document?.ownerAgent ?? null,
+            subscribers: document ? this.options.db.listDocumentSubscribers(documentId) : [],
+        };
+    }
+    setDocumentOwner(payload) {
+        const parsed = parseDocumentAgentRequest(payload);
+        if (!parsed)
+            throw new Error("anchor and agentId are required");
+        if (!this.options.getAgentById(parsed.agentId))
+            throw new Error(`Unknown agent: ${parsed.agentId}`);
+        const existingDocument = this.resolveGitDocument(parsed.anchor);
+        const documentId = existingDocument?.documentId ?? buildGitFileDocumentId(parsed.anchor);
+        if (!existingDocument) {
+            this.options.db.upsertDocument({
+                documentId,
+                kind: "git_file",
+                title: parsed.anchor.path,
+                ownerAgent: parsed.agentId,
+                ownerBinding: "explicit",
+                metadata: {
+                    repository: parsed.anchor.repository,
+                    worktree: parsed.anchor.worktree,
+                    path: parsed.anchor.path,
+                },
+            });
+        }
+        else {
+            this.options.db.setDocumentOwner(documentId, parsed.agentId);
+        }
+        this.options.db.bindDocumentAlias("nvim", buildGitFileAliasExternalId(parsed.anchor), documentId);
+        for (const thread of this.options.db.getThreads()) {
+            if (thread.metadata?.documentId === documentId && thread.ownerAgent !== parsed.agentId) {
+                this.options.db.updateThread(thread.threadId, {
+                    ownerAgent: parsed.agentId,
+                    ownerBinding: "explicit",
+                });
+            }
+        }
+        this.emitDocumentEvent(documentId, parsed.agentId, `Document owner changed to ${parsed.agentId}.`, "document.owner_changed");
+        return this.getDocument({ anchor: parsed.anchor });
+    }
+    subscribeDocument(payload, subscribe) {
+        const parsed = parseDocumentAgentRequest(payload);
+        if (!parsed)
+            throw new Error("anchor and agentId are required");
+        if (!this.options.getAgentById(parsed.agentId))
+            throw new Error(`Unknown agent: ${parsed.agentId}`);
+        const document = this.resolveGitDocument(parsed.anchor);
+        const documentId = document?.documentId ?? buildGitFileDocumentId(parsed.anchor);
+        if (!document)
+            throw new Error(`Unknown document: ${documentId}`);
+        if (subscribe)
+            this.options.db.subscribeDocument(documentId, parsed.agentId);
+        else
+            this.options.db.unsubscribeDocument(documentId, parsed.agentId);
+        const updatedDocument = this.options.db.getDocument(documentId);
+        this.emitDocumentEvent(documentId, updatedDocument.ownerAgent ?? parsed.agentId, subscribe
+            ? `${parsed.agentId} subscribed to this document.`
+            : `${parsed.agentId} unsubscribed from this document.`, subscribe ? "document.subscribed" : "document.unsubscribed");
+        return this.getDocument({ anchor: parsed.anchor });
+    }
+    bindDocumentThread(payload) {
+        const parsed = parseBindThreadRequest(payload);
+        if (!parsed)
+            throw new Error("anchor and threadId are required");
+        const document = this.resolveGitDocument(parsed.anchor);
+        if (!document?.ownerAgent)
+            throw new Error("Set a document owner before binding a Slack thread");
+        const thread = this.options.db.getThread(parsed.threadId);
+        if (!thread || thread.source !== "slack") {
+            throw new Error(`Unknown Slack thread: ${parsed.threadId}`);
+        }
+        const previousDocumentId = typeof thread.metadata?.documentId === "string" ? thread.metadata.documentId : null;
+        if (previousDocumentId && previousDocumentId !== document.documentId) {
+            for (const subscriber of this.options.db.listDocumentSubscribers(previousDocumentId)) {
+                this.options.db.subscribeDocument(document.documentId, subscriber);
+            }
+        }
+        const referenceExternalId = `${thread.channel}\0${thread.threadId}`;
+        this.options.db.bindDocumentAlias("slack-thread-ref", referenceExternalId, document.documentId, { channelId: thread.channel, threadTs: thread.threadId });
+        const scopedExternalId = typeof thread.metadata?.documentAliasExternalId === "string"
+            ? thread.metadata.documentAliasExternalId
+            : null;
+        if (scopedExternalId) {
+            this.options.db.bindDocumentAlias("slack", scopedExternalId, document.documentId, {
+                channelId: thread.channel,
+                threadTs: thread.threadId,
+            });
+        }
+        this.options.db.updateThread(thread.threadId, {
+            ownerAgent: document.ownerAgent,
+            ownerBinding: "explicit",
+            metadata: {
+                ...(thread.metadata ?? {}),
+                documentId: document.documentId,
+                documentReferenceExternalId: referenceExternalId,
+            },
+        });
+        this.emitDocumentEvent(document.documentId, document.ownerAgent, `Bound Slack thread ${thread.channel}/${thread.threadId} to this document.`, "document.thread_bound");
+        return this.getDocument({ anchor: parsed.anchor });
+    }
+    emitDocumentEvent(documentId, ownerAgentId, body, event) {
+        const threadId = `document:${documentId}`;
+        const now = new Date().toISOString();
+        const existing = this.options.db.getThread(threadId);
+        if (!existing) {
+            this.options.db.createThread({
+                threadId,
+                source: "nvim",
+                channel: this.repoSocketHash,
+                ownerAgent: ownerAgentId,
+                ownerBinding: "explicit",
+                metadata: { pinetKind: "document_thread", documentId },
+                createdAt: now,
+                updatedAt: now,
+            });
+        }
+        else if (existing.ownerAgent !== ownerAgentId) {
+            this.options.db.updateThread(threadId, { ownerAgent: ownerAgentId });
+        }
+        this.emitInbound(threadId, ownerAgentId, body, {
+            pinetKind: "document_message",
+            schemaVersion: 1,
+            event,
+            documentId,
+        });
+        this.broadcast({ type: "document.updated", payload: { documentId } });
+    }
+    serializeThread(thread, metadata, messageLimit) {
+        const messages = this.options.db.getMessagesForThread(thread.threadId, messageLimit);
+        return {
+            threadId: thread.threadId,
+            updatedAt: thread.updatedAt,
+            metadata: serializeMetadata(metadata),
+            messages: messages.map((message) => ({
+                id: message.id,
+                sender: message.sender,
+                direction: message.direction,
+                body: message.body,
+                createdAt: message.createdAt,
+            })),
+        };
+    }
+    emitInbound(threadId, targetAgentId, text, metadata) {
+        this.inboundHandler?.({
+            source: "nvim",
+            threadId,
+            channel: this.repoSocketHash,
+            userId: "nvim",
+            userName: "Neovim",
+            text,
+            timestamp: new Date().toISOString(),
+            metadata: {
+                ...metadata,
+                ...(targetAgentId ? { threadAffinityOwnerAgentId: targetAgentId } : {}),
+            },
+        });
+    }
+    broadcast(payload) {
+        for (const client of this.clients)
+            sendJson(client, payload);
+    }
+}
+export function createNvimPinetRuntimeAdapterFactory() {
+    return ({ broker, ctx }) => {
+        const repositoryContext = resolveNvimRepositoryContext(ctx.cwd);
+        if (!repositoryContext)
+            return [];
+        return {
+            adapter: new NvimPinetAdapter({
+                ...repositoryContext,
+                db: broker.db,
+                getAgentById: (agentId) => broker.db.getAgent?.(agentId) ?? null,
+            }),
+        };
+    };
+}

package/dist/pinet-tools.d.ts

@@ -66,6 +66,12 @@ export interface RegisterPinetToolsDeps {
         messageIds: number[];
         recipients: string[];
     };
+    replyToPinetThread?: (threadId: string, body: string) => Promise<{
+        messageId: number;
+        threadId: string;
+        source: string;
+        channel: string;
+    }>;
     signalAgentFree: (ctx: ExtensionContext | undefined, options: {
         requirePinet?: boolean;
     }) => Promise<{

package/dist/pinet-tools.js

@@ -19,6 +19,9 @@ const PINET_DISPATCHER_EXAMPLES = {
         { action: "send", args: { to: "@worker", message: "Please review PR #123" } },
         { action: "send", args: { to: "@worker", message: "/steer stop polling" } },
     ],
+    reply: [
+        { action: "reply", args: { thread_id: "nvim:<repo>:<id>", message: "I updated this block." } },
+    ],
     read: [
         // Routine inbox drain: defaults are `unread_only: true` + `mark_read: true`,
         // so this returns and consumes only this agent's unread rows. The compact
@@ -100,6 +103,7 @@ function normalizeDispatcherAction(value) {
         "help",
         "send",
         "read",
+        "reply",
         "free",
         "snooze",
         "schedule",
@@ -681,6 +685,44 @@ function runPinetSendAction(params, deps, toolName, output) {
         };
     })();
 }
+// agent-standards-ignore prefer-inline-single-use-helper: dispatcher actions are kept as named seams for progressive discovery.
+function runPinetReplyAction(params, deps, toolName, output) {
+    return (async () => {
+        const threadId = typeof params.thread_id === "string" ? params.thread_id.trim() : "";
+        const message = typeof params.message === "string" ? params.message : "";
+        if (!threadId)
+            throw new Error("thread_id is required");
+        if (!message)
+            throw new Error("message is required");
+        if (!deps.replyToPinetThread) {
+            throw new Error("pinet:reply is only available when the broker thread sender is active.");
+        }
+        deps.requireToolPolicy(toolName, undefined, `thread_id=${threadId} | message=${message}`);
+        const result = await deps.replyToPinetThread(threadId, message);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: output.full
+                        ? `Reply sent to ${result.source} thread ${result.threadId} (${result.channel}); message id ${result.messageId}.`
+                        : `Pinet thread reply sent to ${result.threadId}.`,
+                },
+            ],
+            details: result,
+            compactDetails: {
+                messageId: result.messageId,
+                threadId: result.threadId,
+                source: result.source,
+            },
+            expandedText: buildSentMessageExpandedText([
+                ["thread id", result.threadId],
+                ["source", result.source],
+                ["channel", result.channel],
+                ["message id", String(result.messageId)],
+            ], message),
+        };
+    })();
+}
 function runPinetReadAction(params, deps, toolName, output) {
     return (async () => {
         deps.requireToolPolicy(toolName, undefined, `thread_id=${params.thread_id ?? ""} | limit=${params.limit ?? ""} | unread_only=${params.unread_only ?? ""} | mark_read=${params.mark_read ?? ""} | format=${output.format} | full=${output.full}`);
@@ -1765,6 +1807,16 @@ export function registerPinetTools(pi, deps) {
         }),
         execute: (_id, params, output) => runPinetSendAction(params, deps, "pinet:send", output),
     });
+    registerAction({
+        name: "reply",
+        description: "Reply to an existing Pinet transport thread using the thread's stored source/channel. Use for ordinary anchored contextual threads such as Neovim code comments.",
+        parameters: Type.Object({
+            thread_id: Type.String({ description: "Existing Pinet transport thread id." }),
+            message: Type.String({ description: "Reply body." }),
+            ...PINET_OUTPUT_OPTION_PARAMETERS,
+        }),
+        execute: (_id, params, output) => runPinetReplyAction(params, deps, "pinet:reply", output),
+    });
     registerAction({
         name: "read",
         description: "Read this agent's durable SQLite-backed Pinet inbox context with unread/read semantics. Defaults to draining unread rows (`unread_only: true`, `mark_read: true`) with compact per-message previews — no `full=true` required for routine reads. Override `unread_only`/`mark_read` only for a non-destructive latest-history peek. Ordinary workers only see rows addressed to their own agent identity; broker coordination visibility is limited to broker-addressed inbox rows.",
@@ -1998,7 +2050,7 @@ export function registerPinetTools(pi, deps) {
         promptGuidelines: deps.promptGuidelines,
         parameters: Type.Object({
             action: Type.String({
-                description: "Action name: help, send, read, free, snooze, schedule, agents, sessions, lanes, ports, reload, exit, hibernate (broker-managed checkpoint+hibernate), or wake (broker-managed fenced wake). Also supports spawn for launching worker-owned subtree children.",
+                description: "Action name: help, send, read, reply, free, snooze, schedule, agents, sessions, lanes, ports, reload, exit, hibernate (broker-managed checkpoint+hibernate), or wake (broker-managed fenced wake). 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-pinet-runtime-adapter.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { SlackAdapter } from "./broker/adapters/slack.js";
 export function readStoredSlackThreadContext(metadata) {
     const value = metadata?.slackThreadContext;
@@ -34,12 +35,45 @@ function getKnownSlackThread(broker, threadTs) {
     };
 }
 function rememberKnownSlackThread(broker, threadTs, channelId, context) {
-    const existingMetadata = broker.db.getThread(threadTs)?.metadata ?? {};
+    const existing = broker.db.getThread(threadTs);
+    const existingMetadata = existing?.metadata ?? {};
+    const scopeKey = context ? JSON.stringify(context.scope) : "workspace";
+    const externalId = `${scopeKey}\0${channelId}\0${threadTs}`;
+    const referenceExternalId = `${channelId}\0${threadTs}`;
+    const aliasedDocument = broker.db.getDocumentByAlias("slack-thread-ref", referenceExternalId) ??
+        broker.db.getDocumentByAlias("slack", externalId);
+    const documentId = aliasedDocument?.documentId ??
+        `doc:slack-thread:${createHash("sha256").update(externalId).digest("hex")}`;
+    if (!aliasedDocument) {
+        broker.db.upsertDocument({
+            documentId,
+            kind: "slack_thread",
+            title: `Slack ${channelId}/${threadTs}`,
+            ownerAgent: existing?.ownerAgent ?? null,
+            ownerBinding: existing?.ownerBinding ?? null,
+            metadata: {
+                channelId,
+                threadTs,
+                ...(context ? { slackThreadContext: context } : {}),
+            },
+        });
+    }
+    broker.db.bindDocumentAlias("slack", externalId, documentId, {
+        channelId,
+        threadTs,
+    });
+    broker.db.bindDocumentAlias("slack-thread-ref", referenceExternalId, documentId, {
+        channelId,
+        threadTs,
+    });
     broker.db.updateThread(threadTs, {
         source: "slack",
         channel: channelId,
         metadata: {
             ...existingMetadata,
+            documentId,
+            documentAliasExternalId: externalId,
+            documentReferenceExternalId: referenceExternalId,
             ...(context ? { slackThreadContext: context } : {}),
         },
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinet/slack-bridge",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "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 --config ../vitest.config.ts"
   },
   "dependencies": {
-    "@pinet/broker-core": "0.2.11",
-    "@pinet/imessage-bridge": "0.2.11",
-    "@pinet/pinet-core": "0.2.11",
-    "@pinet/transport-core": "0.2.11",
+    "@pinet/broker-core": "0.2.13",
+    "@pinet/imessage-bridge": "0.2.13",
+    "@pinet/pinet-core": "0.2.13",
+    "@pinet/transport-core": "0.2.13",
     "@sinclair/typebox": "^0.34.49"
   },
   "types": "./dist/index.d.ts",