@alignfirst/service-openclaw-plugin 0.4.2 → 0.5.0

package/README.md

@@ -43,8 +43,7 @@ their IDs to the corresponding native contract:
 The plugin observes successful native `message` actions but never creates a thread itself.
 
 - Slack evidence is a `send` to the current parent channel with an explicit `threadId`, nonempty body, `deliveryStatus: "sent"`, and `messageDelivery: { status: "settled", partialDelivery: false }`. The result must include a channel-kind `target` naming the parent and a nonempty `messageId`; `result.receipt.threadId`, when present, must match the requested thread. The plugin-path `{ ok, result }` shape used by team-qualified Slack sends is rejected.
-- Discord evidence is a successful anchored `thread-create` in the current parent channel with a
-  nonempty starter and returned thread ID. A partial result is rejected.
+- Discord evidence is the starter `thread-reply` into a thread the session created. A successful `thread-create` in the current parent channel, anchored on a message and returning a thread ID, records the thread for the session; it is never evidence by itself, even with content. The `thread-reply` into that thread must carry a nonempty starter, and a returned `result.channelId` must name the thread; `result.messageId` becomes the starter message ID. A partial result is rejected at either step. The created thread is kept in gateway memory for one hour.
 - `thread_handoff { "action": "start", "threadId": "..." }` returns `queued` or
   `alreadyStarted`, plus the opaque handoff ID and canonical target session key.
 
@@ -61,7 +60,7 @@ The receiving turn calls `thread_handoff { "action": "claim" }` once before task
 Inputs are strict. Errors begin with a stable reason code: `unsupportedContext`,
 `unverifiedThreadDelivery`, `conflictingHandoff`, `invalidTarget`, or
 `unavailablePersistentState`. A capacity failure preserves `STORE_LIMIT_EXCEEDED` as its cause.
-Rejected eligible delivery observations emit one debug line with `notSent`, `partialDelivery`, `channelMismatch`, `threadMismatch`, `missingMessageId`, `missingThread`, `missingStarter`, or `accountMismatch`. The line contains no starter text or result payload.
+Rejected eligible delivery observations emit one debug line with `notSent`, `partialDelivery`, `channelMismatch`, `threadMismatch`, `missingMessageId`, `missingThread`, `missingStarter`, `unknownThread`, or `accountMismatch`. The line contains no starter text or result payload.
 
 Starts are limited to distinct regular parent-channel sessions. DMs, group DMs, Slack Agent View,
 ACP, subagent, cron, global/shared, already-threaded, and ambiguous cross-account routes are not

package/dist/thread-handoff/index.js

