@humain/humain-code-contracts 0.3.2

package/dist/orchestration.d.ts

@@ -0,0 +1,327 @@
+import { type Static, Type } from "typebox";
+export * from "./subagent-progress.ts";
+export declare const ORCHESTRATION_CONTRACT_VERSION: 1;
+export declare const ORCHESTRATION_CAPABILITIES: readonly ["architect", "technical_lead", "implementation_fast", "implementation_strong", "technical_review", "security_review"];
+export type OrchestrationCapability = (typeof ORCHESTRATION_CAPABILITIES)[number];
+export declare const ORCHESTRATION_EFFORTS: readonly ["low", "medium", "high"];
+export type OrchestrationEffort = (typeof ORCHESTRATION_EFFORTS)[number];
+export declare const ORCHESTRATION_RISKS: readonly ["low", "medium", "high", "critical"];
+export type OrchestrationRisk = (typeof ORCHESTRATION_RISKS)[number];
+export declare const OrchestrationCapabilitySchema: Type.TUnion<[Type.TLiteral<"architect">, Type.TLiteral<"technical_lead">, Type.TLiteral<"implementation_fast">, Type.TLiteral<"implementation_strong">, Type.TLiteral<"technical_review">, Type.TLiteral<"security_review">]>;
+export type OrchestrationCapabilityLiteral = Static<typeof OrchestrationCapabilitySchema>;
+export declare const OrchestrationEffortSchema: Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">]>;
+export type OrchestrationEffortLiteral = Static<typeof OrchestrationEffortSchema>;
+export declare const OrchestrationRiskSchema: Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"critical">]>;
+export type OrchestrationRiskLiteral = Static<typeof OrchestrationRiskSchema>;
+export declare const OrchestrationPackageSchema: Type.TObject<{
+    readonly route: Type.TString;
+    readonly effort: Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">]>;
+    readonly contextBudget: Type.TInteger;
+    readonly model: Type.TString;
+    readonly independentFrom: Type.TOptional<Type.TArray<Type.TUnion<[Type.TLiteral<"architect">, Type.TLiteral<"technical_lead">, Type.TLiteral<"implementation_fast">, Type.TLiteral<"implementation_strong">, Type.TLiteral<"technical_review">, Type.TLiteral<"security_review">]>>>;
+}>;
+export type OrchestrationPackage = Static<typeof OrchestrationPackageSchema>;
+export declare const OrchestrationTopologySchema: Type.TObject<{
+    readonly maxDepth: Type.TInteger;
+    readonly maxWorkers: Type.TInteger;
+    readonly maxConcurrent: Type.TInteger;
+    readonly maxWorktrees: Type.TInteger;
+}>;
+export type OrchestrationTopology = Static<typeof OrchestrationTopologySchema>;
+export declare const OrchestrationRunClassSchema: Type.TObject<{
+    readonly taskClass: Type.TString;
+    readonly complexity: Type.TInteger;
+    readonly risk: Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"critical">]>;
+    readonly classificationSource: Type.TUnion<[Type.TLiteral<"deterministic">, Type.TLiteral<"classifier">, Type.TLiteral<"fallback">, Type.TLiteral<"architect">]>;
+}>;
+export type OrchestrationRunClass = Static<typeof OrchestrationRunClassSchema>;
+export declare const OrchestrationFeaturesSchema: Type.TObject<{
+    readonly adaptiveRouting: Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"observe">, Type.TLiteral<"recommend">, Type.TLiteral<"enforce">]>;
+    readonly exploration: Type.TBoolean;
+    readonly shadowRouting: Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"estimate">]>;
+    readonly budget: Type.TUnion<[Type.TLiteral<"monitor">, Type.TLiteral<"warn">, Type.TLiteral<"enforce">]>;
+    readonly budgetMicrocents: Type.TInteger;
+    readonly timeBudgetMs: Type.TInteger;
+    readonly autoMerge: Type.TLiteral<false>;
+    readonly destructiveOps: Type.TLiteral<"deny">;
+    readonly dependencyChanges: Type.TUnion<[Type.TLiteral<"deny">, Type.TLiteral<"ask">]>;
+}>;
+export type OrchestrationFeatures = Static<typeof OrchestrationFeaturesSchema>;
+export declare const OrchestrationDecisionV1Schema: Type.TObject<{
+    readonly defaultPackage: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+        readonly route: Type.TString;
+        readonly effort: Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">]>;
+        readonly contextBudget: Type.TInteger;
+        readonly model: Type.TString;
+        readonly independentFrom: Type.TOptional<Type.TArray<Type.TUnion<[Type.TLiteral<"architect">, Type.TLiteral<"technical_lead">, Type.TLiteral<"implementation_fast">, Type.TLiteral<"implementation_strong">, Type.TLiteral<"technical_review">, Type.TLiteral<"security_review">]>>>;
+    }>>>;
+    readonly recommendedPackage: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+        readonly route: Type.TString;
+        readonly effort: Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">]>;
+        readonly contextBudget: Type.TInteger;
+        readonly model: Type.TString;
+        readonly independentFrom: Type.TOptional<Type.TArray<Type.TUnion<[Type.TLiteral<"architect">, Type.TLiteral<"technical_lead">, Type.TLiteral<"implementation_fast">, Type.TLiteral<"implementation_strong">, Type.TLiteral<"technical_review">, Type.TLiteral<"security_review">]>>>;
+    }>>>;
+    readonly selected: Type.TUnion<[Type.TLiteral<"default">, Type.TLiteral<"recommended">, Type.TLiteral<"explored">, Type.TLiteral<"canary">]>;
+    readonly sampleCount: Type.TInteger;
+    readonly minSamples: Type.TInteger;
+    readonly explored: Type.TBoolean;
+    readonly canary: Type.TBoolean;
+    readonly shadowEstimate: Type.TOptional<Type.TObject<{
+        readonly costMicrocents: Type.TInteger;
+        readonly durationMs: Type.TInteger;
+    }>>;
+}>;
+export type OrchestrationDecisionV1 = Static<typeof OrchestrationDecisionV1Schema>;
+export declare const OrchestrationPolicyV1Schema: Type.TObject<{
+    readonly contractVersion: Type.TLiteral<1>;
+    readonly policyId: Type.TString;
+    readonly runClass: Type.TObject<{
+        readonly taskClass: Type.TString;
+        readonly complexity: Type.TInteger;
+        readonly risk: Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"critical">]>;
+        readonly classificationSource: Type.TUnion<[Type.TLiteral<"deterministic">, Type.TLiteral<"classifier">, Type.TLiteral<"fallback">, Type.TLiteral<"architect">]>;
+    }>;
+    readonly topology: Type.TObject<{
+        readonly maxDepth: Type.TInteger;
+        readonly maxWorkers: Type.TInteger;
+        readonly maxConcurrent: Type.TInteger;
+        readonly maxWorktrees: Type.TInteger;
+    }>;
+    readonly packages: Type.TRecord<"^.*$", Type.TObject<{
+        readonly route: Type.TString;
+        readonly effort: Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">]>;
+        readonly contextBudget: Type.TInteger;
+        readonly model: Type.TString;
+        readonly independentFrom: Type.TOptional<Type.TArray<Type.TUnion<[Type.TLiteral<"architect">, Type.TLiteral<"technical_lead">, Type.TLiteral<"implementation_fast">, Type.TLiteral<"implementation_strong">, Type.TLiteral<"technical_review">, Type.TLiteral<"security_review">]>>>;
+    }>>;
+    readonly agentCapabilities: Type.TRecord<"^.*$", Type.TUnion<[Type.TLiteral<"architect">, Type.TLiteral<"technical_lead">, Type.TLiteral<"implementation_fast">, Type.TLiteral<"implementation_strong">, Type.TLiteral<"technical_review">, Type.TLiteral<"security_review">]>>;
+    readonly escalation: Type.TArray<Type.TUnion<[Type.TLiteral<"architect">, Type.TLiteral<"technical_lead">, Type.TLiteral<"implementation_fast">, Type.TLiteral<"implementation_strong">, Type.TLiteral<"technical_review">, Type.TLiteral<"security_review">]>>;
+    readonly verification: Type.TObject<{
+        readonly depth: Type.TUnion<[Type.TLiteral<"none">, Type.TLiteral<"targeted">, Type.TLiteral<"broad">, Type.TLiteral<"full">]>;
+        readonly review: Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"sampled">, Type.TLiteral<"risk_based">, Type.TLiteral<"always">]>;
+        readonly gate: Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"on">]>;
+    }>;
+    readonly features: Type.TObject<{
+        readonly adaptiveRouting: Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"observe">, Type.TLiteral<"recommend">, Type.TLiteral<"enforce">]>;
+        readonly exploration: Type.TBoolean;
+        readonly shadowRouting: Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"estimate">]>;
+        readonly budget: Type.TUnion<[Type.TLiteral<"monitor">, Type.TLiteral<"warn">, Type.TLiteral<"enforce">]>;
+        readonly budgetMicrocents: Type.TInteger;
+        readonly timeBudgetMs: Type.TInteger;
+        readonly autoMerge: Type.TLiteral<false>;
+        readonly destructiveOps: Type.TLiteral<"deny">;
+        readonly dependencyChanges: Type.TUnion<[Type.TLiteral<"deny">, Type.TLiteral<"ask">]>;
+    }>;
+    readonly decision: Type.TObject<{
+        readonly defaultPackage: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+            readonly route: Type.TString;
+            readonly effort: Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">]>;
+            readonly contextBudget: Type.TInteger;
+            readonly model: Type.TString;
+            readonly independentFrom: Type.TOptional<Type.TArray<Type.TUnion<[Type.TLiteral<"architect">, Type.TLiteral<"technical_lead">, Type.TLiteral<"implementation_fast">, Type.TLiteral<"implementation_strong">, Type.TLiteral<"technical_review">, Type.TLiteral<"security_review">]>>>;
+        }>>>;
+        readonly recommendedPackage: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+            readonly route: Type.TString;
+            readonly effort: Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">]>;
+            readonly contextBudget: Type.TInteger;
+            readonly model: Type.TString;
+            readonly independentFrom: Type.TOptional<Type.TArray<Type.TUnion<[Type.TLiteral<"architect">, Type.TLiteral<"technical_lead">, Type.TLiteral<"implementation_fast">, Type.TLiteral<"implementation_strong">, Type.TLiteral<"technical_review">, Type.TLiteral<"security_review">]>>>;
+        }>>>;
+        readonly selected: Type.TUnion<[Type.TLiteral<"default">, Type.TLiteral<"recommended">, Type.TLiteral<"explored">, Type.TLiteral<"canary">]>;
+        readonly sampleCount: Type.TInteger;
+        readonly minSamples: Type.TInteger;
+        readonly explored: Type.TBoolean;
+        readonly canary: Type.TBoolean;
+        readonly shadowEstimate: Type.TOptional<Type.TObject<{
+            readonly costMicrocents: Type.TInteger;
+            readonly durationMs: Type.TInteger;
+        }>>;
+    }>;
+    readonly approvedDependencyChanges: Type.TOptional<Type.TArray<Type.TString>>;
+}>;
+export type OrchestrationPolicyV1 = Static<typeof OrchestrationPolicyV1Schema>;
+export declare function parseOrchestrationPolicy(value: unknown): OrchestrationPolicyV1;
+export declare const RunOrchestrationDecisionV1Schema: Type.TObject<{
+    readonly schemaVersion: Type.TLiteral<1>;
+    readonly policyId: Type.TUnion<[Type.TString, Type.TNull]>;
+    readonly contractVersion: Type.TLiteral<1>;
+    readonly runClass: Type.TUnion<[Type.TObject<{
+        readonly taskClass: Type.TString;
+        readonly complexity: Type.TInteger;
+        readonly risk: Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"critical">]>;
+        readonly classificationSource: Type.TUnion<[Type.TLiteral<"deterministic">, Type.TLiteral<"classifier">, Type.TLiteral<"fallback">, Type.TLiteral<"architect">]>;
+    }>, Type.TNull]>;
+    readonly topology: Type.TUnion<[Type.TObject<{
+        readonly maxDepth: Type.TInteger;
+        readonly maxWorkers: Type.TInteger;
+        readonly maxConcurrent: Type.TInteger;
+        readonly maxWorktrees: Type.TInteger;
+    }>, Type.TNull]>;
+    readonly decision: Type.TUnion<[Type.TObject<{
+        readonly defaultPackage: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+            readonly route: Type.TString;
+            readonly effort: Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">]>;
+            readonly contextBudget: Type.TInteger;
+            readonly model: Type.TString;
+            readonly independentFrom: Type.TOptional<Type.TArray<Type.TUnion<[Type.TLiteral<"architect">, Type.TLiteral<"technical_lead">, Type.TLiteral<"implementation_fast">, Type.TLiteral<"implementation_strong">, Type.TLiteral<"technical_review">, Type.TLiteral<"security_review">]>>>;
+        }>>>;
+        readonly recommendedPackage: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+            readonly route: Type.TString;
+            readonly effort: Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">]>;
+            readonly contextBudget: Type.TInteger;
+            readonly model: Type.TString;
+            readonly independentFrom: Type.TOptional<Type.TArray<Type.TUnion<[Type.TLiteral<"architect">, Type.TLiteral<"technical_lead">, Type.TLiteral<"implementation_fast">, Type.TLiteral<"implementation_strong">, Type.TLiteral<"technical_review">, Type.TLiteral<"security_review">]>>>;
+        }>>>;
+        readonly selected: Type.TUnion<[Type.TLiteral<"default">, Type.TLiteral<"recommended">, Type.TLiteral<"explored">, Type.TLiteral<"canary">]>;
+        readonly sampleCount: Type.TInteger;
+        readonly minSamples: Type.TInteger;
+        readonly explored: Type.TBoolean;
+        readonly canary: Type.TBoolean;
+        readonly shadowEstimate: Type.TOptional<Type.TObject<{
+            readonly costMicrocents: Type.TInteger;
+            readonly durationMs: Type.TInteger;
+        }>>;
+    }>, Type.TNull]>;
+    readonly degradationReason: Type.TUnion<[Type.TLiteral<"orchestration-unsupported">, Type.TLiteral<"orchestration-disabled">, Type.TNull]>;
+}>;
+export type RunOrchestrationDecisionV1 = Static<typeof RunOrchestrationDecisionV1Schema>;
+export declare const SubagentTaskEventSchema: Type.TUnion<[Type.TObject<{
+    readonly type: Type.TLiteral<"schedule">;
+    readonly taskId: Type.TString;
+    readonly dependsOn: Type.TArray<Type.TString>;
+    readonly ownerPaths: Type.TArray<Type.TString>;
+    readonly baseRevision: Type.TOptional<Type.TString>;
+    readonly at: Type.TInteger;
+}>, Type.TObject<{
+    readonly type: Type.TLiteral<"wait">;
+    readonly taskId: Type.TString;
+    readonly reason: Type.TLiteral<"concurrency">;
+    readonly at: Type.TInteger;
+}>, Type.TObject<{
+    readonly type: Type.TLiteral<"serialize">;
+    readonly taskId: Type.TString;
+    readonly after: Type.TArray<Type.TString>;
+    readonly at: Type.TInteger;
+}>, Type.TObject<{
+    readonly type: Type.TLiteral<"start">;
+    readonly taskId: Type.TString;
+    readonly attempt: Type.TInteger;
+    readonly at: Type.TInteger;
+}>, Type.TObject<{
+    readonly type: Type.TLiteral<"complete">;
+    readonly taskId: Type.TString;
+    readonly attempt: Type.TInteger;
+    readonly at: Type.TInteger;
+}>, Type.TObject<{
+    readonly type: Type.TLiteral<"fail">;
+    readonly taskId: Type.TString;
+    readonly attempt: Type.TInteger;
+    readonly reason: Type.TString;
+    readonly at: Type.TInteger;
+}>, Type.TObject<{
+    readonly type: Type.TLiteral<"escalate">;
+    readonly taskId: Type.TString;
+    readonly fromAttempt: Type.TInteger;
+    readonly toAttempt: Type.TInteger;
+    readonly model: Type.TOptional<Type.TString>;
+    readonly thinking: Type.TOptional<Type.TString>;
+    readonly at: Type.TInteger;
+}>, Type.TObject<{
+    readonly type: Type.TLiteral<"skip">;
+    readonly taskId: Type.TString;
+    readonly failedDependency: Type.TString;
+    readonly at: Type.TInteger;
+}>]>;
+export type SubagentTaskEvent = Static<typeof SubagentTaskEventSchema>;
+export declare function parseSubagentTaskEvent(value: unknown): SubagentTaskEvent;
+export declare const SubagentIdentityEnvelopeSchema: Type.TObject<{
+    readonly taskId: Type.TOptional<Type.TString>;
+    readonly parentTaskId: Type.TOptional<Type.TString>;
+    readonly depth: Type.TOptional<Type.TInteger>;
+}>;
+export type SubagentIdentityEnvelope = Static<typeof SubagentIdentityEnvelopeSchema>;
+export declare const SubagentWorkerStatusSchema: Type.TUnion<[Type.TLiteral<"queued">, Type.TLiteral<"waiting">, Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">, Type.TLiteral<"skipped">, Type.TLiteral<"unresolved">]>;
+export declare const SubagentCancellationOutcomeSchema: Type.TUnion<[Type.TLiteral<"none">, Type.TLiteral<"not_started">, Type.TLiteral<"direct_worker_terminated">, Type.TLiteral<"unconfirmed">]>;
+export declare const SubagentFailureKindSchema: Type.TUnion<[Type.TLiteral<"spawn_failed">, Type.TLiteral<"process_error">, Type.TLiteral<"model_error">, Type.TLiteral<"merge_failed">, Type.TNull]>;
+export declare const SubagentRunModeSchema: Type.TUnion<[Type.TLiteral<"single">, Type.TLiteral<"parallel">, Type.TLiteral<"chain">]>;
+/**
+ * Structural TypeBox description of the C1 worker. The hand-written parsers in `subagent-progress.ts` are
+ * authoritative: they also enforce lone-surrogate and edge-whitespace rules and the cross-field invariants.
+ */
+export declare const SubagentWorkerSnapshotSchema: Type.TObject<{
+    readonly workerId: Type.TString;
+    readonly attempt: Type.TInteger;
+    readonly status: Type.TUnion<[Type.TLiteral<"queued">, Type.TLiteral<"waiting">, Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">, Type.TLiteral<"skipped">, Type.TLiteral<"unresolved">]>;
+    readonly cancelRequested: Type.TBoolean;
+    readonly cancellationOutcome: Type.TUnion<[Type.TLiteral<"none">, Type.TLiteral<"not_started">, Type.TLiteral<"direct_worker_terminated">, Type.TLiteral<"unconfirmed">]>;
+    readonly agent: Type.TUnion<[Type.TString, Type.TNull]>;
+    readonly label: Type.TUnion<[Type.TString, Type.TNull]>;
+    readonly task: Type.TUnion<[Type.TString, Type.TNull]>;
+    readonly model: Type.TUnion<[Type.TString, Type.TNull]>;
+    readonly startedAt: Type.TUnion<[Type.TInteger, Type.TNull]>;
+    readonly endedAt: Type.TUnion<[Type.TInteger, Type.TNull]>;
+    readonly turns: Type.TInteger;
+    readonly toolCalls: Type.TInteger;
+    readonly failureKind: Type.TUnion<[Type.TLiteral<"spawn_failed">, Type.TLiteral<"process_error">, Type.TLiteral<"model_error">, Type.TLiteral<"merge_failed">, Type.TNull]>;
+    readonly resultPreview: Type.TUnion<[Type.TString, Type.TNull]>;
+}>;
+export declare const SubagentRunSnapshotSchema: Type.TObject<{
+    readonly runId: Type.TString;
+    readonly seq: Type.TInteger;
+    readonly final: Type.TBoolean;
+    readonly workers: Type.TArray<Type.TObject<{
+        readonly workerId: Type.TString;
+        readonly attempt: Type.TInteger;
+        readonly status: Type.TUnion<[Type.TLiteral<"queued">, Type.TLiteral<"waiting">, Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">, Type.TLiteral<"skipped">, Type.TLiteral<"unresolved">]>;
+        readonly cancelRequested: Type.TBoolean;
+        readonly cancellationOutcome: Type.TUnion<[Type.TLiteral<"none">, Type.TLiteral<"not_started">, Type.TLiteral<"direct_worker_terminated">, Type.TLiteral<"unconfirmed">]>;
+        readonly agent: Type.TUnion<[Type.TString, Type.TNull]>;
+        readonly label: Type.TUnion<[Type.TString, Type.TNull]>;
+        readonly task: Type.TUnion<[Type.TString, Type.TNull]>;
+        readonly model: Type.TUnion<[Type.TString, Type.TNull]>;
+        readonly startedAt: Type.TUnion<[Type.TInteger, Type.TNull]>;
+        readonly endedAt: Type.TUnion<[Type.TInteger, Type.TNull]>;
+        readonly turns: Type.TInteger;
+        readonly toolCalls: Type.TInteger;
+        readonly failureKind: Type.TUnion<[Type.TLiteral<"spawn_failed">, Type.TLiteral<"process_error">, Type.TLiteral<"model_error">, Type.TLiteral<"merge_failed">, Type.TNull]>;
+        readonly resultPreview: Type.TUnion<[Type.TString, Type.TNull]>;
+    }>>;
+    readonly toolCallId: Type.TUnion<[Type.TString, Type.TNull]>;
+    readonly mode: Type.TUnion<[Type.TLiteral<"single">, Type.TLiteral<"parallel">, Type.TLiteral<"chain">]>;
+    readonly startedAt: Type.TInteger;
+    readonly endedAt: Type.TUnion<[Type.TInteger, Type.TNull]>;
+}>;
+export declare const SubagentProgressSnapshotSchema: Type.TObject<{
+    readonly schemaVersion: Type.TLiteral<1>;
+    readonly runtimeId: Type.TString;
+    readonly sessionEpoch: Type.TString;
+    readonly complete: Type.TBoolean;
+    readonly runs: Type.TArray<Type.TObject<{
+        readonly runId: Type.TString;
+        readonly seq: Type.TInteger;
+        readonly final: Type.TBoolean;
+        readonly workers: Type.TArray<Type.TObject<{
+            readonly workerId: Type.TString;
+            readonly attempt: Type.TInteger;
+            readonly status: Type.TUnion<[Type.TLiteral<"queued">, Type.TLiteral<"waiting">, Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">, Type.TLiteral<"skipped">, Type.TLiteral<"unresolved">]>;
+            readonly cancelRequested: Type.TBoolean;
+            readonly cancellationOutcome: Type.TUnion<[Type.TLiteral<"none">, Type.TLiteral<"not_started">, Type.TLiteral<"direct_worker_terminated">, Type.TLiteral<"unconfirmed">]>;
+            readonly agent: Type.TUnion<[Type.TString, Type.TNull]>;
+            readonly label: Type.TUnion<[Type.TString, Type.TNull]>;
+            readonly task: Type.TUnion<[Type.TString, Type.TNull]>;
+            readonly model: Type.TUnion<[Type.TString, Type.TNull]>;
+            readonly startedAt: Type.TUnion<[Type.TInteger, Type.TNull]>;
+            readonly endedAt: Type.TUnion<[Type.TInteger, Type.TNull]>;
+            readonly turns: Type.TInteger;
+            readonly toolCalls: Type.TInteger;
+            readonly failureKind: Type.TUnion<[Type.TLiteral<"spawn_failed">, Type.TLiteral<"process_error">, Type.TLiteral<"model_error">, Type.TLiteral<"merge_failed">, Type.TNull]>;
+            readonly resultPreview: Type.TUnion<[Type.TString, Type.TNull]>;
+        }>>;
+        readonly toolCallId: Type.TUnion<[Type.TString, Type.TNull]>;
+        readonly mode: Type.TUnion<[Type.TLiteral<"single">, Type.TLiteral<"parallel">, Type.TLiteral<"chain">]>;
+        readonly startedAt: Type.TInteger;
+        readonly endedAt: Type.TUnion<[Type.TInteger, Type.TNull]>;
+    }>>;
+}>;
+//# sourceMappingURL=orchestration.d.ts.map

package/dist/orchestration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestration.d.ts","sourceRoot":"","sources":["../src/orchestration.ts"],"names":[],"mappings":"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"}

package/dist/orchestration.js

@@ -0,0 +1,307 @@
+import { Type } from "typebox";
+import { Compile } from "typebox/compile";
+import { SUBAGENT_CANCELLATION_OUTCOMES, SUBAGENT_FAILURE_KINDS, SUBAGENT_PROGRESS_AGENT_MAX_CODE_UNITS, SUBAGENT_PROGRESS_IDENTIFIER_PATTERN, SUBAGENT_PROGRESS_MAX_RUNS, SUBAGENT_PROGRESS_MAX_WORKERS_PER_RUN, SUBAGENT_PROGRESS_MODEL_MAX_CODE_UNITS, SUBAGENT_PROGRESS_MODEL_PATTERN, SUBAGENT_PROGRESS_RESULT_PREVIEW_MAX_CODE_UNITS, SUBAGENT_PROGRESS_SCHEMA_VERSION, SUBAGENT_PROGRESS_TASK_MAX_CODE_UNITS, SUBAGENT_PROGRESS_TEXT_PATTERN, SUBAGENT_PROGRESS_TOOL_CALL_ID_MAX_CODE_UNITS, SUBAGENT_PROGRESS_TOOL_CALL_ID_PATTERN, SUBAGENT_PROGRESS_UUID_PATTERN, SUBAGENT_RUN_MODES, SUBAGENT_WORKER_STATUSES, } from "./subagent-progress.js";
+export * from "./subagent-progress.js";
+const StrictObject = (properties) => Type.Object(properties, { additionalProperties: false });
+const PositiveInteger = Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER });
+const NonnegativeInteger = Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER });
+const Digest = Type.String({ pattern: "^[a-f0-9]{64}$" });
+export const ORCHESTRATION_CONTRACT_VERSION = 1;
+export const ORCHESTRATION_CAPABILITIES = [
+    "architect",
+    "technical_lead",
+    "implementation_fast",
+    "implementation_strong",
+    "technical_review",
+    "security_review",
+];
+export const ORCHESTRATION_EFFORTS = ["low", "medium", "high"];
+export const ORCHESTRATION_RISKS = ["low", "medium", "high", "critical"];
+export const OrchestrationCapabilitySchema = Type.Union([
+    Type.Literal(ORCHESTRATION_CAPABILITIES[0]),
+    Type.Literal(ORCHESTRATION_CAPABILITIES[1]),
+    Type.Literal(ORCHESTRATION_CAPABILITIES[2]),
+    Type.Literal(ORCHESTRATION_CAPABILITIES[3]),
+    Type.Literal(ORCHESTRATION_CAPABILITIES[4]),
+    Type.Literal(ORCHESTRATION_CAPABILITIES[5]),
+]);
+export const OrchestrationEffortSchema = Type.Union([
+    Type.Literal(ORCHESTRATION_EFFORTS[0]),
+    Type.Literal(ORCHESTRATION_EFFORTS[1]),
+    Type.Literal(ORCHESTRATION_EFFORTS[2]),
+]);
+export const OrchestrationRiskSchema = Type.Union([
+    Type.Literal(ORCHESTRATION_RISKS[0]),
+    Type.Literal(ORCHESTRATION_RISKS[1]),
+    Type.Literal(ORCHESTRATION_RISKS[2]),
+    Type.Literal(ORCHESTRATION_RISKS[3]),
+]);
+export const OrchestrationPackageSchema = StrictObject({
+    route: Type.String({ minLength: 1 }),
+    effort: OrchestrationEffortSchema,
+    contextBudget: PositiveInteger,
+    model: Type.String({ minLength: 1 }),
+    independentFrom: Type.Optional(Type.Array(OrchestrationCapabilitySchema)),
+});
+export const OrchestrationTopologySchema = StrictObject({
+    maxDepth: Type.Integer({ minimum: 1, maximum: 3 }),
+    maxWorkers: Type.Integer({ minimum: 1, maximum: 16 }),
+    maxConcurrent: Type.Integer({ minimum: 1, maximum: 8 }),
+    maxWorktrees: Type.Integer({ minimum: 0, maximum: 8 }),
+});
+export const OrchestrationRunClassSchema = StrictObject({
+    taskClass: Type.String({ minLength: 1 }),
+    complexity: Type.Integer({ minimum: 1, maximum: 10 }),
+    risk: OrchestrationRiskSchema,
+    classificationSource: Type.Union([
+        Type.Literal("deterministic"),
+        Type.Literal("classifier"),
+        Type.Literal("fallback"),
+        Type.Literal("architect"),
+    ]),
+});
+export const OrchestrationFeaturesSchema = StrictObject({
+    adaptiveRouting: Type.Union([
+        Type.Literal("off"),
+        Type.Literal("observe"),
+        Type.Literal("recommend"),
+        Type.Literal("enforce"),
+    ]),
+    exploration: Type.Boolean(),
+    shadowRouting: Type.Union([Type.Literal("off"), Type.Literal("estimate")]),
+    budget: Type.Union([Type.Literal("monitor"), Type.Literal("warn"), Type.Literal("enforce")]),
+    budgetMicrocents: NonnegativeInteger,
+    timeBudgetMs: NonnegativeInteger,
+    autoMerge: Type.Literal(false),
+    destructiveOps: Type.Literal("deny"),
+    dependencyChanges: Type.Union([Type.Literal("deny"), Type.Literal("ask")]),
+});
+export const OrchestrationDecisionV1Schema = StrictObject({
+    defaultPackage: Type.Optional(Type.Record(Type.String(), OrchestrationPackageSchema)),
+    recommendedPackage: Type.Optional(Type.Record(Type.String(), OrchestrationPackageSchema)),
+    selected: Type.Union([
+        Type.Literal("default"),
+        Type.Literal("recommended"),
+        Type.Literal("explored"),
+        Type.Literal("canary"),
+    ]),
+    sampleCount: NonnegativeInteger,
+    minSamples: PositiveInteger,
+    explored: Type.Boolean(),
+    canary: Type.Boolean(),
+    shadowEstimate: Type.Optional(StrictObject({ costMicrocents: NonnegativeInteger, durationMs: NonnegativeInteger })),
+});
+export const OrchestrationPolicyV1Schema = StrictObject({
+    contractVersion: Type.Literal(ORCHESTRATION_CONTRACT_VERSION),
+    policyId: Digest,
+    runClass: OrchestrationRunClassSchema,
+    topology: OrchestrationTopologySchema,
+    packages: Type.Record(Type.String(), OrchestrationPackageSchema),
+    agentCapabilities: Type.Record(Type.String(), OrchestrationCapabilitySchema),
+    escalation: Type.Array(OrchestrationCapabilitySchema),
+    verification: StrictObject({
+        depth: Type.Union([Type.Literal("none"), Type.Literal("targeted"), Type.Literal("broad"), Type.Literal("full")]),
+        review: Type.Union([
+            Type.Literal("off"),
+            Type.Literal("sampled"),
+            Type.Literal("risk_based"),
+            Type.Literal("always"),
+        ]),
+        gate: Type.Union([Type.Literal("off"), Type.Literal("on")]),
+    }),
+    features: OrchestrationFeaturesSchema,
+    decision: OrchestrationDecisionV1Schema,
+    approvedDependencyChanges: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+});
+const OrchestrationPolicyValidator = Compile(OrchestrationPolicyV1Schema);
+const ORCHESTRATION_CAPABILITY_SET = new Set(ORCHESTRATION_CAPABILITIES);
+export function parseOrchestrationPolicy(value) {
+    if (!OrchestrationPolicyValidator.Check(value)) {
+        throw new Error("Invalid orchestration policy");
+    }
+    if (Object.keys(value.packages).some((capability) => !ORCHESTRATION_CAPABILITY_SET.has(capability))) {
+        throw new Error("Invalid orchestration policy: packages keyed by an unknown capability");
+    }
+    return deepFreeze(structuredClone(value));
+}
+export const RunOrchestrationDecisionV1Schema = StrictObject({
+    schemaVersion: Type.Literal(1),
+    policyId: Type.Union([Digest, Type.Null()]),
+    contractVersion: Type.Literal(ORCHESTRATION_CONTRACT_VERSION),
+    runClass: Type.Union([OrchestrationRunClassSchema, Type.Null()]),
+    topology: Type.Union([OrchestrationTopologySchema, Type.Null()]),
+    decision: Type.Union([OrchestrationDecisionV1Schema, Type.Null()]),
+    degradationReason: Type.Union([
+        Type.Literal("orchestration-unsupported"),
+        Type.Literal("orchestration-disabled"),
+        Type.Null(),
+    ]),
+});
+// Runtime -> host wire shapes, mirroring packages/coding-agent/src/core/tools/subagent.ts
+// (SubagentTaskEvent) and src/modes/json-event.ts (OrchestrationEnvelope). Field names
+// match the runtime exactly.
+export const SubagentTaskEventSchema = Type.Union([
+    StrictObject({
+        type: Type.Literal("schedule"),
+        taskId: Type.String(),
+        dependsOn: Type.Array(Type.String()),
+        ownerPaths: Type.Array(Type.String()),
+        baseRevision: Type.Optional(Type.String()),
+        at: NonnegativeInteger,
+    }),
+    StrictObject({
+        type: Type.Literal("wait"),
+        taskId: Type.String(),
+        reason: Type.Literal("concurrency"),
+        at: NonnegativeInteger,
+    }),
+    StrictObject({
+        type: Type.Literal("serialize"),
+        taskId: Type.String(),
+        after: Type.Array(Type.String()),
+        at: NonnegativeInteger,
+    }),
+    StrictObject({
+        type: Type.Literal("start"),
+        taskId: Type.String(),
+        attempt: PositiveInteger,
+        at: NonnegativeInteger,
+    }),
+    StrictObject({
+        type: Type.Literal("complete"),
+        taskId: Type.String(),
+        attempt: PositiveInteger,
+        at: NonnegativeInteger,
+    }),
+    StrictObject({
+        type: Type.Literal("fail"),
+        taskId: Type.String(),
+        attempt: PositiveInteger,
+        reason: Type.String(),
+        at: NonnegativeInteger,
+    }),
+    StrictObject({
+        type: Type.Literal("escalate"),
+        taskId: Type.String(),
+        fromAttempt: PositiveInteger,
+        toAttempt: PositiveInteger,
+        model: Type.Optional(Type.String()),
+        thinking: Type.Optional(Type.String()),
+        at: NonnegativeInteger,
+    }),
+    StrictObject({
+        type: Type.Literal("skip"),
+        taskId: Type.String(),
+        failedDependency: Type.String(),
+        at: NonnegativeInteger,
+    }),
+]);
+const SubagentTaskEventValidator = Compile(SubagentTaskEventSchema);
+export function parseSubagentTaskEvent(value) {
+    if (!SubagentTaskEventValidator.Check(value)) {
+        throw new Error("Invalid subagent task event");
+    }
+    return deepFreeze(structuredClone(value));
+}
+export const SubagentIdentityEnvelopeSchema = StrictObject({
+    taskId: Type.Optional(Type.String({ minLength: 1 })),
+    parentTaskId: Type.Optional(Type.String({ minLength: 1 })),
+    depth: Type.Optional(Type.Integer({ minimum: 1, maximum: 3 })),
+});
+const ProgressUuid = Type.String({
+    pattern: SUBAGENT_PROGRESS_UUID_PATTERN,
+    minLength: 36,
+    maxLength: 36,
+});
+const Nullable = (schema) => Type.Union([schema, Type.Null()]);
+const ProgressIdentifier = Nullable(Type.String({
+    pattern: SUBAGENT_PROGRESS_IDENTIFIER_PATTERN,
+    minLength: 1,
+    maxLength: SUBAGENT_PROGRESS_AGENT_MAX_CODE_UNITS,
+}));
+const ProgressModel = Nullable(Type.String({
+    pattern: SUBAGENT_PROGRESS_MODEL_PATTERN,
+    minLength: 1,
+    maxLength: SUBAGENT_PROGRESS_MODEL_MAX_CODE_UNITS,
+}));
+const ProgressToolCallId = Nullable(Type.String({
+    pattern: SUBAGENT_PROGRESS_TOOL_CALL_ID_PATTERN,
+    minLength: 1,
+    maxLength: SUBAGENT_PROGRESS_TOOL_CALL_ID_MAX_CODE_UNITS,
+}));
+const ProgressText = (maxLength) => Nullable(Type.String({ pattern: SUBAGENT_PROGRESS_TEXT_PATTERN, minLength: 1, maxLength }));
+export const SubagentWorkerStatusSchema = Type.Union([
+    Type.Literal(SUBAGENT_WORKER_STATUSES[0]),
+    Type.Literal(SUBAGENT_WORKER_STATUSES[1]),
+    Type.Literal(SUBAGENT_WORKER_STATUSES[2]),
+    Type.Literal(SUBAGENT_WORKER_STATUSES[3]),
+    Type.Literal(SUBAGENT_WORKER_STATUSES[4]),
+    Type.Literal(SUBAGENT_WORKER_STATUSES[5]),
+    Type.Literal(SUBAGENT_WORKER_STATUSES[6]),
+    Type.Literal(SUBAGENT_WORKER_STATUSES[7]),
+]);
+export const SubagentCancellationOutcomeSchema = Type.Union([
+    Type.Literal(SUBAGENT_CANCELLATION_OUTCOMES[0]),
+    Type.Literal(SUBAGENT_CANCELLATION_OUTCOMES[1]),
+    Type.Literal(SUBAGENT_CANCELLATION_OUTCOMES[2]),
+    Type.Literal(SUBAGENT_CANCELLATION_OUTCOMES[3]),
+]);
+export const SubagentFailureKindSchema = Type.Union([
+    Type.Literal(SUBAGENT_FAILURE_KINDS[0]),
+    Type.Literal(SUBAGENT_FAILURE_KINDS[1]),
+    Type.Literal(SUBAGENT_FAILURE_KINDS[2]),
+    Type.Literal(SUBAGENT_FAILURE_KINDS[3]),
+    Type.Null(),
+]);
+export const SubagentRunModeSchema = Type.Union([
+    Type.Literal(SUBAGENT_RUN_MODES[0]),
+    Type.Literal(SUBAGENT_RUN_MODES[1]),
+    Type.Literal(SUBAGENT_RUN_MODES[2]),
+]);
+/**
+ * Structural TypeBox description of the C1 worker. The hand-written parsers in `subagent-progress.ts` are
+ * authoritative: they also enforce lone-surrogate and edge-whitespace rules and the cross-field invariants.
+ */
+export const SubagentWorkerSnapshotSchema = StrictObject({
+    workerId: ProgressUuid,
+    attempt: NonnegativeInteger,
+    status: SubagentWorkerStatusSchema,
+    cancelRequested: Type.Boolean(),
+    cancellationOutcome: SubagentCancellationOutcomeSchema,
+    agent: ProgressIdentifier,
+    label: ProgressIdentifier,
+    task: ProgressText(SUBAGENT_PROGRESS_TASK_MAX_CODE_UNITS),
+    model: ProgressModel,
+    startedAt: Nullable(NonnegativeInteger),
+    endedAt: Nullable(NonnegativeInteger),
+    turns: NonnegativeInteger,
+    toolCalls: NonnegativeInteger,
+    failureKind: SubagentFailureKindSchema,
+    resultPreview: ProgressText(SUBAGENT_PROGRESS_RESULT_PREVIEW_MAX_CODE_UNITS),
+});
+export const SubagentRunSnapshotSchema = StrictObject({
+    runId: ProgressUuid,
+    seq: PositiveInteger,
+    final: Type.Boolean(),
+    workers: Type.Array(SubagentWorkerSnapshotSchema, { maxItems: SUBAGENT_PROGRESS_MAX_WORKERS_PER_RUN }),
+    toolCallId: ProgressToolCallId,
+    mode: SubagentRunModeSchema,
+    startedAt: NonnegativeInteger,
+    endedAt: Nullable(NonnegativeInteger),
+});
+export const SubagentProgressSnapshotSchema = StrictObject({
+    schemaVersion: Type.Literal(SUBAGENT_PROGRESS_SCHEMA_VERSION),
+    runtimeId: ProgressUuid,
+    sessionEpoch: ProgressUuid,
+    complete: Type.Boolean(),
+    runs: Type.Array(SubagentRunSnapshotSchema, { maxItems: SUBAGENT_PROGRESS_MAX_RUNS }),
+});
+function deepFreeze(value) {
+    if (value === null || typeof value !== "object" || Object.isFrozen(value))
+        return value;
+    Object.freeze(value);
+    for (const child of Object.values(value))
+        deepFreeze(child);
+    return value;
+}
+//# sourceMappingURL=orchestration.js.map