@useorgx/openclaw-plugin 0.4.9 → 0.7.2

package/dist/contracts/practice-exercise-schema.js

@@ -0,0 +1,314 @@
+export const PRACTICE_EXERCISE_TEMPLATE_SCHEMA_VERSION = "practice-exercise-template.v1";
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function readString(source, key, errors, opts = {}) {
+    const { required = true } = opts;
+    const value = source[key];
+    if (typeof value !== "string") {
+        if (required)
+            errors.push(`${key} must be a string`);
+        return "";
+    }
+    const normalized = value.trim();
+    if (!normalized && required) {
+        errors.push(`${key} must not be empty`);
+    }
+    return normalized;
+}
+function readStringArray(source, key, errors, opts = {}) {
+    const { required = true, minItems = 0 } = opts;
+    const value = source[key];
+    if (!Array.isArray(value)) {
+        if (required)
+            errors.push(`${key} must be an array`);
+        return [];
+    }
+    const output = [];
+    value.forEach((entry, index) => {
+        if (typeof entry !== "string" || !entry.trim()) {
+            errors.push(`${key}[${index}] must be a non-empty string`);
+            return;
+        }
+        output.push(entry.trim());
+    });
+    if (output.length < minItems) {
+        errors.push(`${key} must include at least ${minItems} item(s)`);
+    }
+    return output;
+}
+const TASK_TYPE_SET = new Set([
+    "analysis",
+    "implementation",
+    "review",
+    "debugging",
+    "planning",
+]);
+const CONSTRAINT_SEVERITY_SET = new Set(["hard", "soft"]);
+const OUTPUT_FORMAT_SET = new Set(["json_object", "markdown", "text"]);
+function parseScenario(raw, index, errors) {
+    if (!isRecord(raw)) {
+        errors.push(`scenarios[${index}] must be an object`);
+        return null;
+    }
+    const id = readString(raw, "id", errors);
+    const title = readString(raw, "title", errors);
+    const input = raw.input;
+    if (!isRecord(input)) {
+        errors.push(`scenarios[${index}].input must be an object`);
+    }
+    const contextRaw = raw.context;
+    const context = typeof contextRaw === "string" && contextRaw.trim() ? contextRaw.trim() : undefined;
+    const successCriteria = readStringArray(raw, "success_criteria", errors, {
+        minItems: 1,
+    });
+    if (!isRecord(input))
+        return null;
+    return {
+        id,
+        title,
+        input,
+        context,
+        success_criteria: successCriteria,
+    };
+}
+function parseConstraint(raw, index, errors) {
+    if (!isRecord(raw)) {
+        errors.push(`constraints[${index}] must be an object`);
+        return null;
+    }
+    const id = readString(raw, "id", errors);
+    const title = readString(raw, "title", errors);
+    const description = readString(raw, "description", errors);
+    const severityRaw = readString(raw, "severity", errors);
+    if (!CONSTRAINT_SEVERITY_SET.has(severityRaw)) {
+        errors.push(`constraints[${index}].severity must be one of: hard, soft`);
+    }
+    const rationaleRaw = raw.rationale;
+    const rationale = typeof rationaleRaw === "string" && rationaleRaw.trim() ? rationaleRaw.trim() : undefined;
+    return {
+        id,
+        title,
+        description,
+        severity: severityRaw,
+        rationale,
+    };
+}
+function parseExpectedOutputShape(raw, errors) {
+    if (!isRecord(raw)) {
+        errors.push("expected_output_shape must be an object");
+        return null;
+    }
+    const format = readString(raw, "format", errors);
+    if (!OUTPUT_FORMAT_SET.has(format)) {
+        errors.push("expected_output_shape.format must be one of: json_object, markdown, text");
+    }
+    const fieldsRaw = raw.fields;
+    if (!Array.isArray(fieldsRaw)) {
+        errors.push("expected_output_shape.fields must be an array");
+        return null;
+    }
+    const fields = [];
+    fieldsRaw.forEach((entry, index) => {
+        if (!isRecord(entry)) {
+            errors.push(`expected_output_shape.fields[${index}] must be an object`);
+            return;
+        }
+        const path = readString(entry, "path", errors);
+        const type = readString(entry, "type", errors);
+        const required = entry.required;
+        if (typeof required !== "boolean") {
+            errors.push(`expected_output_shape.fields[${index}].required must be boolean`);
+            return;
+        }
+        const description = readString(entry, "description", errors);
+        fields.push({ path, type, required, description });
+    });
+    if (fields.length === 0) {
+        errors.push("expected_output_shape.fields must include at least 1 field");
+    }
+    const exampleRaw = raw.example;
+    const example = typeof exampleRaw === "string"
+        ? exampleRaw
+        : isRecord(exampleRaw)
+            ? exampleRaw
+            : undefined;
+    if (typeof exampleRaw !== "undefined" &&
+        typeof exampleRaw !== "string" &&
+        !isRecord(exampleRaw)) {
+        errors.push("expected_output_shape.example must be a string or object");
+    }
+    return {
+        format: format,
+        fields,
+        example,
+    };
+}
+export function validatePracticeExerciseTemplate(input) {
+    if (!isRecord(input)) {
+        return {
+            ok: false,
+            errors: ["template must be an object"],
+            template: null,
+        };
+    }
+    const errors = [];
+    const schemaVersion = readString(input, "schema_version", errors);
+    if (schemaVersion !== PRACTICE_EXERCISE_TEMPLATE_SCHEMA_VERSION) {
+        errors.push(`schema_version must equal "${PRACTICE_EXERCISE_TEMPLATE_SCHEMA_VERSION}"`);
+    }
+    const id = readString(input, "id", errors);
+    const title = readString(input, "title", errors);
+    const summary = readString(input, "summary", errors);
+    const taskType = readString(input, "task_type", errors);
+    if (!TASK_TYPE_SET.has(taskType)) {
+        errors.push("task_type must be one of: analysis, implementation, review, debugging, planning");
+    }
+    const scenariosRaw = input.scenarios;
+    const scenarios = [];
+    if (!Array.isArray(scenariosRaw)) {
+        errors.push("scenarios must be an array");
+    }
+    else {
+        scenariosRaw.forEach((entry, index) => {
+            const parsed = parseScenario(entry, index, errors);
+            if (parsed)
+                scenarios.push(parsed);
+        });
+    }
+    if (scenarios.length === 0) {
+        errors.push("scenarios must include at least 1 scenario");
+    }
+    const constraintsRaw = input.constraints;
+    const constraints = [];
+    if (!Array.isArray(constraintsRaw)) {
+        errors.push("constraints must be an array");
+    }
+    else {
+        constraintsRaw.forEach((entry, index) => {
+            const parsed = parseConstraint(entry, index, errors);
+            if (parsed)
+                constraints.push(parsed);
+        });
+    }
+    const expectedOutputShape = parseExpectedOutputShape(input.expected_output_shape, errors);
+    const tags = readStringArray(input, "tags", errors, { required: false });
+    const template = errors.length === 0 && expectedOutputShape
+        ? {
+            schema_version: PRACTICE_EXERCISE_TEMPLATE_SCHEMA_VERSION,
+            id,
+            title,
+            summary,
+            task_type: taskType,
+            scenarios,
+            constraints,
+            expected_output_shape: expectedOutputShape,
+            tags: tags.length > 0 ? tags : undefined,
+        }
+        : null;
+    return { ok: errors.length === 0, errors, template };
+}
+export const PRACTICE_EXERCISE_TEMPLATE_JSON_SCHEMA = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://schemas.useorgx.com/practice-exercise-template/v1.json",
+    title: "OrgX Practice Exercise Template v1",
+    description: "Structured exercise template for practice loops with scenarios, constraints, and expected output shape.",
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "schema_version",
+        "id",
+        "title",
+        "summary",
+        "task_type",
+        "scenarios",
+        "constraints",
+        "expected_output_shape",
+    ],
+    properties: {
+        schema_version: {
+            type: "string",
+            const: PRACTICE_EXERCISE_TEMPLATE_SCHEMA_VERSION,
+        },
+        id: { type: "string", minLength: 1, maxLength: 120 },
+        title: { type: "string", minLength: 1, maxLength: 300 },
+        summary: { type: "string", minLength: 1, maxLength: 3000 },
+        task_type: {
+            type: "string",
+            enum: ["analysis", "implementation", "review", "debugging", "planning"],
+        },
+        scenarios: {
+            type: "array",
+            minItems: 1,
+            maxItems: 25,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["id", "title", "input", "success_criteria"],
+                properties: {
+                    id: { type: "string", minLength: 1, maxLength: 120 },
+                    title: { type: "string", minLength: 1, maxLength: 300 },
+                    input: { type: "object", additionalProperties: true },
+                    context: { type: "string", minLength: 1, maxLength: 4000 },
+                    success_criteria: {
+                        type: "array",
+                        minItems: 1,
+                        maxItems: 20,
+                        items: { type: "string", minLength: 1, maxLength: 1000 },
+                    },
+                },
+            },
+        },
+        constraints: {
+            type: "array",
+            maxItems: 25,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["id", "title", "description", "severity"],
+                properties: {
+                    id: { type: "string", minLength: 1, maxLength: 120 },
+                    title: { type: "string", minLength: 1, maxLength: 300 },
+                    description: { type: "string", minLength: 1, maxLength: 2000 },
+                    severity: { type: "string", enum: ["hard", "soft"] },
+                    rationale: { type: "string", minLength: 1, maxLength: 2000 },
+                },
+            },
+        },
+        expected_output_shape: {
+            type: "object",
+            additionalProperties: false,
+            required: ["format", "fields"],
+            properties: {
+                format: { type: "string", enum: ["json_object", "markdown", "text"] },
+                fields: {
+                    type: "array",
+                    minItems: 1,
+                    maxItems: 50,
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["path", "type", "required", "description"],
+                        properties: {
+                            path: { type: "string", minLength: 1, maxLength: 400 },
+                            type: { type: "string", minLength: 1, maxLength: 120 },
+                            required: { type: "boolean" },
+                            description: { type: "string", minLength: 1, maxLength: 2000 },
+                        },
+                    },
+                },
+                example: {
+                    oneOf: [
+                        { type: "string", minLength: 1, maxLength: 20000 },
+                        { type: "object", additionalProperties: true },
+                    ],
+                },
+            },
+        },
+        tags: {
+            type: "array",
+            maxItems: 30,
+            items: { type: "string", minLength: 1, maxLength: 80 },
+        },
+    },
+};

