@useorgx/openclaw-plugin 0.4.9 → 0.7.2

package/dist/http/routes/chat.js

@@ -0,0 +1,522 @@
+import { getChatThread, linkChatThreadScope, listChatThreads, recordChatLaunch, sendChatMessage, updateChatLaunchStatus, } from "../../chat-store.js";
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const entry of value) {
+        if (typeof entry !== "string")
+            continue;
+        const trimmed = entry.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+    }
+    return out;
+}
+function normalizeStatus(value) {
+    const normalized = (value ?? "").trim().toLowerCase();
+    if (normalized === "requested" ||
+        normalized === "queued" ||
+        normalized === "running" ||
+        normalized === "blocked" ||
+        normalized === "completed" ||
+        normalized === "failed") {
+        return normalized;
+    }
+    return "requested";
+}
+function normalizeAttachments(input) {
+    if (!Array.isArray(input))
+        return [];
+    return input
+        .map((entry) => asRecord(entry))
+        .filter((entry) => Boolean(entry))
+        .map((entry) => ({
+        id: typeof entry.id === "string" ? entry.id : undefined,
+        name: typeof entry.name === "string" ? entry.name : undefined,
+        mimeType: typeof entry.mimeType === "string" ? entry.mimeType : null,
+        sizeBytes: typeof entry.sizeBytes === "number" && Number.isFinite(entry.sizeBytes)
+            ? Math.max(0, Math.floor(entry.sizeBytes))
+            : null,
+        status: entry.status === "preparing" ||
+            entry.status === "indexing" ||
+            entry.status === "ready" ||
+            entry.status === "failed"
+            ? entry.status
+            : "ready",
+        error: typeof entry.error === "string" ? entry.error : null,
+        masked: entry.masked === true,
+    }));
+}
+function extractUiMessageText(value) {
+    const row = asRecord(value);
+    if (!row)
+        return null;
+    const parts = Array.isArray(row.parts) ? row.parts : [];
+    const text = parts
+        .map((part) => asRecord(part))
+        .filter((part) => Boolean(part))
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => String(part.text).trim())
+        .filter(Boolean)
+        .join(" ")
+        .trim();
+    if (text.length > 0)
+        return text;
+    if (typeof row.content === "string" && row.content.trim().length > 0) {
+        return row.content.trim();
+    }
+    return null;
+}
+function extractLastUserPrompt(messages) {
+    if (!Array.isArray(messages))
+        return null;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = asRecord(messages[index]);
+        if (!message)
+            continue;
+        if (message.role !== "user")
+            continue;
+        const text = extractUiMessageText(message);
+        if (text)
+            return text;
+    }
+    return null;
+}
+function chunkText(value, chunkSize = 36) {
+    const compact = value.replace(/\s+/g, " ").trim();
+    if (!compact)
+        return [];
+    const chunks = [];
+    for (let i = 0; i < compact.length; i += chunkSize) {
+        chunks.push(compact.slice(i, i + chunkSize));
+    }
+    return chunks;
+}
+function buildAssistantReply(input) {
+    const hasAgent = Boolean(input.assigneeName);
+    const hasScope = Boolean(input.initiativeTitle);
+    if (hasAgent && hasScope) {
+        return `Got it \u2014 ${input.assigneeName} is on it. Scoped to ${input.initiativeTitle}.`;
+    }
+    if (hasAgent && !hasScope) {
+        return `Got it \u2014 ${input.assigneeName} is assigned. Scope to an initiative when ready to launch.`;
+    }
+    if (!hasAgent && hasScope) {
+        return `Saved to ${input.initiativeTitle}. Pick an agent with @ to get started.`;
+    }
+    return "Message saved. Pick an agent with @ and scope with # to get started.";
+}
+function sendThreadList(deps, res, input) {
+    const listed = listChatThreads({
+        commandCenterId: input.commandCenterId,
+        initiativeId: input.initiativeId,
+        query: input.query,
+        status: input.status,
+        limit: input.limit,
+        offset: input.offset,
+    });
+    deps.sendJson(res, 200, {
+        ok: true,
+        threads: listed.threads,
+        total: listed.total,
+        limit: input.limit,
+        offset: input.offset,
+        updatedAt: listed.updatedAt,
+    });
+}
+async function emitThreadEvent(deps, input) {
+    if (typeof deps.emitActivitySafe !== "function")
+        return;
+    const normalizedStatus = (input.status ?? "").trim().toLowerCase();
+    const phase = normalizedStatus === "running"
+        ? "execution"
+        : normalizedStatus === "blocked" || normalizedStatus === "failed"
+            ? "blocked"
+            : normalizedStatus === "completed"
+                ? "completed"
+                : "intent";
+    try {
+        await deps.emitActivitySafe({
+            initiativeId: input.thread.initiativeId ?? null,
+            sourceClient: "openclaw",
+            message: input.message,
+            phase,
+            metadata: {
+                event: input.event,
+                activity_bucket: "message",
+                thread_id: input.thread.id,
+                message_id: input.messageId ?? null,
+                launch_id: input.launchId ?? null,
+                run_id: input.runId ?? null,
+                status: input.status ?? null,
+                initiative_id: input.thread.initiativeId ?? null,
+                workstream_id: input.thread.workstreamId ?? null,
+                task_id: input.thread.taskId ?? null,
+                assignee_id: input.assigneeId ?? null,
+                watcher_count: input.watcherCount ?? null,
+                provider: input.provider ?? null,
+            },
+        });
+    }
+    catch {
+        // best effort
+    }
+}
+export function registerChatRoutes(router, deps) {
+    router.add("GET", "chat/threads", async ({ query, res }) => {
+        try {
+            const commandCenterId = query.get("project_id") ??
+                query.get("workspace_id") ??
+                query.get("workspaceId") ??
+                query.get("command_center_id") ??
+                query.get("commandCenterId");
+            const initiativeId = query.get("initiative_id") ?? query.get("initiative");
+            const searchQuery = query.get("query") ?? query.get("q");
+            const status = query.get("status");
+            const limit = deps.parsePositiveInt(query.get("limit"), 60);
+            const offset = deps.parsePositiveInt(query.get("offset"), 0);
+            sendThreadList(deps, res, {
+                commandCenterId: commandCenterId?.trim() ?? null,
+                initiativeId: initiativeId?.trim() ?? null,
+                query: searchQuery?.trim() ?? null,
+                status: status?.trim() ?? null,
+                limit,
+                offset,
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, { ok: false, error: deps.safeErrorMessage(err) });
+        }
+    }, "List chat threads");
+    router.add("GET", "chat/threads/*", async ({ path, res }) => {
+        try {
+            const match = path.match(/^chat\/threads\/([^/]+)$/);
+            if (!match) {
+                deps.sendJson(res, 404, { ok: false, error: "Unknown API endpoint" });
+                return;
+            }
+            const threadId = decodeURIComponent(match[1]).trim();
+            if (!threadId) {
+                deps.sendJson(res, 400, { ok: false, error: "threadId is required" });
+                return;
+            }
+            const thread = getChatThread(threadId);
+            if (!thread) {
+                deps.sendJson(res, 404, { ok: false, error: "thread not found" });
+                return;
+            }
+            deps.sendJson(res, 200, { ok: true, thread });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, { ok: false, error: deps.safeErrorMessage(err) });
+        }
+    }, "Get chat thread detail");
+    router.add("POST", "chat/messages", async ({ req, res }) => {
+        try {
+            const payload = await deps.parseJsonRequest(req);
+            const threadId = deps.pickString(payload, ["threadId", "thread_id"]);
+            const body = deps.pickString(payload, ["body", "message", "text"]);
+            if (!body) {
+                deps.sendJson(res, 400, { ok: false, error: "message body is required" });
+                return;
+            }
+            const result = sendChatMessage({
+                threadId,
+                commandCenterId: deps.pickString(payload, [
+                    "projectId",
+                    "project_id",
+                    "workspaceId",
+                    "workspace_id",
+                    "commandCenterId",
+                    "command_center_id",
+                ]) ??
+                    null,
+                initiativeId: deps.pickString(payload, ["initiativeId", "initiative_id"]) ?? null,
+                initiativeTitle: deps.pickString(payload, [
+                    "initiativeTitle",
+                    "initiative_title",
+                    "initiativeName",
+                    "initiative_name",
+                ]) ?? null,
+                workstreamId: deps.pickString(payload, ["workstreamId", "workstream_id"]) ?? null,
+                taskId: deps.pickString(payload, ["taskId", "task_id"]) ?? null,
+                title: deps.pickString(payload, ["title"]),
+                body,
+                senderId: deps.pickString(payload, ["senderId", "sender_id", "authorId", "author_id"]),
+                senderName: deps.pickString(payload, ["senderName", "sender_name", "authorName", "author_name"]),
+                assigneeId: deps.pickString(payload, ["assigneeId", "assignee_id"]),
+                assigneeName: deps.pickString(payload, ["assigneeName", "assignee_name"]),
+                watcherIds: asStringArray(payload.watcherIds),
+                watcherNames: asStringArray(payload.watcherNames),
+                attachments: normalizeAttachments(payload.attachments),
+                metadata: asRecord(payload.metadata) ?? {},
+            });
+            await emitThreadEvent(deps, {
+                event: result.createdThread ? "chat_thread_created" : "chat_message_sent",
+                message: result.createdThread
+                    ? `Thread created: ${result.thread.title}`
+                    : `Message sent: ${result.thread.title}`,
+                thread: result.thread,
+                messageId: result.message.id,
+                assigneeId: result.thread.assigneeId,
+                watcherCount: result.thread.watcherIds.length,
+                status: result.thread.status,
+            });
+            deps.sendJson(res, 201, {
+                ok: true,
+                createdThread: result.createdThread,
+                thread: result.thread,
+                message: result.message,
+                updatedAt: result.updatedAt,
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, { ok: false, error: deps.safeErrorMessage(err) });
+        }
+    }, "Create thread message");
+    router.add("POST", "chat/usechat", async ({ req, res }) => {
+        try {
+            const payload = await deps.parseJsonRequest(req);
+            const threadId = deps.pickString(payload, ["threadId", "thread_id"]);
+            const prompt = deps.pickString(payload, ["prompt", "text", "message"]) ??
+                extractLastUserPrompt(payload.messages);
+            if (!prompt) {
+                deps.sendJson(res, 400, { ok: false, error: "A user prompt is required." });
+                return;
+            }
+            const assigneeId = deps.pickString(payload, ["assigneeId", "assignee_id"]);
+            const assigneeName = deps.pickString(payload, ["assigneeName", "assignee_name"]);
+            const initiativeId = deps.pickString(payload, ["initiativeId", "initiative_id"]);
+            const initiativeTitle = deps.pickString(payload, [
+                "initiativeTitle",
+                "initiative_title",
+                "initiativeName",
+                "initiative_name",
+            ]);
+            const watcherIds = asStringArray(payload.watcherIds);
+            const watcherNames = asStringArray(payload.watcherNames);
+            const commandCenterId = deps.pickString(payload, [
+                "projectId",
+                "project_id",
+                "workspaceId",
+                "workspace_id",
+                "commandCenterId",
+                "command_center_id",
+            ]) ??
+                null;
+            const reply = buildAssistantReply({
+                prompt,
+                assigneeName,
+                initiativeTitle,
+                watcherCount: watcherIds.length > 0 ? watcherIds.length : watcherNames.length,
+            });
+            // Persist the assistant guidance onto the active thread when possible, without
+            // altering the user-message-first thread summary semantics.
+            if (threadId && getChatThread(threadId)) {
+                const result = sendChatMessage({
+                    threadId,
+                    commandCenterId,
+                    initiativeId,
+                    initiativeTitle,
+                    role: "agent",
+                    body: reply,
+                    senderId: assigneeId ?? "orgx-assistant",
+                    senderName: assigneeName ?? "OrgX Assistant",
+                    watcherIds,
+                    watcherNames,
+                    metadata: {
+                        source: "usechat",
+                        mode: "guidance",
+                    },
+                });
+                await emitThreadEvent(deps, {
+                    event: "chat_assistant_guidance_sent",
+                    message: `Assistant guidance updated: ${result.thread.title}`,
+                    thread: result.thread,
+                    messageId: result.message.id,
+                    assigneeId: result.thread.assigneeId,
+                    watcherCount: result.thread.watcherIds.length,
+                    status: result.thread.status,
+                });
+            }
+            const writable = res;
+            const write = writable.write?.bind(writable);
+            if (!writable.writeHead || !write || !writable.end) {
+                deps.sendJson(res, 501, { ok: false, error: "Streaming not supported" });
+                return;
+            }
+            writable.writeHead(200, {
+                "Content-Type": "text/plain; charset=utf-8",
+                "Cache-Control": "no-cache, no-transform",
+                Connection: "keep-alive",
+            });
+            const chunks = chunkText(reply, 28);
+            for (let index = 0; index < chunks.length; index += 1) {
+                const chunk = index === chunks.length - 1 ? chunks[index] : `${chunks[index]} `;
+                const writeOk = write(chunk);
+                if (!writeOk && typeof writable.once === "function") {
+                    await new Promise((resolve) => writable.once?.("drain", resolve));
+                }
+                await new Promise((resolve) => setTimeout(resolve, 12));
+            }
+            writable.end();
+        }
+        catch (err) {
+            deps.sendJson(res, 500, { ok: false, error: deps.safeErrorMessage(err) });
+        }
+    }, "Stream assistant guidance for Vercel useChat");
+    router.add("POST", "chat/launch", async ({ req, res }) => {
+        try {
+            const payload = await deps.parseJsonRequest(req);
+            const threadId = deps.pickString(payload, ["threadId", "thread_id"]);
+            const messageId = deps.pickString(payload, ["messageId", "message_id"]);
+            if (!threadId || !messageId) {
+                deps.sendJson(res, 400, {
+                    ok: false,
+                    error: "threadId and messageId are required",
+                });
+                return;
+            }
+            const status = normalizeStatus(deps.pickString(payload, ["status"]));
+            const result = recordChatLaunch({
+                threadId,
+                messageId,
+                assigneeId: deps.pickString(payload, ["assigneeId", "assignee_id"]),
+                assigneeName: deps.pickString(payload, ["assigneeName", "assignee_name"]),
+                watcherIds: asStringArray(payload.watcherIds),
+                watcherNames: asStringArray(payload.watcherNames),
+                executionMode: deps.pickString(payload, ["executionMode", "execution_mode"]) === "cloud"
+                    ? "cloud"
+                    : deps.pickString(payload, ["executionMode", "execution_mode"]) === "hybrid"
+                        ? "hybrid"
+                        : "local_queue",
+                provider: deps.pickString(payload, ["provider", "runtimeProvider", "runtime_provider"]),
+                runId: deps.pickString(payload, ["runId", "run_id", "sessionId", "session_id"]),
+                status,
+                blockedReason: deps.pickString(payload, ["blockedReason", "blocked_reason", "error", "reason"]),
+                warnings: asStringArray(payload.warnings),
+                metadata: asRecord(payload.metadata) ?? {},
+            });
+            await emitThreadEvent(deps, {
+                event: status === "queued"
+                    ? "chat_launch_queued"
+                    : status === "running"
+                        ? "chat_launch_started"
+                        : status === "blocked"
+                            ? "chat_launch_blocked"
+                            : status === "completed"
+                                ? "chat_launch_completed"
+                                : status === "failed"
+                                    ? "chat_launch_failed"
+                                    : "chat_launch_requested",
+                message: status === "blocked"
+                    ? `Launch blocked: ${result.thread.title}`
+                    : `Launch ${status}: ${result.thread.title}`,
+                thread: result.thread,
+                messageId,
+                launchId: result.launch.id,
+                runId: result.launch.runId,
+                status,
+                assigneeId: result.launch.assigneeId,
+                watcherCount: result.launch.watcherIds.length,
+                provider: result.launch.provider,
+            });
+            deps.sendJson(res, 201, {
+                ok: true,
+                thread: result.thread,
+                launch: result.launch,
+                updatedAt: result.updatedAt,
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, { ok: false, error: deps.safeErrorMessage(err) });
+        }
+    }, "Record chat launch attempt");
+    router.add("PATCH", "chat/launch", async ({ req, res }) => {
+        try {
+            const payload = await deps.parseJsonRequest(req);
+            const threadId = deps.pickString(payload, ["threadId", "thread_id"]);
+            const launchId = deps.pickString(payload, ["launchId", "launch_id"]);
+            if (!threadId || !launchId) {
+                deps.sendJson(res, 400, { ok: false, error: "threadId and launchId are required" });
+                return;
+            }
+            const result = updateChatLaunchStatus({
+                threadId,
+                launchId,
+                status: normalizeStatus(deps.pickString(payload, ["status"])),
+                runId: deps.pickString(payload, ["runId", "run_id", "sessionId", "session_id"]),
+                blockedReason: deps.pickString(payload, ["blockedReason", "blocked_reason", "error"]),
+                warnings: asStringArray(payload.warnings),
+            });
+            deps.sendJson(res, 200, {
+                ok: true,
+                thread: result.thread,
+                launch: result.launch,
+                updatedAt: result.updatedAt,
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, { ok: false, error: deps.safeErrorMessage(err) });
+        }
+    }, "Update chat launch status");
+    router.add("POST", "chat/link", async ({ req, res }) => {
+        try {
+            const payload = await deps.parseJsonRequest(req);
+            const threadId = deps.pickString(payload, ["threadId", "thread_id"]);
+            if (!threadId) {
+                deps.sendJson(res, 400, { ok: false, error: "threadId is required" });
+                return;
+            }
+            const result = linkChatThreadScope({
+                threadId,
+                commandCenterId: deps.pickString(payload, [
+                    "projectId",
+                    "project_id",
+                    "workspaceId",
+                    "workspace_id",
+                    "commandCenterId",
+                    "command_center_id",
+                ]) ??
+                    null,
+                initiativeId: deps.pickString(payload, ["initiativeId", "initiative_id"]),
+                initiativeTitle: deps.pickString(payload, [
+                    "initiativeTitle",
+                    "initiative_title",
+                    "initiativeName",
+                    "initiative_name",
+                ]) ?? null,
+                workstreamId: deps.pickString(payload, ["workstreamId", "workstream_id"]),
+                taskId: deps.pickString(payload, ["taskId", "task_id"]),
+            });
+            const metadata = asRecord(payload);
+            const relinked = Boolean(metadata?.relinked === true);
+            await emitThreadEvent(deps, {
+                event: relinked ? "chat_thread_relinked_initiative" : "chat_thread_linked_initiative",
+                message: result.eventMessage.body,
+                thread: result.thread,
+                messageId: result.eventMessage.id,
+                status: result.thread.status,
+                assigneeId: result.thread.assigneeId,
+                watcherCount: result.thread.watcherIds.length,
+            });
+            deps.sendJson(res, 200, {
+                ok: true,
+                thread: result.thread,
+                eventMessage: result.eventMessage,
+                updatedAt: result.updatedAt,
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, { ok: false, error: deps.safeErrorMessage(err) });
+        }
+    }, "Link/relink chat thread scope");
+}

package/dist/http/routes/decision-actions.d.ts

@@ -3,9 +3,16 @@ type JsonRecord = Record<string, unknown>;
 type DecisionAction = "approve" | "reject";
 type RegisterDecisionActionsRoutesDeps<TReq, TRes> = {
     parseJsonRequest: (req: TReq) => Promise<JsonRecord>;
-    bulkDecideDecisions: (ids: string[], action: DecisionAction, note?: string) => Promise<Array<{
+    bulkDecideDecisions: (ids: string[], action: DecisionAction, input?: {
+        note?: string;
+        optionId?: string;
+    }) => Promise<Array<{
         ok?: boolean;
     }>>;
+    emitDecisionResolvedActivity?: (ids: string[], action: DecisionAction, input?: {
+        note?: string;
+        optionId?: string;
+    }) => Promise<void>;
     sendJson: (res: TRes, status: number, payload: unknown) => void;
     safeErrorMessage: (err: unknown) => string;
 };

package/dist/http/routes/decision-actions.js

@@ -13,20 +13,45 @@ async function handleApproveRequest(req, res, deps, routeIds) {
     const note = typeof payload.note === "string" && payload.note.trim().length > 0
         ? payload.note.trim()
         : undefined;
+    const optionIdRaw = typeof payload.option_id === "string"
+        ? payload.option_id
+        : typeof payload.optionId === "string"
+            ? payload.optionId
+            : null;
+    const optionId = typeof optionIdRaw === "string" && optionIdRaw.trim().length > 0
+        ? optionIdRaw.trim()
+        : undefined;
     const ids = routeIds ?? extractIdsFromPayload(payload);
     if (ids.length === 0) {
         deps.sendJson(res, 400, {
             error: "Decision IDs are required.",
             expected: {
                 route: "/orgx/api/live/decisions/approve",
-                body: { ids: ["decision-id"], action: "approve|reject" },
+                body: { ids: ["decision-id"], action: "approve|reject", option_id: "optional-option-id" },
             },
         });
         return;
     }
-    const results = await deps.bulkDecideDecisions(ids, action, note);
+    const results = await deps.bulkDecideDecisions(ids, action, {
+        note,
+        optionId,
+    });
+    const resolvedIds = results
+        .map((result, index) => (result.ok === true ? ids[index] ?? null : null))
+        .filter((id) => typeof id === "string" && id.length > 0);
     const updated = results.filter((result) => result.ok === true).length;
     const failed = results.length - updated;
+    if (resolvedIds.length > 0 && typeof deps.emitDecisionResolvedActivity === "function") {
+        try {
+            await deps.emitDecisionResolvedActivity(resolvedIds, action, {
+                note,
+                optionId,
+            });
+        }
+        catch {
+            // best effort; decision mutation succeeded so do not fail the response
+        }
+    }
     deps.sendJson(res, failed > 0 ? 207 : 200, {
         action,
         requested: ids.length,
@@ -35,6 +60,15 @@ async function handleApproveRequest(req, res, deps, routeIds) {
         results,
     });
 }
+function decodeDecisionId(encodedDecisionId) {
+    try {
+        const decoded = decodeURIComponent(encodedDecisionId).trim();
+        return decoded.length > 0 ? decoded : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function registerDecisionActionsRoutes(router, deps) {
     router.add("POST", "live/decisions/approve", async ({ req, res }) => {
         try {
@@ -52,10 +86,13 @@ export function registerDecisionActionsRoutes(router, deps) {
             deps.sendJson(res, 404, { error: "Unknown API endpoint" });
             return;
         }
+        const decisionId = decodeDecisionId(decisionApproveMatch[1]);
+        if (!decisionId) {
+            deps.sendJson(res, 400, { error: "Invalid decision ID." });
+            return;
+        }
         try {
-            await handleApproveRequest(req, res, deps, [
-                decodeURIComponent(decisionApproveMatch[1]),
-            ]);
+            await handleApproveRequest(req, res, deps, [decisionId]);
         }
         catch (err) {
             deps.sendJson(res, 500, {

package/dist/http/routes/dispatch-gateway-envelope.d.ts

@@ -0,0 +1,25 @@
+export type DispatchGatewayEnvelopeInput = {
+    dispatchId?: string;
+    dispatchMode: string;
+    route: "mission-control.next-up.play" | "mission-control.auto-continue.start";
+    source: "manual_play" | "auto_continue_start";
+    initiativeId: string;
+    workstreamId?: string | null;
+    workstreamIds?: string[] | null;
+    taskIds?: string[] | null;
+};
+export declare function buildDispatchGatewayEnvelope(input: DispatchGatewayEnvelopeInput): {
+    readonly dispatchId: string;
+    readonly dispatchMode: string;
+    readonly executionPath: "orgx_orchestrator_gateway";
+    readonly dispatchGateway: "orchestrator-agent";
+    readonly dispatchLineage: {
+        readonly route: "mission-control.next-up.play" | "mission-control.auto-continue.start";
+        readonly source: "manual_play" | "auto_continue_start";
+        readonly dispatchedAt: string;
+        readonly initiativeId: string;
+        readonly workstreamId: string | null;
+        readonly workstreamIds: string[];
+        readonly taskIds: string[];
+    };
+};

package/dist/http/routes/dispatch-gateway-envelope.js

@@ -0,0 +1,26 @@
+import { randomUUID } from "node:crypto";
+function uniqueStringIds(values) {
+    return Array.from(new Set(values
+        .map((value) => (typeof value === "string" ? value.trim() : ""))
+        .filter((value) => value.length > 0)));
+}
+export function buildDispatchGatewayEnvelope(input) {
+    return {
+        dispatchId: input.dispatchId ?? randomUUID(),
+        dispatchMode: input.dispatchMode,
+        executionPath: "orgx_orchestrator_gateway",
+        dispatchGateway: "orchestrator-agent",
+        dispatchLineage: {
+            route: input.route,
+            source: input.source,
+            dispatchedAt: new Date().toISOString(),
+            initiativeId: input.initiativeId,
+            workstreamId: input.workstreamId ?? null,
+            workstreamIds: uniqueStringIds([
+                input.workstreamId,
+                ...(input.workstreamIds ?? []),
+            ]),
+            taskIds: uniqueStringIds(input.taskIds ?? []),
+        },
+    };
+}