@pugi/sdk 0.1.0-alpha.3 → 0.1.0-alpha.5

package/dist/subagent-contracts.d.ts

@@ -0,0 +1,549 @@
+/**
+ * Subagent dispatch contracts (Sprint a5.4 — M1 gap remediation D).
+ *
+ * The Pugi CLI's subagent surface is a typed contract between three layers:
+ *   1. The orchestrator (Mira in the brand persona registry; the parent
+ *      engine loop in the actual runtime) decides a SubagentTask.
+ *   2. The CLI dispatcher (apps/pugi-cli/src/core/subagents/dispatcher.ts)
+ *      resolves role to Cyber-Zoo persona, classifies isolation, emits
+ *      lifecycle events, and returns a SubagentResult.
+ *   3. Future M2 worktree + M3 remote-VM implementations swap the dispatch
+ *      backend without changing the contract.
+ *
+ * IMPORTANT: this module does NOT re-declare the persona roster. The
+ * Cyber-Zoo persona identities live in @pugi/personas and are mapped to
+ * roles inside the CLI. The SDK only carries the role + persona-slug pair
+ * on the wire so the cabinet UI can render the brand persona without
+ * shipping the full roster.
+ */
+import { z } from 'zod';
+/**
+ * Closed enumeration of CLI subagent roles. Mirrors the SubagentRole union
+ * declared in apps/pugi-cli/src/core/agents/registry.ts. Keep both in
+ * lockstep: the CLI dispatcher imports from @pugi/sdk for wire validation
+ * and from the local registry for persona resolution, so adding a role
+ * requires touching both files together.
+ */
+export declare const subagentRoleSchema: z.ZodEnum<["orchestrator", "architect", "coder", "verifier", "reviewer", "researcher", "release", "devops", "design_qa"]>;
+export type SubagentRole = z.infer<typeof subagentRoleSchema>;
+/**
+ * Isolation classification for a dispatched subagent. M1 ships the first
+ * three tiers; worktree lands in alpha-6 (per-task git worktree for every
+ * write subagent), remote_vm in M3 (dangerous / long-running jobs).
+ *
+ *   - prompt_only:           reasoning/review folded into the parent
+ *                            engine context. No separate filesystem
+ *                            handle; the parent owns every tool call.
+ *                            Mira (orchestrator) uses this at M1.
+ *   - shared_fs_readonly:    read tools are allowed; write/edit/bash
+ *                            classes are denied at the permission layer.
+ *                            Marcus / Vera / Anika get this at M1.
+ *   - shared_fs_serialized:  write tools are allowed but serialized
+ *                            through a coordinator-held lock so two
+ *                            write-subagents never race on the same
+ *                            workspace. Hiroshi / Olivia / Diego / Sofia.
+ *   - worktree:              per-subagent worktree directory (M2,
+ *                            ADR-0057). Writes never touch the primary
+ *                            workspace until merge.
+ *   - remote_vm:             engine VM spawn (M3). Out of scope for the
+ *                            CLI but reserved in the enum so the wire
+ *                            format does not change between milestones.
+ */
+export declare const subagentIsolationSchema: z.ZodEnum<["prompt_only", "shared_fs_readonly", "shared_fs_serialized", "worktree", "remote_vm"]>;
+export type SubagentIsolation = z.infer<typeof subagentIsolationSchema>;
+/**
+ * Status of a completed subagent dispatch.
+ *   - shipped:   the subagent returned a final answer and any write tools
+ *                it invoked succeeded.
+ *   - blocked:   the subagent stopped because the budget was hit, plan
+ *                mode refused a write, or a permission rule denied a tool
+ *                call.
+ *   - failed:    the subagent crashed or returned a parseable error.
+ *   - cancelled: the parent or operator cancelled the dispatch via the
+ *                abort signal.
+ */
+export declare const subagentStatusSchema: z.ZodEnum<["shipped", "blocked", "failed", "cancelled"]>;
+export type SubagentStatus = z.infer<typeof subagentStatusSchema>;
+/**
+ * Per-dispatch budget. All three limits are optional; the dispatcher
+ * applies its own per-role defaults when a field is missing. Setting a
+ * field tightens the cap; the dispatcher never relaxes a budget.
+ */
+export declare const subagentBudgetSchema: z.ZodObject<{
+    tokens: z.ZodOptional<z.ZodNumber>;
+    dollars: z.ZodOptional<z.ZodNumber>;
+    wallClockMs: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    tokens?: number | undefined;
+    dollars?: number | undefined;
+    wallClockMs?: number | undefined;
+}, {
+    tokens?: number | undefined;
+    dollars?: number | undefined;
+    wallClockMs?: number | undefined;
+}>;
+export type SubagentBudget = z.infer<typeof subagentBudgetSchema>;
+/**
+ * Dispatch input. allowedPaths / deniedPaths mirror the per-task shape on
+ * EngineTask so callers that already build engine tasks can promote a
+ * subset of the fields into a subagent dispatch without a second
+ * translation step.
+ */
+export declare const subagentTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<["orchestrator", "architect", "coder", "verifier", "reviewer", "researcher", "release", "devops", "design_qa"]>;
+    prompt: z.ZodString;
+    permissionMode: z.ZodEnum<["plan", "ask", "acceptEdits", "auto", "dontAsk", "bypassPermissions"]>;
+    budget: z.ZodOptional<z.ZodObject<{
+        tokens: z.ZodOptional<z.ZodNumber>;
+        dollars: z.ZodOptional<z.ZodNumber>;
+        wallClockMs: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        tokens?: number | undefined;
+        dollars?: number | undefined;
+        wallClockMs?: number | undefined;
+    }, {
+        tokens?: number | undefined;
+        dollars?: number | undefined;
+        wallClockMs?: number | undefined;
+    }>>;
+    allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    deniedPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    prompt: string;
+    permissionMode: "plan" | "ask" | "acceptEdits" | "auto" | "dontAsk" | "bypassPermissions";
+    budget?: {
+        tokens?: number | undefined;
+        dollars?: number | undefined;
+        wallClockMs?: number | undefined;
+    } | undefined;
+    allowedPaths?: string[] | undefined;
+    deniedPaths?: string[] | undefined;
+}, {
+    id: string;
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    prompt: string;
+    permissionMode: "plan" | "ask" | "acceptEdits" | "auto" | "dontAsk" | "bypassPermissions";
+    budget?: {
+        tokens?: number | undefined;
+        dollars?: number | undefined;
+        wallClockMs?: number | undefined;
+    } | undefined;
+    allowedPaths?: string[] | undefined;
+    deniedPaths?: string[] | undefined;
+}>;
+export type SubagentTask = z.infer<typeof subagentTaskSchema>;
+/**
+ * Dispatch result. personaSlug is the brand persona that owned the
+ * dispatch (from @pugi/personas via the CLI registry); cabinet UI and
+ * audit replay use it to render the persona avatar / hue token without
+ * needing to re-resolve the role.
+ *
+ * permissionDecisions is an OPTIONAL summary of the most important
+ * permission decisions the dispatcher applied or recorded. Full decision
+ * history lives in .pugi/events.jsonl; this field is a convenience pointer
+ * so cabinet UI can render the "Vera was blocked from editing X" line
+ * without re-parsing the events log.
+ */
+export declare const subagentResultSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    role: z.ZodEnum<["orchestrator", "architect", "coder", "verifier", "reviewer", "researcher", "release", "devops", "design_qa"]>;
+    personaSlug: z.ZodString;
+    status: z.ZodEnum<["shipped", "blocked", "failed", "cancelled"]>;
+    summary: z.ZodString;
+    filesChanged: z.ZodArray<z.ZodString, "many">;
+    toolCallCount: z.ZodNumber;
+    tokensIn: z.ZodNumber;
+    tokensOut: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    permissionDecisions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"decision", [z.ZodObject<{
+        decision: z.ZodLiteral<"allow">;
+        reason: z.ZodString;
+        source: z.ZodString;
+        expiresAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        decision: "allow";
+        reason: string;
+        source: string;
+        expiresAt?: string | undefined;
+    }, {
+        decision: "allow";
+        reason: string;
+        source: string;
+        expiresAt?: string | undefined;
+    }>, z.ZodObject<{
+        decision: z.ZodLiteral<"ask">;
+        reason: z.ZodString;
+        risk: z.ZodEnum<["low", "medium", "high"]>;
+    }, "strip", z.ZodTypeAny, {
+        decision: "ask";
+        reason: string;
+        risk: "low" | "medium" | "high";
+    }, {
+        decision: "ask";
+        reason: string;
+        risk: "low" | "medium" | "high";
+    }>, z.ZodObject<{
+        decision: z.ZodLiteral<"deny">;
+        reason: z.ZodString;
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        decision: "deny";
+        reason: string;
+        source: string;
+    }, {
+        decision: "deny";
+        reason: string;
+        source: string;
+    }>]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    status: "shipped" | "blocked" | "failed" | "cancelled";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    summary: string;
+    filesChanged: string[];
+    toolCallCount: number;
+    tokensIn: number;
+    tokensOut: number;
+    durationMs: number;
+    permissionDecisions?: ({
+        decision: "allow";
+        reason: string;
+        source: string;
+        expiresAt?: string | undefined;
+    } | {
+        decision: "ask";
+        reason: string;
+        risk: "low" | "medium" | "high";
+    } | {
+        decision: "deny";
+        reason: string;
+        source: string;
+    })[] | undefined;
+}, {
+    status: "shipped" | "blocked" | "failed" | "cancelled";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    summary: string;
+    filesChanged: string[];
+    toolCallCount: number;
+    tokensIn: number;
+    tokensOut: number;
+    durationMs: number;
+    permissionDecisions?: ({
+        decision: "allow";
+        reason: string;
+        source: string;
+        expiresAt?: string | undefined;
+    } | {
+        decision: "ask";
+        reason: string;
+        risk: "low" | "medium" | "high";
+    } | {
+        decision: "deny";
+        reason: string;
+        source: string;
+    })[] | undefined;
+}>;
+export type SubagentResult = z.infer<typeof subagentResultSchema>;
+/**
+ * Emitted once at dispatch start. parentSessionId is the session that owns
+ * the dispatch (typically the CLI's top-level PugiSession.id); future M2
+ * worktree dispatches will introduce a child session id that
+ * cross-references back to the parent.
+ */
+export declare const subagentSpawnedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"subagent.spawned">;
+    taskId: z.ZodString;
+    role: z.ZodEnum<["orchestrator", "architect", "coder", "verifier", "reviewer", "researcher", "release", "devops", "design_qa"]>;
+    personaSlug: z.ZodString;
+    parentSessionId: z.ZodString;
+    isolation: z.ZodEnum<["prompt_only", "shared_fs_readonly", "shared_fs_serialized", "worktree", "remote_vm"]>;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "subagent.spawned";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    parentSessionId: string;
+    isolation: "prompt_only" | "shared_fs_readonly" | "shared_fs_serialized" | "worktree" | "remote_vm";
+    timestamp: string;
+}, {
+    type: "subagent.spawned";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    parentSessionId: string;
+    isolation: "prompt_only" | "shared_fs_readonly" | "shared_fs_serialized" | "worktree" | "remote_vm";
+    timestamp: string;
+}>;
+export type SubagentSpawnedEvent = z.infer<typeof subagentSpawnedEventSchema>;
+/**
+ * Emitted once per tool call the subagent makes. toolName is the
+ * registered tool slug (read, write, edit, bash, ...). Full argument
+ * payloads stay in the global audit log under tool_call; this event is
+ * the subagent-scoped index so cabinet UI can render the per-persona tool
+ * tree without a second join.
+ */
+export declare const subagentToolCallEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"subagent.tool_call">;
+    taskId: z.ZodString;
+    role: z.ZodEnum<["orchestrator", "architect", "coder", "verifier", "reviewer", "researcher", "release", "devops", "design_qa"]>;
+    personaSlug: z.ZodString;
+    toolName: z.ZodString;
+    toolCallId: z.ZodString;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "subagent.tool_call";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    timestamp: string;
+    toolName: string;
+    toolCallId: string;
+}, {
+    type: "subagent.tool_call";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    timestamp: string;
+    toolName: string;
+    toolCallId: string;
+}>;
+export type SubagentToolCallEvent = z.infer<typeof subagentToolCallEventSchema>;
+/**
+ * Emitted once when the subagent reaches a terminal state with status
+ * shipped. The numeric fields mirror the SubagentResult summary so a
+ * downstream consumer can build a cabinet UI activity row from a single
+ * event without joining back to the result envelope.
+ */
+export declare const subagentCompletedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"subagent.completed">;
+    taskId: z.ZodString;
+    role: z.ZodEnum<["orchestrator", "architect", "coder", "verifier", "reviewer", "researcher", "release", "devops", "design_qa"]>;
+    personaSlug: z.ZodString;
+    toolCallCount: z.ZodNumber;
+    tokensIn: z.ZodNumber;
+    tokensOut: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "subagent.completed";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    toolCallCount: number;
+    tokensIn: number;
+    tokensOut: number;
+    durationMs: number;
+    timestamp: string;
+}, {
+    type: "subagent.completed";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    toolCallCount: number;
+    tokensIn: number;
+    tokensOut: number;
+    durationMs: number;
+    timestamp: string;
+}>;
+export type SubagentCompletedEvent = z.infer<typeof subagentCompletedEventSchema>;
+/**
+ * Emitted once when the subagent terminates with status blocked. reason is
+ * a short machine-friendly slug (budget_exhausted, plan_mode_refused,
+ * permission_denied, tool_unavailable) so cabinet UI can group blocked
+ * dispatches by cause; detail is a human-readable summary the operator
+ * can act on.
+ */
+export declare const subagentBlockedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"subagent.blocked">;
+    taskId: z.ZodString;
+    role: z.ZodEnum<["orchestrator", "architect", "coder", "verifier", "reviewer", "researcher", "release", "devops", "design_qa"]>;
+    personaSlug: z.ZodString;
+    reason: z.ZodEnum<["budget_exhausted", "plan_mode_refused", "permission_denied", "tool_unavailable"]>;
+    detail: z.ZodString;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "subagent.blocked";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    reason: "budget_exhausted" | "plan_mode_refused" | "permission_denied" | "tool_unavailable";
+    timestamp: string;
+    detail: string;
+}, {
+    type: "subagent.blocked";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    reason: "budget_exhausted" | "plan_mode_refused" | "permission_denied" | "tool_unavailable";
+    timestamp: string;
+    detail: string;
+}>;
+export type SubagentBlockedEvent = z.infer<typeof subagentBlockedEventSchema>;
+/**
+ * Emitted once when the subagent terminates with status failed. The error
+ * field is a one-line summary safe to print in the operator console; full
+ * stack traces stay in the global audit log.
+ */
+export declare const subagentFailedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"subagent.failed">;
+    taskId: z.ZodString;
+    role: z.ZodEnum<["orchestrator", "architect", "coder", "verifier", "reviewer", "researcher", "release", "devops", "design_qa"]>;
+    personaSlug: z.ZodString;
+    error: z.ZodString;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "subagent.failed";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    timestamp: string;
+    error: string;
+}, {
+    type: "subagent.failed";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    timestamp: string;
+    error: string;
+}>;
+export type SubagentFailedEvent = z.infer<typeof subagentFailedEventSchema>;
+/**
+ * Discriminated union of every subagent lifecycle event. Folded into the
+ * broader auditEventSchema in audit-trace.ts; exported here separately so
+ * dispatcher unit tests can validate against just the subagent surface
+ * without pulling the full audit-trace dependency graph through the test
+ * bundle.
+ */
+export declare const subagentEventSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"subagent.spawned">;
+    taskId: z.ZodString;
+    role: z.ZodEnum<["orchestrator", "architect", "coder", "verifier", "reviewer", "researcher", "release", "devops", "design_qa"]>;
+    personaSlug: z.ZodString;
+    parentSessionId: z.ZodString;
+    isolation: z.ZodEnum<["prompt_only", "shared_fs_readonly", "shared_fs_serialized", "worktree", "remote_vm"]>;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "subagent.spawned";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    parentSessionId: string;
+    isolation: "prompt_only" | "shared_fs_readonly" | "shared_fs_serialized" | "worktree" | "remote_vm";
+    timestamp: string;
+}, {
+    type: "subagent.spawned";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    parentSessionId: string;
+    isolation: "prompt_only" | "shared_fs_readonly" | "shared_fs_serialized" | "worktree" | "remote_vm";
+    timestamp: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"subagent.tool_call">;
+    taskId: z.ZodString;
+    role: z.ZodEnum<["orchestrator", "architect", "coder", "verifier", "reviewer", "researcher", "release", "devops", "design_qa"]>;
+    personaSlug: z.ZodString;
+    toolName: z.ZodString;
+    toolCallId: z.ZodString;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "subagent.tool_call";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    timestamp: string;
+    toolName: string;
+    toolCallId: string;
+}, {
+    type: "subagent.tool_call";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    timestamp: string;
+    toolName: string;
+    toolCallId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"subagent.completed">;
+    taskId: z.ZodString;
+    role: z.ZodEnum<["orchestrator", "architect", "coder", "verifier", "reviewer", "researcher", "release", "devops", "design_qa"]>;
+    personaSlug: z.ZodString;
+    toolCallCount: z.ZodNumber;
+    tokensIn: z.ZodNumber;
+    tokensOut: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "subagent.completed";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    toolCallCount: number;
+    tokensIn: number;
+    tokensOut: number;
+    durationMs: number;
+    timestamp: string;
+}, {
+    type: "subagent.completed";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    toolCallCount: number;
+    tokensIn: number;
+    tokensOut: number;
+    durationMs: number;
+    timestamp: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"subagent.blocked">;
+    taskId: z.ZodString;
+    role: z.ZodEnum<["orchestrator", "architect", "coder", "verifier", "reviewer", "researcher", "release", "devops", "design_qa"]>;
+    personaSlug: z.ZodString;
+    reason: z.ZodEnum<["budget_exhausted", "plan_mode_refused", "permission_denied", "tool_unavailable"]>;
+    detail: z.ZodString;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "subagent.blocked";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    reason: "budget_exhausted" | "plan_mode_refused" | "permission_denied" | "tool_unavailable";
+    timestamp: string;
+    detail: string;
+}, {
+    type: "subagent.blocked";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    reason: "budget_exhausted" | "plan_mode_refused" | "permission_denied" | "tool_unavailable";
+    timestamp: string;
+    detail: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"subagent.failed">;
+    taskId: z.ZodString;
+    role: z.ZodEnum<["orchestrator", "architect", "coder", "verifier", "reviewer", "researcher", "release", "devops", "design_qa"]>;
+    personaSlug: z.ZodString;
+    error: z.ZodString;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "subagent.failed";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    timestamp: string;
+    error: string;
+}, {
+    type: "subagent.failed";
+    role: "orchestrator" | "architect" | "coder" | "verifier" | "reviewer" | "researcher" | "release" | "devops" | "design_qa";
+    taskId: string;
+    personaSlug: string;
+    timestamp: string;
+    error: string;
+}>]>;
+export type SubagentEvent = z.infer<typeof subagentEventSchema>;
+//# sourceMappingURL=subagent-contracts.d.ts.map