package/dist/contracts/retro-schema.d.ts

@@ -0,0 +1,81 @@
+export declare const RETRO_ARTIFACT_SCHEMA_VERSION: "retro.v1";
+export type RetroArtifactSchemaVersion = typeof RETRO_ARTIFACT_SCHEMA_VERSION;
+export declare const RETRO_ARTIFACT_JSON_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.useorgx.com/retro-artifact/v1.json";
+    readonly title: "OrgX Run Retro Artifact v1";
+    readonly description: "Structured post-run retrospective artifact emitted by OpenClaw/OrgX execution paths.";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["schema_version", "summary"];
+    readonly properties: {
+        readonly schema_version: {
+            readonly type: "string";
+            readonly const: "retro.v1";
+            readonly description: "Version marker for safe schema evolution.";
+        };
+        readonly summary: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 4000;
+            readonly description: "Required high-level run retrospective summary.";
+        };
+        readonly what_went_well: {
+            readonly type: "array";
+            readonly maxItems: 25;
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 1000;
+            };
+        };
+        readonly what_went_wrong: {
+            readonly type: "array";
+            readonly maxItems: 25;
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 1000;
+            };
+        };
+        readonly decisions: {
+            readonly type: "array";
+            readonly maxItems: 25;
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 1000;
+            };
+        };
+        readonly follow_ups: {
+            readonly type: "array";
+            readonly maxItems: 25;
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["title"];
+                readonly properties: {
+                    readonly title: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 500;
+                    };
+                    readonly priority: {
+                        readonly type: "string";
+                        readonly enum: readonly ["p0", "p1", "p2"];
+                    };
+                    readonly reason: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 2000;
+                    };
+                };
+            };
+        };
+        readonly signals: {
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly description: "Telemetry-style structured metadata for analytics and drill-down.";
+        };
+    };
+};

