@kici-dev/engine 0.1.23 → 0.1.25

package/dist/protocol/messages/agent-run-result.d.ts

@@ -0,0 +1,425 @@
+/**
+ * Agent-facing, provenance-tagged run-result schema.
+ *
+ * A machine-first read shape for a run: the typed job DAG, per-step exit codes,
+ * durations, statuses, and a coarse derived failure classification. Every field
+ * an agent could be tricked by — names, refs, error text, log lines, job outputs —
+ * is wrapped in an {@link untrusted} envelope so a consumer can keep
+ * user-controlled content out of an instruction channel. KiCI-generated values
+ * (ids, enum statuses, exit codes, durations, hashes, derived categories) stay
+ * plain (trusted).
+ *
+ * Read-only contract — produced by the orchestrator admin run API and consumed by
+ * agents / the developer MCP server. Reuses the existing execution status enums;
+ * never define a parallel status string.
+ */
+import { z } from 'zod';
+/**
+ * Wrap a value KiCI does not vouch for — content from the user's repo, the
+ * contributor, or a process's output. Trusted fields are left plain. The
+ * envelope self-tags so the value survives reshaping / fencing: a renderer that
+ * fences untrusted content just refuses to emit any `{ untrusted: true }` value
+ * into an instruction channel.
+ */
+export declare const untrusted: <T extends z.ZodTypeAny>(v: T) => z.ZodObject<{
+    untrusted: z.ZodLiteral<true>;
+    value: T;
+}, z.core.$strip>;
+/** Construct an untrusted envelope around a runtime value. */
+export declare function wrapUntrusted<T>(value: T): {
+    untrusted: true;
+    value: T;
+};
+/** Coarse, derived run-failure classification (trusted — KiCI computes it). */
+export declare const AgentFailureCategory: z.ZodEnum<{
+    unknown: "unknown";
+    cancelled: "cancelled";
+    init_failure: "init_failure";
+    timed_out: "timed_out";
+    step_failed: "step_failed";
+    infra: "infra";
+}>;
+export type AgentFailureCategory = z.infer<typeof AgentFailureCategory>;
+export declare const agentStepResultSchema: z.ZodObject<{
+    stepIndex: z.ZodNumber;
+    stepName: z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        skipped: "skipped";
+        success: "success";
+        pending: "pending";
+        running: "running";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    startedAt: z.ZodNullable<z.ZodString>;
+    completedAt: z.ZodNullable<z.ZodString>;
+    errorMessage: z.ZodNullable<z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    stepType: z.ZodString;
+    checkOutcome: z.ZodNullable<z.ZodEnum<{
+        skipped: "skipped";
+        applied: "applied";
+        declined: "declined";
+        "dry-run": "dry-run";
+        no_check: "no_check";
+    }>>;
+    secretsAccessed: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type AgentStepResult = z.infer<typeof agentStepResultSchema>;
+export declare const agentJobResultSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    jobName: z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        skipped: "skipped";
+        success: "success";
+        pending: "pending";
+        running: "running";
+        failed: "failed";
+        cancelled: "cancelled";
+        cancelling: "cancelling";
+        queued: "queued";
+        recovering: "recovering";
+        timed_out_stale: "timed_out_stale";
+        drift_dropped: "drift_dropped";
+    }>;
+    startedAt: z.ZodNullable<z.ZodString>;
+    completedAt: z.ZodNullable<z.ZodString>;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    agentId: z.ZodNullable<z.ZodString>;
+    errorMessage: z.ZodNullable<z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    initFailure: z.ZodNullable<z.ZodObject<{
+        scope: z.ZodEnum<{
+            job: "job";
+            run: "run";
+        }>;
+        category: z.ZodEnum<{
+            secret_resolution: "secret_resolution";
+            install_secrets: "install_secrets";
+            lock_resolution: "lock_resolution";
+            build_coordination: "build_coordination";
+            environment_rules: "environment_rules";
+            dynamic_eval: "dynamic_eval";
+            no_agent: "no_agent";
+            matrix_expansion: "matrix_expansion";
+        }>;
+        message: z.ZodObject<{
+            untrusted: z.ZodLiteral<true>;
+            value: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    needs: z.ZodArray<z.ZodObject<{
+        ref: z.ZodObject<{
+            untrusted: z.ZodLiteral<true>;
+            value: z.ZodString;
+        }, z.core.$strip>;
+        runOn: z.ZodArray<z.ZodEnum<{
+            skipped: "skipped";
+            success: "success";
+            pending: "pending";
+            running: "running";
+            failed: "failed";
+            cancelled: "cancelled";
+            cancelling: "cancelling";
+            queued: "queued";
+            recovering: "recovering";
+            timed_out_stale: "timed_out_stale";
+            drift_dropped: "drift_dropped";
+        }>>;
+    }, z.core.$strip>>;
+    outputs: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>>;
+    secretOutputKeys: z.ZodArray<z.ZodString>;
+    steps: z.ZodArray<z.ZodObject<{
+        stepIndex: z.ZodNumber;
+        stepName: z.ZodObject<{
+            untrusted: z.ZodLiteral<true>;
+            value: z.ZodString;
+        }, z.core.$strip>;
+        status: z.ZodEnum<{
+            skipped: "skipped";
+            success: "success";
+            pending: "pending";
+            running: "running";
+            failed: "failed";
+            cancelled: "cancelled";
+        }>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        startedAt: z.ZodNullable<z.ZodString>;
+        completedAt: z.ZodNullable<z.ZodString>;
+        errorMessage: z.ZodNullable<z.ZodObject<{
+            untrusted: z.ZodLiteral<true>;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        stepType: z.ZodString;
+        checkOutcome: z.ZodNullable<z.ZodEnum<{
+            skipped: "skipped";
+            applied: "applied";
+            declined: "declined";
+            "dry-run": "dry-run";
+            no_check: "no_check";
+        }>>;
+        secretsAccessed: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentJobResult = z.infer<typeof agentJobResultSchema>;
+export declare const agentRunResultSchema: z.ZodObject<{
+    runId: z.ZodString;
+    workflowName: z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        success: "success";
+        pending: "pending";
+        running: "running";
+        failed: "failed";
+        cancelled: "cancelled";
+        cancelling: "cancelling";
+        held: "held";
+    }>;
+    provider: z.ZodString;
+    repoIdentifier: z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    ref: z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    sha: z.ZodString;
+    baseSha: z.ZodNullable<z.ZodString>;
+    startedAt: z.ZodNullable<z.ZodString>;
+    completedAt: z.ZodNullable<z.ZodString>;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    trustTier: z.ZodNullable<z.ZodEnum<{
+        unknown: "unknown";
+        known: "known";
+        trusted: "trusted";
+    }>>;
+    contributorUsername: z.ZodNullable<z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    failureCategory: z.ZodNullable<z.ZodEnum<{
+        unknown: "unknown";
+        cancelled: "cancelled";
+        init_failure: "init_failure";
+        timed_out: "timed_out";
+        step_failed: "step_failed";
+        infra: "infra";
+    }>>;
+    failureReason: z.ZodNullable<z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    triggeredBy: z.ZodNullable<z.ZodString>;
+    triggeredByAgentLabel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    jobs: z.ZodArray<z.ZodObject<{
+        jobId: z.ZodString;
+        jobName: z.ZodObject<{
+            untrusted: z.ZodLiteral<true>;
+            value: z.ZodString;
+        }, z.core.$strip>;
+        status: z.ZodEnum<{
+            skipped: "skipped";
+            success: "success";
+            pending: "pending";
+            running: "running";
+            failed: "failed";
+            cancelled: "cancelled";
+            cancelling: "cancelling";
+            queued: "queued";
+            recovering: "recovering";
+            timed_out_stale: "timed_out_stale";
+            drift_dropped: "drift_dropped";
+        }>;
+        startedAt: z.ZodNullable<z.ZodString>;
+        completedAt: z.ZodNullable<z.ZodString>;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        agentId: z.ZodNullable<z.ZodString>;
+        errorMessage: z.ZodNullable<z.ZodObject<{
+            untrusted: z.ZodLiteral<true>;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        initFailure: z.ZodNullable<z.ZodObject<{
+            scope: z.ZodEnum<{
+                job: "job";
+                run: "run";
+            }>;
+            category: z.ZodEnum<{
+                secret_resolution: "secret_resolution";
+                install_secrets: "install_secrets";
+                lock_resolution: "lock_resolution";
+                build_coordination: "build_coordination";
+                environment_rules: "environment_rules";
+                dynamic_eval: "dynamic_eval";
+                no_agent: "no_agent";
+                matrix_expansion: "matrix_expansion";
+            }>;
+            message: z.ZodObject<{
+                untrusted: z.ZodLiteral<true>;
+                value: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        needs: z.ZodArray<z.ZodObject<{
+            ref: z.ZodObject<{
+                untrusted: z.ZodLiteral<true>;
+                value: z.ZodString;
+            }, z.core.$strip>;
+            runOn: z.ZodArray<z.ZodEnum<{
+                skipped: "skipped";
+                success: "success";
+                pending: "pending";
+                running: "running";
+                failed: "failed";
+                cancelled: "cancelled";
+                cancelling: "cancelling";
+                queued: "queued";
+                recovering: "recovering";
+                timed_out_stale: "timed_out_stale";
+                drift_dropped: "drift_dropped";
+            }>>;
+        }, z.core.$strip>>;
+        outputs: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+            untrusted: z.ZodLiteral<true>;
+            value: z.ZodString;
+        }, z.core.$strip>>>;
+        secretOutputKeys: z.ZodArray<z.ZodString>;
+        steps: z.ZodArray<z.ZodObject<{
+            stepIndex: z.ZodNumber;
+            stepName: z.ZodObject<{
+                untrusted: z.ZodLiteral<true>;
+                value: z.ZodString;
+            }, z.core.$strip>;
+            status: z.ZodEnum<{
+                skipped: "skipped";
+                success: "success";
+                pending: "pending";
+                running: "running";
+                failed: "failed";
+                cancelled: "cancelled";
+            }>;
+            exitCode: z.ZodNullable<z.ZodNumber>;
+            durationMs: z.ZodNullable<z.ZodNumber>;
+            startedAt: z.ZodNullable<z.ZodString>;
+            completedAt: z.ZodNullable<z.ZodString>;
+            errorMessage: z.ZodNullable<z.ZodObject<{
+                untrusted: z.ZodLiteral<true>;
+                value: z.ZodString;
+            }, z.core.$strip>>;
+            stepType: z.ZodString;
+            checkOutcome: z.ZodNullable<z.ZodEnum<{
+                skipped: "skipped";
+                applied: "applied";
+                declined: "declined";
+                "dry-run": "dry-run";
+                no_check: "no_check";
+            }>>;
+            secretsAccessed: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentRunResult = z.infer<typeof agentRunResultSchema>;
+export declare const agentStepLogsSchema: z.ZodObject<{
+    runId: z.ZodString;
+    jobId: z.ZodString;
+    stepIndex: z.ZodNumber;
+    totalLines: z.ZodNumber;
+    lines: z.ZodArray<z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type AgentStepLogs = z.infer<typeof agentStepLogsSchema>;
+/**
+ * Compact run-list row for the agent surface. KiCI ids/status/hashes are trusted
+ * (plain); the workflow name, repo identifier, and ref are user-controlled and
+ * wrapped untrusted so the fencing renderer keeps them out of the instruction
+ * channel.
+ */
+export declare const agentRunListItemSchema: z.ZodObject<{
+    runId: z.ZodString;
+    status: z.ZodEnum<{
+        success: "success";
+        pending: "pending";
+        running: "running";
+        failed: "failed";
+        cancelled: "cancelled";
+        cancelling: "cancelling";
+        held: "held";
+    }>;
+    sha: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodNullable<z.ZodString>;
+    workflowName: z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    repoIdentifier: z.ZodNullable<z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    ref: z.ZodNullable<z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentRunListItem = z.infer<typeof agentRunListItemSchema>;
+/**
+ * Agent-facing workflow registration summary. Ids, flags, the commit sha, the
+ * KiCI trigger-type tags, and timestamps are trusted (plain); the workflow name,
+ * repo identifier, source repos, source file path, and friendly source name are
+ * user-controlled and wrapped untrusted.
+ */
+export declare const agentWorkflowSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    workflowName: z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    repoIdentifier: z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    triggerTypes: z.ZodArray<z.ZodString>;
+    sourceRepos: z.ZodArray<z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    disabled: z.ZodBoolean;
+    commitSha: z.ZodNullable<z.ZodString>;
+    sourceFile: z.ZodNullable<z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    lastTriggeredAt: z.ZodNullable<z.ZodString>;
+    nextFireAt: z.ZodNullable<z.ZodString>;
+    source: z.ZodNullable<z.ZodObject<{
+        routingKey: z.ZodString;
+        name: z.ZodNullable<z.ZodObject<{
+            untrusted: z.ZodLiteral<true>;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        provider: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentWorkflowSummary = z.infer<typeof agentWorkflowSummarySchema>;
+//# sourceMappingURL=agent-run-result.d.ts.map

package/dist/protocol/messages/agent-run-result.js

@@ -0,0 +1,165 @@
+import "../../rolldown-runtime-ClRpJifh.js";
+import { CheckStepOutcome } from "../../check-mode.js";
+import { ExecutionJobStatus, ExecutionRunStatus, ExecutionStepStatus, InitFailureCategory } from "./execution-status.js";
+import { TrustTierSchema } from "../../environment/types.js";
+import { z } from "zod";
+//#region src/protocol/messages/agent-run-result.ts
+/**
+* Agent-facing, provenance-tagged run-result schema.
+*
+* A machine-first read shape for a run: the typed job DAG, per-step exit codes,
+* durations, statuses, and a coarse derived failure classification. Every field
+* an agent could be tricked by — names, refs, error text, log lines, job outputs —
+* is wrapped in an {@link untrusted} envelope so a consumer can keep
+* user-controlled content out of an instruction channel. KiCI-generated values
+* (ids, enum statuses, exit codes, durations, hashes, derived categories) stay
+* plain (trusted).
+*
+* Read-only contract — produced by the orchestrator admin run API and consumed by
+* agents / the developer MCP server. Reuses the existing execution status enums;
+* never define a parallel status string.
+*/
+/**
+* Wrap a value KiCI does not vouch for — content from the user's repo, the
+* contributor, or a process's output. Trusted fields are left plain. The
+* envelope self-tags so the value survives reshaping / fencing: a renderer that
+* fences untrusted content just refuses to emit any `{ untrusted: true }` value
+* into an instruction channel.
+*/
+const untrusted = (v) => z.object({
+	untrusted: z.literal(true),
+	value: v
+});
+/** Construct an untrusted envelope around a runtime value. */
+function wrapUntrusted(value) {
+	return {
+		untrusted: true,
+		value
+	};
+}
+const untrustedString = untrusted(z.string());
+const untrustedStringNullable = untrusted(z.string()).nullable();
+/** Coarse, derived run-failure classification (trusted — KiCI computes it). */
+const AgentFailureCategory = z.enum([
+	"init_failure",
+	"timed_out",
+	"step_failed",
+	"cancelled",
+	"infra",
+	"unknown"
+]);
+const agentStepResultSchema = z.object({
+	stepIndex: z.number().int(),
+	stepName: untrustedString,
+	status: ExecutionStepStatus,
+	exitCode: z.number().int().nullable(),
+	durationMs: z.number().nullable(),
+	startedAt: z.string().nullable(),
+	completedAt: z.string().nullable(),
+	errorMessage: untrustedStringNullable,
+	/** Existing `step_type` discriminator (e.g. `step`, `hook:cleanup`, `cache:save`). */
+	stepType: z.string(),
+	checkOutcome: CheckStepOutcome.nullable(),
+	/** Secret context key names accessed by this step — names only, never values. */
+	secretsAccessed: z.array(z.string())
+});
+const agentJobResultSchema = z.object({
+	jobId: z.string(),
+	jobName: untrustedString,
+	status: ExecutionJobStatus,
+	startedAt: z.string().nullable(),
+	completedAt: z.string().nullable(),
+	durationMs: z.number().nullable(),
+	agentId: z.string().nullable(),
+	errorMessage: untrustedStringNullable,
+	initFailure: z.object({
+		scope: z.enum(["run", "job"]),
+		category: InitFailureCategory,
+		message: untrustedString
+	}).nullable(),
+	needs: z.array(z.object({
+		ref: untrustedString,
+		runOn: z.array(ExecutionJobStatus)
+	})),
+	/** Non-secret job outputs only (secret outputs are surfaced as key names). */
+	outputs: z.record(z.string(), untrustedString).nullable(),
+	/** Secret output key names produced by this job — names only, never values. */
+	secretOutputKeys: z.array(z.string()),
+	steps: z.array(agentStepResultSchema)
+});
+const agentRunResultSchema = z.object({
+	runId: z.string(),
+	workflowName: untrustedString,
+	status: ExecutionRunStatus,
+	provider: z.string(),
+	repoIdentifier: untrustedString,
+	ref: untrustedString,
+	sha: z.string(),
+	/** Best-effort base commit (provider context); null when unavailable. */
+	baseSha: z.string().nullable(),
+	startedAt: z.string().nullable(),
+	completedAt: z.string().nullable(),
+	durationMs: z.number().nullable(),
+	trustTier: TrustTierSchema.nullable(),
+	contributorUsername: untrustedStringNullable,
+	failureCategory: AgentFailureCategory.nullable(),
+	failureReason: untrustedStringNullable,
+	/** Identity that triggered a re-run (null for webhook-triggered runs). */
+	triggeredBy: z.string().nullable(),
+	/** Agent provenance label when the run was triggered through an agent credential. */
+	triggeredByAgentLabel: z.string().nullable().optional(),
+	jobs: z.array(agentJobResultSchema)
+});
+const agentStepLogsSchema = z.object({
+	runId: z.string(),
+	jobId: z.string(),
+	stepIndex: z.number().int(),
+	totalLines: z.number().int(),
+	/** Every log line is user/process-controlled — each is enveloped untrusted. */
+	lines: z.array(untrustedString),
+	nextCursor: z.string().nullable()
+});
+/**
+* Compact run-list row for the agent surface. KiCI ids/status/hashes are trusted
+* (plain); the workflow name, repo identifier, and ref are user-controlled and
+* wrapped untrusted so the fencing renderer keeps them out of the instruction
+* channel.
+*/
+const agentRunListItemSchema = z.object({
+	runId: z.string(),
+	status: ExecutionRunStatus,
+	sha: z.string().nullable(),
+	createdAt: z.string().nullable(),
+	workflowName: untrustedString,
+	repoIdentifier: untrustedStringNullable,
+	ref: untrustedStringNullable
+});
+/**
+* Agent-facing workflow registration summary. Ids, flags, the commit sha, the
+* KiCI trigger-type tags, and timestamps are trusted (plain); the workflow name,
+* repo identifier, source repos, source file path, and friendly source name are
+* user-controlled and wrapped untrusted.
+*/
+const agentWorkflowSummarySchema = z.object({
+	id: z.string(),
+	workflowName: untrustedString,
+	repoIdentifier: untrustedString,
+	triggerTypes: z.array(z.string()),
+	sourceRepos: z.array(untrustedString),
+	disabled: z.boolean(),
+	commitSha: z.string().nullable(),
+	sourceFile: untrustedStringNullable,
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	lastTriggeredAt: z.string().nullable(),
+	nextFireAt: z.string().nullable(),
+	source: z.object({
+		routingKey: z.string(),
+		name: untrustedStringNullable,
+		provider: z.string()
+	}).nullable()
+});
+//#endregion
+export { AgentFailureCategory, agentJobResultSchema, agentRunListItemSchema, agentRunResultSchema, agentStepLogsSchema, agentStepResultSchema, agentWorkflowSummarySchema, untrusted, wrapUntrusted };
+
+//# sourceMappingURL=agent-run-result.js.map

package/dist/protocol/messages/auth.d.ts

@@ -28,6 +28,7 @@ export declare const authRequestSchema: z.ZodObject<{
             "held_runs.reject": "held_runs.reject";
             "event_dlq.retry": "event_dlq.retry";
             "event_dlq.discard": "event_dlq.discard";
+            "attestations.retry": "attestations.retry";
             "registration.disable": "registration.disable";
             "registration.delete": "registration.delete";
             "global_workflows.update": "global_workflows.update";
@@ -37,6 +38,7 @@ export declare const authRequestSchema: z.ZodObject<{
             "fleet.host.declare": "fleet.host.declare";
             "fleet.host.remove": "fleet.host.remove";
         }> & z.core.$partial, z.ZodBoolean>>;
+        supportedDashboardRequests: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$loose>>;
 }, z.core.$strip>;
 /** Auth success response sent by Platform to orchestrator after successful authentication. */
@@ -45,6 +47,7 @@ export declare const authSuccessSchema: z.ZodObject<{
     connectionId: z.ZodString;
     orgPublicAlias: z.ZodOptional<z.ZodString>;
     orgId: z.ZodOptional<z.ZodString>;
+    provenanceIssuer: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 /** Auth failure response sent by Platform to orchestrator when authentication fails. */
 export declare const authFailureSchema: z.ZodObject<{

package/dist/protocol/messages/auth.js

@@ -1,4 +1,4 @@
-import "../../chunk-BTugEXQM.js";
+import "../../rolldown-runtime-ClRpJifh.js";
 import { orchCapabilitiesSchema } from "./capabilities.js";
 import { z } from "zod";
 //#region src/protocol/messages/auth.ts
@@ -32,7 +32,16 @@ const authSuccessSchema = z.object({
 	* that don't yet supply it; when absent, the orchestrator skips
 	* remote-source provisioning.
 	*/
-	orgId: z.string().optional()
+	orgId: z.string().optional(),
+	/**
+	* Provenance trust root (the OIDC issuer) the Platform mints build-provenance
+	* tokens under. The orchestrator uses it to verify provenance bundles at
+	* ingest: it derives the JWKS URI (`<issuer>/.well-known/jwks.json`) and
+	* caches the key set. `null` (or absent) means provenance is not configured —
+	* the orchestrator records each attestation's verdict as `unverifiable`
+	* rather than silently `verified`.
+	*/
+	provenanceIssuer: z.string().nullable().optional()
 });
 /** Auth failure response sent by Platform to orchestrator when authentication fails. */
 const authFailureSchema = z.object({

package/dist/protocol/messages/browser.js

@@ -1,4 +1,4 @@
-import "../../chunk-BTugEXQM.js";
+import "../../rolldown-runtime-ClRpJifh.js";
 import { browserJobContextSchema, browserRunEventSchema } from "./run-events.js";
 import { browserEventLogPayloadChunkSchema } from "./dashboard.js";
 import { z } from "zod";

package/dist/protocol/messages/capabilities.d.ts

@@ -47,6 +47,7 @@ export declare const orchCapabilitiesSchema: z.ZodObject<{
         "held_runs.reject": "held_runs.reject";
         "event_dlq.retry": "event_dlq.retry";
         "event_dlq.discard": "event_dlq.discard";
+        "attestations.retry": "attestations.retry";
         "registration.disable": "registration.disable";
         "registration.delete": "registration.delete";
         "global_workflows.update": "global_workflows.update";
@@ -56,12 +57,14 @@ export declare const orchCapabilitiesSchema: z.ZodObject<{
         "fleet.host.declare": "fleet.host.declare";
         "fleet.host.remove": "fleet.host.remove";
     }> & z.core.$partial, z.ZodBoolean>>;
+    supportedDashboardRequests: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>;
 /** Inferred type for orchestrator capabilities. */
 export type OrchCapabilities = z.infer<typeof orchCapabilitiesSchema>;
 /** Default orchestrator capabilities sent in auth.request. */
 export declare const ORCH_CAPABILITIES: Readonly<{
     orchRole: "coordinator";
+    supportedDashboardRequests: string[];
 }>;
 /**
  * Check whether an orchestrator advertises a specific capability flag.