@ai-dev-orchestrator/schemas 0.1.1

package/dist/persistence/state-persistence.d.ts

@@ -0,0 +1,276 @@
+import { z } from 'zod/v4';
+export declare const budgetExhaustionContextSchema: z.ZodObject<{
+    limitType: z.ZodLiteral<"token">;
+    current: z.ZodNumber;
+    limit: z.ZodNumber;
+    role: z.ZodOptional<z.ZodString>;
+    cumulativeTokens: z.ZodNumber;
+}, z.core.$strip>;
+export type BudgetExhaustionContext = z.infer<typeof budgetExhaustionContextSchema>;
+export declare const persistedWaitingContextSchema: z.ZodObject<{
+    reason: z.ZodString;
+    requiredInput: z.ZodString;
+    requestingState: z.ZodString;
+    autoResumeSafe: z.ZodBoolean;
+    presentedArtifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>>>;
+    waitingSince: z.ZodString;
+    budgetExhaustion: z.ZodOptional<z.ZodObject<{
+        limitType: z.ZodLiteral<"token">;
+        current: z.ZodNumber;
+        limit: z.ZodNumber;
+        role: z.ZodOptional<z.ZodString>;
+        cumulativeTokens: z.ZodNumber;
+    }, z.core.$strip>>;
+    liveSessionId: z.ZodOptional<z.ZodString>;
+    pendingRequestId: z.ZodOptional<z.ZodString>;
+    liveRequestType: z.ZodOptional<z.ZodEnum<{
+        permission: "permission";
+        clarification: "clarification";
+    }>>;
+    sessionTransport: z.ZodOptional<z.ZodEnum<{
+        stdio: "stdio";
+        remote: "remote";
+    }>>;
+}, z.core.$strip>;
+export type PersistedWaitingContext = z.infer<typeof persistedWaitingContextSchema>;
+export declare const persistedStateSchema: z.ZodObject<{
+    runId: z.core.$ZodBranded<z.ZodString, "RunId", "out">;
+    schemaVersion: z.ZodNumber;
+    repoRoot: z.ZodOptional<z.ZodString>;
+    currentState: z.ZodString;
+    previousState: z.ZodNullable<z.ZodString>;
+    stateEnteredAt: z.ZodString;
+    transitionCount: z.ZodNumber;
+    stateHistory: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    iterationCounts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    judgeArbitrationCounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    activeArtifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>>>;
+    lastProducedArtifact: z.ZodNullable<z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>>;
+    waitingContext: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodString;
+        requiredInput: z.ZodString;
+        requestingState: z.ZodString;
+        autoResumeSafe: z.ZodBoolean;
+        presentedArtifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                intake_requirements: "intake_requirements";
+                canonical_specification: "canonical_specification";
+                clarification_questions: "clarification_questions";
+                clarification_answers: "clarification_answers";
+                plan: "plan";
+                plan_review: "plan_review";
+                test_plan: "test_plan";
+                implementation: "implementation";
+                static_review: "static_review";
+                security_review: "security_review";
+                performance_review: "performance_review";
+                adversarial_review: "adversarial_review";
+                design_review: "design_review";
+                docs_review: "docs_review";
+                ux_review: "ux_review";
+                review_report: "review_report";
+                remediation_plan: "remediation_plan";
+                verification: "verification";
+                judge_decision: "judge_decision";
+                planning_agreement: "planning_agreement";
+                implementation_agreement: "implementation_agreement";
+                verification_agreement: "verification_agreement";
+                release_summary: "release_summary";
+                release_agreement: "release_agreement";
+                escalation_context: "escalation_context";
+                run_manifest: "run_manifest";
+                codebase_context: "codebase_context";
+                test_suite: "test_suite";
+                acceptance_validation: "acceptance_validation";
+                review_findings: "review_findings";
+                task_breakdown: "task_breakdown";
+                decomposition_review: "decomposition_review";
+                task_specifications: "task_specifications";
+                pr_diff_context: "pr_diff_context";
+            }>;
+            name: z.ZodString;
+            version: z.ZodNumber;
+            checksum: z.ZodString;
+        }, z.core.$strip>>>;
+        waitingSince: z.ZodString;
+        budgetExhaustion: z.ZodOptional<z.ZodObject<{
+            limitType: z.ZodLiteral<"token">;
+            current: z.ZodNumber;
+            limit: z.ZodNumber;
+            role: z.ZodOptional<z.ZodString>;
+            cumulativeTokens: z.ZodNumber;
+        }, z.core.$strip>>;
+        liveSessionId: z.ZodOptional<z.ZodString>;
+        pendingRequestId: z.ZodOptional<z.ZodString>;
+        liveRequestType: z.ZodOptional<z.ZodEnum<{
+            permission: "permission";
+            clarification: "clarification";
+        }>>;
+        sessionTransport: z.ZodOptional<z.ZodEnum<{
+            stdio: "stdio";
+            remote: "remote";
+        }>>;
+    }, z.core.$strip>>;
+    workflowName: z.ZodString;
+    workflowVersion: z.ZodString;
+    persistedAt: z.ZodString;
+    persistenceVersion: z.ZodNumber;
+    checksum: z.ZodString;
+    cumulativeInputTokens: z.ZodOptional<z.ZodNumber>;
+    cumulativeOutputTokens: z.ZodOptional<z.ZodNumber>;
+    hasReceivedUsage: z.ZodOptional<z.ZodBoolean>;
+    governanceDecisionCount: z.ZodOptional<z.ZodNumber>;
+    escalationCount: z.ZodOptional<z.ZodNumber>;
+    workerMetricsByRole: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        dispatches: z.ZodNumber;
+        durationMs: z.ZodNumber;
+        artifactsProduced: z.ZodNumber;
+    }, z.core.$strip>>>;
+    dispatchCounter: z.ZodOptional<z.ZodNumber>;
+    firedThresholdIndex: z.ZodOptional<z.ZodNumber>;
+    lastHumanFeedback: z.ZodOptional<z.ZodString>;
+    lastReviewContent: z.ZodOptional<z.ZodString>;
+    lastTrigger: z.ZodOptional<z.ZodString>;
+    stateTimestamps: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        stateId: z.ZodString;
+        enteredAt: z.ZodString;
+        exitedAt: z.ZodString;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+export type PersistedState = z.infer<typeof persistedStateSchema>;
+export declare const stateValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    warnings: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type StateValidationResult = z.infer<typeof stateValidationResultSchema>;
+export declare const lockHandleSchema: z.ZodObject<{
+    runId: z.core.$ZodBranded<z.ZodString, "RunId", "out">;
+    pid: z.ZodNumber;
+    acquiredAt: z.ZodString;
+    lockPath: z.ZodString;
+    hostname: z.ZodString;
+}, z.core.$strip>;
+export type LockHandle = z.infer<typeof lockHandleSchema>;

