@useorgx/openclaw-plugin 0.4.8 → 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,6 +4,9 @@
  * Types for the plugin's API client and tool interfaces.
  * Mirrors the server-side types in orgx/lib/client-integration/types.ts
  */
+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;
@@ -24,23 +27,6 @@ export interface OrgXConfig {
      */
     autoInstallAgentSuiteOnConnect?: boolean;
 }
-export type OnboardingStatus = 'idle' | 'starting' | 'awaiting_browser_auth' | 'pairing' | 'connected' | 'error' | 'manual_key';
-export type OnboardingNextAction = 'connect' | 'wait_for_browser' | 'open_dashboard' | 'enter_manual_key' | 'retry' | 'reconnect';
-export interface OnboardingState {
-    status: OnboardingStatus;
-    hasApiKey: boolean;
-    connectionVerified: boolean;
-    workspaceName: string | null;
-    lastError: string | null;
-    nextAction: OnboardingNextAction;
-    docsUrl: string;
-    keySource: 'config' | 'environment' | 'persisted' | 'openclaw-config-file' | 'legacy-dev' | 'none';
-    installationId: string | null;
-    connectUrl: string | null;
-    pairingId: string | null;
-    expiresAt: string | null;
-    pollIntervalMs: number | null;
-}
 export interface OrgSnapshot {
     /** Active initiatives */
     initiatives: Initiative[];
@@ -97,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;
@@ -140,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;
@@ -200,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 */
@@ -221,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;
@@ -265,7 +314,80 @@ export interface BillingUrlResult {
     url: string | null;
     checkout_url?: string | null;
 }
-export type RunPhase = 'intent' | 'execution' | 'blocked' | 'review' | 'handoff' | 'completed';
+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;
@@ -394,15 +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 RuntimeSourceClient = ReportingSourceClient | 'unknown';
 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;
@@ -449,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;
@@ -504,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[];
@@ -538,118 +721,27 @@ export interface RecordRunRetroResponse {
     event_id: string | null;
     auth_mode?: 'service' | 'api_key';
 }
-export type LiveActivityType = 'run_started' | 'run_completed' | 'run_failed' | 'artifact_created' | 'decision_requested' | 'decision_resolved' | 'handoff_requested' | 'handoff_claimed' | 'handoff_fulfilled' | 'blocker_created' | 'milestone_completed' | 'delegation';
-export type RuntimeInstanceState = 'active' | 'stale' | 'stopped' | 'error';
-export interface RuntimeInstance {
-    id: string;
-    sourceClient: RuntimeSourceClient;
-    displayName: string;
-    providerLogo: 'codex' | 'openai' | 'anthropic' | 'openclaw' | 'orgx' | 'unknown';
-    state: RuntimeInstanceState;
-    runId: string | null;
-    correlationId: string | null;
-    initiativeId: string | null;
-    workstreamId: string | null;
-    taskId: string | null;
-    agentId: string | null;
-    agentName: string | null;
-    phase: string | null;
-    progressPct: number | null;
-    currentTask: string | null;
-    lastHeartbeatAt: string | null;
-    lastEventAt: string;
-    lastMessage: string | null;
-    metadata: Record<string, unknown> | null;
-}
-export interface LiveActivityItem {
-    id: string;
-    type: LiveActivityType;
-    title: string;
-    description: string | null;
-    agentId: string | null;
-    agentName: string | null;
-    requesterAgentId: string | null;
-    requesterAgentName: string | null;
-    executorAgentId: string | null;
-    executorAgentName: string | null;
-    runId: string | null;
-    initiativeId: string | null;
-    timestamp: string;
-    phase?: RunPhase | null;
-    state?: string | null;
-    kind?: string | null;
-    summary?: string | null;
-    decisionRequired?: boolean;
-    costDelta?: number | null;
-    runtimeClient?: RuntimeSourceClient | null;
-    runtimeLabel?: string | null;
-    runtimeProvider?: RuntimeInstance['providerLogo'] | null;
-    instanceId?: string | null;
-    lastHeartbeatAt?: string | null;
-    metadata?: Record<string, unknown>;
-}
-export interface SessionTreeNode {
-    id: string;
-    parentId: string | null;
-    runId: string;
-    title: string;
-    agentId: string | null;
-    agentName: string | null;
-    status: string;
-    progress: number | null;
-    initiativeId: string | null;
-    workstreamId: string | null;
-    groupId: string;
-    groupLabel: string;
-    startedAt: string | null;
-    updatedAt: string | null;
-    lastEventAt: string | null;
-    lastEventSummary: string | null;
-    blockers: string[];
-    phase?: RunPhase | null;
-    state?: string | null;
-    eta?: string | null;
-    cost?: number | null;
-    checkpointCount?: number | null;
-    blockerReason?: string | null;
-    runtimeClient?: RuntimeSourceClient | null;
-    runtimeLabel?: string | null;
-    runtimeProvider?: RuntimeInstance['providerLogo'] | null;
-    instanceId?: string | null;
-    lastHeartbeatAt?: string | null;
-}
-export interface SessionTreeEdge {
-    parentId: string;
-    childId: string;
-}
-export interface SessionTreeGroup {
-    id: string;
+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;
-    status: string | null;
-}
-export interface SessionTreeResponse {
-    nodes: SessionTreeNode[];
-    edges: SessionTreeEdge[];
-    groups: SessionTreeGroup[];
+    passed: boolean;
+    enforcement: ProofEnforcement;
+    missingFields: string[];
+    details?: string;
 }
-export interface HandoffEvent {
-    id: string;
-    handoffId: string;
-    eventType: string;
-    actorType: string | null;
-    actorId: string | null;
-    payload: Record<string, unknown> | null;
-    createdAt: string;
-}
-export interface HandoffSummary {
-    id: string;
-    title: string;
-    status: string;
-    priority: string | null;
-    summary: string | null;
-    currentActorType: string | null;
-    currentActorId: string | null;
-    createdAt: string;
-    updatedAt: string;
-    events: HandoffEvent[];
+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/contracts/types.js

@@ -5,3 +5,8 @@
  * Mirrors the server-side types in orgx/lib/client-integration/types.ts
  */
 export {};
+// =============================================================================
+// LIVE SESSION GRAPH + HANDOFFS
+// =============================================================================
+// Live/session/handoff activity shapes are imported and re-exported from
+// ./shared-types.ts to keep dashboard and plugin contracts in lockstep.

package/dist/entities/auto-assignment.d.ts

@@ -0,0 +1,36 @@
+export type AutoAssignedAgent = {
+    id: string;
+    name: string;
+    domain: string | null;
+};
+export declare function autoAssignEntityForCreate(input: {
+    client: {
+        getLiveAgents: (payload: {
+            initiative: string | null;
+            includeIdle: boolean;
+        }) => Promise<{
+            agents?: unknown[];
+        }>;
+        delegationPreflight: (payload: {
+            intent: string;
+        }) => Promise<{
+            data?: {
+                recommended_split?: Array<{
+                    owner_domain?: string | null;
+                }>;
+            };
+        }>;
+        updateEntity: (entityType: string, entityId: string, payload: Record<string, unknown>) => Promise<unknown>;
+    };
+    toErrorMessage: (err: unknown) => string;
+    entityType: string;
+    entityId: string;
+    initiativeId: string | null;
+    title: string;
+    summary: string | null;
+}): Promise<{
+    assignmentSource: "orchestrator" | "fallback" | "manual";
+    assignedAgents: AutoAssignedAgent[];
+    warnings: string[];
+    updatedEntity: Record<string, unknown> | null;
+}>;