cohorte 2.10.1 → 3.0.0-dev.1

package/dist/chunks/schema-C9QbUW4H.mjs

@@ -0,0 +1,578 @@
+import { n as sha256Hex, t as canonicalJson } from "./canonical-C8UxeEmB.mjs";
+import { S as IsoInstant, T as Sha256, d as ModelRef, l as AuthMode, p as ThinkingLevel, t as BudgetCounters, u as ModelCapability, x as ID_PATTERN } from "./src-Cu3TxNob.mjs";
+import { d as EscalationPolicy, u as ActivePipelineState } from "./src-s7YRvk0t.mjs";
+import { Type } from "typebox";
+//#region ../../packages/config/src/schema/policy.ts
+const closed$5 = { additionalProperties: false };
+const tokens = () => Type.Array(Type.String({ minLength: 1 }));
+const max = () => Type.Integer({ minimum: 0 });
+const CommandRuleSchema = Type.Object({
+	id: Type.String({ minLength: 1 }),
+	program: Type.String({ pattern: "^[^/\\\\\\s]+$" }),
+	subcommand: Type.Optional(tokens()),
+	flags: Type.Optional(Type.Object({
+		allow: tokens(),
+		deny: Type.Optional(tokens())
+	}, closed$5)),
+	positionals: Type.Optional(Type.Union([
+		Type.Object({ kind: Type.Literal("none") }, closed$5),
+		Type.Object({
+			kind: Type.Literal("paths-in-worktree"),
+			max: max()
+		}, closed$5),
+		Type.Object({
+			kind: Type.Literal("enum"),
+			values: tokens(),
+			max: max()
+		}, closed$5),
+		Type.Object({
+			kind: Type.Literal("exact"),
+			values: Type.Array(Type.String())
+		}, closed$5)
+	])),
+	decision: Type.Union([
+		Type.Literal("allow"),
+		Type.Literal("ask"),
+		Type.Literal("deny")
+	]),
+	when: Type.Optional(Type.Object({
+		branch: Type.Optional(Type.Union([Type.Literal("any"), Type.Literal("unprotected-only")])),
+		roles: Type.Optional(tokens()),
+		phases: Type.Optional(tokens())
+	}, closed$5)),
+	replay: Type.Union([Type.Literal("idempotent"), Type.Literal("at-most-once")]),
+	network: Type.Boolean(),
+	origin: Type.Union([
+		Type.Literal("builtin"),
+		Type.Literal("project-config"),
+		Type.Literal("project-checks")
+	])
+}, closed$5);
+/** [S]. The explicit annotation keeps Biome's type inference out of the union (docs/v3/requests/U0.02.md R1). */
+const CommandRule = Type.Unsafe(CommandRuleSchema);
+/** [S] DESIGN 2.6.3. Default: deny-outgoing + deny. */
+const SymlinkPolicy = Type.Object({
+	mode: Type.Union([
+		Type.Literal("deny-outgoing"),
+		Type.Literal("deny-all"),
+		Type.Literal("allow")
+	]),
+	hardlinksOnWrite: Type.Union([Type.Literal("deny"), Type.Literal("allow")])
+}, closed$5);
+Type.Object({ default: Type.Literal("deny") }, closed$5);
+const DEFAULT_SYMLINK_POLICY = Object.freeze({
+	mode: "deny-outgoing",
+	hardlinksOnWrite: "deny"
+});
+const DEFAULT_NETWORK_POLICY = Object.freeze({ default: "deny" });
+//#endregion
+//#region ../../packages/config/src/schema/config.ts
+const closed$4 = { additionalProperties: false };
+const oneOf = (values) => Type.Unsafe({
+	type: "string",
+	enum: [...values]
+});
+const count = (minimum = 0) => Type.Integer({ minimum });
+const argv = () => Type.Array(Type.String(), { minItems: 1 });
+const strings = () => Type.Array(Type.String({ minLength: 1 }));
+const rules = () => Type.Array(CommandRule);
+const budgetMap = () => Type.Unsafe(Type.Record(Type.String(), BudgetCounters));
+const roleDefaults = () => Type.Unsafe(Type.Record(Type.String(), ModelCapability));
+const tier = () => Type.Optional(Type.Object({
+	ref: ModelRef,
+	thinking: ThinkingLevel
+}, closed$4));
+const envValue = () => Type.Optional(Type.String({ minLength: 1 }));
+const leftover = () => oneOf([
+	"fix",
+	"park",
+	"ask"
+]);
+const CohorteConfigSchema = Type.Object({
+	schemaVersion: Type.Literal(1),
+	project: Type.Object({
+		id: Type.String({ pattern: ID_PATTERN }),
+		defaultBranch: Type.String({ minLength: 1 }),
+		protectedBranches: strings()
+	}, closed$4),
+	runtime: Type.Object({
+		id: Type.String({ minLength: 1 }),
+		pi: Type.Optional(Type.Object({ loadFrom: oneOf(["package", "bundle"]) }, closed$4))
+	}, closed$4),
+	authentication: Type.Object({
+		mode: AuthMode,
+		allowApiKeys: Type.Boolean(),
+		anthropicSubscriptionViaPi: Type.Optional(Type.Object({
+			enabled: Type.Boolean(),
+			acknowledgePerTokenBilling: Type.Boolean(),
+			acknowledgeProviderTermsRisk: Type.Boolean()
+		}, closed$4))
+	}, closed$4),
+	routing: Type.Object({
+		allowedProviders: strings(),
+		defaults: roleDefaults(),
+		tiers: Type.Object({
+			fast: tier(),
+			coding: tier(),
+			reasoning: tier(),
+			vision: tier(),
+			cheap: tier()
+		}, closed$4),
+		escalation: EscalationPolicy,
+		fallback: Type.Object({ enabled: Type.Boolean() }, closed$4)
+	}, closed$4),
+	budgets: Type.Object({
+		run: BudgetCounters,
+		phase: BudgetCounters,
+		agent: BudgetCounters,
+		provider: budgetMap(),
+		tool: budgetMap(),
+		concurrency: count(1),
+		maxIncarnations: count(1)
+	}, closed$4),
+	loop: Type.Object({
+		maxFixRounds: count(),
+		noProgressWindow: count(1),
+		maxDeniedCallsPerAgent: count(),
+		leftovers: Type.Object({
+			major: leftover(),
+			minor: leftover(),
+			info: leftover()
+		}, closed$4)
+	}, closed$4),
+	checks: Type.Object({
+		typecheck: Type.Optional(argv()),
+		lint: Type.Optional(argv()),
+		test: Type.Optional(argv()),
+		timeoutMs: count(1)
+	}, closed$4),
+	provision: Type.Object({
+		argv: Type.Optional(argv()),
+		network: Type.Boolean(),
+		cacheDirs: strings(),
+		lockfiles: strings(),
+		env: Type.Object({
+			npm_config_store_dir: envValue(),
+			npm_config_cache: envValue(),
+			YARN_CACHE_FOLDER: envValue(),
+			COREPACK_HOME: envValue()
+		}, closed$4),
+		dependencyDirs: strings(),
+		writableCaches: strings()
+	}, closed$4),
+	policy: Type.Object({
+		commands: Type.Object({
+			allow: rules(),
+			ask: rules(),
+			deny: rules()
+		}, closed$4),
+		dangerousCommands: rules(),
+		symlinks: SymlinkPolicy,
+		approvals: Type.Object({
+			unattended: oneOf(["deny", "wait"]),
+			expiryMinutes: Type.Optional(count(1)),
+			parkAfterMinutes: count(),
+			ship: oneOf(["human", "auto"]),
+			notify: Type.Boolean(),
+			autoResume: Type.Boolean()
+		}, closed$4),
+		inDoubt: oneOf(["ask", "continue"]),
+		skip: Type.Array(ActivePipelineState),
+		steer: Type.Object({ enabled: Type.Boolean() }, closed$4),
+		admin: Type.Object({ runTool: Type.Boolean() }, closed$4),
+		quota: Type.Object({ autoResume: Type.Boolean() }, closed$4)
+	}, closed$4),
+	host: Type.Object({
+		idleExitMinutes: count(),
+		pauseKeepAliveMinutes: count(),
+		pollMs: count(1)
+	}, closed$4),
+	network: Type.Object({ proxyEnv: Type.Boolean() }, closed$4),
+	sandbox: Type.Object({
+		require: Type.Optional(oneOf(["native", "best-effort"])),
+		brain: oneOf([
+			"os-if-available",
+			"os",
+			"process"
+		])
+	}, closed$4),
+	git: Type.Object({
+		worktreeRoot: Type.Optional(Type.String({ minLength: 1 })),
+		branchPrefix: Type.String({ minLength: 1 }),
+		commitIdentity: oneOf(["user", "cohorte"]),
+		keepWorktrees: oneOf([
+			"on-failure",
+			"always",
+			"never"
+		])
+	}, closed$4),
+	retention: Type.Object({
+		transcriptsDays: count(),
+		eventsDays: Type.Union([count(), Type.Literal("forever")]),
+		artifactsDays: count(),
+		compressAfterDays: count()
+	}, closed$4),
+	telemetry: Type.Object({ remote: Type.Boolean() }, closed$4)
+}, closed$4);
+/** [S]. Annotated on purpose: Biome must not infer this type (docs/v3/requests/U0.02.md R1, U0.05.md R1). */
+const CohorteConfig = Type.Unsafe(CohorteConfigSchema);
+function deepFreeze(value) {
+	if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		for (const member of Object.values(value)) deepFreeze(member);
+	}
+	return value;
+}
+const MINUTE = 6e4;
+/**
+* The lowest layer of the load order (DESIGN 2.10): shipped defaults < user file < project file < CLI flags.
+* `project.id` is a placeholder that `cohorte init` always replaces. DESIGN gives the numbers it cares about
+* (concurrency 3, maxIncarnations 5, loop 5/3/5, host 30/30/250, parkAfterMinutes 10); the budget and retention
+* figures are provisional defaults of this file.
+*/
+const DEFAULT_CONFIG = deepFreeze({
+	schemaVersion: 1,
+	project: {
+		id: "project",
+		defaultBranch: "main",
+		protectedBranches: ["main", "master"]
+	},
+	runtime: {
+		id: "pi",
+		pi: { loadFrom: "package" }
+	},
+	authentication: {
+		mode: "subscription",
+		allowApiKeys: false
+	},
+	routing: {
+		allowedProviders: ["openai-codex"],
+		defaults: {
+			implementer: "coding",
+			fixer: "coding",
+			reviewer: "reasoning",
+			"security-reviewer": "reasoning"
+		},
+		tiers: {
+			coding: {
+				ref: {
+					provider: "openai-codex",
+					model: "gpt-5.5",
+					capability: "coding"
+				},
+				thinking: "medium"
+			},
+			reasoning: {
+				ref: {
+					provider: "openai-codex",
+					model: "gpt-5.5",
+					capability: "reasoning"
+				},
+				thinking: "high"
+			},
+			fast: {
+				ref: {
+					provider: "openai-codex",
+					model: "gpt-5.4-mini",
+					capability: "fast"
+				},
+				thinking: "low"
+			},
+			cheap: {
+				ref: {
+					provider: "openai-codex",
+					model: "gpt-5.4-mini",
+					capability: "cheap"
+				},
+				thinking: "low"
+			}
+		},
+		escalation: {
+			sameFailureCount: 2,
+			ladder: [{ kind: "human" }],
+			maxPerRun: 2
+		},
+		fallback: { enabled: false }
+	},
+	budgets: {
+		run: {
+			modelRequests: 2e3,
+			toolCalls: 1e4,
+			wallClockMs: 360 * MINUTE
+		},
+		phase: { wallClockMs: 120 * MINUTE },
+		agent: {
+			modelRequests: 200,
+			toolCalls: 400,
+			wallClockMs: 45 * MINUTE,
+			contextTokens: 2e5
+		},
+		provider: {},
+		tool: {},
+		concurrency: 3,
+		maxIncarnations: 5
+	},
+	loop: {
+		maxFixRounds: 5,
+		noProgressWindow: 3,
+		maxDeniedCallsPerAgent: 5,
+		leftovers: {
+			major: "fix",
+			minor: "park",
+			info: "park"
+		}
+	},
+	checks: { timeoutMs: 10 * MINUTE },
+	provision: {
+		network: false,
+		cacheDirs: [],
+		lockfiles: [
+			"pnpm-lock.yaml",
+			"package-lock.json",
+			"yarn.lock"
+		],
+		env: {},
+		dependencyDirs: ["**/node_modules"],
+		writableCaches: [
+			"node_modules/.cache",
+			"node_modules/.vite",
+			"node_modules/.vitest",
+			"node_modules/.vite-temp"
+		]
+	},
+	policy: {
+		commands: {
+			allow: [],
+			ask: [],
+			deny: []
+		},
+		dangerousCommands: [],
+		symlinks: { ...DEFAULT_SYMLINK_POLICY },
+		approvals: {
+			unattended: "deny",
+			parkAfterMinutes: 10,
+			ship: "human",
+			notify: false,
+			autoResume: false
+		},
+		inDoubt: "ask",
+		skip: [],
+		steer: { enabled: false },
+		admin: { runTool: false },
+		quota: { autoResume: false }
+	},
+	host: {
+		idleExitMinutes: 30,
+		pauseKeepAliveMinutes: 30,
+		pollMs: 250
+	},
+	network: { proxyEnv: false },
+	sandbox: { brain: "os-if-available" },
+	git: {
+		branchPrefix: "cohorte/",
+		commitIdentity: "user",
+		keepWorktrees: "on-failure"
+	},
+	retention: {
+		transcriptsDays: 30,
+		eventsDays: "forever",
+		artifactsDays: 90,
+		compressAfterDays: 7
+	},
+	telemetry: { remote: false }
+});
+//#endregion
+//#region ../../packages/config/src/schema/manifest.ts
+const closed$3 = { additionalProperties: false };
+const GeneratedFile = Type.Object({
+	/** `.cohorte`-relative POSIX path */
+	path: Type.String({ minLength: 1 }),
+	templateId: Type.String({ minLength: 1 }),
+	templateSha256: Sha256,
+	/** a generated file is replaced only if its CURRENT hash equals this one */
+	renderedSha256: Sha256
+}, closed$3);
+Type.Object({
+	schemaVersion: Type.Literal(1),
+	cohorteVersion: Type.String({ minLength: 1 }),
+	createdWith: Type.String({ minLength: 1 }),
+	protocol: Type.Object({
+		min: Type.String({ minLength: 1 }),
+		max: Type.String({ minLength: 1 })
+	}, closed$3),
+	stateSchemaVersion: Type.Integer({ minimum: 0 }),
+	generated: Type.Array(GeneratedFile)
+}, closed$3);
+//#endregion
+//#region ../../packages/config/src/schema/ownership.ts
+const closed$2 = { additionalProperties: false };
+const names$1 = () => Type.Array(Type.String({ minLength: 1 }));
+const SurfaceSchema = Type.Object({
+	paths: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+	owners: names$1(),
+	reviewers: names$1(),
+	approval: Type.Optional(Type.Literal("human"))
+}, closed$2);
+const OwnershipSchema = Type.Object({ surfaces: Type.Record(Type.String({ pattern: ID_PATTERN }), SurfaceSchema) }, closed$2);
+/** [S]. Annotated: a `Static<TRecord>` inferred by Biome overflows its stack (docs/v3/requests/U0.03.md R1). */
+const Ownership = Type.Unsafe(OwnershipSchema);
+const GLOB_META = /[*?[\]{}()!]/;
+/** The literal prefix of a glob, by path SEGMENT: the segments before the first one holding a glob metacharacter (DESIGN 5.6). */
+function literalPrefixOf(pattern) {
+	const prefix = [];
+	for (const segment of pattern.split("/")) {
+		if (segment === "" || segment === ".") continue;
+		if (GLOB_META.test(segment)) break;
+		prefix.push(segment);
+	}
+	return prefix;
+}
+//#endregion
+//#region ../../packages/config/src/schema/skill.ts
+const closed$1 = { additionalProperties: false };
+const names = () => Type.Optional(Type.Array(Type.String({ minLength: 1 })));
+Type.Object({
+	id: Type.String({ pattern: ID_PATTERN }),
+	version: Type.String({ minLength: 1 }),
+	/** matched against the Project Model, deterministically */
+	appliesWhen: Type.Object({
+		languages: names(),
+		frameworks: names(),
+		packageManagers: names(),
+		roles: names()
+	}, closed$1),
+	/** relative path of the Markdown, inside the skill directory */
+	prompt: Type.String({ minLength: 1 }),
+	checks: Type.Optional(Type.Array(Type.Object({
+		name: Type.Optional(Type.String({ minLength: 1 })),
+		argv: Type.Array(Type.String(), { minItems: 1 })
+	}, closed$1))),
+	/** reserved (ADR-0011): no signature is verified in V3.0 */
+	signature: Type.Optional(Type.String()),
+	/** reserved (ADR-0011) */
+	source: Type.Optional(Type.String())
+}, closed$1);
+//#endregion
+//#region ../../packages/config/src/schema/spec.ts
+const closed = { additionalProperties: false };
+const texts = () => Type.Array(Type.String({ minLength: 1 }));
+const body = {
+	id: Type.String({ pattern: ID_PATTERN }),
+	kind: Type.Union([Type.Literal("feature"), Type.Literal("patch")]),
+	title: Type.String({ minLength: 1 }),
+	acceptance: texts(),
+	surfaces: Type.Record(Type.String({ pattern: ID_PATTERN }), Type.Object({ tasks: texts() }, closed)),
+	contract: Type.Optional(Type.String({ minLength: 1 })),
+	openQuestions: texts(),
+	patch: Type.Optional(Type.Object({
+		repro: Type.String(),
+		regressionTest: Type.String(),
+		causeConfirmed: Type.Boolean()
+	}, closed))
+};
+const SpecSchema = Type.Union([Type.Object({
+	...body,
+	status: Type.Literal("draft")
+}, closed), Type.Object({
+	...body,
+	status: Type.Literal("frozen"),
+	sha256: Sha256
+}, closed)]);
+/** [S]. A frozen spec WITHOUT a sha256, and a draft WITH one, are both invalid. */
+const Spec = Type.Unsafe(SpecSchema);
+/** What freezing signs: everything a human wrote, nothing the freeze itself adds. */
+function specContentSha256(spec) {
+	const content = {};
+	for (const [key, value] of Object.entries(spec)) if (key !== "status" && key !== "sha256" && value !== void 0) content[key] = value;
+	return sha256Hex(canonicalJson(content));
+}
+/** A frozen spec rejects edits: its content must still hash to the sha256 it was frozen with. A draft has nothing to prove. */
+function frozenSpecProblems(spec) {
+	if (spec.status !== "frozen") return [];
+	const actual = specContentSha256(spec);
+	if (actual === spec.sha256) return [];
+	return [{
+		path: "/sha256",
+		message: `spec "${spec.id}" is frozen and was edited: content hashes to ${actual}, frozen as ${spec.sha256}. Revert the edit, or write a new spec`
+	}];
+}
+//#endregion
+//#region ../../packages/config/src/schema/trust.ts
+const tighten = (pointer) => Object.freeze({
+	pointer,
+	class: "tighten-only"
+});
+const neutral = (pointer) => Object.freeze({
+	pointer,
+	class: "neutral"
+});
+const loosen = (pointer, ...loosenOnly) => Object.freeze(loosenOnly.length === 0 ? {
+	pointer,
+	class: "loosen"
+} : {
+	pointer,
+	class: "loosen",
+	loosenOnly: Object.freeze(loosenOnly)
+});
+Object.freeze([
+	neutral("/schemaVersion"),
+	neutral("/project"),
+	neutral("/runtime/id"),
+	loosen("/runtime/pi"),
+	neutral("/authentication/mode"),
+	loosen("/authentication/allowApiKeys"),
+	loosen("/authentication/anthropicSubscriptionViaPi"),
+	loosen("/routing/allowedProviders"),
+	neutral("/routing/defaults"),
+	neutral("/routing/tiers"),
+	neutral("/routing/escalation"),
+	loosen("/routing/fallback"),
+	tighten("/budgets"),
+	tighten("/loop"),
+	loosen("/checks"),
+	loosen("/provision/argv"),
+	loosen("/provision/network"),
+	loosen("/provision/cacheDirs"),
+	neutral("/provision/lockfiles"),
+	loosen("/provision/env"),
+	loosen("/provision/dependencyDirs"),
+	loosen("/provision/writableCaches"),
+	loosen("/policy/commands/allow"),
+	tighten("/policy/commands/ask"),
+	tighten("/policy/commands/deny"),
+	loosen("/policy/dangerousCommands"),
+	loosen("/policy/symlinks/mode", "allow"),
+	loosen("/policy/symlinks/hardlinksOnWrite", "allow"),
+	loosen("/policy/approvals/unattended", "wait"),
+	tighten("/policy/approvals/expiryMinutes"),
+	tighten("/policy/approvals/parkAfterMinutes"),
+	loosen("/policy/approvals/ship", "auto"),
+	neutral("/policy/approvals/notify"),
+	loosen("/policy/approvals/autoResume"),
+	loosen("/policy/inDoubt", "continue"),
+	loosen("/policy/skip"),
+	loosen("/policy/steer"),
+	loosen("/policy/admin"),
+	neutral("/policy/quota"),
+	neutral("/host"),
+	loosen("/network/proxyEnv"),
+	loosen("/sandbox/require", "best-effort"),
+	loosen("/sandbox/brain", "process"),
+	loosen("/git/worktreeRoot"),
+	neutral("/git/branchPrefix"),
+	neutral("/git/commitIdentity"),
+	neutral("/git/keepWorktrees"),
+	tighten("/retention"),
+	neutral("/telemetry")
+]);
+Type.Unsafe(Type.Object({
+	policySha256: Sha256,
+	loosenedKeys: Type.Array(Type.String()),
+	grantedAt: IsoInstant,
+	grantedBy: Type.String({ minLength: 1 }),
+	mac: Type.String({ minLength: 1 })
+}, { additionalProperties: false }));
+//#endregion
+export { literalPrefixOf as a, CommandRule as c, Ownership as i, DEFAULT_NETWORK_POLICY as l, frozenSpecProblems as n, CohorteConfig as o, specContentSha256 as r, DEFAULT_CONFIG as s, Spec as t };
+
+//# sourceMappingURL=schema-C9QbUW4H.mjs.map