@useorgx/openclaw-plugin 0.4.9 → 0.7.0

package/dist/sync/local-agent-telemetry.js

@@ -0,0 +1,128 @@
+const KNOWN_DOMAINS = [
+    "engineering",
+    "product",
+    "design",
+    "marketing",
+    "sales",
+    "operations",
+    "orchestration",
+];
+const IDLE_MIRROR_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+function inferDomainFromAgentId(agentId) {
+    const normalized = agentId.trim().toLowerCase();
+    for (const domain of KNOWN_DOMAINS) {
+        if (normalized.includes(domain))
+            return domain;
+    }
+    return "operations";
+}
+function inferNameFromAgentId(agentId) {
+    const cleaned = agentId
+        .trim()
+        .replace(/[_-]+/g, " ")
+        .replace(/\s+/g, " ");
+    if (!cleaned)
+        return "Local Agent";
+    return cleaned
+        .split(" ")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function toEpoch(value) {
+    const epoch = Date.parse(value);
+    return Number.isFinite(epoch) ? epoch : 0;
+}
+function normalizeMirror(input) {
+    const id = typeof input.id === "string" ? input.id.trim() : "";
+    if (!id)
+        return null;
+    const status = input.status === "active" || input.status === "throttled" ? input.status : "idle";
+    const name = typeof input.name === "string" && input.name.trim().length > 0
+        ? input.name.trim()
+        : inferNameFromAgentId(id);
+    const domain = typeof input.domain === "string" && input.domain.trim().length > 0
+        ? input.domain.trim()
+        : inferDomainFromAgentId(id);
+    return {
+        id,
+        name,
+        domain,
+        status,
+        currentTask: input.currentTask,
+        lastActive: input.lastActive,
+    };
+}
+export function buildLocalAgentMirrorsFromSnapshot(input) {
+    const latestByAgent = new Map();
+    for (const source of input.agents ?? []) {
+        const normalized = normalizeMirror(source);
+        if (!normalized)
+            continue;
+        const previous = latestByAgent.get(normalized.id);
+        if (!previous ||
+            toEpoch(normalized.lastActive ?? "") >= toEpoch(previous.lastActive ?? "")) {
+            latestByAgent.set(normalized.id, normalized);
+        }
+    }
+    return Array.from(latestByAgent.values()).sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+ * Derive live local agent states from active OpenClaw runs so sync can mirror
+ * local runtime telemetry into OrgX.
+ */
+export function buildLocalSyncAgentsFromRuns(input) {
+    const latestRunningByAgent = new Map();
+    const latestStoppedByAgent = new Map();
+    const mergedByAgent = new Map();
+    const now = Date.now();
+    for (const mirror of buildLocalAgentMirrorsFromSnapshot({ agents: input.mirrors })) {
+        mergedByAgent.set(mirror.id, mirror);
+    }
+    for (const run of Object.values(input.runs ?? {})) {
+        if (!run)
+            continue;
+        const agentId = run.agentId?.trim();
+        if (!agentId)
+            continue;
+        const isRunning = run.status === "running";
+        const index = isRunning ? latestRunningByAgent : latestStoppedByAgent;
+        const runTimestamp = isRunning ? toEpoch(run.startedAt) : toEpoch(run.stoppedAt ?? run.startedAt);
+        const previous = index.get(agentId);
+        const previousTimestamp = previous
+            ? toEpoch(previous.status === "running" ? previous.startedAt : previous.stoppedAt ?? previous.startedAt)
+            : 0;
+        if (!previous || runTimestamp >= previousTimestamp) {
+            index.set(agentId, run);
+        }
+    }
+    for (const [agentId, run] of latestRunningByAgent) {
+        mergedByAgent.set(agentId, {
+            id: agentId,
+            name: inferNameFromAgentId(agentId),
+            domain: inferDomainFromAgentId(agentId),
+            status: "active",
+            currentTask: run.taskId ?? undefined,
+            lastActive: run.startedAt,
+        });
+    }
+    for (const [agentId, run] of latestStoppedByAgent) {
+        if (latestRunningByAgent.has(agentId))
+            continue;
+        const lastActive = run.stoppedAt ?? run.startedAt;
+        const idleAgeMs = now - toEpoch(lastActive);
+        if (!Number.isFinite(idleAgeMs) || idleAgeMs < 0 || idleAgeMs > IDLE_MIRROR_MAX_AGE_MS) {
+            continue;
+        }
+        const existing = mergedByAgent.get(agentId);
+        if (existing && toEpoch(existing.lastActive ?? "") > toEpoch(lastActive))
+            continue;
+        mergedByAgent.set(agentId, {
+            id: agentId,
+            name: existing?.name ?? inferNameFromAgentId(agentId),
+            domain: existing?.domain ?? inferDomainFromAgentId(agentId),
+            status: "idle",
+            lastActive,
+        });
+    }
+    return Array.from(mergedByAgent.values()).sort((a, b) => a.id.localeCompare(b.id));
+}

package/dist/sync/outbox-replay.js

@@ -1,6 +1,14 @@
 import { registerArtifact } from "../artifacts/register-artifact.js";
-import { readOutbox, readOutboxSummary, replaceOutbox } from "../outbox.js";
+import { appendOutboxDeadLetter, readOutbox, readOutboxSummary, replaceOutbox, } from "../outbox.js";
 import { extractProgressOutboxMessage } from "../reporting/outbox-replay.js";
+import { RETRO_ARTIFACT_SCHEMA_VERSION } from "../contracts/retro-schema.js";
+import { classifyOutboxReplaySkip } from "../event-sanitization.js";
+const OUTBOX_MAX_REPLAY_FAILURES = (() => {
+    const raw = Number(process.env.ORGX_OUTBOX_MAX_REPLAY_FAILURES ?? "");
+    if (!Number.isFinite(raw))
+        return 3;
+    return Math.max(1, Math.min(20, Math.floor(raw)));
+})();
 export function createOutboxReplayer(deps) {
     const { client, logger, toErrorMessage, stableHash, resolveReportingContext, pickStringField, pickStringArrayField, toReportingPhase, parseRetroEntityType, isUuid, } = deps;
     async function replayOutboxEvent(event) {
@@ -19,6 +27,78 @@ export function createOutboxReplayer(deps) {
             }
             return { run_id: undefined, correlation_id: undefined };
         }
+        function normalizeRetro(payload) {
+            const retro = payload.retro && typeof payload.retro === "object" && !Array.isArray(payload.retro)
+                ? payload.retro
+                : null;
+            const trimAndClamp = (value, maxLength) => value.trim().slice(0, maxLength);
+            const summary = retro && typeof retro.summary === "string"
+                ? trimAndClamp(retro.summary, 4000)
+                : "";
+            if (!retro || !summary) {
+                return null;
+            }
+            const normalizeStringList = (value) => {
+                if (!Array.isArray(value))
+                    return undefined;
+                const normalized = value
+                    .filter((item) => typeof item === "string")
+                    .map((item) => trimAndClamp(item, 1000))
+                    .filter((item) => item.length > 0)
+                    .slice(0, 25);
+                return normalized.length > 0 ? normalized : undefined;
+            };
+            const pickRetroStringList = (snakeCaseKey, camelCaseKey) => normalizeStringList(retro[snakeCaseKey]) ?? normalizeStringList(retro[camelCaseKey]);
+            const followUpsRaw = Array.isArray(retro.follow_ups)
+                ? retro.follow_ups
+                : Array.isArray(retro.followUps)
+                    ? retro.followUps
+                    : [];
+            const followUps = [];
+            for (const candidate of followUpsRaw) {
+                if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+                    continue;
+                }
+                const title = typeof candidate.title === "string"
+                    ? trimAndClamp(candidate.title, 500)
+                    : "";
+                if (!title) {
+                    continue;
+                }
+                const priorityRaw = typeof candidate.priority === "string"
+                    ? candidate.priority.trim().toLowerCase()
+                    : "";
+                const priority = priorityRaw === "p0" || priorityRaw === "p1" || priorityRaw === "p2"
+                    ? priorityRaw
+                    : undefined;
+                const reason = typeof candidate.reason === "string"
+                    ? trimAndClamp(candidate.reason, 2000)
+                    : "";
+                const normalizedFollowUp = { title };
+                if (priority) {
+                    normalizedFollowUp.priority = priority;
+                }
+                if (reason) {
+                    normalizedFollowUp.reason = reason;
+                }
+                followUps.push(normalizedFollowUp);
+                if (followUps.length >= 25) {
+                    break;
+                }
+            }
+            const signals = retro.signals && typeof retro.signals === "object" && !Array.isArray(retro.signals)
+                ? retro.signals
+                : undefined;
+            return {
+                schema_version: RETRO_ARTIFACT_SCHEMA_VERSION,
+                summary,
+                what_went_well: pickRetroStringList("what_went_well", "whatWentWell"),
+                what_went_wrong: pickRetroStringList("what_went_wrong", "whatWentWrong"),
+                decisions: pickRetroStringList("decisions", "keyDecisions"),
+                follow_ups: followUps.length > 0 ? followUps : undefined,
+                signals,
+            };
+        }
         if (event.type === "progress") {
             const message = extractProgressOutboxMessage(payload);
             if (!message) {
@@ -68,20 +148,6 @@ export function createOutboxReplayer(deps) {
                     undefined,
                 metadata: baseMetadata,
             };
-            // Locally-buffered progress events often store a local UUID in run_id. OrgX may reject
-            // unknown run IDs on replay; prefer a deterministic non-UUID correlation key instead.
-            if (emitPayload.run_id && !emitPayload.correlation_id) {
-                const replayCorrelationId = `openclaw_run_${stableHash(emitPayload.run_id).slice(0, 24)}`;
-                emitPayload = {
-                    ...emitPayload,
-                    run_id: undefined,
-                    correlation_id: replayCorrelationId,
-                    metadata: {
-                        ...(emitPayload.metadata ?? {}),
-                        replay_run_id_as_correlation: true,
-                    },
-                };
-            }
             try {
                 await client.emitActivity(emitPayload);
             }
@@ -92,8 +158,8 @@ export function createOutboxReplayer(deps) {
                 // create/attach a run deterministically.
                 const msg = toErrorMessage(err);
                 if (emitPayload.run_id &&
-                    /^404\\b/.test(msg) &&
-                    /\\brun\\b/i.test(msg) &&
+                    /(?:^|\b)404\b/.test(msg) &&
+                    /\brun\b/i.test(msg) &&
                     /not found/i.test(msg)) {
                     const replayCorrelationId = `openclaw_run_${stableHash(emitPayload.run_id).slice(0, 24)}`;
                     await client.emitActivity({
@@ -350,11 +416,8 @@ export function createOutboxReplayer(deps) {
                 runId: context.value.runId,
                 correlationId: context.value.correlationId,
             });
-            const retro = payload.retro && typeof payload.retro === "object" && !Array.isArray(payload.retro)
-                ? payload.retro
-                : null;
-            const summary = retro && typeof retro.summary === "string" ? retro.summary.trim() : "";
-            if (!retro || !summary) {
+            const normalizedRetro = normalizeRetro(payload);
+            if (!normalizedRetro) {
                 logger.warn?.("[orgx] Dropping invalid retro outbox event", {
                     eventId: event.id,
                 });
@@ -383,7 +446,7 @@ export function createOutboxReplayer(deps) {
                 idempotency_key: pickStringField(payload, "idempotency_key") ??
                     pickStringField(payload, "idempotencyKey") ??
                     undefined,
-                retro: retro,
+                retro: normalizedRetro,
                 markdown: pickStringField(payload, "markdown") ?? undefined,
             });
             return;
@@ -402,6 +465,13 @@ export function createOutboxReplayer(deps) {
             const description = pickStringField(payload, "description") ?? undefined;
             const externalUrl = pickStringField(payload, "url") ?? pickStringField(payload, "artifact_url") ?? null;
             const content = pickStringField(payload, "content") ?? pickStringField(payload, "preview_markdown") ?? null;
+            const confidenceRaw = payload.confidence_score;
+            const confidenceScore = typeof confidenceRaw === "number" &&
+                Number.isFinite(confidenceRaw) &&
+                confidenceRaw >= 0 &&
+                confidenceRaw <= 1
+                ? confidenceRaw
+                : null;
             const allowedEntityType = entityType === "initiative" ||
                 entityType === "milestone" ||
                 entityType === "task" ||
@@ -423,6 +493,7 @@ export function createOutboxReplayer(deps) {
                 entity_id: entityId,
                 name: name.trim(),
                 artifact_type: artifactType.trim() || "other",
+                confidence_score: confidenceScore,
                 description,
                 external_url: externalUrl,
                 preview_markdown: content,
@@ -430,6 +501,7 @@ export function createOutboxReplayer(deps) {
                 metadata: {
                     source: "outbox_replay",
                     outbox_event_id: event.id,
+                    confidence_score: confidenceScore,
                     ...(payload.metadata && typeof payload.metadata === "object" && !Array.isArray(payload.metadata)
                         ? payload.metadata
                         : {}),
@@ -466,16 +538,51 @@ export function createOutboxReplayer(deps) {
             }
             const remaining = [];
             for (const event of pending) {
+                const skipReason = classifyOutboxReplaySkip(event);
+                if (skipReason) {
+                    await appendOutboxDeadLetter(queue, event, `dropped_before_replay:${skipReason}`, null);
+                    logger.warn?.("[orgx] Dropping non-replayable outbox event", {
+                        queue,
+                        eventId: event.id,
+                        reason: skipReason,
+                    });
+                    continue;
+                }
                 try {
                     await replayOutboxEvent(event);
                 }
                 catch (err) {
                     hadReplayFailure = true;
                     lastReplayError = toErrorMessage(err);
-                    remaining.push(event);
+                    const nextFailures = typeof event.replayFailures === "number" && Number.isFinite(event.replayFailures)
+                        ? Math.max(0, Math.floor(event.replayFailures)) + 1
+                        : 1;
+                    if (nextFailures >= OUTBOX_MAX_REPLAY_FAILURES) {
+                        await appendOutboxDeadLetter(queue, {
+                            ...event,
+                            replayFailures: nextFailures,
+                            lastReplayError,
+                            lastReplayAt: new Date().toISOString(),
+                        }, "max_replay_failures", lastReplayError);
+                        logger.warn?.("[orgx] Dead-lettering outbox event after max replay failures", {
+                            queue,
+                            eventId: event.id,
+                            failures: nextFailures,
+                            maxFailures: OUTBOX_MAX_REPLAY_FAILURES,
+                            error: lastReplayError,
+                        });
+                        continue;
+                    }
+                    remaining.push({
+                        ...event,
+                        replayFailures: nextFailures,
+                        lastReplayError,
+                        lastReplayAt: new Date().toISOString(),
+                    });
                     logger.warn?.("[orgx] Outbox replay failed", {
                         queue,
                         eventId: event.id,
+                        replayFailures: nextFailures,
                         error: lastReplayError,
                     });
                 }

package/dist/team-context-store.d.ts

@@ -0,0 +1,23 @@
+export type TeamCompletion = {
+    domain: string;
+    task_title: string;
+    summary: string;
+    key_outputs?: string[];
+    completed_at: string;
+};
+export type TeamDecision = {
+    title: string;
+    resolution: string;
+    affected_domains?: string[];
+    resolved_at: string;
+};
+type PersistedTeamContext = {
+    updatedAt: string;
+    recent_completions: TeamCompletion[];
+    recent_decisions: TeamDecision[];
+};
+export declare function readTeamContext(initiativeId: string): PersistedTeamContext;
+export declare function appendTeamCompletion(initiativeId: string, completion: TeamCompletion): void;
+export declare function appendTeamDecision(initiativeId: string, decision: TeamDecision): void;
+export declare function clearTeamContext(initiativeId?: string): void;
+export {};

package/dist/team-context-store.js

@@ -0,0 +1,116 @@
+/**
+ * Team Context Store — Local cache for cross-agent awareness.
+ *
+ * Persists recent slice completions and decisions per initiative so the
+ * auto-continue engine can provide degraded team context when the server
+ * is unreachable (offline fallback for KickoffContext.team_context).
+ *
+ * Follows the same patterns as agent-context-store.ts: bounded store,
+ * atomic writes, corrupt file recovery.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "./paths.js";
+import { backupCorruptFileSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+import { clearStoreFileSync, ensureStoreDirSync, parseJsonSafe, } from "./stores/json-store.js";
+const MAX_COMPLETIONS = 20;
+const MAX_DECISIONS = 20;
+const MAX_INITIATIVES = 50;
+function storeDir() {
+    return getOrgxPluginConfigDir();
+}
+function storeFile() {
+    return getOrgxPluginConfigPath("team-context.json");
+}
+function emptyContext() {
+    return { updatedAt: new Date().toISOString(), recent_completions: [], recent_decisions: [] };
+}
+function emptyIndex() {
+    return { initiatives: {} };
+}
+function isValidIndex(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return record.initiatives !== undefined && typeof record.initiatives === "object";
+}
+function readIndex() {
+    const file = storeFile();
+    try {
+        if (!existsSync(file))
+            return emptyIndex();
+        const raw = readFileSync(file, "utf8");
+        const parsed = parseJsonSafe(raw);
+        if (!isValidIndex(parsed)) {
+            backupCorruptFileSync(file);
+            return emptyIndex();
+        }
+        return parsed;
+    }
+    catch {
+        return emptyIndex();
+    }
+}
+function writeIndex(index) {
+    ensureStoreDirSync(storeDir());
+    // Prune if too many initiatives.
+    const keys = Object.keys(index.initiatives);
+    if (keys.length > MAX_INITIATIVES) {
+        const sorted = keys
+            .map((k) => ({ key: k, updatedAt: index.initiatives[k]?.updatedAt ?? "" }))
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        const keep = new Set(sorted.slice(0, MAX_INITIATIVES).map((e) => e.key));
+        for (const key of keys) {
+            if (!keep.has(key))
+                delete index.initiatives[key];
+        }
+    }
+    writeJsonFileAtomicSync(storeFile(), index, 0o600);
+}
+export function readTeamContext(initiativeId) {
+    const id = initiativeId.trim();
+    if (!id)
+        return emptyContext();
+    const index = readIndex();
+    const ctx = index.initiatives[id];
+    return ctx ?? emptyContext();
+}
+export function appendTeamCompletion(initiativeId, completion) {
+    const id = initiativeId.trim();
+    if (!id)
+        return;
+    const index = readIndex();
+    const ctx = index.initiatives[id] ?? emptyContext();
+    ctx.recent_completions.push(completion);
+    if (ctx.recent_completions.length > MAX_COMPLETIONS) {
+        ctx.recent_completions = ctx.recent_completions.slice(-MAX_COMPLETIONS);
+    }
+    ctx.updatedAt = new Date().toISOString();
+    index.initiatives[id] = ctx;
+    writeIndex(index);
+}
+export function appendTeamDecision(initiativeId, decision) {
+    const id = initiativeId.trim();
+    if (!id)
+        return;
+    const index = readIndex();
+    const ctx = index.initiatives[id] ?? emptyContext();
+    ctx.recent_decisions.push(decision);
+    if (ctx.recent_decisions.length > MAX_DECISIONS) {
+        ctx.recent_decisions = ctx.recent_decisions.slice(-MAX_DECISIONS);
+    }
+    ctx.updatedAt = new Date().toISOString();
+    index.initiatives[id] = ctx;
+    writeIndex(index);
+}
+export function clearTeamContext(initiativeId) {
+    if (!initiativeId) {
+        clearStoreFileSync(storeFile());
+        return;
+    }
+    const id = initiativeId.trim();
+    if (!id)
+        return;
+    const index = readIndex();
+    delete index.initiatives[id];
+    writeIndex(index);
+}

package/dist/telemetry/posthog.js

@@ -1,4 +1,3 @@
-const POSTHOG_DEFAULT_API_KEY = "phc_s4KPgkYEFZgvkMYw4zXG41H5FN6haVwbEWPYHfNjxOc";
 const POSTHOG_DEFAULT_HOST = "https://us.i.posthog.com";
 function isTruthyEnv(value) {
     if (!value)
@@ -15,6 +14,9 @@ function isTruthyEnv(value) {
     }
 }
 export function isOrgxTelemetryDisabled() {
+    const explicitEnable = isTruthyEnv(process.env.ORGX_TELEMETRY_ENABLED);
+    if (!explicitEnable)
+        return true;
     return (isTruthyEnv(process.env.ORGX_TELEMETRY_DISABLED) ||
         isTruthyEnv(process.env.OPENCLAW_TELEMETRY_DISABLED) ||
         isTruthyEnv(process.env.POSTHOG_DISABLED));
@@ -28,7 +30,7 @@ export function resolvePosthogApiKey() {
     const trimmed = fromEnv.trim();
     if (trimmed)
         return trimmed;
-    return POSTHOG_DEFAULT_API_KEY;
+    return null;
 }
 export function resolvePosthogHost() {
     const fromEnv = process.env.ORGX_POSTHOG_HOST ??

package/dist/tools/core-tools.d.ts

@@ -57,20 +57,16 @@ export interface RegisterCoreToolsDeps {
         ok: false;
         error: string;
     };
-    readSkillPackState: () => {
-        pack?: {
-            name?: string | null;
-            version?: string | null;
-            checksum?: string | null;
-        } | null;
-        overrides?: {
-            source?: string | null;
-            name?: string | null;
-            version?: string | null;
-            checksum?: string | null;
-        } | null;
-        etag?: string | null;
-    };
+    readSkillPackState: () => import("../skill-pack-state.js").SkillPackState;
+    updateSkillPackPolicy: (input: {
+        frozen?: boolean;
+        pinnedChecksum?: string | null;
+        pinToCurrent?: boolean;
+        clearPin?: boolean;
+    }) => import("../skill-pack-state.js").SkillPackState;
+    rollbackSkillPackPolicy: (input?: {
+        auditId?: string;
+    }) => import("../skill-pack-state.js").SkillPackState;
     randomUUID?: () => string;
 }
 export declare function registerCoreTools(deps: RegisterCoreToolsDeps): Map<string, RegisteredTool>;