cohorte 3.0.0-dev.6 → 3.0.0-dev.8

package/dist/chunks/{src-Daa5lIcP.mjs → src-CPW2_Ons.mjs}

@@ -1,9 +1,10 @@
 import { n as sha256Hex, t as canonicalJson } from "./canonical-C8UxeEmB.mjs";
 import { E as SpecId, I as isErrorCode, M as NotImplemented, N as errorOf, P as toErrorInfo, S as IsoInstant, T as Sha256, j as CohorteError, k as isSafeId, o as err, s as ok } from "./src-Cu3TxNob.mjs";
-import { f as HALTED_STATES, h as TERMINAL_STATES, i as canonicalCommandBody, l as ACTIVE_PIPELINE_STATES, m as SUSPENDED_STATES, n as isDurableEventType, p as PipelineProfile, t as catalogue } from "./src-s7YRvk0t.mjs";
-import { d as SandboxCapabilities, g as createRedactor, p as DEFAULT_DENY_GLOBS, r as RuntimePin, u as RuntimeCapabilities } from "./src-C7hs8Bjw.mjs";
+import { c as AgentOutput, g as TERMINAL_STATES, h as SUSPENDED_STATES, i as canonicalCommandBody, l as ReviewResult, m as PipelineProfile, n as isDurableEventType, p as HALTED_STATES, t as catalogue, u as ACTIVE_PIPELINE_STATES } from "./src-yi5whv3n.mjs";
+import { d as SandboxCapabilities, g as createRedactor, p as DEFAULT_DENY_GLOBS, r as RuntimePin, u as RuntimeCapabilities } from "./src-Bfr1yzsn.mjs";
 import { Type } from "typebox";
 import { Compile } from "typebox/compile";
