@pinet/slack-bridge 0.2.12 → 0.2.13

package/dist/code-anchor.d.ts

@@ -3,6 +3,7 @@ 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;
@@ -10,7 +11,10 @@ export interface CodeRevisionIdentity extends ContextJsonObject {
     baseOid: string | null;
     headOid: string;
     blobOid: string;
-    side: CodeAnchorSide;
+    anchorKind: CodeAnchorKind;
+    side?: CodeAnchorSide;
+    headBlobOid?: string | null;
+    dirty?: boolean;
 }
 export interface CodeAnchor extends CodeRevisionIdentity {
     startLine: number;
@@ -25,7 +29,7 @@ export interface ContextualThreadState extends ContextJsonObject {
 }
 export interface ContextualThreadMetadata extends ContextJsonObject {
     pinetKind: "contextual_thread";
-    schemaVersion: 1;
+    schemaVersion: 1 | 2;
     codeAnchor: CodeAnchor;
     state: ContextualThreadState;
 }
@@ -38,7 +42,10 @@ export declare function buildContextualThreadMetadata(input: {
     baseOid?: string | null;
     headOid: string;
     blobOid: string;
-    side: CodeAnchorSide;
+    anchorKind?: CodeAnchorKind;
+    side?: CodeAnchorSide;
+    headBlobOid?: string | null;
+    dirty?: boolean;
     startLine: number;
     endLine?: number;
     selectedText?: string | null;

package/dist/code-anchor.js

@@ -8,9 +8,12 @@ export function buildNvimThreadId(repoSocketHash) {
 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: 1,
+        schemaVersion: anchorKind === "normal" ? 2 : 1,
         codeAnchor: {
             repository: input.repository,
             worktree: input.worktree,
@@ -18,7 +21,11 @@ export function buildContextualThreadMetadata(input) {
             baseOid: input.baseOid ?? null,
             headOid: input.headOid,
             blobOid: input.blobOid,
-            side: input.side,
+            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,
@@ -43,7 +50,9 @@ function readPositiveInteger(record, key) {
 }
 export function parseContextualThreadMetadata(value) {
     const metadata = readRecord(value);
-    if (!metadata || metadata.pinetKind !== "contextual_thread" || metadata.schemaVersion !== 1) {
+    if (!metadata ||
+        metadata.pinetKind !== "contextual_thread" ||
+        (metadata.schemaVersion !== 1 && metadata.schemaVersion !== 2)) {
         return null;
     }
     const anchorRecord = readRecord(metadata.codeAnchor);
@@ -55,7 +64,14 @@ export function parseContextualThreadMetadata(value) {
     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 ||
@@ -63,7 +79,6 @@ export function parseContextualThreadMetadata(value) {
         !path ||
         !headOid ||
         !blobOid ||
-        !side ||
         startLine == null ||
         endLine == null) {
         return null;
@@ -72,7 +87,7 @@ export function parseContextualThreadMetadata(value) {
     const resolvedBy = readString(stateRecord, "resolvedBy");
     return {
         pinetKind: "contextual_thread",
-        schemaVersion: 1,
+        schemaVersion: metadata.schemaVersion,
         codeAnchor: {
             repository,
             worktree,
@@ -80,7 +95,14 @@ export function parseContextualThreadMetadata(value) {
             baseOid: readString(anchorRecord, "baseOid"),
             headOid,
             blobOid,
-            side,
+            anchorKind,
+            ...(side ? { side } : {}),
+            ...(anchorKind === "normal"
+                ? {
+                    headBlobOid: readString(anchorRecord, "headBlobOid"),
+                    dirty: anchorRecord.dirty === true,
+                }
+                : {}),
             startLine,
             endLine,
             selectedTextSha256: readString(anchorRecord, "selectedTextSha256"),
@@ -106,7 +128,10 @@ export function hasSameCodeRevision(anchor, candidate) {
         anchor.baseOid === candidate.baseOid &&
         anchor.headOid === candidate.headOid &&
         anchor.blobOid === candidate.blobOid &&
-        anchor.side === candidate.side);
+        anchor.anchorKind === candidate.anchorKind &&
+        anchor.side === candidate.side &&
+        anchor.headBlobOid === candidate.headBlobOid &&
+        anchor.dirty === candidate.dirty);
 }
 export function formatAnchorForMessage(metadata) {
     const anchor = metadata.codeAnchor;
@@ -114,5 +139,6 @@ export function formatAnchorForMessage(metadata) {
         ? `${anchor.path}:${anchor.startLine}`
         : `${anchor.path}:${anchor.startLine}-${anchor.endLine}`;
     const base = anchor.baseOid ? ` base=${anchor.baseOid}` : "";
-    return `[code-anchor ${range} side=${anchor.side} head=${anchor.headOid} blob=${anchor.blobOid}${base}]`;
+    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/index.js

@@ -631,7 +631,21 @@ export default function (pi) {
                     broker.db.queueMessage(decision.agentId, routedMessage);
                     return;
                 }
-                if (decision.action === "deliver" || decision.action === "unrouted") {
+                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;

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

@@ -1,7 +1,16 @@
-import { type ContextJsonValue } from "./code-anchor.js";
-import type { BrokerMessage, InboundMessage, MessageAdapter, OutboundMessage, ThreadInfo } from "./broker/types.js";
+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[];
@@ -27,6 +36,8 @@ export interface NvimPinetAdapterOptions extends NvimRepositoryContext {
     } | 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;
@@ -45,11 +56,17 @@ export declare class NvimPinetAdapter implements MessageAdapter {
     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;

package/dist/nvim-pinet-adapter.js

@@ -31,6 +31,12 @@ export function resolveNvimRepositoryContext(cwd) {
         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");
 }
@@ -82,7 +88,16 @@ function parseAnchor(payload) {
     const headOid = getString(anchor, "headOid");
     const blobOid = getString(anchor, "blobOid");
     const side = anchor.side === "old" || anchor.side === "new" ? anchor.side : null;
-    if (!repository || !worktree || !anchorPath || !headOid || !blobOid || !side)
+    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,
@@ -91,7 +106,11 @@ function parseAnchor(payload) {
         baseOid: getString(anchor, "baseOid"),
         headOid,
         blobOid,
-        side,
+        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.
@@ -101,7 +120,7 @@ function parseCreateThreadRequest(payload) {
     const anchor = parseAnchor(payload);
     const startLine = getPositiveInteger(payload, "startLine", null);
     const endLine = getPositiveInteger(payload, "endLine", startLine);
-    if (!targetAgentId || !body || !anchor || startLine == null || endLine == null)
+    if (!body || !anchor || startLine == null || endLine == null)
         return null;
     return {
         targetAgentId,
@@ -137,6 +156,21 @@ function parseListRequest(payload) {
         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));
 }
@@ -304,20 +338,54 @@ export class NvimPinetAdapter {
                 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("targetAgentId, body, anchor, startLine, and endLine are required");
+            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");
         }
-        if (!this.options.getAgentById(parsed.targetAgentId)) {
-            throw new Error(`Unknown target agent: ${parsed.targetAgentId}`);
+        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,
@@ -332,16 +400,17 @@ export class NvimPinetAdapter {
             threadId,
             source: "nvim",
             channel: this.repoSocketHash,
-            ownerAgent: parsed.targetAgentId,
+            ownerAgent: targetAgentId,
             ownerBinding: "explicit",
-            metadata: serializeMetadata(metadata),
+            metadata: { ...serializeMetadata(metadata), documentId },
             createdAt: now,
             updatedAt: now,
         });
-        this.emitInbound(threadId, parsed.targetAgentId, `${formatAnchorForMessage(metadata)}\n\n${parsed.body}`, {
+        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) };
     }
@@ -352,10 +421,12 @@ export class NvimPinetAdapter {
         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 };
     }
@@ -369,10 +440,12 @@ export class NvimPinetAdapter {
             throw new Error(`Unknown contextual thread: ${parsed.threadId}`);
         const updated = updateContextualThreadResolvedState(metadata, parsed.resolved, "nvim");
         this.options.db.updateThread(parsed.threadId, { metadata: serializeMetadata(updated) });
-        this.options.db.insertMessage(parsed.threadId, "nvim", "inbound", "nvim", parsed.resolved ? "Resolved this thread." : "Reopened this thread.", thread.ownerAgent ? [thread.ownerAgent] : [], {
+        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) };
@@ -403,6 +476,142 @@ export class NvimPinetAdapter {
             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 {

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.12",
+  "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.12",
-    "@pinet/imessage-bridge": "0.2.12",
-    "@pinet/pinet-core": "0.2.12",
-    "@pinet/transport-core": "0.2.12",
+    "@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",