@useorgx/openclaw-plugin 0.4.5 → 0.4.8

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;
+}

package/dist/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "orgx",
   "name": "OrgX Integration",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Connects Clawdbot to OrgX for agent orchestration, quality gates, and model routing",
   "entry": "./index.js",
   "author": "OrgX Team",

package/dist/outbox.d.ts

@@ -6,7 +6,7 @@
 import type { LiveActivityItem } from "./types.js";
 export interface OutboxEvent {
     id: string;
-    type: "progress" | "decision" | "artifact" | "changeset";
+    type: "progress" | "decision" | "artifact" | "changeset" | "retro" | "outcome";
     timestamp: string;
     payload: Record<string, unknown>;
     /** Converted to a LiveActivityItem for dashboard display. */

package/dist/runtime-instance-store.d.ts

@@ -21,7 +21,7 @@ export type RuntimeInstanceRecord = {
     id: string;
     sourceClient: RuntimeSourceClient;
     displayName: string;
-    providerLogo: "openai" | "anthropic" | "openclaw" | "orgx" | "unknown";
+    providerLogo: "codex" | "openai" | "anthropic" | "openclaw" | "orgx" | "unknown";
     state: RuntimeInstanceState;
     event: RuntimeHookEvent;
     runId: string | null;

package/dist/runtime-instance-store.js

@@ -94,6 +94,22 @@ function toProviderLogo(sourceClient) {
         return "orgx";
     return "unknown";
 }
+function normalizeProviderLogo(value, sourceClient) {
+    const normalized = normalizeNullableString(value)?.toLowerCase();
+    if (normalized === "codex")
+        return sourceClient === "codex" ? "openai" : "codex";
+    if (normalized === "openai")
+        return "openai";
+    if (normalized === "anthropic")
+        return "anthropic";
+    if (normalized === "openclaw")
+        return "openclaw";
+    if (normalized === "orgx")
+        return "orgx";
+    if (normalized === "unknown")
+        return "unknown";
+    return toProviderLogo(sourceClient);
+}
 function toDisplayName(sourceClient) {
     if (sourceClient === "codex")
         return "Codex";
@@ -152,11 +168,12 @@ function normalizeProgress(value) {
     return Math.max(0, Math.min(100, Math.round(value)));
 }
 function normalizeRecord(input) {
+    const sourceClient = normalizeSourceClient(input.sourceClient);
     return {
         id: normalizeNullableString(input.id) ?? input.id,
-        sourceClient: normalizeSourceClient(input.sourceClient),
+        sourceClient,
         displayName: normalizeNullableString(input.displayName) ?? "Runtime",
-        providerLogo: input.providerLogo,
+        providerLogo: normalizeProviderLogo(input.providerLogo, sourceClient),
         state: normalizeState(input.state),
         event: normalizeHookEvent(input.event),
         runId: normalizeNullableString(input.runId),

package/dist/skill-pack-state.d.ts

@@ -0,0 +1,69 @@
+import type { SkillPack } from "./contracts/types.js";
+import type { OrgxSkillPackOverrides } from "./agent-suite.js";
+export type SkillPackState = {
+    version: 1;
+    updatedAt: string;
+    lastCheckedAt: string | null;
+    lastError: string | null;
+    etag: string | null;
+    policy: {
+        frozen: boolean;
+        pinnedChecksum: string | null;
+    };
+    pack: {
+        name: string;
+        version: string;
+        checksum: string;
+        updated_at: string | null;
+    } | null;
+    remote: {
+        name: string;
+        version: string;
+        checksum: string;
+        updated_at: string | null;
+    } | null;
+    overrides: OrgxSkillPackOverrides | null;
+};
+export declare function readSkillPackState(input?: {
+    openclawDir?: string;
+}): SkillPackState;
+export declare function writeSkillPackState(state: SkillPackState, input?: {
+    openclawDir?: string;
+}): void;
+export declare function updateSkillPackPolicy(input: {
+    openclawDir?: string;
+    frozen?: boolean;
+    pinnedChecksum?: string | null;
+    pinToCurrent?: boolean;
+    clearPin?: boolean;
+}): SkillPackState;
+export declare function toOrgxSkillPackOverrides(input: {
+    pack: SkillPack;
+    etag: string | null;
+}): OrgxSkillPackOverrides;
+export declare function refreshSkillPackState(input: {
+    getSkillPack: (args: {
+        name?: string;
+        ifNoneMatch?: string | null;
+    }) => Promise<{
+        ok: true;
+        notModified: true;
+        etag: string | null;
+        pack: null;
+    } | {
+        ok: true;
+        notModified: false;
+        etag: string | null;
+        pack: SkillPack;
+    } | {
+        ok: false;
+        status: number;
+        error: string;
+    }>;
+    packName?: string;
+    openclawDir?: string;
+    force?: boolean;
+}): Promise<{
+    state: SkillPackState;
+    changed: boolean;
+}>;

package/dist/skill-pack-state.js

@@ -0,0 +1,232 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomicSync } from "./fs-utils.js";
+import { getOpenClawDir } from "./paths.js";
+const STORE_VERSION = 1;
+const STATE_FILENAME = "orgx-skill-pack-state.json";
+function nowIso() {
+    return new Date().toISOString();
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function coerceString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function statePath(openclawDir) {
+    return join(openclawDir, STATE_FILENAME);
+}
+export function readSkillPackState(input) {
+    const openclawDir = input?.openclawDir ?? getOpenClawDir();
+    const path = statePath(openclawDir);
+    const empty = {
+        version: STORE_VERSION,
+        updatedAt: nowIso(),
+        lastCheckedAt: null,
+        lastError: null,
+        etag: null,
+        policy: { frozen: false, pinnedChecksum: null },
+        pack: null,
+        remote: null,
+        overrides: null,
+    };
+    try {
+        if (!existsSync(path))
+            return empty;
+        const raw = readFileSync(path, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed))
+            return empty;
+        if (parsed.version !== STORE_VERSION)
+            return empty;
+        const policy = isRecord(parsed.policy) ? parsed.policy : null;
+        const pack = isRecord(parsed.pack) ? parsed.pack : null;
+        const remote = isRecord(parsed.remote) ? parsed.remote : null;
+        const overrides = isRecord(parsed.overrides) ? parsed.overrides : null;
+        return {
+            version: STORE_VERSION,
+            updatedAt: coerceString(parsed.updatedAt) ?? nowIso(),
+            lastCheckedAt: coerceString(parsed.lastCheckedAt),
+            lastError: coerceString(parsed.lastError),
+            etag: coerceString(parsed.etag),
+            policy: {
+                frozen: Boolean(policy?.frozen),
+                pinnedChecksum: coerceString(policy?.pinnedChecksum),
+            },
+            pack: pack
+                ? {
+                    name: coerceString(pack.name) ?? "",
+                    version: coerceString(pack.version) ?? "",
+                    checksum: coerceString(pack.checksum) ?? "",
+                    updated_at: coerceString(pack.updated_at),
+                }
+                : null,
+            remote: remote
+                ? {
+                    name: coerceString(remote.name) ?? "",
+                    version: coerceString(remote.version) ?? "",
+                    checksum: coerceString(remote.checksum) ?? "",
+                    updated_at: coerceString(remote.updated_at),
+                }
+                : null,
+            overrides: overrides
+                ? overrides
+                : null,
+        };
+    }
+    catch {
+        return empty;
+    }
+}
+export function writeSkillPackState(state, input) {
+    const openclawDir = input?.openclawDir ?? getOpenClawDir();
+    const path = statePath(openclawDir);
+    writeFileAtomicSync(path, `${JSON.stringify(state, null, 2)}\n`, {
+        mode: 0o600,
+        encoding: "utf8",
+    });
+}
+export function updateSkillPackPolicy(input) {
+    const prev = readSkillPackState({ openclawDir: input.openclawDir });
+    const nextPolicy = { ...prev.policy };
+    if (typeof input.frozen === "boolean") {
+        nextPolicy.frozen = input.frozen;
+    }
+    if (input.clearPin) {
+        nextPolicy.pinnedChecksum = null;
+    }
+    else if (input.pinToCurrent) {
+        nextPolicy.pinnedChecksum = prev.pack?.checksum ?? prev.remote?.checksum ?? null;
+    }
+    else if (typeof input.pinnedChecksum === "string") {
+        nextPolicy.pinnedChecksum = input.pinnedChecksum.trim() || null;
+    }
+    else if (input.pinnedChecksum === null) {
+        nextPolicy.pinnedChecksum = null;
+    }
+    const next = {
+        ...prev,
+        updatedAt: nowIso(),
+        policy: nextPolicy,
+    };
+    writeSkillPackState(next, { openclawDir: input.openclawDir });
+    return next;
+}
+function asRecord(value) {
+    return isRecord(value) ? value : null;
+}
+function parseOpenclawSkillOverridesFromManifest(manifest) {
+    const root = manifest ?? {};
+    const candidates = [
+        asRecord(root.openclaw_skills),
+        asRecord(root.openclawSkills),
+        asRecord(asRecord(root.openclaw)?.skills),
+    ].filter(Boolean);
+    const out = {};
+    for (const candidate of candidates) {
+        for (const [k, v] of Object.entries(candidate)) {
+            if (typeof v !== "string")
+                continue;
+            const key = k.trim().toLowerCase();
+            if (!key)
+                continue;
+            out[key] = v;
+        }
+    }
+    return out;
+}
+export function toOrgxSkillPackOverrides(input) {
+    const manifest = asRecord(input.pack.manifest) ?? {};
+    const rawOverrides = parseOpenclawSkillOverridesFromManifest(manifest);
+    const openclaw_skills = {};
+    for (const [k, v] of Object.entries(rawOverrides)) {
+        // Domains are normalized to lowercase keys in the manifest.
+        openclaw_skills[k] = v;
+    }
+    return {
+        source: "server",
+        name: input.pack.name,
+        version: input.pack.version,
+        checksum: input.pack.checksum,
+        etag: input.etag,
+        updated_at: input.pack.updated_at ?? null,
+        openclaw_skills,
+    };
+}
+export async function refreshSkillPackState(input) {
+    const packName = (input.packName ?? "").trim() || "orgx-agent-suite";
+    const prev = readSkillPackState({ openclawDir: input.openclawDir });
+    if (!input.force && prev.policy.frozen) {
+        const next = {
+            ...prev,
+            updatedAt: nowIso(),
+            lastCheckedAt: nowIso(),
+            lastError: null,
+        };
+        writeSkillPackState(next, { openclawDir: input.openclawDir });
+        return { state: next, changed: false };
+    }
+    const result = await input.getSkillPack({
+        name: packName,
+        ifNoneMatch: input.force ? null : prev.etag,
+    });
+    if (result.ok && result.notModified) {
+        const next = {
+            ...prev,
+            updatedAt: nowIso(),
+            lastCheckedAt: nowIso(),
+            lastError: null,
+            etag: result.etag ?? prev.etag,
+        };
+        writeSkillPackState(next, { openclawDir: input.openclawDir });
+        return { state: next, changed: false };
+    }
+    if (result.ok && !result.notModified && result.pack) {
+        const remoteMeta = {
+            name: result.pack.name,
+            version: result.pack.version,
+            checksum: result.pack.checksum,
+            updated_at: result.pack.updated_at ?? null,
+        };
+        if (prev.policy.pinnedChecksum &&
+            prev.policy.pinnedChecksum !== result.pack.checksum) {
+            const next = {
+                ...prev,
+                updatedAt: nowIso(),
+                lastCheckedAt: nowIso(),
+                lastError: null,
+                etag: result.etag ?? prev.etag,
+                remote: remoteMeta,
+            };
+            writeSkillPackState(next, { openclawDir: input.openclawDir });
+            return { state: next, changed: false };
+        }
+        const overrides = toOrgxSkillPackOverrides({ pack: result.pack, etag: result.etag ?? null });
+        const next = {
+            version: STORE_VERSION,
+            updatedAt: nowIso(),
+            lastCheckedAt: nowIso(),
+            lastError: null,
+            etag: result.etag ?? null,
+            policy: prev.policy,
+            pack: {
+                name: result.pack.name,
+                version: result.pack.version,
+                checksum: result.pack.checksum,
+                updated_at: result.pack.updated_at ?? null,
+            },
+            remote: remoteMeta,
+            overrides,
+        };
+        writeSkillPackState(next, { openclawDir: input.openclawDir });
+        return { state: next, changed: prev.pack?.checksum !== next.pack?.checksum };
+    }
+    const next = {
+        ...prev,
+        updatedAt: nowIso(),
+        lastCheckedAt: nowIso(),
+        lastError: !result.ok ? result.error : prev.lastError,
+    };
+    writeSkillPackState(next, { openclawDir: input.openclawDir });
+    return { state: next, changed: false };
+}

package/dist/worker-supervisor.d.ts

@@ -0,0 +1,25 @@
+export type WorkerKillDecision = {
+    kill: false;
+    elapsedMs: number;
+    idleMs: number;
+} | {
+    kill: true;
+    kind: "timeout" | "log_stall";
+    reason: string;
+    elapsedMs: number;
+    idleMs: number;
+};
+export type McpHandshakeFailure = {
+    kind: "mcp_handshake";
+    server: string | null;
+    line: string | null;
+};
+export declare function detectMcpHandshakeFailure(logText: unknown): McpHandshakeFailure | null;
+export declare function shouldKillWorker(input: {
+    nowEpochMs: number;
+    startedAtEpochMs: number;
+    logUpdatedAtEpochMs: number;
+}, limits: {
+    timeoutMs: number;
+    stallMs: number;
+}): WorkerKillDecision;

package/dist/worker-supervisor.js

@@ -0,0 +1,77 @@
+function pickString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function parseIgnoredMcpServers(raw) {
+    if (typeof raw !== "string")
+        return new Set(["codex_apps"]);
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.toLowerCase() === "none")
+        return new Set();
+    return new Set(trimmed
+        .split(",")
+        .map((entry) => entry.trim().toLowerCase())
+        .filter(Boolean));
+}
+export function detectMcpHandshakeFailure(logText) {
+    const text = String(logText ?? "");
+    const lower = text.toLowerCase();
+    const handshakeSignals = [
+        "mcp startup failed",
+        "handshaking with mcp server failed",
+        "initialize response",
+        "send message error transport",
+    ];
+    if (!handshakeSignals.some((needle) => lower.includes(needle))) {
+        return null;
+    }
+    const lines = text
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const signalLine = lines.find((line) => /mcp startup failed|handshaking with mcp server failed/i.test(line)) ??
+        lines.find((line) => /initialize response|send message error transport/i.test(line)) ??
+        null;
+    const serverMatch = signalLine?.match(/mcp(?:\s*:\s*)?\s*([a-z0-9_-]+)\s+failed:/i) ??
+        signalLine?.match(/mcp client for\s+`?([^`]+)`?\s+failed to start/i) ??
+        signalLine?.match(/mcp client for\s+\[?([^\]]+)\]?\s+failed to start/i) ??
+        null;
+    const server = serverMatch ? pickString(serverMatch[1]) ?? null : null;
+    const ignoredServers = parseIgnoredMcpServers(process.env.ORGX_AUTOPILOT_MCP_HANDSHAKE_IGNORE_SERVERS);
+    if (server && ignoredServers.has(server.toLowerCase())) {
+        return null;
+    }
+    return {
+        kind: "mcp_handshake",
+        server,
+        line: signalLine,
+    };
+}
+export function shouldKillWorker(input, limits) {
+    const now = Number(input.nowEpochMs) || Date.now();
+    const startedAt = Number(input.startedAtEpochMs) || now;
+    const logUpdatedAt = Number(input.logUpdatedAtEpochMs) || startedAt;
+    const elapsedMs = Math.max(0, now - startedAt);
+    const idleMs = Math.max(0, now - logUpdatedAt);
+    if (Number.isFinite(limits.timeoutMs) && limits.timeoutMs > 0 && elapsedMs > limits.timeoutMs) {
+        return {
+            kill: true,
+            kind: "timeout",
+            reason: `Worker exceeded timeout (${Math.round(limits.timeoutMs / 1_000)}s)`,
+            elapsedMs,
+            idleMs,
+        };
+    }
+    if (Number.isFinite(limits.stallMs) && limits.stallMs > 0 && idleMs > limits.stallMs) {
+        return {
+            kill: true,
+            kind: "log_stall",
+            reason: `Worker log stalled (${Math.round(limits.stallMs / 1_000)}s)`,
+            elapsedMs,
+            idleMs,
+        };
+    }
+    return { kill: false, elapsedMs, idleMs };
+}

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "orgx",
   "name": "OrgX Integration",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Connects Clawdbot to OrgX for agent orchestration, quality gates, and model routing",
   "entry": "./dist/index.js",
   "author": "OrgX Team",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useorgx/openclaw-plugin",
-  "version": "0.4.5",
+  "version": "0.4.8",
   "description": "OrgX plugin for OpenClaw — agent orchestration, quality gates, model routing, and live dashboard",
   "type": "module",
   "main": "./dist/index.js",
@@ -35,10 +35,24 @@
     "typecheck": "tsc --noEmit",
     "test:hooks": "npm run build:core && node --test --test-concurrency=1 tests/*.test.mjs tests/**/*.test.mjs",
     "job:dispatch": "npm run build:core && node ./scripts/run-codex-dispatch-job.mjs",
+    "agents:refresh": "node ./scripts/daily-agents-refresh.mjs",
+    "agents:install": "node ./scripts/install-daily-agents-refresh.mjs",
     "verify:clean-install": "node ./scripts/verify-clean-install.mjs",
+    "verify:agent-suite": "npm run build:core && node ./scripts/verify-agent-suite-install.mjs",
     "verify:billing": "npm run build:core && node ./scripts/verify-billing-scenarios.mjs",
+    "verify:autopilot-e2e:local": "npm run build:core && node ./scripts/verify-autopilot-e2e-local.mjs",
+    "verify:autopilot-e2e:matrix": "npm run build:core && node ./scripts/verify-autopilot-e2e-matrix.mjs",
+    "verify:autopilot-e2e:entities": "npm run build:core && node ./scripts/verify-autopilot-e2e-entities.mjs",
+    "verify:autopilot-e2e:entities-matrix": "npm run build:core && node ./scripts/verify-autopilot-e2e-entities-matrix.mjs",
+    "verify:iwmt-cascade": "npm run build:core && node ./scripts/verify-iwmt-cascade-e2e.mjs",
+    "e2e:auto-continue": "node ./scripts/e2e-auto-continue.mjs",
+    "e2e:agent-suite": "npm run build:core && node ./scripts/e2e-agent-suite-kickoff-3x.mjs",
+    "demo:record": "node ./scripts/record-demo.mjs",
     "qa:capture": "node ./scripts/capture-qa-evidence.mjs",
+    "ship": "node ./scripts/ship.mjs",
     "ops:launch-checklist": "node ./scripts/run-launch-checklist.mjs",
+    "seo:plan": "node ./scripts/apply-seo-plan-v1.mjs",
+    "seo:run": "node ./scripts/seo/run.mjs",
     "install:dashboard": "npm --prefix dashboard ci",
     "build:dashboard": "npm run install:dashboard && npm --prefix dashboard run build",
     "build:core": "rm -rf dist && tsc && node ./scripts/copy-manifest.mjs",