@@ -21,7 +21,7 @@ export function registerThreadHandoff(api) {
         configuration,
         getStore,
         logger: api.logger,
-        cache: processShared("receipt-cache/v1", createReceiptCache),
+        cache: processShared("receipt-cache/v2", createReceiptCache),
     });
     const runIds = processShared("run-ids/v1", () => createRunIdCache());
     const service = createHandoffService({

package/dist/thread-handoff/receipts.d.ts

@@ -17,15 +17,21 @@ interface HookContext {
     sessionKey?: string;
     sessionId?: string;
 }
-/** Captured contexts and observation errors, shared by every registration of the plugin. */
+/**
+ * Captured contexts, threads created by a session and observation errors, shared by every
+ * registration of the plugin.
+ */
 export interface ReceiptCache {
     contexts: Map<string, CachedContext>;
+    createdThreads: Map<string, CachedEntry>;
     observationErrors: Map<string, Error>;
 }
-export interface CachedContext {
-    source: SourceContext;
+export interface CachedEntry {
     capturedAt: number;
 }
+export interface CachedContext extends CachedEntry {
+    source: SourceContext;
+}
 export declare function createReceiptCoordinator(params: {
     configuration: PluginConfiguration;
     getStore: () => HandoffStore;

package/dist/thread-handoff/receipts.js

@@ -7,43 +7,41 @@ const RECEIPT_WAIT_MS = 1_000;
 const RECEIPT_POLL_MS = 25;
 export function createReceiptCoordinator(params) {
     const now = params.now ?? Date.now;
-    const { contexts, observationErrors } = params.cache ?? createReceiptCache();
+    const { contexts, createdThreads, observationErrors } = params.cache ?? createReceiptCache();
     return {
         captureContext(context) {
             const source = readSourceContext(context, params.configuration);
             if (!source)
                 return;
             contexts.set(contextKey(source.sessionKey, source.sessionId), { source, capturedAt: now() });
-            pruneContexts(contexts, now());
+            pruneEntries(contexts, now());
         },
         observe(event, context) {
             const source = readCachedSource(contexts, context, now());
             if (!source || event.toolName !== "message" || event.error !== undefined)
                 return;
             const surface = params.configuration.channelSurfaces[source.channelId];
-            const receipt = parseDeliveryReceipt({
+            pruneEntries(createdThreads, now());
+            const result = parseObservation({
                 event,
                 source,
                 surface,
+                isCreatedThread: (threadId) => createdThreads.has(lookupKey(source.sessionKey, source.sessionId, threadId)),
                 now: now(),
             });
-            if (!receipt)
+            if (!result)
                 return;
-            if (typeof receipt === "string") {
+            if (typeof result === "string") {
                 const threadId = readObservedThreadId(event, surface);
-                params.logger.debug?.(`thread-handoff receipt rejected: surface=${surface} session=${source.sessionKey} thread=${threadId ?? "-"} reason=${receipt}`);
+                params.logger.debug?.(`thread-handoff receipt rejected: surface=${surface} session=${source.sessionKey} thread=${threadId ?? "-"} reason=${result}`);
                 return;
             }
-            const key = lookupKey(receipt.sessionKey, receipt.sessionId, receipt.threadId);
-            try {
-                params.getStore().insertReceipt(receipt, now());
-                observationErrors.delete(key);
-            }
-            catch (error) {
-                const storedError = error instanceof Error ? error : new Error(String(error));
-                observationErrors.set(key, storedError);
-                params.logger.error(`thread-handoff receipt persistence failed: ${storedError.message}`);
+            if ("createdThreadId" in result) {
+                const key = lookupKey(source.sessionKey, source.sessionId, result.createdThreadId);
+                createdThreads.set(key, { capturedAt: now() });
+                return;
             }
+            persistReceipt({ ...params, receipt: result, observationErrors, now: now() });
         },
         async waitForReceipt(identity) {
             const key = lookupKey(identity.sourceSessionKey, identity.sourceSessionId, identity.threadId);
@@ -60,36 +58,52 @@ export function createReceiptCoordinator(params) {
         },
     };
 }
+function persistReceipt(params) {
+    const { receipt, observationErrors } = params;
+    const key = lookupKey(receipt.sessionKey, receipt.sessionId, receipt.threadId);
+    try {
+        params.getStore().insertReceipt(receipt, params.now);
+        observationErrors.delete(key);
+    }
+    catch (error) {
+        const storedError = error instanceof Error ? error : new Error(String(error));
+        observationErrors.set(key, storedError);
+        params.logger.error(`thread-handoff receipt persistence failed: ${storedError.message}`);
+    }
+}
 export function createReceiptCache() {
-    return { contexts: new Map(), observationErrors: new Map() };
+    return { contexts: new Map(), createdThreads: new Map(), observationErrors: new Map() };
 }
 function readCachedSource(contexts, context, now) {
     const sessionKey = nonempty(context.sessionKey);
     const sessionId = nonempty(context.sessionId);
     if (!sessionKey || !sessionId)
         return;
-    pruneContexts(contexts, now);
+    pruneEntries(contexts, now);
     return contexts.get(contextKey(sessionKey, sessionId))?.source;
 }
-function pruneContexts(contexts, now) {
-    for (const [key, value] of contexts) {
+function pruneEntries(entries, now) {
+    for (const [key, value] of entries) {
         if (value.capturedAt + RECEIPT_TTL_MS <= now)
-            contexts.delete(key);
+            entries.delete(key);
     }
-    while (contexts.size > CONTEXT_LIMIT) {
-        const oldest = contexts.keys().next().value;
+    while (entries.size > CONTEXT_LIMIT) {
+        const oldest = entries.keys().next().value;
         if (typeof oldest !== "string")
             return;
-        contexts.delete(oldest);
+        entries.delete(oldest);
     }
 }
-function parseDeliveryReceipt(params) {
-    if (params.surface === "slack" && params.event.params.action === "send") {
+function parseObservation(params) {
+    const action = params.event.params.action;
+    if (params.surface === "slack" && action === "send")
         return parseSlackReceipt(params);
-    }
-    if (params.surface === "discord" && params.event.params.action === "thread-create") {
-        return parseDiscordReceipt(params);
-    }
+    if (params.surface !== "discord")
+        return;
+    if (action === "thread-create")
+        return parseDiscordThreadCreation(params);
+    if (action === "thread-reply")
+        return parseDiscordStarterReply(params);
     return;
 }
 function parseSlackReceipt(params) {
@@ -138,9 +152,9 @@ function parseSlackReceipt(params) {
         now: params.now,
     });
 }
-function parseDiscordReceipt(params) {
+/** A thread this session created in its own channel, anchored on a message. Not a receipt. */
+function parseDiscordThreadCreation(params) {
     const { event, source } = params;
-    const starterText = readStarter(event.params);
     const destination = readDestination(event.params);
     const anchorMessageId = nonempty(event.params.messageId);
     const details = readResultDetails(event.result);
@@ -148,8 +162,6 @@ function parseDiscordReceipt(params) {
     const threadId = nonempty(thread?.id);
     if (!threadId)
         return "missingThread";
-    if (starterText === undefined)
-        return "missingStarter";
     if (!anchorMessageId)
         return "missingMessageId";
     const returnedParent = nonempty(thread?.parent_id) ?? nonempty(thread?.parentId);
@@ -164,19 +176,50 @@ function parseDiscordReceipt(params) {
         return "partialDelivery";
     if (!accountMatches(event.params, source.accountId))
         return "accountMismatch";
+    return { createdThreadId: threadId };
+}
+/** The starter posted by `thread-reply` into a thread this session created. */
+function parseDiscordStarterReply(params) {
+    const { event, source } = params;
+    const threadId = readReplyThreadId(event.params);
+    if (!threadId)
+        return "missingThread";
+    const starterText = readStarter(event.params);
+    if (starterText === undefined)
+        return "missingStarter";
+    if (!params.isCreatedThread(threadId))
+        return "unknownThread";
+    const details = readResultDetails(event.result);
+    if (details?.ok !== true)
+        return "notSent";
+    if (details.partial === true)
+        return "partialDelivery";
+    const result = asRecord(details.result);
+    const returnedChannelId = nonempty(result?.channelId);
+    if (returnedChannelId !== undefined && returnedChannelId !== threadId)
+        return "threadMismatch";
+    if (!accountMatches(event.params, source.accountId))
+        return "accountMismatch";
     return createReceipt({
         source,
         threadId,
         starterText,
+        starterMessageId: nonempty(result?.messageId),
         toolCallId: event.toolCallId,
         now: params.now,
     });
 }
+/** Bundled Discord replies into `threadId`, or into the target when it is absent. */
+function readReplyThreadId(params) {
+    return nonempty(params.threadId) ?? readDestination(params)?.replace(/^channel:/i, "");
+}
 function readObservedThreadId(event, surface) {
     if (surface === "slack")
         return nonempty(event.params.threadId);
     if (surface !== "discord")
         return;
+    if (event.params.action === "thread-reply")
+        return readReplyThreadId(event.params);
     const details = readResultDetails(event.result);
     const thread = asRecord(details?.thread);
     return nonempty(thread?.id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alignfirst/service-openclaw-plugin",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "OpenClaw capabilities for the AlignFirst Dev Kit.",
   "keywords": [
     "alignfirst",
@@ -43,7 +43,7 @@
     "typebox": "~1.3.23"
   },
   "devDependencies": {
-    "@alignfirst/openclaw-channel-mock-core": "0.10.3",
+    "@alignfirst/openclaw-channel-mock-core": "0.11.0",
     "@types/node": "~26.5.0",
     "openclaw": "~2026.9.8",
     "rimraf": "~6.1.3",