@alignfirst/service-openclaw-plugin 0.4.1 → 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
@@ -73,7 +72,7 @@ The plugin commits a pending record before dispatching `Take over this thread.`
 
 The message body is static: it carries no starter copy, routing fields, or handoff ID. The playbook routes by thread metadata, claims the current session, and reads the visible starter and human replies through thread history. The nudge supplies no missing input or approval. A takeover turn with nothing to report ends with `HEARTBEAT_OK`; the deterministic gateway probe confirmed that `NO_REPLY` still triggers isolated finalization on this path.
 
-The plugin starts the thread session and does nothing after that. Alcode completion uses OpenClaw's own completion path.
+The plugin starts the thread session and does nothing after that. `aligndev code` completion uses OpenClaw's own completion path.
 
 Each takeover turn gets the regular agent budget from `agents.defaults.timeoutSeconds`, including the 48-hour OpenClaw default and the unlimited `0` value.
 
@@ -111,7 +110,7 @@ npm run lint --workspace @alignfirst/service-openclaw-plugin
 ```
 
 The ordinary test command excludes the real-gateway suite. To exercise the package as an external
-plugin against the pinned OpenClaw 2026.9.5 runtime, including Slack/Discord delivery, concurrent human messages, duplicate starts, same-session continuation, and abrupt restart recovery:
+plugin against the OpenClaw runtime pinned in the root lockfile, including Slack/Discord delivery, concurrent human messages, duplicate starts, same-session continuation, and abrupt restart recovery:
 
 ```bash
 KEEP_THREAD_HANDOFF_ARTIFACTS=1 npm run test:integration --workspace @alignfirst/service-openclaw-plugin

package/dist/thread-handoff/index.js

@@ -1,5 +1,6 @@
 import { registerThreadHandoffCli } from "./cli.js";
-import { createReceiptCoordinator } from "./receipts.js";
+import { processShared } from "./process-shared.js";
+import { createReceiptCache, createReceiptCoordinator } from "./receipts.js";
 import { createRunIdCache } from "./run-ids.js";
 import { createHandoffService } from "./service.js";
 import { createHandoffStore, resolveDatabasePath } from "./state.js";
@@ -16,8 +17,13 @@ export function registerThreadHandoff(api) {
         store ??= createHandoffStore(api.runtime.state.resolveStateDir());
         return store;
     };
-    const receipts = createReceiptCoordinator({ configuration, getStore, logger: api.logger });
-    const runIds = createRunIdCache();
+    const receipts = createReceiptCoordinator({
+        configuration,
+        getStore,
+        logger: api.logger,
+        cache: processShared("receipt-cache/v2", createReceiptCache),
+    });
+    const runIds = processShared("run-ids/v1", () => createRunIdCache());
     const service = createHandoffService({
         runtime: api.runtime,
         configuration,

package/dist/thread-handoff/process-shared.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the value stored under `name` for the whole gateway process, created on first use.
+ *
+ * Since 2026.9.8, OpenClaw evaluates this plugin more than once in one gateway process: a turn
+ * takes its tools from the gateway's registration and runs its tool hooks in its own. State that
+ * both a tool and a hook read must outlive a single registration.
+ */
+export declare function processShared<T>(name: string, create: () => T): T;

package/dist/thread-handoff/process-shared.js

@@ -0,0 +1,15 @@
+/**
+ * Returns the value stored under `name` for the whole gateway process, created on first use.
+ *
+ * Since 2026.9.8, OpenClaw evaluates this plugin more than once in one gateway process: a turn
+ * takes its tools from the gateway's registration and runs its tool hooks in its own. State that
+ * both a tool and a hook read must outlive a single registration.
+ */
+export function processShared(name, create) {
+    const slots = globalThis;
+    const key = Symbol.for(`@alignfirst/service-openclaw-plugin/${name}`);
+    if (!(key in slots))
+        slots[key] = create();
+    // The slot holds what `create` returned under this versioned name.
+    return slots[key];
+}

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

@@ -1,6 +1,6 @@
 import type { OpenClawPluginToolContext, PluginLogger } from "openclaw/plugin-sdk/plugin-entry";
 import type { HandoffStore } from "./state.js";
-import type { DeliveryReceipt, PluginConfiguration, ReceiptIdentity } from "./types.js";
+import type { DeliveryReceipt, PluginConfiguration, ReceiptIdentity, SourceContext } from "./types.js";
 export interface ReceiptCoordinator {
     captureContext(context: OpenClawPluginToolContext): void;
     observe(event: ToolObservation, context: HookContext): void;
@@ -17,10 +17,27 @@ interface HookContext {
     sessionKey?: string;
     sessionId?: string;
 }
+/**
+ * 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 CachedEntry {
+    capturedAt: number;
+}
+export interface CachedContext extends CachedEntry {
+    source: SourceContext;
+}
 export declare function createReceiptCoordinator(params: {
     configuration: PluginConfiguration;
     getStore: () => HandoffStore;
     logger: PluginLogger;
+    cache?: ReceiptCache;
     now?: () => number;
 }): ReceiptCoordinator;
+export declare function createReceiptCache(): ReceiptCache;
 export {};

package/dist/thread-handoff/receipts.js

@@ -7,44 +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 = new Map();
-    const observationErrors = new Map();
+    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);
@@ -61,33 +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(), 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) {
@@ -136,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);
@@ -146,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);
@@ -162,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.1",
+  "version": "0.5.0",
   "description": "OpenClaw capabilities for the AlignFirst Dev Kit.",
   "keywords": [
     "alignfirst",
@@ -43,9 +43,9 @@
     "typebox": "~1.3.23"
   },
   "devDependencies": {
-    "@alignfirst/openclaw-channel-mock-core": "0.10.1",
+    "@alignfirst/openclaw-channel-mock-core": "0.11.0",
     "@types/node": "~26.5.0",
-    "openclaw": "~2026.9.3",
+    "openclaw": "~2026.9.8",
     "rimraf": "~6.1.3",
     "typescript": "~7.0.2",
     "vitest": "~5.0.1"