@kici-dev/engine 0.1.24 → 0.1.25

package/dist/protocol/messages/agent-dev-ops.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Agent-facing, provenance-tagged shapes for the developer MCP's read tools
+ * beyond runs: organizations, connected orchestrators, diagnostics, and secret
+ * scope key names. Same discipline as {@link ./agent-run-result.js}: every
+ * user/process-controlled value (org and cluster names, routing keys, scope and
+ * secret key names) is wrapped in an {@link untrusted} envelope so the fencing
+ * renderer keeps it out of an agent's instruction channel; KiCI-generated ids,
+ * enum statuses, counts, and timestamps stay plain (trusted).
+ *
+ * Browser-safe (zod only) so it can ride the engine barrel alongside the rest
+ * of the agent-facing read contract.
+ */
+import { z } from 'zod';
+/**
+ * Organization the calling user belongs to. `displayName` / `publicAlias` are
+ * user-chosen → untrusted; the id, the owner flag, and the creation timestamp
+ * are trusted.
+ */
+export declare const agentOrgSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    publicAlias: z.ZodNullable<z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    displayName: z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    isOwner: z.ZodBoolean;
+    createdAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type AgentOrgSummary = z.infer<typeof agentOrgSummarySchema>;
+/**
+ * Connected orchestrator cluster (the customer-deployed data plane the org's
+ * runs execute on). The cluster name and routing keys carry user/source-derived
+ * content → untrusted; versions, modes, roles, scaler-backend enum tags, the S3
+ * flag, ids, and timestamps are trusted.
+ */
+export declare const agentOrchestratorSummarySchema: z.ZodObject<{
+    connectionId: z.ZodString;
+    clusterName: z.ZodNullable<z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    routingKeys: z.ZodArray<z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    orchVersion: z.ZodNullable<z.ZodString>;
+    orchMode: z.ZodNullable<z.ZodString>;
+    orchRole: z.ZodNullable<z.ZodString>;
+    scalerBackends: z.ZodArray<z.ZodString>;
+    s3LogAccess: z.ZodBoolean;
+    connectedAt: z.ZodString;
+    lastHeartbeatAt: z.ZodString;
+}, z.core.$strip>;
+export type AgentOrchestratorSummary = z.infer<typeof agentOrchestratorSummarySchema>;
+/** One orchestrator connection row inside the diagnostics summary. */
+export declare const agentDiagnosticsConnectionSchema: z.ZodObject<{
+    connectionId: z.ZodString;
+    healthBadge: z.ZodEnum<{
+        stale: "stale";
+        connected: "connected";
+        unhealthy: "unhealthy";
+    }>;
+    routingKeys: z.ZodArray<z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    lastHeartbeatAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Org diagnostics summary: execution metrics over the last 24h plus per-orch
+ * connection health. All metrics/counts/badges are KiCI-computed (trusted); only
+ * the routing keys carry user content.
+ */
+export declare const agentDiagnosticsSchema: z.ZodObject<{
+    executionMetrics: z.ZodObject<{
+        totalRuns: z.ZodNumber;
+        successRate: z.ZodNumber;
+        avgDurationSeconds: z.ZodNumber;
+        queuedJobs: z.ZodNumber;
+        runningJobs: z.ZodNumber;
+    }, z.core.$strip>;
+    orchestrators: z.ZodArray<z.ZodObject<{
+        connectionId: z.ZodString;
+        healthBadge: z.ZodEnum<{
+            stale: "stale";
+            connected: "connected";
+            unhealthy: "unhealthy";
+        }>;
+        routingKeys: z.ZodArray<z.ZodObject<{
+            untrusted: z.ZodLiteral<true>;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        lastHeartbeatAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    orphanedConnections: z.ZodNumber;
+}, z.core.$strip>;
+export type AgentDiagnostics = z.infer<typeof agentDiagnosticsSchema>;
+/**
+ * A secret scope and the key NAMES it holds — never values. Both the scope name
+ * and each key name are user-chosen → untrusted. This is the read contract for
+ * `list_secrets`: an agent can discover which secret keys exist without ever
+ * being handed a secret value.
+ */
+export declare const agentSecretScopeSchema: z.ZodObject<{
+    scope: z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    keys: z.ZodArray<z.ZodObject<{
+        untrusted: z.ZodLiteral<true>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentSecretScope = z.infer<typeof agentSecretScopeSchema>;
+//# sourceMappingURL=agent-dev-ops.d.ts.map

package/dist/protocol/messages/agent-dev-ops.js

@@ -0,0 +1,89 @@
+import "../../rolldown-runtime-ClRpJifh.js";
+import { untrusted } from "./agent-run-result.js";
+import { z } from "zod";
+//#region src/protocol/messages/agent-dev-ops.ts
+/**
+* Agent-facing, provenance-tagged shapes for the developer MCP's read tools
+* beyond runs: organizations, connected orchestrators, diagnostics, and secret
+* scope key names. Same discipline as {@link ./agent-run-result.js}: every
+* user/process-controlled value (org and cluster names, routing keys, scope and
+* secret key names) is wrapped in an {@link untrusted} envelope so the fencing
+* renderer keeps it out of an agent's instruction channel; KiCI-generated ids,
+* enum statuses, counts, and timestamps stay plain (trusted).
+*
+* Browser-safe (zod only) so it can ride the engine barrel alongside the rest
+* of the agent-facing read contract.
+*/
+const untrustedString = untrusted(z.string());
+const untrustedStringNullable = untrusted(z.string()).nullable();
+/**
+* Organization the calling user belongs to. `displayName` / `publicAlias` are
+* user-chosen → untrusted; the id, the owner flag, and the creation timestamp
+* are trusted.
+*/
+const agentOrgSummarySchema = z.object({
+	id: z.string(),
+	publicAlias: untrustedStringNullable,
+	displayName: untrustedString,
+	isOwner: z.boolean(),
+	createdAt: z.string().nullable()
+});
+/**
+* Connected orchestrator cluster (the customer-deployed data plane the org's
+* runs execute on). The cluster name and routing keys carry user/source-derived
+* content → untrusted; versions, modes, roles, scaler-backend enum tags, the S3
+* flag, ids, and timestamps are trusted.
+*/
+const agentOrchestratorSummarySchema = z.object({
+	connectionId: z.string(),
+	clusterName: untrustedStringNullable,
+	routingKeys: z.array(untrustedString),
+	orchVersion: z.string().nullable(),
+	orchMode: z.string().nullable(),
+	orchRole: z.string().nullable(),
+	scalerBackends: z.array(z.string()),
+	s3LogAccess: z.boolean(),
+	connectedAt: z.string(),
+	lastHeartbeatAt: z.string()
+});
+/** One orchestrator connection row inside the diagnostics summary. */
+const agentDiagnosticsConnectionSchema = z.object({
+	connectionId: z.string(),
+	healthBadge: z.enum([
+		"connected",
+		"unhealthy",
+		"stale"
+	]),
+	routingKeys: z.array(untrustedString),
+	lastHeartbeatAt: z.string().nullable()
+});
+/**
+* Org diagnostics summary: execution metrics over the last 24h plus per-orch
+* connection health. All metrics/counts/badges are KiCI-computed (trusted); only
+* the routing keys carry user content.
+*/
+const agentDiagnosticsSchema = z.object({
+	executionMetrics: z.object({
+		totalRuns: z.number().int(),
+		successRate: z.number(),
+		avgDurationSeconds: z.number(),
+		queuedJobs: z.number().int(),
+		runningJobs: z.number().int()
+	}),
+	orchestrators: z.array(agentDiagnosticsConnectionSchema),
+	orphanedConnections: z.number().int()
+});
+/**
+* A secret scope and the key NAMES it holds — never values. Both the scope name
+* and each key name are user-chosen → untrusted. This is the read contract for
+* `list_secrets`: an agent can discover which secret keys exist without ever
+* being handed a secret value.
+*/
+const agentSecretScopeSchema = z.object({
+	scope: untrustedString,
+	keys: z.array(untrustedString)
+});
+//#endregion
+export { agentDiagnosticsConnectionSchema, agentDiagnosticsSchema, agentOrchestratorSummarySchema, agentOrgSummarySchema, agentSecretScopeSchema };
+
+//# sourceMappingURL=agent-dev-ops.js.map

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

@@ -102,8 +102,8 @@ export declare const agentJobResultSchema: z.ZodObject<{
     }, z.core.$strip>>;
     initFailure: z.ZodNullable<z.ZodObject<{
         scope: z.ZodEnum<{
-            run: "run";
             job: "job";
+            run: "run";
         }>;
         category: z.ZodEnum<{
             secret_resolution: "secret_resolution";
@@ -229,6 +229,7 @@ export declare const agentRunResultSchema: z.ZodObject<{
         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<{
@@ -258,8 +259,8 @@ export declare const agentRunResultSchema: z.ZodObject<{
         }, z.core.$strip>>;
         initFailure: z.ZodNullable<z.ZodObject<{
             scope: z.ZodEnum<{
-                run: "run";
                 job: "job";
+                run: "run";
             }>;
             category: z.ZodEnum<{
                 secret_resolution: "secret_resolution";
@@ -347,4 +348,78 @@ export declare const agentStepLogsSchema: z.ZodObject<{
     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

@@ -1,4 +1,4 @@
-import "../../chunk-BTugEXQM.js";
+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";
@@ -106,6 +106,8 @@ const agentRunResultSchema = z.object({
 	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({
@@ -117,7 +119,47 @@ const agentStepLogsSchema = z.object({
 	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, agentRunResultSchema, agentStepLogsSchema, agentStepResultSchema, untrusted, wrapUntrusted };
+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";

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

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";

package/dist/protocol/messages/capabilities.js

@@ -1,4 +1,4 @@
-import "../../chunk-BTugEXQM.js";
+import "../../rolldown-runtime-ClRpJifh.js";
 import { dashboardWritePolicyMap } from "../dashboard-write-operations.js";
 import { DASHBOARD_REQUEST_TYPES } from "./dashboard.js";
 import { z } from "zod";

package/dist/protocol/messages/common.js

@@ -1,4 +1,4 @@
-import "../../chunk-BTugEXQM.js";
+import "../../rolldown-runtime-ClRpJifh.js";
 import { z } from "zod";
 //#region src/protocol/messages/common.ts
 /**

package/dist/protocol/messages/dashboard-global-workflows.d.ts

@@ -64,6 +64,9 @@ export declare const globalWorkflowsGetRequestSchema: z.ZodObject<{
         type: z.ZodLiteral<"api_key">;
         keyId: z.ZodString;
         ownerSub: z.ZodString;
+        agent: z.ZodOptional<z.ZodObject<{
+            label: z.ZodString;
+        }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"service_account">;
         id: z.ZodString;
@@ -97,6 +100,9 @@ export declare const globalWorkflowsUpdateRequestSchema: z.ZodObject<{
         type: z.ZodLiteral<"api_key">;
         keyId: z.ZodString;
         ownerSub: z.ZodString;
+        agent: z.ZodOptional<z.ZodObject<{
+            label: z.ZodString;
+        }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"service_account">;
         id: z.ZodString;

package/dist/protocol/messages/dashboard-global-workflows.js

@@ -1,4 +1,4 @@
-import "../../chunk-BTugEXQM.js";
+import "../../rolldown-runtime-ClRpJifh.js";
 import { actorPrincipalSchema } from "./actor.js";
 import { z } from "zod";
 //#region src/protocol/messages/dashboard-global-workflows.ts