@useorgx/openclaw-plugin 0.4.5 → 0.4.6

package/dist/mcp-client-setup.js

@@ -3,6 +3,27 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { writeFileAtomicSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+const ORGX_LOCAL_MCP_KEY = "orgx-openclaw";
+const ORGX_HOSTED_MCP_URL = "https://mcp.useorgx.com/mcp";
+const ORGX_LOCAL_MCP_SCOPES = [
+    "engineering",
+    "product",
+    "design",
+    "marketing",
+    "sales",
+    "operations",
+    "orchestration",
+];
+function scopedMcpServerKey(scope) {
+    return `${ORGX_LOCAL_MCP_KEY}-${scope}`;
+}
+function scopedMcpUrl(localMcpUrl, scope) {
+    const base = localMcpUrl.replace(/\/+$/, "");
+    return `${base}/${scope}`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function isRecord(value) {
     return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -40,51 +61,109 @@ function backupFileSync(path, mode) {
 }
 export function patchClaudeMcpConfig(input) {
     const currentServers = isRecord(input.current.mcpServers) ? input.current.mcpServers : {};
-    const currentOrgx = isRecord(currentServers.orgx) ? currentServers.orgx : {};
-    const priorUrl = typeof currentOrgx.url === "string" ? currentOrgx.url : "";
-    const priorType = typeof currentOrgx.type === "string" ? currentOrgx.type : "";
-    const nextOrgx = {
-        ...currentOrgx,
+    const existingOrgx = isRecord(currentServers.orgx) ? currentServers.orgx : {};
+    const existingOrgxUrl = typeof existingOrgx.url === "string" ? existingOrgx.url : "";
+    const existingOrgxType = typeof existingOrgx.type === "string" ? existingOrgx.type : "";
+    const existing = isRecord(currentServers[ORGX_LOCAL_MCP_KEY]) ? currentServers[ORGX_LOCAL_MCP_KEY] : {};
+    const priorUrl = typeof existing.url === "string" ? existing.url : "";
+    const priorType = typeof existing.type === "string" ? existing.type : "";
+    // Ensure hosted OrgX is available alongside the local proxy. Avoid overwriting
+    // custom `orgx` entries unless it's clearly redundant (pointing at the same
+    // local proxy URL we install under `orgx-openclaw`).
+    const shouldSetHostedOrgx = !isRecord(currentServers.orgx) ||
+        (existingOrgxUrl === input.localMcpUrl && existingOrgxType === "http");
+    const nextOrgxEntry = {
+        ...existingOrgx,
+        type: "http",
+        url: ORGX_HOSTED_MCP_URL,
+        description: typeof existingOrgx.description === "string" && existingOrgx.description.trim().length > 0
+            ? existingOrgx.description
+            : "OrgX cloud MCP (OAuth)",
+    };
+    const nextEntry = {
+        ...existing,
         type: "http",
         url: input.localMcpUrl,
-        description: typeof currentOrgx.description === "string" && currentOrgx.description.trim().length > 0
-            ? currentOrgx.description
+        description: typeof existing.description === "string" && existing.description.trim().length > 0
+            ? existing.description
             : "OrgX platform via local OpenClaw plugin (no OAuth)",
     };
+    const updatedScopes = [];
+    const scopedEntries = {};
+    for (const scope of ORGX_LOCAL_MCP_SCOPES) {
+        const key = scopedMcpServerKey(scope);
+        const expectedUrl = scopedMcpUrl(input.localMcpUrl, scope);
+        const existingScoped = isRecord(currentServers[key]) ? currentServers[key] : {};
+        const priorUrl = typeof existingScoped.url === "string" ? existingScoped.url : "";
+        const priorType = typeof existingScoped.type === "string" ? existingScoped.type : "";
+        const nextScoped = {
+            ...existingScoped,
+            type: "http",
+            url: expectedUrl,
+            description: typeof existingScoped.description === "string" && existingScoped.description.trim().length > 0
+                ? existingScoped.description
+                : `OrgX platform via local OpenClaw plugin (${scope} scope)`,
+        };
+        scopedEntries[key] = nextScoped;
+        if (priorUrl !== expectedUrl || priorType !== "http") {
+            updatedScopes.push(scope);
+        }
+    }
     const nextServers = {
         ...currentServers,
-        orgx: nextOrgx,
+        ...(shouldSetHostedOrgx ? { orgx: nextOrgxEntry } : {}),
+        [ORGX_LOCAL_MCP_KEY]: nextEntry,
+        ...scopedEntries,
     };
     const next = {
         ...input.current,
         mcpServers: nextServers,
     };
-    const updated = priorUrl !== input.localMcpUrl || priorType !== "http";
+    const updatedLocal = priorUrl !== input.localMcpUrl || priorType !== "http";
+    const updatedHosted = shouldSetHostedOrgx &&
+        (existingOrgxUrl !== ORGX_HOSTED_MCP_URL || existingOrgxType !== "http");
+    const updated = updatedLocal || updatedHosted || updatedScopes.length > 0;
     return { updated, next };
 }
 export function patchCursorMcpConfig(input) {
     const currentServers = isRecord(input.current.mcpServers) ? input.current.mcpServers : {};
-    const key = "orgx-openclaw";
-    const existing = isRecord(currentServers[key]) ? currentServers[key] : {};
+    const existing = isRecord(currentServers[ORGX_LOCAL_MCP_KEY]) ? currentServers[ORGX_LOCAL_MCP_KEY] : {};
     const priorUrl = typeof existing.url === "string" ? existing.url : "";
     const nextEntry = {
         ...existing,
         url: input.localMcpUrl,
     };
+    const scopedEntries = {};
+    let updatedScopes = false;
+    for (const scope of ORGX_LOCAL_MCP_SCOPES) {
+        const key = scopedMcpServerKey(scope);
+        const expectedUrl = scopedMcpUrl(input.localMcpUrl, scope);
+        const existingScoped = isRecord(currentServers[key]) ? currentServers[key] : {};
+        const priorScopedUrl = typeof existingScoped.url === "string" ? existingScoped.url : "";
+        scopedEntries[key] = {
+            ...existingScoped,
+            url: expectedUrl,
+        };
+        if (priorScopedUrl !== expectedUrl)
+            updatedScopes = true;
+    }
     const nextServers = {
         ...currentServers,
-        [key]: nextEntry,
+        [ORGX_LOCAL_MCP_KEY]: nextEntry,
+        ...scopedEntries,
     };
     const next = {
         ...input.current,
         mcpServers: nextServers,
     };
-    const updated = priorUrl !== input.localMcpUrl;
+    const updated = priorUrl !== input.localMcpUrl || updatedScopes;
     return { updated, next };
 }
-export function patchCodexConfigToml(input) {
-    const lines = input.current.split(/\r?\n/);
-    const headerRegex = /^\[mcp_servers\.(?:orgx|"orgx")\]\s*$/;
+function upsertCodexMcpServerSection(input) {
+    const currentText = input.current;
+    const lines = currentText.split(/\r?\n/);
+    const escapedKey = escapeRegExp(input.key);
+    const headerRegex = new RegExp(`^\\[mcp_servers\\.(?:"${escapedKey}"|${escapedKey})\\]\\s*$`);
     let headerIndex = -1;
     for (let i = 0; i < lines.length; i += 1) {
         if (headerRegex.test(lines[i].trim())) {
@@ -92,15 +171,10 @@ export function patchCodexConfigToml(input) {
             break;
         }
     }
-    const urlLine = `url = "${input.localMcpUrl}"`;
+    const urlLine = `url = "${input.url}"`;
     if (headerIndex === -1) {
-        const suffix = [
-            "",
-            "[mcp_servers.orgx]",
-            urlLine,
-            "",
-        ].join("\n");
-        const normalized = input.current.endsWith("\n") ? input.current : `${input.current}\n`;
+        const suffix = ["", `[mcp_servers.\"${input.key}\"]`, urlLine, ""].join("\n");
+        const normalized = currentText.endsWith("\n") ? currentText : `${currentText}\n`;
         return { updated: true, next: `${normalized}${suffix}` };
     }
     let sectionEnd = lines.length;
@@ -127,9 +201,67 @@ export function patchCodexConfigToml(input) {
     else {
         lines.splice(headerIndex + 1, 0, urlLine);
         updated = true;
+        // Recalculate sectionEnd after splice
+        sectionEnd = lines.length;
+        for (let i = headerIndex + 1; i < lines.length; i += 1) {
+            if (lines[i].trim().startsWith("[")) {
+                sectionEnd = i;
+                break;
+            }
+        }
+    }
+    // Strip stale stdio-transport fields that conflict with url-only entries.
+    // Codex rejects `url` when `command`/`args` are present (stdio transport).
+    const staleFieldRegex = /^\s*(command|args|startup_timeout_sec)\s*=/;
+    for (let i = sectionEnd - 1; i > headerIndex; i -= 1) {
+        if (staleFieldRegex.test(lines[i])) {
+            lines.splice(i, 1);
+            updated = true;
+        }
     }
     return { updated, next: `${lines.join("\n")}\n` };
 }
+export function patchCodexConfigToml(input) {
+    let current = input.current;
+    let updatedHosted = false;
+    // If the hosted OrgX entry is missing entirely, add a sensible default. This is
+    // a no-op if the user already has `orgx` pointed at staging or another URL.
+    const hostedHeaderRegex = /^\[mcp_servers\.(?:"orgx"|orgx)\]\s*$/;
+    {
+        const lines = current.split(/\r?\n/);
+        const hasHosted = lines.some((line) => hostedHeaderRegex.test(line.trim()));
+        if (!hasHosted) {
+            const hostedUrlLine = `url = "${ORGX_HOSTED_MCP_URL}"`;
+            const suffix = [
+                ...(current.trim().length === 0 ? [] : [""]),
+                "[mcp_servers.orgx]",
+                hostedUrlLine,
+                "",
+            ].join("\n");
+            const normalized = current.endsWith("\n") ? current : `${current}\n`;
+            current = `${normalized}${suffix}`;
+            updatedHosted = true;
+        }
+    }
+    let updated = false;
+    const base = upsertCodexMcpServerSection({
+        current,
+        key: ORGX_LOCAL_MCP_KEY,
+        url: input.localMcpUrl,
+    });
+    updated = updated || base.updated;
+    current = base.next;
+    for (const scope of ORGX_LOCAL_MCP_SCOPES) {
+        const next = upsertCodexMcpServerSection({
+            current,
+            key: scopedMcpServerKey(scope),
+            url: scopedMcpUrl(input.localMcpUrl, scope),
+        });
+        updated = updated || next.updated;
+        current = next.next;
+    }
+    return { updated: updatedHosted || updated, next: current };
+}
 export async function autoConfigureDetectedMcpClients(input) {
     const logger = input.logger ?? {};
     const home = input.homeDir ?? homedir();

package/dist/mcp-http-handler.d.ts

@@ -30,9 +30,26 @@ export type RegisteredTool = {
     parameters: Record<string, unknown>;
     execute: (callId: string, params?: unknown) => Promise<ToolResult>;
 };
+type PromptRole = "system" | "user" | "assistant";
+type PromptMessage = {
+    role: PromptRole;
+    content: string;
+};
+export type RegisteredPrompt = {
+    name: string;
+    description?: string;
+    arguments?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+    messages: PromptMessage[];
+};
 export declare function createMcpHttpHandler(input: {
     tools: Map<string, RegisteredTool>;
+    prompts?: Map<string, RegisteredPrompt>;
     logger?: Logger;
     serverName: string;
     serverVersion: string;
 }): (req: PluginRequest, res: PluginResponse) => Promise<boolean>;
+export {};

package/dist/mcp-http-handler.js

@@ -1,5 +1,79 @@
 import { randomUUID } from "node:crypto";
 const DEFAULT_PROTOCOL_VERSION = "2024-11-05";
+// Domain-scoped MCP servers are meant to be "default safe". The unscoped
+// `/orgx/mcp` endpoint remains available for power users / debugging.
+//
+// NOTE: This scopes only the tools exposed by this plugin (OrgX reporting + mutation).
+// It cannot restrict OpenClaw-native tools (filesystem, shell, etc).
+const ORGX_MCP_ALLOWED_TOOLS_BY_SCOPE = {
+    engineering: [
+        "orgx_status",
+        "orgx_sync",
+        "orgx_emit_activity",
+        "orgx_report_progress",
+        "orgx_register_artifact",
+        "orgx_request_decision",
+        "orgx_spawn_check",
+    ],
+    product: [
+        "orgx_status",
+        "orgx_sync",
+        "orgx_emit_activity",
+        "orgx_report_progress",
+        "orgx_register_artifact",
+        "orgx_request_decision",
+        "orgx_spawn_check",
+    ],
+    design: [
+        "orgx_status",
+        "orgx_sync",
+        "orgx_emit_activity",
+        "orgx_report_progress",
+        "orgx_register_artifact",
+        "orgx_request_decision",
+        "orgx_spawn_check",
+    ],
+    marketing: [
+        "orgx_status",
+        "orgx_sync",
+        "orgx_emit_activity",
+        "orgx_report_progress",
+        "orgx_register_artifact",
+        "orgx_request_decision",
+        "orgx_spawn_check",
+    ],
+    sales: [
+        "orgx_status",
+        "orgx_sync",
+        "orgx_emit_activity",
+        "orgx_report_progress",
+        "orgx_register_artifact",
+        "orgx_request_decision",
+        "orgx_spawn_check",
+    ],
+    operations: [
+        "orgx_status",
+        "orgx_sync",
+        "orgx_emit_activity",
+        "orgx_report_progress",
+        "orgx_register_artifact",
+        "orgx_request_decision",
+        "orgx_spawn_check",
+        // Operations is allowed to do explicit changesets for remediation/runbooks.
+        "orgx_apply_changeset",
+    ],
+    orchestration: [
+        "orgx_status",
+        "orgx_sync",
+        "orgx_emit_activity",
+        "orgx_report_progress",
+        "orgx_register_artifact",
+        "orgx_request_decision",
+        "orgx_spawn_check",
+        // Orchestrator is the primary mutation surface by design.
+        "orgx_apply_changeset",
+    ],
+};
 function isRecord(value) {
     return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -38,6 +112,28 @@ function normalizePath(rawUrl) {
     const [path] = rawUrl.split("?", 2);
     return path || "/";
 }
+function parseScopeKey(url) {
+    // Supported paths:
+    // - /orgx/mcp (unscoped)
+    // - /orgx/mcp/<scope> (domain-scoped)
+    if (!url.startsWith("/orgx/mcp/"))
+        return null;
+    const rest = url.slice("/orgx/mcp/".length);
+    const key = rest.split("/", 1)[0]?.trim() ?? "";
+    if (!key)
+        return null;
+    if (!Object.prototype.hasOwnProperty.call(ORGX_MCP_ALLOWED_TOOLS_BY_SCOPE, key))
+        return null;
+    return key;
+}
+function resolveToolScope(scopeKey) {
+    if (!scopeKey)
+        return null;
+    return {
+        key: scopeKey,
+        allowedTools: new Set(ORGX_MCP_ALLOWED_TOOLS_BY_SCOPE[scopeKey]),
+    };
+}
 async function readRequestBodyBuffer(req) {
     const body = req.body;
     if (typeof body === "string")
@@ -131,13 +227,15 @@ async function handleRpcMessage(input) {
     if (method === "initialize") {
         const requestedProtocol = typeof params.protocolVersion === "string" ? params.protocolVersion : null;
         const protocolVersion = requestedProtocol?.trim() || DEFAULT_PROTOCOL_VERSION;
+        const scopedServerName = input.toolScope ? `${input.serverName}/${input.toolScope.key}` : input.serverName;
         return jsonRpcResult(id, {
             protocolVersion,
             capabilities: {
                 tools: {},
+                prompts: {},
             },
             serverInfo: {
-                name: input.serverName,
+                name: scopedServerName,
                 version: input.serverVersion,
             },
         });
@@ -146,6 +244,15 @@ async function handleRpcMessage(input) {
         return jsonRpcResult(id, { ok: true });
     }
     if (method === "tools/list") {
+        if (input.toolScope) {
+            const scopedTools = new Map();
+            for (const name of input.toolScope.allowedTools) {
+                const tool = input.tools.get(name);
+                if (tool)
+                    scopedTools.set(name, tool);
+            }
+            return jsonRpcResult(id, { tools: buildToolsList(scopedTools) });
+        }
         return jsonRpcResult(id, {
             tools: buildToolsList(input.tools),
         });
@@ -155,6 +262,9 @@ async function handleRpcMessage(input) {
         if (!toolName) {
             return jsonRpcError(id, -32602, "Missing tool name");
         }
+        if (input.toolScope && !input.toolScope.allowedTools.has(toolName)) {
+            return jsonRpcError(id, -32601, `Tool not available in scope '${input.toolScope.key}': ${toolName}`);
+        }
         const tool = input.tools.get(toolName) ?? null;
         if (!tool) {
             return jsonRpcError(id, -32601, `Tool not found: ${toolName}`);
@@ -188,7 +298,28 @@ async function handleRpcMessage(input) {
         return jsonRpcResult(id, { resources: [] });
     }
     if (method === "prompts/list") {
-        return jsonRpcResult(id, { prompts: [] });
+        const prompts = Array.from(input.prompts.values())
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map((prompt) => ({
+            name: prompt.name,
+            description: prompt.description ?? "",
+            arguments: Array.isArray(prompt.arguments) ? prompt.arguments : [],
+        }));
+        return jsonRpcResult(id, { prompts });
+    }
+    if (method === "prompts/get") {
+        const promptName = typeof params.name === "string" ? params.name.trim() : "";
+        if (!promptName) {
+            return jsonRpcError(id, -32602, "Missing prompt name");
+        }
+        const prompt = input.prompts.get(promptName) ?? null;
+        if (!prompt) {
+            return jsonRpcError(id, -32601, `Prompt not found: ${promptName}`);
+        }
+        return jsonRpcResult(id, {
+            description: prompt.description ?? "",
+            messages: prompt.messages,
+        });
     }
     if (method.startsWith("notifications/")) {
         return null;
@@ -197,6 +328,7 @@ async function handleRpcMessage(input) {
 }
 export function createMcpHttpHandler(input) {
     const logger = input.logger ?? {};
+    const prompts = input.prompts ?? new Map();
     return async function handler(req, res) {
         const method = (req.method ?? "GET").toUpperCase();
         const rawUrl = req.url ?? "/";
@@ -204,6 +336,12 @@ export function createMcpHttpHandler(input) {
         if (!(url === "/orgx/mcp" || url.startsWith("/orgx/mcp/"))) {
             return false;
         }
+        const scopeKey = parseScopeKey(url);
+        const toolScope = resolveToolScope(scopeKey);
+        if (url.startsWith("/orgx/mcp/") && !scopeKey) {
+            sendText(res, 404, `Unknown OrgX MCP scope. Supported: ${Object.keys(ORGX_MCP_ALLOWED_TOOLS_BY_SCOPE).join(", ")}\n`);
+            return true;
+        }
         if (method === "OPTIONS") {
             res.writeHead(204, {
                 "cache-control": "no-store",
@@ -212,7 +350,8 @@ export function createMcpHttpHandler(input) {
             return true;
         }
         if (method === "GET") {
-            sendText(res, 200, "OrgX Local MCP bridge is running.\n");
+            const suffix = toolScope ? ` (scope: ${toolScope.key})` : "";
+            sendText(res, 200, `OrgX Local MCP bridge is running${suffix}.\n`);
             return true;
         }
         if (method !== "POST") {
@@ -234,9 +373,11 @@ export function createMcpHttpHandler(input) {
             const response = await handleRpcMessage({
                 message,
                 tools: input.tools,
+                prompts,
                 logger,
                 serverName: input.serverName,
                 serverVersion: input.serverVersion,
+                toolScope,
             });
             if (response)
                 responses.push(response);

package/dist/next-up-queue-store.d.ts

@@ -0,0 +1,31 @@
+export type NextUpPinnedEntry = {
+    initiativeId: string;
+    workstreamId: string;
+    preferredTaskId: string | null;
+    preferredMilestoneId: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type PersistedNextUpQueue = {
+    version: 1;
+    updatedAt: string;
+    pins: NextUpPinnedEntry[];
+};
+export declare function readNextUpQueuePins(): PersistedNextUpQueue;
+export declare function upsertNextUpQueuePin(input: {
+    initiativeId: string;
+    workstreamId: string;
+    preferredTaskId?: string | null;
+    preferredMilestoneId?: string | null;
+}): PersistedNextUpQueue;
+export declare function removeNextUpQueuePin(input: {
+    initiativeId: string;
+    workstreamId: string;
+}): PersistedNextUpQueue;
+export declare function setNextUpQueuePinOrder(input: {
+    order: Array<{
+        initiativeId: string;
+        workstreamId: string;
+    }>;
+}): PersistedNextUpQueue;
+export {};

package/dist/next-up-queue-store.js

@@ -0,0 +1,169 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, } from "node:fs";
+import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "./paths.js";
+import { backupCorruptFileSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+const MAX_PINS = 240;
+function storeDir() {
+    return getOrgxPluginConfigDir();
+}
+function storeFile() {
+    return getOrgxPluginConfigPath("next-up-queue.json");
+}
+function ensureStoreDir() {
+    const dir = storeDir();
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(dir, 0o700);
+    }
+    catch {
+        // best effort
+    }
+}
+function parseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeNullableString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeEntry(input) {
+    return {
+        initiativeId: input.initiativeId.trim(),
+        workstreamId: input.workstreamId.trim(),
+        preferredTaskId: normalizeNullableString(input.preferredTaskId),
+        preferredMilestoneId: normalizeNullableString(input.preferredMilestoneId),
+        createdAt: input.createdAt,
+        updatedAt: input.updatedAt,
+    };
+}
+export function readNextUpQueuePins() {
+    const file = storeFile();
+    try {
+        if (!existsSync(file)) {
+            return { version: 1, updatedAt: new Date().toISOString(), pins: [] };
+        }
+        const raw = readFileSync(file, "utf8");
+        const parsed = parseJson(raw);
+        if (!parsed || typeof parsed !== "object") {
+            backupCorruptFileSync(file);
+            return { version: 1, updatedAt: new Date().toISOString(), pins: [] };
+        }
+        const pins = Array.isArray(parsed.pins) ? parsed.pins : [];
+        return {
+            version: 1,
+            updatedAt: typeof parsed.updatedAt === "string"
+                ? parsed.updatedAt
+                : new Date().toISOString(),
+            pins: pins
+                .filter((entry) => Boolean(entry && typeof entry === "object"))
+                .map((entry) => normalizeEntry(entry)),
+        };
+    }
+    catch {
+        return { version: 1, updatedAt: new Date().toISOString(), pins: [] };
+    }
+}
+export function upsertNextUpQueuePin(input) {
+    const initiativeId = input.initiativeId.trim();
+    const workstreamId = input.workstreamId.trim();
+    if (!initiativeId || !workstreamId) {
+        return readNextUpQueuePins();
+    }
+    ensureStoreDir();
+    const now = new Date().toISOString();
+    const next = readNextUpQueuePins();
+    const key = `${initiativeId}:${workstreamId}`;
+    const existing = next.pins.find((pin) => `${pin.initiativeId}:${pin.workstreamId}` === key);
+    const updated = normalizeEntry({
+        initiativeId,
+        workstreamId,
+        preferredTaskId: input.preferredTaskId ?? existing?.preferredTaskId ?? null,
+        preferredMilestoneId: input.preferredMilestoneId ?? existing?.preferredMilestoneId ?? null,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+    });
+    next.pins = [updated, ...next.pins.filter((pin) => `${pin.initiativeId}:${pin.workstreamId}` !== key)].slice(0, MAX_PINS);
+    next.updatedAt = now;
+    try {
+        writeJsonFileAtomicSync(storeFile(), next, 0o600);
+    }
+    catch {
+        // best effort
+    }
+    return next;
+}
+export function removeNextUpQueuePin(input) {
+    const initiativeId = input.initiativeId.trim();
+    const workstreamId = input.workstreamId.trim();
+    if (!initiativeId || !workstreamId) {
+        return readNextUpQueuePins();
+    }
+    ensureStoreDir();
+    const next = readNextUpQueuePins();
+    const key = `${initiativeId}:${workstreamId}`;
+    const filtered = next.pins.filter((pin) => `${pin.initiativeId}:${pin.workstreamId}` !== key);
+    if (filtered.length === next.pins.length)
+        return next;
+    next.pins = filtered;
+    next.updatedAt = new Date().toISOString();
+    try {
+        writeJsonFileAtomicSync(storeFile(), next, 0o600);
+    }
+    catch {
+        // best effort
+    }
+    return next;
+}
+export function setNextUpQueuePinOrder(input) {
+    ensureStoreDir();
+    const next = readNextUpQueuePins();
+    const now = new Date().toISOString();
+    const byKey = new Map(next.pins.map((pin) => [`${pin.initiativeId}:${pin.workstreamId}`, pin]));
+    const ordered = [];
+    const seen = new Set();
+    for (const entry of input.order) {
+        const initiativeId = (entry.initiativeId ?? "").trim();
+        const workstreamId = (entry.workstreamId ?? "").trim();
+        if (!initiativeId || !workstreamId)
+            continue;
+        const key = `${initiativeId}:${workstreamId}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const pin = byKey.get(key);
+        if (pin) {
+            ordered.push(pin);
+        }
+        else {
+            ordered.push({
+                initiativeId,
+                workstreamId,
+                preferredTaskId: null,
+                preferredMilestoneId: null,
+                createdAt: now,
+                updatedAt: now,
+            });
+        }
+    }
+    for (const pin of next.pins) {
+        const key = `${pin.initiativeId}:${pin.workstreamId}`;
+        if (seen.has(key))
+            continue;
+        ordered.push(pin);
+    }
+    next.pins = ordered.slice(0, MAX_PINS);
+    next.updatedAt = now;
+    try {
+        writeJsonFileAtomicSync(storeFile(), next, 0o600);
+    }
+    catch {
+        // best effort
+    }
+    return next;
+}