@useorgx/openclaw-plugin 0.4.9 → 0.7.2

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,42 @@ 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;
+        question_auto_answer_enabled?: boolean;
+        question_auto_answer_timeout_sec?: number;
+        question_auto_answer_policy?: "contextual" | "approve_non_blocking" | "defer_non_blocking";
+        question_blocking_behavior?: "require_human" | "guarded_auto_resolve_then_human";
+        question_policy_version?: number;
+        question_auto_answer_delay_seconds?: number;
+        question_auto_answer_action?: "approve" | "reject";
+        workspace_question_defaults?: {
+            question_auto_answer_enabled?: boolean;
+            question_auto_answer_timeout_sec?: number;
+            question_auto_answer_policy?: "contextual" | "approve_non_blocking" | "defer_non_blocking";
+            question_blocking_behavior?: "require_human" | "guarded_auto_resolve_then_human";
+        } | null;
+        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 +162,49 @@ 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;
+    question_auto_answer_enabled?: boolean;
+    question_auto_answer_timeout_sec?: number;
+    question_auto_answer_policy?: "contextual" | "approve_non_blocking" | "defer_non_blocking";
+    question_blocking_behavior?: "require_human" | "guarded_auto_resolve_then_human";
+    question_policy_version?: number;
+    question_auto_answer_delay_seconds?: number;
+    question_auto_answer_action?: "approve" | "reject";
+    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 +265,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 +288,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 +334,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 +536,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 +637,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 +706,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 +741,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;
+}

package/dist/gateway-watchdog.d.ts

@@ -8,4 +8,9 @@ export declare function ensureGatewayWatchdog(logger: Logger): {
     started: boolean;
     pid: number | null;
 };
+export declare function stopGatewayWatchdog(logger?: Logger, timeoutMs?: number): Promise<{
+    pid: number | null;
+    wasRunning: boolean;
+    stopped: boolean;
+}>;
 export {};

package/dist/gateway-watchdog.js

@@ -8,6 +8,31 @@ const DEFAULT_MONITOR_INTERVAL_MS = 30_000;
 const DEFAULT_FAILURES_BEFORE_RESTART = 2;
 const DEFAULT_PROBE_TIMEOUT_MS = 2_500;
 const WATCHDOG_PID_FILE = join(getOpenClawDir(), "orgx-gateway-watchdog.pid");
+function sendSignal(pid, signal) {
+    try {
+        // Detached child uses its own process group on Unix.
+        process.kill(-pid, signal);
+        return;
+    }
+    catch {
+        // Fall through to direct pid kill.
+    }
+    try {
+        process.kill(pid, signal);
+    }
+    catch {
+        // best effort
+    }
+}
+async function waitForExit(pid, timeoutMs) {
+    const deadline = Date.now() + Math.max(100, timeoutMs);
+    while (Date.now() < deadline) {
+        if (!isPidAlive(pid))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return !isPidAlive(pid);
+}
 function readEnvNumber(name, fallback, min) {
     const raw = (process.env[name] ?? "").trim();
     if (!raw)
@@ -219,3 +244,28 @@ export function ensureGatewayWatchdog(logger) {
     child.unref();
     return { started: true, pid: child.pid ?? null };
 }
+export async function stopGatewayWatchdog(logger = console, timeoutMs = 1_500) {
+    const pid = readWatchdogPid();
+    if (!pid) {
+        clearWatchdogPid();
+        return { pid: null, wasRunning: false, stopped: true };
+    }
+    if (!isPidAlive(pid)) {
+        clearWatchdogPid();
+        return { pid, wasRunning: false, stopped: true };
+    }
+    sendSignal(pid, "SIGTERM");
+    let stopped = await waitForExit(pid, timeoutMs);
+    if (!stopped) {
+        sendSignal(pid, "SIGKILL");
+        stopped = await waitForExit(pid, 500);
+    }
+    if (stopped) {
+        clearWatchdogPid();
+        logger.info?.("[orgx] Gateway watchdog stopped", { pid });
+    }
+    else {
+        logger.warn?.("[orgx] Gateway watchdog did not exit after stop attempt", { pid });
+    }
+    return { pid, wasRunning: true, stopped };
+}

package/dist/hooks/post-reporting-event.mjs

@@ -168,11 +168,7 @@ export async function main({
   const runId = pickString(args.run_id, env.ORGX_RUN_ID);
   const correlationId = runId
     ? undefined
-    : pickString(
-        args.correlation_id,
-        env.ORGX_CORRELATION_ID,
-        `hook-${now()}`
-      );
+    : pickString(args.correlation_id, env.ORGX_CORRELATION_ID);
 
   const event = pickString(args.event, "hook_event");
   const phase = pickString(args.phase, "execution");