package/dist/contracts/retro-schema.js

@@ -0,0 +1,80 @@
+export const RETRO_ARTIFACT_SCHEMA_VERSION = 'retro.v1';
+export const RETRO_ARTIFACT_JSON_SCHEMA = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://schemas.useorgx.com/retro-artifact/v1.json',
+    title: 'OrgX Run Retro Artifact v1',
+    description: 'Structured post-run retrospective artifact emitted by OpenClaw/OrgX execution paths.',
+    type: 'object',
+    additionalProperties: false,
+    required: ['schema_version', 'summary'],
+    properties: {
+        schema_version: {
+            type: 'string',
+            const: RETRO_ARTIFACT_SCHEMA_VERSION,
+            description: 'Version marker for safe schema evolution.',
+        },
+        summary: {
+            type: 'string',
+            minLength: 1,
+            maxLength: 4000,
+            description: 'Required high-level run retrospective summary.',
+        },
+        what_went_well: {
+            type: 'array',
+            maxItems: 25,
+            items: {
+                type: 'string',
+                minLength: 1,
+                maxLength: 1000,
+            },
+        },
+        what_went_wrong: {
+            type: 'array',
+            maxItems: 25,
+            items: {
+                type: 'string',
+                minLength: 1,
+                maxLength: 1000,
+            },
+        },
+        decisions: {
+            type: 'array',
+            maxItems: 25,
+            items: {
+                type: 'string',
+                minLength: 1,
+                maxLength: 1000,
+            },
+        },
+        follow_ups: {
+            type: 'array',
+            maxItems: 25,
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['title'],
+                properties: {
+                    title: {
+                        type: 'string',
+                        minLength: 1,
+                        maxLength: 500,
+                    },
+                    priority: {
+                        type: 'string',
+                        enum: ['p0', 'p1', 'p2'],
+                    },
+                    reason: {
+                        type: 'string',
+                        minLength: 1,
+                        maxLength: 2000,
+                    },
+                },
+            },
+        },
+        signals: {
+            type: 'object',
+            additionalProperties: true,
+            description: 'Telemetry-style structured metadata for analytics and drill-down.',
+        },
+    },
+};

