@useorgx/openclaw-plugin 0.4.9 → 0.7.0

package/dist/contracts/skill-pack-schema.js

@@ -0,0 +1,180 @@
+export const OPENCLAW_SKILL_PACK_SCHEMA_VERSION = "openclaw-skill-pack.v1";
+export const ORGX_AGENT_DOMAINS = [
+    "engineering",
+    "product",
+    "design",
+    "marketing",
+    "sales",
+    "operations",
+    "orchestration",
+];
+const DOMAIN_SET = new Set(ORGX_AGENT_DOMAINS);
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function hasOwn(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
+const DOMAIN_STRING_SCHEMA = {
+    type: "string",
+    minLength: 1,
+};
+export const OPENCLAW_SKILLS_MAP_JSON_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        engineering: DOMAIN_STRING_SCHEMA,
+        product: DOMAIN_STRING_SCHEMA,
+        design: DOMAIN_STRING_SCHEMA,
+        marketing: DOMAIN_STRING_SCHEMA,
+        sales: DOMAIN_STRING_SCHEMA,
+        operations: DOMAIN_STRING_SCHEMA,
+        orchestration: DOMAIN_STRING_SCHEMA,
+    },
+};
+export const OPENCLAW_SKILL_PACK_MANIFEST_JSON_SCHEMA = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://schemas.useorgx.com/openclaw-skill-pack/v1.json",
+    title: "OrgX OpenClaw Skill Pack Manifest",
+    description: "Behavior config manifest for OpenClaw skill overrides by domain.",
+    type: "object",
+    additionalProperties: true,
+    oneOf: [
+        {
+            type: "object",
+            additionalProperties: true,
+            properties: {
+                schema_version: { type: "string", const: OPENCLAW_SKILL_PACK_SCHEMA_VERSION },
+                openclaw_skills: OPENCLAW_SKILLS_MAP_JSON_SCHEMA,
+            },
+            required: ["openclaw_skills"],
+        },
+        {
+            type: "object",
+            additionalProperties: true,
+            properties: {
+                schema_version: { type: "string", const: OPENCLAW_SKILL_PACK_SCHEMA_VERSION },
+                openclawSkills: OPENCLAW_SKILLS_MAP_JSON_SCHEMA,
+            },
+            required: ["openclawSkills"],
+        },
+        {
+            type: "object",
+            additionalProperties: true,
+            properties: {
+                schema_version: { type: "string", const: OPENCLAW_SKILL_PACK_SCHEMA_VERSION },
+                openclaw: {
+                    type: "object",
+                    additionalProperties: true,
+                    properties: {
+                        skills: OPENCLAW_SKILLS_MAP_JSON_SCHEMA,
+                    },
+                    required: ["skills"],
+                },
+            },
+            required: ["openclaw"],
+        },
+    ],
+};
+function resolveManifestConfigType(manifest) {
+    const hasOpenclawSkills = hasOwn(manifest, "openclaw_skills");
+    const hasOpenclawSkillsCamel = hasOwn(manifest, "openclawSkills");
+    const openclaw = manifest.openclaw;
+    const hasOpenclawNestedSkills = isRecord(openclaw) && hasOwn(openclaw, "skills");
+    const errors = [];
+    const selectedConfigTypes = [
+        hasOpenclawSkills ? "openclaw_skills" : null,
+        hasOpenclawSkillsCamel ? "openclawSkills" : null,
+        hasOpenclawNestedSkills ? "openclaw.skills" : null,
+    ].filter((value) => value !== null);
+    if (selectedConfigTypes.length > 1) {
+        errors.push("manifest must define only one config container: openclaw_skills, openclawSkills, or openclaw.skills");
+    }
+    if (hasOpenclawSkills) {
+        const value = manifest.openclaw_skills;
+        if (!isRecord(value)) {
+            return {
+                type: "openclaw_skills",
+                rawMap: null,
+                errors: [...errors, "manifest.openclaw_skills must be an object"],
+            };
+        }
+        return { type: "openclaw_skills", rawMap: value, errors };
+    }
+    if (hasOpenclawSkillsCamel) {
+        const value = manifest.openclawSkills;
+        if (!isRecord(value)) {
+            return {
+                type: "openclawSkills",
+                rawMap: null,
+                errors: [...errors, "manifest.openclawSkills must be an object"],
+            };
+        }
+        return { type: "openclawSkills", rawMap: value, errors };
+    }
+    if (hasOpenclawNestedSkills) {
+        const value = openclaw.skills;
+        if (!isRecord(value)) {
+            return {
+                type: "openclaw.skills",
+                rawMap: null,
+                errors: [...errors, "manifest.openclaw.skills must be an object"],
+            };
+        }
+        return { type: "openclaw.skills", rawMap: value, errors };
+    }
+    return { type: "none", rawMap: null, errors };
+}
+export function validateOpenClawSkillPackManifest(manifest) {
+    if (!isRecord(manifest)) {
+        return {
+            ok: false,
+            configType: "none",
+            openclaw_skills: {},
+            errors: ["manifest must be an object"],
+        };
+    }
+    const errors = [];
+    if ("schema_version" in manifest) {
+        const version = manifest.schema_version;
+        if (typeof version !== "string") {
+            errors.push("manifest.schema_version must be a string");
+        }
+        else if (version.trim() !== OPENCLAW_SKILL_PACK_SCHEMA_VERSION) {
+            errors.push(`manifest.schema_version must equal "${OPENCLAW_SKILL_PACK_SCHEMA_VERSION}"`);
+        }
+    }
+    const { type, rawMap, errors: manifestConfigErrors } = resolveManifestConfigType(manifest);
+    errors.push(...manifestConfigErrors);
+    if (!rawMap) {
+        return {
+            ok: errors.length === 0,
+            configType: type,
+            openclaw_skills: {},
+            errors,
+        };
+    }
+    const openclaw_skills = {};
+    for (const [domain, rawValue] of Object.entries(rawMap)) {
+        if (!DOMAIN_SET.has(domain)) {
+            errors.push(`unknown domain key "${domain}" in manifest ${type}`);
+            continue;
+        }
+        if (typeof rawValue !== "string") {
+            errors.push(`manifest ${type}.${domain} must be a string`);
+            continue;
+        }
+        const normalized = rawValue.trim();
+        if (!normalized) {
+            errors.push(`manifest ${type}.${domain} must not be empty`);
+            continue;
+        }
+        openclaw_skills[domain] = normalized;
+    }
+    return {
+        ok: errors.length === 0,
+        configType: type,
+        openclaw_skills,
+        errors,
+    };
+}