package/dist/persistence/state-persistence.js

@@ -0,0 +1,83 @@
+import { z } from 'zod/v4';
+import { artifactRefSchema } from '../artifacts/artifact-system';
+import { runIdSchema } from '../shared/shared';
+import { liveRequestKindSchema, sessionTransportSchema } from '../shared/string-enums';
+export const budgetExhaustionContextSchema = z.object({
+    limitType: z.literal('token'),
+    current: z.number(),
+    limit: z.number(),
+    role: z.string().optional(),
+    cumulativeTokens: z.number(),
+});
+export const persistedWaitingContextSchema = z.object({
+    reason: z.string(),
+    requiredInput: z.string(),
+    requestingState: z.string(),
+    autoResumeSafe: z.boolean(),
+    presentedArtifacts: z.array(artifactRefSchema).readonly(),
+    waitingSince: z.string(),
+    budgetExhaustion: budgetExhaustionContextSchema.optional(),
+    liveSessionId: z.string().optional(),
+    pendingRequestId: z.string().optional(),
+    liveRequestType: liveRequestKindSchema.optional(),
+    sessionTransport: sessionTransportSchema.optional(),
+});
+export const persistedStateSchema = z.object({
+    runId: runIdSchema,
+    schemaVersion: z.number(),
+    repoRoot: z.string().optional(),
+    currentState: z.string(),
+    previousState: z.string().nullable(),
+    stateEnteredAt: z.string(),
+    transitionCount: z.number(),
+    stateHistory: z.array(z.string()).readonly(),
+    iterationCounts: z.record(z.string(), z.number()),
+    judgeArbitrationCounts: z.record(z.string(), z.number()).optional(),
+    activeArtifacts: z.array(artifactRefSchema).readonly(),
+    lastProducedArtifact: artifactRefSchema.nullable(),
+    waitingContext: persistedWaitingContextSchema.optional(),
+    workflowName: z.string(),
+    workflowVersion: z.string(),
+    persistedAt: z.string(),
+    persistenceVersion: z.number(),
+    checksum: z.string(),
+    cumulativeInputTokens: z.number().optional(),
+    cumulativeOutputTokens: z.number().optional(),
+    hasReceivedUsage: z.boolean().optional(),
+    governanceDecisionCount: z.number().optional(),
+    escalationCount: z.number().optional(),
+    workerMetricsByRole: z
+        .record(z.string(), z.object({
+        inputTokens: z.number(),
+        outputTokens: z.number(),
+        dispatches: z.number(),
+        durationMs: z.number(),
+        artifactsProduced: z.number(),
+    }))
+        .optional(),
+    dispatchCounter: z.number().optional(),
+    firedThresholdIndex: z.number().optional(),
+    lastHumanFeedback: z.string().optional(),
+    lastReviewContent: z.string().optional(),
+    lastTrigger: z.string().optional(),
+    stateTimestamps: z
+        .array(z.object({
+        stateId: z.string(),
+        enteredAt: z.string(),
+        exitedAt: z.string(),
+    }))
+        .readonly()
+        .optional(),
+});
+export const stateValidationResultSchema = z.object({
+    valid: z.boolean(),
+    errors: z.array(z.string()).readonly(),
+    warnings: z.array(z.string()).readonly(),
+});
+export const lockHandleSchema = z.object({
+    runId: runIdSchema,
+    pid: z.number(),
+    acquiredAt: z.string(),
+    lockPath: z.string(),
+    hostname: z.string(),
+});