package/dist/contracts/shared-types.d.ts

@@ -42,6 +42,12 @@ export interface RuntimeInstance {
     metadata: Record<string, unknown> | null;
 }
 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';
+/**
+ * Canonical event names set in `metadata.event` on activity items.
+ * Keep in sync with emitters in auto-continue-engine.ts, autopilot-operations.ts,
+ * dispatch-lifecycle.ts, and http/index.ts.
+ */
+export type ActivityEventName = 'autopilot_slice_dispatched' | 'autopilot_slice_started' | 'autopilot_slice_heartbeat' | 'autopilot_slice_finished' | 'autopilot_slice_result' | 'autopilot_slice_handoff' | 'autopilot_slice_mcp_handshake_failed' | 'autopilot_slice_timeout' | 'autopilot_slice_log_stall' | 'autopilot_slice_artifact_buffered' | 'autopilot_slice_status_updates_buffered' | 'auto_continue_started' | 'auto_continue_stopped' | 'auto_continue_spawn_guard_blocked' | 'auto_continue_spawn_guard_rate_limited' | 'auto_continue_spawn_guard_rate_limit_overridden' | 'auto_continue_behavior_config_drift_detected' | 'auto_continue_behavior_config_approval_required' | 'auto_continue_behavior_automation_manual_blocked' | 'auto_continue_behavior_automation_supervised_one_shot' | 'autopilot_autofix_scheduled' | 'autopilot_autofix_executed' | 'autopilot_autofix_skipped' | 'orchestrator_dispatch' | 'autopilot_transition' | 'next_up_manual_dispatch_started' | 'scope_completed' | 'session_start' | 'session_stop' | 'heartbeat' | 'decision_buffered' | 'decision_resolved' | 'question_asked' | 'question_timeout_started' | 'question_auto_answered' | 'question_answer_applied' | 'question_answer_failed' | 'review_item_created' | 'review_item_resolved' | 'decision_auto_answer_scheduled' | 'decision_auto_answer_timeout' | 'decision_auto_answer_applied' | 'decision_auto_answer_skipped' | 'spawn_guard_degraded' | 'dashboard_run_mark_completed' | 'proof_gate_warning' | 'artifact_registered';
 export interface LiveActivityItem {
     id: string;
     type: LiveActivityType;
@@ -69,16 +75,94 @@ export interface LiveActivityItem {
     lastHeartbeatAt?: string | null;
     metadata?: Record<string, unknown>;
 }
+export declare const KNOWN_ACTIVITY_ACTION_TYPES: readonly ["orchestrator_dispatch", "dispatch_slice", "spawn_worker", "run_heartbeat", "run_state_transition", "run_started", "run_completed", "run_failed", "slice_handoff", "question_asked", "question_timeout_started", "question_auto_answered", "question_answer_applied", "question_answer_failed", "decision_requested", "decision_resolved", "review_item_created", "review_item_resolved", "status_updates_applied", "status_updates_buffered", "artifact_registered", "spawn_guard_blocked", "spawn_guard_rate_limited", "behavior_config_review", "auto_fix", "auto_continue_started", "auto_continue_stopped", "autopilot_resumed", "autopilot_paused", "autopilot_blocked", "milestone_completed", "workflow_error"];
+export type KnownActivityActionType = (typeof KNOWN_ACTIVITY_ACTION_TYPES)[number];
+export type ActivityActionType = KnownActivityActionType | (string & {});
+export declare const KNOWN_ACTIVITY_ACTION_PHASES: readonly ["intent", "dispatch", "execution", "handoff", "review", "completed", "blocked", "error"];
+export type ActivityActionPhase = (typeof KNOWN_ACTIVITY_ACTION_PHASES)[number];
+export declare function normalizeActivityActionType(value: unknown): ActivityActionType | null;
+export declare function isKnownActivityActionType(value: unknown): value is KnownActivityActionType;
+export declare function normalizeActivityActionPhase(value: unknown): ActivityActionPhase | null;
+export declare const KNOWN_DECISION_ACTION_TYPES: readonly ["approve", "reject", "provide_context", "request_info", "confirm_scope", "retry", "resume", "start", "pause", "defer", "cancel", "queue_top", "queue_bottom", "remove_from_queue", "reassign", "assign", "notify", "escalate", "handoff", "spawn", "execute_task", "review_blocker", "review_decision", "open_artifact", "open_logs", "open_session", "open_run", "open_workstream", "open_task", "open_initiative", "open_pr", "open_diff", "open_branch", "open_deal", "update_deal", "open_settings", "open_workspace", "connect_provider", "refresh_credentials", "auto_fix", "ignore_once"];
+export type KnownDecisionActionType = (typeof KNOWN_DECISION_ACTION_TYPES)[number];
+export type DecisionActionType = KnownDecisionActionType | (string & {});
+export declare function normalizeDecisionActionType(value: unknown): DecisionActionType | null;
+export declare function isKnownDecisionActionType(value: unknown): value is KnownDecisionActionType;
+export type LiveDecisionOptionStatus = 'approved' | 'declined' | 'cancelled';
+export interface LiveDecisionOption {
+    id: string;
+    label: string;
+    description: string | null;
+    impliedStatus: LiveDecisionOptionStatus | null;
+    actionType: DecisionActionType | null;
+    requiresNote: boolean;
+}
+export interface LiveDecisionEvidenceRef {
+    evidenceType: string | null;
+    title: string | null;
+    summary: string | null;
+    sourceUrl: string | null;
+    sourcePointer: string | null;
+    freshness: string | null;
+    confidence: number | null;
+    payload: Record<string, unknown> | null;
+}
 export interface LiveDecision {
     id: string;
     title: string;
     context: string | null;
     status: string;
+    priority?: string | null;
+    decisionType?: string | null;
     agentName: string | null;
+    agentId?: string | null;
+    initiativeId?: string | null;
+    workstreamId?: string | null;
+    dueAt?: string | null;
     requestedAt: string | null;
     updatedAt: string | null;
+    sourceSystem?: string | null;
+    conflictSource?: string | null;
+    dedupeKey?: string | null;
+    recommendedAction?: string | null;
+    occurrenceCount?: number | null;
+    firstSeenAt?: string | null;
+    lastSeenAt?: string | null;
+    sourceRunId?: string | null;
+    sourceSessionId?: string | null;
+    sourceStreamId?: string | null;
+    evidenceRefs?: LiveDecisionEvidenceRef[];
     waitingMinutes: number;
     metadata?: Record<string, unknown>;
+    options?: LiveDecisionOption[];
+    selectedOptionId?: string | null;
+}
+export interface SessionBlockerContext {
+    initiativeId: string | null;
+    initiativeIds?: string[];
+    workstreamId: string | null;
+    workstreamIds?: string[];
+    workstreamTitle: string | null;
+    taskIds: string[];
+    milestoneIds: string[];
+    iwmtId?: string | null;
+    iwmtIds?: string[];
+    sliceRunId: string | null;
+    parallelMode: string | null;
+    logPath: string | null;
+    outputPath: string | null;
+}
+export interface SessionBlockerDiagnostics {
+    reason: string | null;
+    source: string | null;
+    errorCode: string | null;
+    errorCategory: string | null;
+    retryable: boolean | null;
+    suggestedActions: string[];
+    eventId: string | null;
+    eventType: string | null;
+    eventTimestamp: string | null;
+    context: SessionBlockerContext;
 }
 export interface SessionTreeNode {
     id: string;
@@ -109,6 +193,7 @@ export interface SessionTreeNode {
     runtimeProvider?: RuntimeProviderLogo | null;
     instanceId?: string | null;
     lastHeartbeatAt?: string | null;
+    blockerDiagnostics?: SessionBlockerDiagnostics | null;
 }
 export interface SessionTreeEdge {
     parentId: string;
@@ -145,3 +230,77 @@ export interface HandoffSummary {
     updatedAt: string;
     events: HandoffEvent[];
 }
+export type TriageItemKind = 'decision_required' | 'blocked_intervention' | 'review_required' | 'failure_diagnostic';
+export type TriageItemStatus = 'open' | 'snoozed' | 'resolved' | 'dismissed';
+export type TriageSeverity = 'critical' | 'high' | 'medium' | 'low';
+export type TriageActionType = 'approve' | 'reject' | 'retry' | 'autofix' | 'defer' | 'snooze' | 'dismiss';
+export interface TriageAction {
+    action: TriageActionType;
+    label: string;
+    description: string;
+    consequences: string;
+    requiresNote: boolean;
+    available: boolean;
+}
+export interface ProofBundle {
+    artifactRefs: string[];
+    fileChanges: string[];
+    prRefs: string[];
+    logRefs: string[];
+    decisionRefs: string[];
+}
+export interface TriageImpact {
+    initiativeCount: number;
+    workstreamCount: number;
+    downstreamBlockedCount: number;
+}
+export interface LiveTriageItem {
+    id: string;
+    kind: TriageItemKind;
+    status: TriageItemStatus;
+    title: string;
+    summary: string;
+    initiativeId: string | null;
+    initiativeTitle: string | null;
+    workstreamId: string | null;
+    workstreamTitle: string | null;
+    taskId: string | null;
+    taskTitle: string | null;
+    sourceSystem: string | null;
+    conflictSource: string | null;
+    dedupeKey: string | null;
+    occurrenceCount: number;
+    severity: TriageSeverity;
+    blocking: boolean;
+    recommendedAction: string | null;
+    agentId: string | null;
+    impact: TriageImpact;
+    proofBundle: ProofBundle;
+    actionContract: TriageAction[];
+    createdAt: string;
+    updatedAt: string;
+    firstSeenAt: string;
+    lastSeenAt: string;
+    snoozedUntil: string | null;
+    sourceDecisionId: string | null;
+    sourceActivityId: string | null;
+}
+export interface TriageActionRequest {
+    action: string;
+    note?: string;
+    optionId?: string;
+    snoozeDurationMinutes?: number;
+}
+export interface TriageActionResponse {
+    ok: boolean;
+    itemStatus: TriageItemStatus;
+    continuationPlan: string | null;
+    sideEffects: string[];
+}
+export interface TriageListResponse {
+    ok: boolean;
+    items: LiveTriageItem[];
+    total: number;
+    generatedAt: string;
+    degraded?: string[];
+}