package/dist/contracts/types.d.ts

@@ -4,7 +4,9 @@
  * Types for the plugin's API client and tool interfaces.
  * Mirrors the server-side types in orgx/lib/client-integration/types.ts
  */
-export type { HandoffEvent, HandoffSummary, LiveActivityItem, LiveActivityType, LiveDecision, OnboardingKeySource, OnboardingNextAction, OnboardingState, OnboardingStatus, RunPhase, RuntimeInstance, RuntimeInstanceState, RuntimeProviderLogo, RuntimeSourceClient, SessionTreeEdge, SessionTreeGroup, SessionTreeNode, SessionTreeResponse, } from './shared-types.js';
+import type { DecisionActionType } from './shared-types.js';
+import type { RetroArtifactSchemaVersion } from './retro-schema.js';
+export type { ActivityEventName, HandoffEvent, HandoffSummary, LiveActivityItem, LiveActivityType, LiveDecision, OnboardingKeySource, OnboardingNextAction, OnboardingState, OnboardingStatus, RunPhase, RuntimeInstance, RuntimeInstanceState, RuntimeProviderLogo, RuntimeSourceClient, SessionBlockerContext, SessionBlockerDiagnostics, SessionTreeEdge, SessionTreeGroup, SessionTreeNode, SessionTreeResponse, } from './shared-types.js';
 export interface OrgXConfig {
     /** OrgX API key */
     apiKey: string;
@@ -81,6 +83,29 @@ export interface KickoffContext {
         collaboration_style?: string | null;
         defaults?: string[] | null;
     } | null;
+    runtime_settings?: {
+        decision_v2_enabled?: boolean;
+        decision_dedupe_enabled?: boolean;
+        decision_evidence_required_for_blocking?: boolean;
+        decision_auto_resolve_guarded_enabled?: boolean;
+        custom_run_instructions?: string | null;
+    } | null;
+    /** Recent team activity for cross-agent awareness. */
+    team_context?: {
+        recent_completions?: Array<{
+            domain: string;
+            task_title: string;
+            summary: string;
+            key_outputs?: string[];
+            completed_at: string;
+        }>;
+        recent_decisions?: Array<{
+            title: string;
+            resolution: string;
+            affected_domains?: string[];
+            resolved_at: string;
+        }>;
+    } | null;
 }
 export type KickoffContextRequest = KickoffContextScope & {
     agent_id?: string | null;
@@ -124,6 +149,42 @@ export type OrgxAgentPack = {
     agents: OrgxAgentProfile[];
     managed_files: string[];
 };
+export interface AgentRuntimeSettingsPayload {
+    decision_v2_enabled?: boolean;
+    decision_dedupe_enabled?: boolean;
+    decision_evidence_required_for_blocking?: boolean;
+    decision_auto_resolve_guarded_enabled?: boolean;
+    custom_run_instructions?: string | null;
+}
+export interface ClientRuntimeSettingsAgent {
+    id: string;
+    name: string;
+    type: string;
+    status: string;
+    model: string | null;
+    runtime_settings: AgentRuntimeSettingsPayload;
+}
+export type ClientRuntimeSettingsResponse = {
+    ok: true;
+    workspace_id?: string | null;
+    /** Legacy alias retained for backward compatibility */
+    project_id?: string | null;
+    agents?: ClientRuntimeSettingsAgent[];
+    agent?: ClientRuntimeSettingsAgent;
+} | {
+    ok: false;
+    error: string;
+};
+export interface ClientRuntimeSettingsUpdateRequest {
+    /** Canonical workspace scope */
+    workspace_id?: string;
+    /** Legacy alias retained for backward compatibility */
+    command_center_id?: string;
+    /** Legacy alias retained for backward compatibility */
+    project_id?: string;
+    agent_id: string;
+    runtime_settings: AgentRuntimeSettingsPayload;
+}
 export type SkillPack = {
     name: string;
     version: string;
@@ -184,6 +245,8 @@ export interface SyncPayload {
     memory?: string;
     /** Today's session log */
     dailyLog?: string;
+    /** Local OpenClaw agent states to mirror into OrgX */
+    agents?: AgentState[];
     /** Workspace state for local↔cloud handoff continuity */
     workspaceState?: HandoffWorkspaceState;
     /** Decisions made this session */
@@ -205,6 +268,8 @@ export interface SyncResponse {
         title: string;
         status: string;
     }>;
+    /** Agent states (optional for backward compatibility with older servers) */
+    agents?: AgentState[];
     /** In-progress tasks */
     activeTasks: Array<{
         id: string;
@@ -249,6 +314,80 @@ export interface BillingUrlResult {
     url: string | null;
     checkout_url?: string | null;
 }
+export type UsageRiskLevel = "safe" | "watch" | "at_risk" | "over_limit";
+export type UsageBreakdownBucket = {
+    key: string;
+    label: string;
+    runs: number;
+    tokens: number;
+    minutes: number;
+    costCents: number;
+};
+export type UsagePrediction = {
+    agentRuns: number;
+    agentMinutes: number;
+    tokens: number;
+    costCents: number;
+    confidence: number;
+    method: string;
+    remainingAgentRuns: number;
+    remainingAgentMinutes: number;
+    remainingTokens: number;
+    remainingCostCents: number;
+};
+export type UsageControlPlaneSummary = {
+    generatedAt: string;
+    period: {
+        start: string;
+        end: string;
+        daysTotal: number;
+        daysElapsed: number;
+        daysRemaining: number;
+    };
+    plan: {
+        id: string;
+        name: string;
+        allowsOverage: boolean;
+        includedBudgetCents: number;
+        overageBudgetCents: number;
+        agentRunsLimit: number;
+        agentMinutesLimit: number;
+        scaffoldsLimit: number;
+    };
+    actual: {
+        agentRuns: number;
+        agentMinutes: number;
+        tokens: number;
+        costCents: number;
+        scaffoldsUsed: number;
+        scaffoldsRemaining: number;
+    };
+    predicted: UsagePrediction;
+    utilization: {
+        runsPct: number | null;
+        minutesPct: number | null;
+        budgetPct: number | null;
+    };
+    headroom: {
+        agentRunsRemaining: number;
+        agentMinutesRemaining: number;
+        budgetRemainingCents: number;
+    };
+    risk: UsageRiskLevel;
+    breakdown: {
+        provider: UsageBreakdownBucket[];
+        executionTarget: UsageBreakdownBucket[];
+        sourceClient: UsageBreakdownBucket[];
+        model: UsageBreakdownBucket[];
+    };
+    velocity: {
+        windowDays: number;
+        dailyAvgRuns: number;
+        dailyAvgMinutes: number;
+        dailyAvgTokens: number;
+        dailyAvgCostCents: number;
+    };
+};
 export interface HandoffWorkspaceState {
     git?: {
         branch?: string | null;
@@ -377,14 +516,61 @@ export interface EntityUpdatePayload {
 export interface EntityListFilters {
     status?: string;
     limit?: number;
+    offset?: number;
+    search?: string;
+    id?: string;
+    ids?: string[] | string;
+    initiative_id?: string;
+    project_id?: string;
+    /** Canonical workspace scope */
+    workspace_id?: string;
+    /** Legacy alias for workspace_id */
+    command_center_id?: string;
     [key: string]: unknown;
 }
+export interface WorkstreamReassignmentStatus {
+    scheduled: boolean;
+    requestId?: string | null;
+    dueAt?: string | null;
+    reason?: string;
+}
+export interface InitiativeReassignmentStatus {
+    triggered: boolean;
+    requested: number;
+    scheduled: number;
+    skipped: number;
+    failures: string[];
+}
+export interface EntityUpdateResult {
+    entity: Entity;
+    reassignment?: WorkstreamReassignmentStatus | null;
+    initiative_reassignment?: InitiativeReassignmentStatus | null;
+}
 export type ReportingSourceClient = 'openclaw' | 'codex' | 'claude-code' | 'api';
 export type ReportingPhase = 'intent' | 'execution' | 'blocked' | 'review' | 'handoff' | 'completed';
 export type ReportingLevel = 'info' | 'warn' | 'error';
 export type TaskStatus = 'todo' | 'in_progress' | 'done' | 'blocked';
 export type MilestoneStatus = 'planned' | 'in_progress' | 'completed' | 'at_risk' | 'cancelled';
 export type DecisionUrgency = 'low' | 'medium' | 'high' | 'urgent';
+export type DecisionOptionImpliedStatus = 'approved' | 'declined' | 'cancelled' | 'rejected';
+export interface DecisionCreateOption {
+    id?: string;
+    label: string;
+    description?: string;
+    implied_status?: DecisionOptionImpliedStatus;
+    action_type?: DecisionActionType;
+    requires_note?: boolean;
+}
+export interface DecisionEvidenceRef {
+    evidence_type?: string;
+    title?: string;
+    summary?: string;
+    source_url?: string;
+    source_pointer?: string;
+    freshness?: string;
+    confidence?: number;
+    payload?: Record<string, unknown>;
+}
 export interface EmitActivityRequest {
     initiative_id: string;
     message: string;
@@ -431,8 +617,22 @@ export type ChangesetOperation = {
     title: string;
     summary?: string;
     urgency?: DecisionUrgency;
-    options?: string[];
+    options?: Array<string | DecisionCreateOption>;
     blocking?: boolean;
+    decision_type?: string;
+    workstream_id?: string;
+    agent_id?: string;
+    due_at?: string;
+    source_system?: string;
+    conflict_source?: string;
+    dedupe_key?: string;
+    recommended_action?: string;
+    source_run_id?: string;
+    source_session_id?: string;
+    source_stream_id?: string;
+    source_ref?: Record<string, unknown>;
+    evidence_refs?: DecisionEvidenceRef[];
+    metadata?: Record<string, unknown>;
 };
 export interface ApplyChangesetRequest {
     initiative_id: string;
@@ -486,6 +686,7 @@ export interface RecordRunOutcomeResponse {
 }
 export type RetroFollowUpPriority = 'p0' | 'p1' | 'p2';
 export interface RetroJson {
+    schema_version: RetroArtifactSchemaVersion;
     summary: string;
     what_went_well?: string[];
     what_went_wrong?: string[];
@@ -520,3 +721,27 @@ export interface RecordRunRetroResponse {
     event_id: string | null;
     auth_mode?: 'service' | 'api_key';
 }
+export type ProofLevel = "L1_traceability" | "L2_correctness" | "L3_completion" | "L4_adoption" | "L5_impact" | "L6_economics" | "L7_repeatability";
+export type ProofEnforcement = "hard_block" | "soft_warn" | "reporting_only";
+export interface ProofLevelStatus {
+    level: ProofLevel;
+    label: string;
+    passed: boolean;
+    enforcement: ProofEnforcement;
+    missingFields: string[];
+    details?: string;
+}
+export interface ProofChainStatus {
+    task_id?: string;
+    run_id?: string;
+    domain?: OrgxAgentDomain;
+    levels: ProofLevelStatus[];
+    overall_passed: boolean;
+    missing_count: number;
+    /** Codes like "no_artifact", "no_quality_gate", "no_outcome" etc. */
+    reason_codes: string[];
+}
+export interface ProofStatusRequest {
+    task_id?: string;
+    run_id?: string;
+}

package/dist/entities/auto-assignment.js

@@ -1,3 +1,24 @@
+import { callLlmJson } from "../http/helpers/llm-client.js";
+const VALID_DOMAINS = new Set([
+    "engineering",
+    "product",
+    "design",
+    "marketing",
+    "sales",
+    "operations",
+]);
+function heuristicDomainGuess(title, summary) {
+    const haystack = `${title} ${summary ?? ""}`.toLowerCase();
+    if (/market|campaign|thread|article|tweet|copy/.test(haystack))
+        return ["marketing"];
+    if (/design|ux|ui|a11y/.test(haystack))
+        return ["design"];
+    if (/ops|runbook|incident|reliability/.test(haystack))
+        return ["operations"];
+    if (/sales|deal|pipeline/.test(haystack))
+        return ["sales"];
+    return ["engineering", "product"];
+}
 export async function autoAssignEntityForCreate(input) {
     const warnings = [];
     const byKey = new Map();
@@ -67,23 +88,28 @@ export async function autoAssignEntityForCreate(input) {
         warnings.push(`delegation preflight failed (${input.toErrorMessage(err)})`);
     }
     if (byKey.size === 0) {
-        const haystack = `${input.title} ${input.summary ?? ""}`.toLowerCase();
-        const domainHints = [];
-        if (/market|campaign|thread|article|tweet|copy/.test(haystack)) {
-            domainHints.push("marketing");
-        }
-        else if (/design|ux|ui|a11y/.test(haystack)) {
-            domainHints.push("design");
-        }
-        else if (/ops|runbook|incident|reliability/.test(haystack)) {
-            domainHints.push("operations");
-        }
-        else if (/sales|deal|pipeline/.test(haystack)) {
-            domainHints.push("sales");
-        }
-        else {
-            domainHints.push("engineering", "product");
-        }
+        const domainResult = await callLlmJson({
+            taskId: "domain_assignment",
+            systemPrompt: 'Classify which agent domain(s) should handle this task. Return JSON: {"domains": [...]} with 1-2 values from: engineering, product, design, marketing, sales, operations. Be precise based on the task content.',
+            userPrompt: `Task: ${input.title}\n${input.summary ? `Details: ${input.summary}` : ""}`,
+            maxTokens: 64,
+            temperature: 0.1,
+            cacheTtlMs: 60 * 60_000, // 1 hour
+        }, (raw) => {
+            try {
+                const parsed = JSON.parse(raw);
+                if (Array.isArray(parsed.domains) &&
+                    parsed.domains.length > 0 &&
+                    parsed.domains.every((d) => typeof d === "string" && VALID_DOMAINS.has(d))) {
+                    return { domains: parsed.domains };
+                }
+            }
+            catch {
+                // fall through
+            }
+            return null;
+        }, () => ({ domains: heuristicDomainGuess(input.title, input.summary ?? null) }));
+        const domainHints = domainResult.result.domains;
         for (const domain of domainHints) {
             const match = liveAgents.find((agent) => (agent.domain ?? "").toLowerCase().includes(domain));
             if (match)

package/dist/event-sanitization.d.ts

@@ -0,0 +1,11 @@
+import type { LiveActivityItem } from "./contracts/shared-types.js";
+export declare function isUuid(value: string | null | undefined): boolean;
+export declare function isSyntheticIdentifier(value: string | null | undefined): boolean;
+type OutboxEventLike = {
+    type?: unknown;
+    payload?: unknown;
+    activityItem?: unknown;
+};
+export declare function classifyOutboxReplaySkip(event: OutboxEventLike): string | null;
+export declare function shouldHideActivityItem(item: LiveActivityItem): boolean;
+export {};

package/dist/event-sanitization.js

@@ -0,0 +1,113 @@
+function toRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function pickString(input, ...keys) {
+    if (!input)
+        return null;
+    for (const key of keys) {
+        const value = input[key];
+        if (typeof value !== "string")
+            continue;
+        const trimmed = value.trim();
+        if (trimmed.length > 0)
+            return trimmed;
+    }
+    return null;
+}
+function pickBool(input, ...keys) {
+    if (!input)
+        return false;
+    for (const key of keys) {
+        if (input[key] === true)
+            return true;
+    }
+    return false;
+}
+function containsMockMarker(value) {
+    if (!value)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return false;
+    // Match whole marker tokens and avoid substring false positives (e.g. "latest").
+    return /(^|[^a-z0-9])(mock|fixture|synthetic|test)([^a-z0-9]|$)/i.test(normalized);
+}
+export function isUuid(value) {
+    if (!value)
+        return false;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return false;
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(trimmed);
+}
+export function isSyntheticIdentifier(value) {
+    if (!value)
+        return false;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return false;
+    if (isUuid(trimmed))
+        return false;
+    return /^(init|initiative|task|workstream|ws|milestone|ms|decision|artifact|demo|mock|test|sample|queue|tmp|local)-/i.test(trimmed);
+}
+function isMockTaggedMetadata(metadata) {
+    if (!metadata)
+        return false;
+    if (pickBool(metadata, "mock", "is_mock", "isMock"))
+        return true;
+    if (containsMockMarker(pickString(metadata, "source")) ||
+        containsMockMarker(pickString(metadata, "worker_kind", "workerKind")) ||
+        containsMockMarker(pickString(metadata, "environment"))) {
+        return true;
+    }
+    return false;
+}
+export function classifyOutboxReplaySkip(event) {
+    const eventType = typeof event.type === "string" ? event.type.trim().toLowerCase() : "";
+    const payload = toRecord(event.payload);
+    const activity = toRecord(event.activityItem);
+    const payloadMetadata = toRecord(payload?.metadata);
+    const activityMetadata = toRecord(activity?.metadata);
+    const normalizedSourceClient = pickString(payload, "source_client", "sourceClient")
+        ?.trim()
+        .toLowerCase();
+    const normalizedPayloadEvent = pickString(payloadMetadata, "event")?.trim().toLowerCase();
+    const normalizedActivityEvent = pickString(activityMetadata, "event")?.trim().toLowerCase();
+    const skipMockOutboxReplay = String(process.env.ORGX_SKIP_MOCK_OUTBOX_REPLAY ?? "false")
+        .trim()
+        .toLowerCase() === "true";
+    if (skipMockOutboxReplay &&
+        (isMockTaggedMetadata(payloadMetadata) ||
+            isMockTaggedMetadata(activityMetadata) ||
+            pickBool(payload, "mock", "is_mock", "isMock"))) {
+        return "mock_event";
+    }
+    if (eventType === "artifact") {
+        const initiativeId = pickString(payload, "initiative_id", "initiativeId");
+        const entityId = pickString(payload, "entity_id", "entityId");
+        const allowSyntheticArtifact = normalizedSourceClient === "openclaw" ||
+            normalizedPayloadEvent === "autopilot_slice_artifact_buffered" ||
+            normalizedActivityEvent === "autopilot_slice_artifact_buffered";
+        if (!allowSyntheticArtifact && isSyntheticIdentifier(initiativeId)) {
+            return "synthetic_initiative_id";
+        }
+        if (!allowSyntheticArtifact && !entityId) {
+            return "missing_artifact_entity_id";
+        }
+        if (!allowSyntheticArtifact && isSyntheticIdentifier(entityId)) {
+            return "synthetic_artifact_entity_id";
+        }
+    }
+    return null;
+}
+export function shouldHideActivityItem(item) {
+    const metadata = toRecord(item.metadata);
+    const hideMockActivity = String(process.env.ORGX_HIDE_MOCK_ACTIVITY ?? "false")
+        .trim()
+        .toLowerCase() === "true";
+    if (hideMockActivity && isMockTaggedMetadata(metadata))
+        return true;
+    return false;
+}