package/dist/runner/built-in-runner-ids.d.ts

@@ -0,0 +1,8 @@
+/** Stable identifiers for the built-in local coding-agent runners. */
+export declare const BUILT_IN_CODING_RUNNER_ID: {
+    readonly CLAUDE_CODE: "claude-code";
+    readonly CODEX: "codex";
+    readonly CURSOR: "cursor";
+};
+export type BuiltInCodingRunnerId = (typeof BUILT_IN_CODING_RUNNER_ID)[keyof typeof BUILT_IN_CODING_RUNNER_ID];
+export declare const BUILT_IN_CODING_RUNNER_IDS: readonly BuiltInCodingRunnerId[];

package/dist/runner/built-in-runner-ids.js

@@ -0,0 +1,11 @@
+/** Stable identifiers for the built-in local coding-agent runners. */
+export const BUILT_IN_CODING_RUNNER_ID = {
+    CLAUDE_CODE: 'claude-code',
+    CODEX: 'codex',
+    CURSOR: 'cursor',
+};
+export const BUILT_IN_CODING_RUNNER_IDS = [
+    BUILT_IN_CODING_RUNNER_ID.CLAUDE_CODE,
+    BUILT_IN_CODING_RUNNER_ID.CODEX,
+    BUILT_IN_CODING_RUNNER_ID.CURSOR,
+];