+import { Value } from "typebox/value";
 //#region ../../packages/core/src/agents/lifecycle.ts
 /** the four edges spawning|running|waiting|paused -> spawning are legal REINCARNATION sources */
 const REINCARNATE_SOURCES = [
@@ -2038,12 +2039,22 @@ async function closePhaseAndAdvance(args) {
 	const now = deps.clock.now();
 	const from = runState.run.state;
 	const phaseChecks = "checks" in outcome ? outcome.checks ?? [] : [];
+	const review = outcome.kind === "passed" && outcome.output !== null && typeof outcome.output === "object" && !Array.isArray(outcome.output) && "review" in outcome.output && typeof outcome.output.review === "object" && outcome.output.review !== null ? outcome.output.review : outcome.kind === "failed" && openPhase.state === "REVIEW" ? {
+		clean: false,
+		kept: outcome.failure.findings
+	} : void 0;
 	const outcomeFacts = {
 		...facts,
 		"checks.all-passed": outcome.kind === "passed" && phaseChecks.every((check) => check.status === "passed" || check.status === "skipped"),
 		"checks.digest-equals-integration": outcome.kind === "passed" || phaseChecks.length > 0,
 		"checks.failed-non-environmental": outcome.kind === "failed" && phaseChecks.some((check) => check.status === "failed"),
-		"loop.may-continue": facts["loop.may-continue"] === true || outcome.kind === "failed" && phaseChecks.some((check) => check.status === "failed")
+		"review.nothing-to-fix": review ? review.clean === true : true,
+		"review.no-unreviewed": review ? (review.unreviewed?.length ?? 0) === 0 : true,
+		"review.leftovers-parked-or-waived": review ? (review.deferred?.length ?? 0) === 0 : true,
+		"review.has-fix-items": review ? review.clean !== true && (review.kept?.length ?? 0) > 0 : false,
+		"review.contract-change": false,
+		"review.leftovers-routed-ask": review ? (review.deferred?.length ?? 0) > 0 : false,
+		"loop.may-continue": facts["loop.may-continue"] === true || outcome.kind === "failed" && outcome.failure.code !== "agent-dead" && openPhase.iteration < 10
 	};
 	const guardOutcomes = evaluateGuards(step.guards, {
 		run: runState,
@@ -3379,6 +3390,8 @@ function calculateReview(findings, unreviewed, changedFiles = /* @__PURE__ */ ne
 //#endregion
 //#region ../../packages/core/src/phases/contracts/index.ts
 const SUPPORTED_PHASES = [
+	"BRAINSTORM",
+	"SPEC",
 	"PREFLIGHT",
 	"BUILD",
 	"TEST",
@@ -3401,6 +3414,8 @@ const RETRY = {
 	}
 };
 const OBJECTIVES = {
+	BRAINSTORM: "challenge the idea from product, UX, architecture and delivery perspectives and produce a structured brief",
+	SPEC: "turn the reviewed brief into a complete, testable and frozen feature specification",
 	PREFLIGHT: "validate readiness, specification completeness and surface ownership",
 	BUILD: "implement the frozen specification in isolated surface worktrees",
 	TEST: "run the project checks against the integration tree",
@@ -3420,7 +3435,7 @@ function surfacesOf(ctx) {
 	])].sort();
 }
 function toolsFor(role) {
-	if (role === "reviewer" || role === "security-reviewer") return [
+	if (role === "brainstormer" || role === "spec-author" || role === "reviewer" || role === "security-reviewer") return [
 		"read_file",
 		"list_files",
 		"search",
@@ -3439,24 +3454,24 @@ function toolsFor(role) {
 	];
 }
 function planFor(role, surface, state) {
-	const ownedPaths = [`${surface}/**`];
+	const ownedPaths = surface ? [`${surface}/**`] : [];
 	const tools = toolsFor(role);
-	const readOnly = role === "reviewer";
+	const readOnly = role === "brainstormer" || role === "spec-author" || role === "reviewer";
 	const task = {
 		role,
 		objective: OBJECTIVES[state],
-		stablePrefix: `cohorte ${state.toLowerCase()} task for surface ${surface}`,
+		stablePrefix: `cohorte ${state.toLowerCase()} task${surface ? ` for surface ${surface}` : ""}`,
 		ownedPaths,
 		facts: {
 			phase: state,
-			surface
+			...surface ? { surface } : {}
 		}
 	};
 	return {
-		agentId: `agt_${role}_${surface}`,
+		agentId: `agt_${role}_${surface ?? "project"}`,
 		role,
-		surface,
-		owner: surface,
+		...surface ? { surface } : {},
+		owner: surface ?? "project",
 		promptId: `agents/${role}`,
 		task,
 		context: {
@@ -3476,21 +3491,63 @@ function planFor(role, surface, state) {
 			...readOnly ? { readOnlyPaths: ownedPaths } : {},
 			tools
 		},
-		modelTier: role === "reviewer" ? "reasoning" : "coding",
+		modelTier: readOnly ? "reasoning" : "coding",
 		budget: { maxEngineRetries: 0 },
-		workspace: readOnly ? {
+		workspace: surface ? readOnly ? {
 			kind: "readonly-ref",
 			ref: "review-ref"
 		} : {
 			kind: "slot",
 			slot: surface
-		}
+		} : { kind: "none" }
 	};
 }
 function budgetFor(run, state) {
 	return run.budgets.find((budget) => budget.level === "phase" && budget.scopeId === state)?.limit ?? {};
 }
+/**
+* The phase handoff is persisted and consumed by the next phase.  Keeping the
+* result envelope closed here is important: `Type.Unknown()` would validate a
+* malformed supervisor result and defer the failure to a later transition,
+* where it is much harder to attribute to the producing agent.
+*/
+const AGENT_RESULT = Type.Object({
+	agent: Type.Object({
+		agentId: Type.String(),
+		role: Type.String(),
+		surface: Type.Optional(Type.String())
+	}),
+	outcome: Type.Enum({
+		completed: "completed",
+		failed: "failed",
+		cancelled: "cancelled"
+	}),
+	output: Type.Optional(AgentOutput),
+	error: Type.Optional(Type.Object({
+		code: Type.String(),
+		class: Type.String(),
+		message: Type.String(),
+		impact: Type.String(),
+		retryable: Type.Boolean(),
+		remediation: Type.String()
+	})),
+	artifacts: Type.Array(Type.Object({
+		artifactId: Type.Optional(Type.String()),
+		path: Type.String(),
+		kind: Type.String(),
+		sha256: Type.Optional(Type.String())
+	})),
+	usage: Type.Record(Type.String(), Type.Number())
+});
 function contractFor(state) {
+	const outputSchema = state === "REVIEW" ? Type.Object({
+		phase: Type.Literal(state),
+		results: Type.Array(AGENT_RESULT),
+		review: ReviewResult
+	}) : Type.Object({
+		phase: Type.Literal(state),
+		results: Type.Array(AGENT_RESULT)
+	});
 	return {
 		id: state.toLowerCase(),
 		version: 1,
@@ -3513,10 +3570,12 @@ function contractFor(state) {
 		planAgents(input, ctx) {
 			const surfaces = input && typeof input === "object" && "surfaces" in input && Array.isArray(input.surfaces) ? input.surfaces.filter((surface) => typeof surface === "string").sort() : surfacesOf(ctx);
 			if (state === "TEST" || state === "PREFLIGHT" || state === "SHIP") return [];
+			if (state === "BRAINSTORM") return [planFor("brainstormer", void 0, state)];
+			if (state === "SPEC") return [planFor("spec-author", void 0, state)];
 			const role = state === "BUILD" ? "implementer" : state === "REVIEW" ? "reviewer" : "fixer";
 			return surfaces.map((surface) => planFor(role, surface, state));
 		},
-		outputSchema: Type.Unknown(),
+		outputSchema,
 		checks: [],
 		budget: (run) => budgetFor(run, state),
 		stop: [],
@@ -3674,6 +3733,31 @@ function createPhaseExecutor$1(deps) {
 		}
 		const assembled = contract.assemble(resolved.value, results, ctx);
 		if (!assembled.ok) return failed("outputs-invalid", assembled.error);
+		if (!Value.Check(contract.outputSchema, assembled.value)) return failed("outputs-invalid", error("validation/phase-output-invalid", `Phase ${ctx.phase.state} produced an output that does not match contract ${contract.id}@${contract.version}.`, "Inspect the phase handoff and retry it with a valid structured output."));
+		if (ctx.phase.state === "REVIEW" && deps.store && deps.redactor) {
+			const redactor = deps.redactor;
+			const findings = results.flatMap((result) => result.output?.findings.map((finding) => ({
+				result,
+				finding
+			})) ?? []);
+			if (findings.length > 0) await deps.store.transact({ runId: ctx.run.run.runId }, ctx.lease, (tx) => {
+				for (const { result, finding } of findings) {
+					const findingId = `fnd_${sha256Hex(JSON.stringify(finding)).slice(0, 16)}`;
+					tx.putFinding({
+						runId: ctx.run.run.runId,
+						findingId,
+						phaseRunId: ctx.phase.phaseRunId,
+						agentId: result.agent.agentId,
+						severity: finding.severity,
+						status: finding.scope === "deferred" ? "deferred" : "open",
+						finding: redactor.sealJson(finding).value,
+						createdAt: ctx.now,
+						updatedAt: ctx.now
+					});
+				}
+			});
+		}
+		for (const check of contract.checks) if (!check.evaluate(resolved.value, assembled.value, ctx)) return failed("outputs-invalid", error(`validation/phase-check-${check.id}`, `Phase check ${check.id} failed for ${ctx.phase.state}.`, "Resolve the failed phase check and retry the phase."));
 		if (ctx.phase.state === "REVIEW" && typeof assembled.value === "object" && assembled.value !== null && "review" in assembled.value && typeof assembled.value.review === "object" && assembled.value.review !== null && "clean" in assembled.value.review && assembled.value.review.clean === false) {
 			const review = assembled.value.review;
 			return failed("checks-red", error("validation/review-findings", `Review found ${review.kept?.length ?? 0} finding(s).`, "Run the FIX phase and review again."), review.kept ?? []);
@@ -3831,7 +3915,7 @@ const hasSpec = (ctx) => ctx.run.run.specId.length > 0 && ctx.run.run.specSha256
 /** Guards with a local, deterministic derivation. All other guards consume a boolean fact and fail closed. */
 const DERIVED = {
 	"input.is-idea": factGuard("input.is-idea"),
-	"phase.available": () => outcome("phase.available", false, "BRAINSTORM/SPEC executors are not available in V3.0"),
+	"phase.available": () => outcome("phase.available", true),
 	"brainstorm.output-valid": factGuard("brainstorm.output-valid"),
 	"spec.schema-valid": derived("spec.schema-valid", hasSpec, "run has no valid spec identity"),
 	"spec.frozen": derived("spec.frozen", hasSpec, "run has no frozen spec identity"),
@@ -5400,4 +5484,4 @@ function createPhaseExecutor(deps) {
 //#endregion
 export { resolveTable as _, createToolHost as a, createApprovalService as b, createResumer as c, createPipelineGuards as d, createFactCollector as f, createEngine as g, createEventWriter as h, createRunSnapshotter as i, verifyProjectionAgainstEvents as l, createGrantComputer as m, createAgentSupervisor as n, createTransitionEffectRunner as o, createPhaseContracts as p, createProvisioner as r, createWorktreeService as s, createPhaseExecutor as t, initialRunState as u, createLeaseManager as v, createToolHostReplay as x, createEffectJournal as y };
 
-//# sourceMappingURL=src-Daa5lIcP.mjs.map
+//# sourceMappingURL=src-CPW2_Ons.mjs.map