package/dist/runner/collaboration-model.d.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod/v4';
+export declare const roleInteractionRelationshipSchema: z.ZodEnum<{
+    reviews: "reviews";
+    produces_for: "produces_for";
+    approves: "approves";
+}>;
+export type RoleInteractionRelationship = z.infer<typeof roleInteractionRelationshipSchema>;
+export declare const roleInteractionSchema: z.ZodObject<{
+    producerRole: z.ZodString;
+    consumerRole: z.ZodString;
+    artifactType: z.ZodEnum<{
+        intake_requirements: "intake_requirements";
+        canonical_specification: "canonical_specification";
+        clarification_questions: "clarification_questions";
+        clarification_answers: "clarification_answers";
+        plan: "plan";
+        plan_review: "plan_review";
+        test_plan: "test_plan";
+        implementation: "implementation";
+        static_review: "static_review";
+        security_review: "security_review";
+        performance_review: "performance_review";
+        adversarial_review: "adversarial_review";
+        design_review: "design_review";
+        docs_review: "docs_review";
+        ux_review: "ux_review";
+        review_report: "review_report";
+        remediation_plan: "remediation_plan";
+        verification: "verification";
+        judge_decision: "judge_decision";
+        planning_agreement: "planning_agreement";
+        implementation_agreement: "implementation_agreement";
+        verification_agreement: "verification_agreement";
+        release_summary: "release_summary";
+        release_agreement: "release_agreement";
+        escalation_context: "escalation_context";
+        run_manifest: "run_manifest";
+        codebase_context: "codebase_context";
+        test_suite: "test_suite";
+        acceptance_validation: "acceptance_validation";
+        review_findings: "review_findings";
+        task_breakdown: "task_breakdown";
+        decomposition_review: "decomposition_review";
+        task_specifications: "task_specifications";
+        pr_diff_context: "pr_diff_context";
+    }>;
+    relationship: z.ZodEnum<{
+        reviews: "reviews";
+        produces_for: "produces_for";
+        approves: "approves";
+    }>;
+}, z.core.$strip>;
+export type RoleInteraction = z.infer<typeof roleInteractionSchema>;
+export declare const artifactFlowDefinitionSchema: z.ZodObject<{
+    artifactType: z.ZodEnum<{
+        intake_requirements: "intake_requirements";
+        canonical_specification: "canonical_specification";
+        clarification_questions: "clarification_questions";
+        clarification_answers: "clarification_answers";
+        plan: "plan";
+        plan_review: "plan_review";
+        test_plan: "test_plan";
+        implementation: "implementation";
+        static_review: "static_review";
+        security_review: "security_review";
+        performance_review: "performance_review";
+        adversarial_review: "adversarial_review";
+        design_review: "design_review";
+        docs_review: "docs_review";
+        ux_review: "ux_review";
+        review_report: "review_report";
+        remediation_plan: "remediation_plan";
+        verification: "verification";
+        judge_decision: "judge_decision";
+        planning_agreement: "planning_agreement";
+        implementation_agreement: "implementation_agreement";
+        verification_agreement: "verification_agreement";
+        release_summary: "release_summary";
+        release_agreement: "release_agreement";
+        escalation_context: "escalation_context";
+        run_manifest: "run_manifest";
+        codebase_context: "codebase_context";
+        test_suite: "test_suite";
+        acceptance_validation: "acceptance_validation";
+        review_findings: "review_findings";
+        task_breakdown: "task_breakdown";
+        decomposition_review: "decomposition_review";
+        task_specifications: "task_specifications";
+        pr_diff_context: "pr_diff_context";
+    }>;
+    producedBy: z.ZodString;
+    consumedBy: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    reviewedBy: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ArtifactFlowDefinition = z.infer<typeof artifactFlowDefinitionSchema>;
+export declare const visibilityCheckSchema: z.ZodObject<{
+    allowed: z.ZodBoolean;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type VisibilityCheck = z.infer<typeof visibilityCheckSchema>;

package/dist/runner/collaboration-model.js

@@ -0,0 +1,19 @@
+import { z } from 'zod/v4';
+import { artifactTypeSchema } from '../artifacts/artifact-system';
+export const roleInteractionRelationshipSchema = z.enum(['produces_for', 'reviews', 'approves']);
+export const roleInteractionSchema = z.object({
+    producerRole: z.string(),
+    consumerRole: z.string(),
+    artifactType: artifactTypeSchema,
+    relationship: roleInteractionRelationshipSchema,
+});
+export const artifactFlowDefinitionSchema = z.object({
+    artifactType: artifactTypeSchema,
+    producedBy: z.string(),
+    consumedBy: z.array(z.string()).readonly(),
+    reviewedBy: z.array(z.string()).readonly(),
+});
+export const visibilityCheckSchema = z.object({
+    allowed: z.boolean(),
+    reason: z.string(),
+});

package/dist/runner/confidence.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod/v4';
+export declare const criterionResultSchema: z.ZodObject<{
+    criterionId: z.ZodString;
+    met: z.ZodBoolean;
+    evidence: z.ZodString;
+}, z.core.$strip>;
+export type CriterionResult = z.infer<typeof criterionResultSchema>;
+export declare const confidenceReportSchema: z.ZodObject<{
+    score: z.ZodNumber;
+    criteriaResults: z.ZodArray<z.ZodObject<{
+        criterionId: z.ZodString;
+        met: z.ZodBoolean;
+        evidence: z.ZodString;
+    }, z.core.$strip>>;
+    rationale: z.ZodString;
+}, z.core.$strip>;
+export type ConfidenceReport = z.infer<typeof confidenceReportSchema>;

package/dist/runner/confidence.js

@@ -0,0 +1,11 @@
+import { z } from 'zod/v4';
+export const criterionResultSchema = z.object({
+    criterionId: z.string(),
+    met: z.boolean(),
+    evidence: z.string(),
+});
+export const confidenceReportSchema = z.object({
+    score: z.number().min(0).max(1),
+    criteriaResults: z.array(criterionResultSchema),
+    rationale: z.string(),
+});

package/dist/runner/index.d.ts

@@ -0,0 +1,8 @@
+export * from './collaboration-model';
+export * from './built-in-runner-ids';
+export * from './confidence';
+export * from './permission-approval';
+export * from './prompt-engine';
+export * from './role-system';
+export * from './runner-system';
+export * from './task-brief';

package/dist/runner/index.js

@@ -0,0 +1,8 @@
+export * from './collaboration-model';
+export * from './built-in-runner-ids';
+export * from './confidence';
+export * from './permission-approval';
+export * from './prompt-engine';
+export * from './role-system';
+export * from './runner-system';
+export * from './task-brief';

package/dist/runner/permission-approval.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod/v4';
+export declare const permissionApprovalEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodEnum<{
+        file_read: "file_read";
+        file_write: "file_write";
+        file_delete: "file_delete";
+        shell_execute: "shell_execute";
+        network_request: "network_request";
+        git_operation: "git_operation";
+        custom: "custom";
+    }>;
+    resource: z.ZodString;
+    detail: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    createdByRole: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PermissionApprovalEntry = z.infer<typeof permissionApprovalEntrySchema>;
+export declare const permissionApprovalFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    approvals: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        action: z.ZodEnum<{
+            file_read: "file_read";
+            file_write: "file_write";
+            file_delete: "file_delete";
+            shell_execute: "shell_execute";
+            network_request: "network_request";
+            git_operation: "git_operation";
+            custom: "custom";
+        }>;
+        resource: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+        createdByRole: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type PermissionApprovalFile = z.infer<typeof permissionApprovalFileSchema>;

package/dist/runner/permission-approval.js

@@ -0,0 +1,14 @@
+import { z } from 'zod/v4';
+import { permissionActionSchema } from '../shared/string-enums';
+export const permissionApprovalEntrySchema = z.object({
+    id: z.string(),
+    action: permissionActionSchema,
+    resource: z.string(),
+    detail: z.string().optional(),
+    createdAt: z.string(),
+    createdByRole: z.string().optional(),
+});
+export const permissionApprovalFileSchema = z.object({
+    version: z.literal(1),
+    approvals: z.array(permissionApprovalEntrySchema).readonly(),
+});