@iowarp/clio-coder 0.4.3 → 0.4.5

package/src/domains/session/decision-board.ts

@@ -1,10 +1,12 @@
+import { randomUUID } from "node:crypto";
 import type { AskUserToolPolicy } from "../../tools/registry.js";
 import type { AutonomyExposure } from "../safety/autonomy.js";
-import type { DecisionLedgerEntry, DecisionRecord } from "./entries.js";
+import { type DecisionLedgerEntry, type DecisionRecord, type DecisionSource, decisionRef } from "./entries.js";
 
 export interface DecisionLedgerEntryFields {
 	kind: "decisionLedger";
 	parentTurnId: string;
+	origin?: "interview" | "agent";
 	interviewId: string;
 	interviewStatus: "complete" | "cancelled";
 	startedAt: string;
@@ -28,11 +30,35 @@ export interface DecisionBoardStoreDeps {
 	now?: () => Date;
 }
 
+/** One design choice the model records itself through the `decide` tool. */
+export interface AgentDecisionInput {
+	key: string;
+	value: string;
+	alternatives: ReadonlyArray<string>;
+	rationale: string;
+	label?: string;
+}
+
+export interface AgentDecisionOutcome {
+	/** The appended agent decision set; `decisionRef(entry.interviewId, key)` cites it. */
+	entry: DecisionLedgerEntryFields;
+	/** The earlier active record with the same key that this decision superseded, when there was one. */
+	superseded: { interviewId: string; key: string } | null;
+}
+
 export interface DecisionBoardStore {
 	/** Latest snapshot per interview, newest interview first. */
 	snapshot(): ReadonlyArray<DecisionLedgerEntry>;
 	/** Persist the one host-finalized snapshot for a settled interview. */
 	recordFinalizedInterview(policy: AskUserToolPolicy): boolean;
+	/**
+	 * Append one agent-recorded decision as its own complete set
+	 * (`origin: "agent"`, `interviewId: "agent:<uuid>"`, `roundCount: 0`). An
+	 * earlier active agent decision with the same key is superseded first with
+	 * the new rationale as its correction. An active operator decision with the
+	 * same key is never overwritten by the model; that throws.
+	 */
+	recordAgentDecision(input: AgentDecisionInput): AgentDecisionOutcome;
 	/** Append an operator revision snapshot anchored to the active branch leaf. */
 	supersede(interviewId: string, key: string, correction?: string): DecisionLedgerEntryFields;
 	/** Force the next read to refold, including after a same-session tree switch. */
@@ -90,6 +116,24 @@ function finalizedInterviewEntryFields(policy: AskUserToolPolicy): DecisionLedge
 	};
 }
 
+/** Most decision refs one dispatch request, envelope, or receipt carries. */
+export const DECISION_REFS_CAP = 32;
+
+/**
+ * Refs of every active decision on a board snapshot, sorted and capped at
+ * {@link DECISION_REFS_CAP}. Dispatch seals this onto each request it builds;
+ * an empty board yields an empty list, which callers leave off the request.
+ */
+export function activeDecisionRefs(board: ReadonlyArray<DecisionLedgerEntry>): string[] {
+	const refs = new Set<string>();
+	for (const entry of board) {
+		for (const decision of entry.decisions) {
+			if (decision.status === "active") refs.add(decisionRef(entry.interviewId, decision.key));
+		}
+	}
+	return [...refs].sort().slice(0, DECISION_REFS_CAP);
+}
+
 function isDecisionLedgerEntry(value: unknown): value is DecisionLedgerEntry {
 	return !!value && typeof value === "object" && (value as { kind?: unknown }).kind === "decisionLedger";
 }
@@ -143,7 +187,47 @@ export function createDecisionBoardStore(deps: DecisionBoardStoreDeps = {}): Dec
 		dirty = true;
 	};
 
-	return {
+	const revise = (
+		interviewId: string,
+		key: string,
+		revisionSource: DecisionSource,
+		correction?: string,
+	): DecisionLedgerEntryFields => {
+		syncToSession();
+		const interview = interviews.find((candidate) => candidate.interviewId === interviewId);
+		if (!interview) throw new Error(`decision board: interview ${interviewId} was not found on the active branch`);
+		const selected = interview.decisions.find((decision) => decision.key === key);
+		if (!selected) throw new Error(`decision board: decision ${key} was not found in interview ${interviewId}`);
+		const revisedAt = (deps.now?.() ?? new Date()).toISOString();
+		const normalizedCorrection = correction?.trim();
+		const entries = deps.readEntries?.() ?? [];
+		const parentTurnId = deps.getActiveLeafTurnId?.() ?? activeLeafFromEntries(entries);
+		if (!parentTurnId) throw new Error("decision board: no active branch leaf is available for the revision");
+		const revision: DecisionLedgerEntryFields = {
+			kind: "decisionLedger",
+			parentTurnId,
+			...(interview.origin !== undefined ? { origin: interview.origin } : {}),
+			interviewId: interview.interviewId,
+			interviewStatus: interview.interviewStatus,
+			startedAt: interview.startedAt,
+			endedAt: interview.endedAt,
+			roundCount: interview.roundCount,
+			...(interview.summary ? { summary: interview.summary } : {}),
+			...(interview.transcriptPath ? { transcriptPath: interview.transcriptPath } : {}),
+			...(interview.exposure ? { exposure: interview.exposure } : {}),
+			decisions: interview.decisions.map((decision) => {
+				if (decision.key !== selected.key) return { ...decision };
+				const next: DecisionRecord = { ...decision, status: "superseded", revisedAt, revisionSource };
+				if (normalizedCorrection) next.correction = normalizedCorrection;
+				else delete next.correction;
+				return next;
+			}),
+		};
+		append(revision);
+		return revision;
+	};
+
+	const store: DecisionBoardStore = {
 		snapshot(): ReadonlyArray<DecisionLedgerEntry> {
 			syncToSession();
 			return interviews;
@@ -154,41 +238,66 @@ export function createDecisionBoardStore(deps: DecisionBoardStoreDeps = {}): Dec
 			append(entry);
 			return true;
 		},
-		supersede(interviewId: string, key: string, correction?: string): DecisionLedgerEntryFields {
+		recordAgentDecision(input: AgentDecisionInput): AgentDecisionOutcome {
 			syncToSession();
-			const interview = interviews.find((candidate) => candidate.interviewId === interviewId);
-			if (!interview) throw new Error(`decision board: interview ${interviewId} was not found on the active branch`);
-			const selected = interview.decisions.find((decision) => decision.key === key);
-			if (!selected) throw new Error(`decision board: decision ${key} was not found in interview ${interviewId}`);
-			const revisedAt = (deps.now?.() ?? new Date()).toISOString();
-			const normalizedCorrection = correction?.trim();
+			let superseded: AgentDecisionOutcome["superseded"] = null;
+			for (const interview of interviews) {
+				const prior = interview.decisions.find((decision) => decision.key === input.key && decision.status === "active");
+				if (prior === undefined) continue;
+				if (interview.origin !== "agent" || prior.source !== "agent") {
+					throw new Error(
+						`decision board: '${input.key}' is an operator decision (${interview.interviewId}); it can only be revised through ask_user`,
+					);
+				}
+				superseded = { interviewId: interview.interviewId, key: prior.key };
+				break;
+			}
+			if (superseded !== null) revise(superseded.interviewId, superseded.key, "agent", input.rationale);
+			const now = (deps.now?.() ?? new Date()).toISOString();
 			const entries = deps.readEntries?.() ?? [];
 			const parentTurnId = deps.getActiveLeafTurnId?.() ?? activeLeafFromEntries(entries);
-			if (!parentTurnId) throw new Error("decision board: no active branch leaf is available for the revision");
-			const revision: DecisionLedgerEntryFields = {
+			if (!parentTurnId) throw new Error("decision board: no active branch leaf is available for the decision");
+			const entry: DecisionLedgerEntryFields = {
 				kind: "decisionLedger",
 				parentTurnId,
-				interviewId: interview.interviewId,
-				interviewStatus: interview.interviewStatus,
-				startedAt: interview.startedAt,
-				endedAt: interview.endedAt,
-				roundCount: interview.roundCount,
-				...(interview.summary ? { summary: interview.summary } : {}),
-				...(interview.transcriptPath ? { transcriptPath: interview.transcriptPath } : {}),
-				...(interview.exposure ? { exposure: interview.exposure } : {}),
-				decisions: interview.decisions.map((decision) => {
-					if (decision.key !== selected.key) return { ...decision };
-					const next: DecisionRecord = { ...decision, status: "superseded", revisedAt };
-					if (normalizedCorrection) next.correction = normalizedCorrection;
-					else delete next.correction;
-					return next;
-				}),
+				origin: "agent",
+				interviewId: `agent:${randomUUID()}`,
+				interviewStatus: "complete",
+				startedAt: now,
+				endedAt: now,
+				roundCount: 0,
+				exposure: "local",
+				decisions: [
+					{
+						key: input.key,
+						value: input.value,
+						...(input.label ? { label: input.label } : {}),
+						status: "active",
+						decidedAt: now,
+						source: "agent",
+						alternatives: [...input.alternatives],
+						rationale: input.rationale,
+					},
+				],
 			};
-			append(revision);
-			return revision;
+			append(entry);
+			return { entry, superseded };
+		},
+		supersede(interviewId: string, key: string, correction?: string): DecisionLedgerEntryFields {
+			return revise(interviewId, key, "operator", correction);
 		},
 		invalidate(): void {
 			dirty = true;
 		},
 	};
+	return store;
+}
+
+/** Preserve the recorded argument wherever a decision is carried into another prompt. */
+export function decisionRationale(decision: DecisionRecord): string | undefined {
+	const parts: string[] = [];
+	if (decision.alternatives?.length) parts.push(`Alternatives: ${decision.alternatives.join("; ")}`);
+	if (decision.rationale) parts.push(`Rationale: ${decision.rationale}`);
+	if (parts.length > 0) return parts.join(". ");
+	return decision.source_question ?? decision.correction;
 }

package/src/domains/session/entries.ts

@@ -5,13 +5,18 @@
  * carries its `kind` discriminant, a `turnId` (uuid v7 where possible so
  * entries sort by creation), a parent pointer, and an ISO timestamp.
  *
- * Later slices extend this union:
- *   - compactionSummary is produced by compaction/compact.ts (slice 12c).
- *   - branchSummary is produced by the fork path (slice 12b).
- *   - bashExecution / fileEntry become the wire shape for Phase 14 extensions.
+ * Non-message kinds and where they come from:
+ *   - compactionSummary is produced by compaction/compact.ts.
+ *   - branchSummary is produced by the fork path.
+ *   - bashExecution is produced by the editor bash path
+ *     (interactive/editor-bash.ts).
+ *   - fileEntry is consumed by the renderer, compaction, handoff, and
+ *     evidence builders but has no in-tree producer.
  */
 
-import { isSkillActivation, type SkillActivation } from "../../core/skill-activation.js";
+import { createHash } from "node:crypto";
+
+import { isSkillActivation, type PendingSkillToolPolicy, type SkillActivation } from "../../core/skill-activation.js";
 import type { ClioTurnRecord } from "../../engine/session.js";
 import { AUTONOMY_EXPOSURES, type AutonomyExposure } from "../safety/autonomy.js";
 
@@ -116,8 +121,159 @@ export interface CompactionUsage {
 	apiCalls: number;
 }
 
+/** Exact historical skill context, independent of generated checkpoint prose. */
+export interface PreservedSkillContext {
+	activationRef: string;
+	requestRef: string;
+	callRef: string;
+	resultRef: string;
+	activation: SkillActivation;
+	requestText: string;
+	content: Array<{ type: "text"; text: string }>;
+	/** Hash of the captured rendered text blocks, not the raw SKILL.md hash. */
+	contentHash: string;
+}
+
+export interface SkillContextCheckpoint {
+	version: 1;
+	skills: PreservedSkillContext[];
+}
+
+export const SKILL_CONTEXT_STATE = "skillContextState";
+export interface SkillContextState {
+	version: 1;
+	/** Empty is an explicit off/replacement; absence is unknown legacy state. */
+	activationRefs: string[];
+	unknown?: true;
+}
+
+export function skillContextContentHash(content: PreservedSkillContext["content"]): string {
+	return createHash("sha256").update(JSON.stringify(content)).digest("hex");
+}
+
+function isSkillContextState(value: unknown): value is SkillContextState {
+	return (
+		isRecord(value) &&
+		value.version === 1 &&
+		(value.unknown === undefined || value.unknown === true) &&
+		Array.isArray(value.activationRefs) &&
+		value.activationRefs.every((ref) => typeof ref === "string")
+	);
+}
+
+/** Ledger validation is structural; bad evidence must not make the session unreadable. */
+function isSkillContextCheckpoint(value: unknown): value is SkillContextCheckpoint {
+	return (
+		isRecord(value) &&
+		value.version === 1 &&
+		Array.isArray(value.skills) &&
+		value.skills.every(
+			(skill: unknown) =>
+				isRecord(skill) &&
+				[skill.activationRef, skill.requestRef, skill.callRef, skill.resultRef, skill.requestText, skill.contentHash].every(
+					isString,
+				) &&
+				isSkillActivation(skill.activation) &&
+				Array.isArray(skill.content) &&
+				skill.content.every((block: unknown) => isRecord(block) && block.type === "text" && typeof block.text === "string"),
+		)
+	);
+}
+
+export function verifiedSkillContextCheckpoint(value: unknown): value is SkillContextCheckpoint {
+	if (!isSkillContextCheckpoint(value)) return false;
+	const refs = new Set<string>();
+	const names = new Set<string>();
+	return value.skills.every((skill) => {
+		const activation = skill.activation;
+		if (
+			![skill.activationRef, skill.requestRef, skill.callRef, skill.resultRef].every((ref) => ref.length > 0) ||
+			activation.runId !== undefined ||
+			activation.triggeredBy !== "tool" ||
+			activation.turnId !== skill.requestRef ||
+			!activation.name ||
+			!activation.filePath ||
+			!activation.source ||
+			!activation.sourceOrigin ||
+			!/^[a-f0-9]{64}$/.test(activation.hash) ||
+			(activation.drift !== undefined && activation.drift !== "match") ||
+			skill.content.length === 0 ||
+			skill.content.every((block) => block.text.length === 0) ||
+			skill.contentHash !== skillContextContentHash(skill.content) ||
+			refs.has(skill.activationRef) ||
+			names.has(activation.name)
+		)
+			return false;
+		refs.add(skill.activationRef);
+		names.add(activation.name);
+		return true;
+	});
+}
+
+export interface PreservedUserContext {
+	turnId: string;
+	text: string;
+}
+function isPreservedUserContext(value: unknown): value is PreservedUserContext {
+	return isRecord(value) && isString(value.turnId) && isString(value.text);
+}
+
+/** Undefined means no live policy; null explicitly forbids reuse during an uncertain replacement. */
+export function mainSkillContextState(
+	entries: ReadonlyArray<SessionEntry>,
+	policy: PendingSkillToolPolicy | undefined,
+): SkillContextState | null | undefined {
+	if (!policy) return latestSkillContextState(entries);
+	// A cold turn may grant optional model activation without selecting or
+	// replacing any skill. Keep the recorded selection, including explicit off.
+	// This preserves historical content; it does not reconstruct tool authority.
+	if (
+		policy.modelActivation === true &&
+		policy.carriedSurface !== true &&
+		policy.requests.length === 0 &&
+		policy.loadedSkillNames.size === 0 &&
+		policy.loadedSkillPolicies.size === 0
+	)
+		return latestSkillContextState(entries);
+	if (policy.requests.some((request) => !policy.loadedSkillNames.has(request.name))) return null;
+	const names = [...policy.loadedSkillNames];
+	if (names.length === 0) return null;
+	const activationRefs: string[] = [];
+	for (const name of names) {
+		const entry = [...entries]
+			.reverse()
+			.find(
+				(candidate) =>
+					candidate.kind === "skillActivation" &&
+					candidate.activation.runId === undefined &&
+					candidate.activation.name === name,
+			);
+		if (!entry) return null;
+		activationRefs.push(entry.turnId);
+	}
+	return { version: 1, activationRefs };
+}
+
+/** Caller supplies an already selected branch. Never infer active skills from audit metadata. */
+export function latestSkillContextState(entries: ReadonlyArray<SessionEntry>): SkillContextState | undefined {
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		if (entry?.kind === "custom" && entry.customType === SKILL_CONTEXT_STATE) {
+			return isSkillContextState(entry.data) ? entry.data : undefined;
+		}
+		if (entry?.kind === "compactionSummary" && entry.skillContext !== undefined) {
+			return verifiedSkillContextCheckpoint(entry.skillContext)
+				? { version: 1, activationRefs: entry.skillContext.skills.map((skill) => skill.activationRef) }
+				: undefined;
+		}
+	}
+	return undefined;
+}
+
 export interface CompactionSummaryEntry extends BaseSessionEntry {
 	kind: "compactionSummary";
+	skillContext?: SkillContextCheckpoint;
+	userContext?: PreservedUserContext;
 	summary: string;
 	tokensBefore: number;
 	firstKeptTurnId: string;
@@ -213,6 +369,14 @@ export interface TaskLedgerEntry extends BaseSessionEntry {
 
 export type DecisionStatus = "active" | "superseded";
 
+/**
+ * Who settled a decision. `operator` is an answer the operator gave in an
+ * `ask_user` interview. `agent` is a design choice the model recorded itself
+ * through the `decide` tool, with the alternatives it rejected and why. Absent
+ * on entries written before agent decisions existed, which were all operator.
+ */
+export type DecisionSource = "operator" | "agent";
+
 export interface DecisionRecord {
 	key: string;
 	value: string;
@@ -221,12 +385,36 @@ export interface DecisionRecord {
 	status: DecisionStatus;
 	decidedAt: string;
 	revisedAt?: string;
+	/** Who made this revision, independently of the original decision source. Absent on legacy revisions. */
+	revisionSource?: DecisionSource;
 	correction?: string;
+	source?: DecisionSource;
+	/** Options considered and not taken. Only agent decisions carry these. */
+	alternatives?: string[];
+	/** Why `value` won over `alternatives`. Only agent decisions carry this. */
+	rationale?: string;
 }
 
-/** One complete, branch-anchored snapshot of a settled operator interview. */
+/**
+ * Stable reference to one decision: `<interviewId>/<key>`. Both halves are
+ * already unique on the active path, so the pair needs no third id. Run
+ * envelopes, receipts, and commit trailers cite decisions by this string.
+ */
+export type DecisionRef = string;
+
+export function decisionRef(interviewId: string, key: string): DecisionRef {
+	return `${interviewId}/${key}`;
+}
+
+/**
+ * One complete, branch-anchored snapshot of a settled decision set. An
+ * `interview` origin is an operator `ask_user` round; an `agent` origin is a
+ * set the model recorded with the `decide` tool, where `interviewId` is the
+ * agent decision set id and `roundCount` is 0. Absent origin means interview.
+ */
 export interface DecisionLedgerEntry extends BaseSessionEntry {
 	kind: "decisionLedger";
+	origin?: "interview" | "agent";
 	interviewId: string;
 	interviewStatus: "complete" | "cancelled";
 	startedAt: string;
@@ -317,6 +505,8 @@ export interface WorkingSetRef {
 }
 
 export interface EvictedItem {
+	/** Stable session-local recall alias; absent on legacy ledger records. */
+	alias?: string;
 	ref: WorkingSetRef;
 	reason: EvictionReason;
 	/** Estimated tokens the projection removes for this item (marker cost already subtracted). */
@@ -503,15 +693,19 @@ function isTaskLedgerEvidence(value: unknown): value is TaskLedgerValidationEvid
 	);
 }
 
-function isDecisionRecord(value: unknown): value is DecisionRecord {
+export function isDecisionRecord(value: unknown): value is DecisionRecord {
 	if (!isRecord(value)) return false;
-	if (!isString(value.key) || !/^[a-z0-9]+(?:_[a-z0-9]+)*$/.test(value.key)) return false;
+	if (!isString(value.key) || !/^[a-z0-9]+(?:[_-][a-z0-9]+)*$/.test(value.key)) return false;
 	if (!isString(value.value) || !isOneOf(value.status, DECISION_STATUSES) || !isString(value.decidedAt)) return false;
 	if (!isOptionalString(value.label) || !isOptionalString(value.source_question)) return false;
+	if (value.source !== undefined && !isOneOf(value.source, ["operator", "agent"])) return false;
+	if (value.revisionSource !== undefined && !isOneOf(value.revisionSource, ["operator", "agent"])) return false;
+	if (value.alternatives !== undefined && !isStringArray(value.alternatives)) return false;
+	if (!isOptionalString(value.rationale)) return false;
 	if (!isOptionalString(value.revisedAt) || !isOptionalString(value.correction)) return false;
 	return value.status === "superseded"
 		? isString(value.revisedAt)
-		: value.revisedAt === undefined && value.correction === undefined;
+		: value.revisedAt === undefined && value.revisionSource === undefined && value.correction === undefined;
 }
 
 function isOptionalCompactionUsage(value: unknown): boolean {
@@ -569,6 +763,7 @@ function isEvictedItem(value: unknown): value is EvictedItem {
 		isOneOf(value.reason, EVICTION_REASONS) &&
 		isNumber(value.tokensFreed) &&
 		isString(value.marker) &&
+		(value.alias === undefined || (typeof value.alias === "string" && /^r[1-9]\d*$/.test(value.alias))) &&
 		isOptionalString(value.by)
 	);
 }
@@ -592,7 +787,11 @@ export function isSessionEntry(value: unknown): value is SessionEntry {
 				isOptionalBoolean(v.excludeFromContext)
 			);
 		case "custom":
-			return isString(v.customType) && isOptionalBoolean(v.display);
+			return (
+				isString(v.customType) &&
+				isOptionalBoolean(v.display) &&
+				(v.customType !== SKILL_CONTEXT_STATE || isSkillContextState(v.data))
+			);
 		case "modelChange":
 			return isString(v.provider) && isString(v.modelId) && isOptionalString(v.target);
 		case "thinkingLevelChange":
@@ -612,7 +811,9 @@ export function isSessionEntry(value: unknown): value is SessionEntry {
 				(v.trigger === undefined || isOneOf(v.trigger, COMPACTION_TRIGGERS)) &&
 				isOptionalNumber(v.tokensAfter) &&
 				isOptionalNumber(v.messagesSummarized) &&
-				isOptionalBoolean(v.isSplitTurn)
+				isOptionalBoolean(v.isSplitTurn) &&
+				(v.skillContext === undefined || isSkillContextCheckpoint(v.skillContext)) &&
+				(v.userContext === undefined || isPreservedUserContext(v.userContext))
 			);
 		case "sessionInfo":
 			return isOptionalString(v.name) && isOptionalString(v.targetTurnId) && isOptionalString(v.label);
@@ -642,6 +843,7 @@ export function isSessionEntry(value: unknown): value is SessionEntry {
 			);
 		case "decisionLedger":
 			return (
+				(v.origin === undefined || isOneOf(v.origin, ["interview", "agent"])) &&
 				isString(v.interviewId) &&
 				isOneOf(v.interviewStatus, DECISION_INTERVIEW_STATUSES) &&
 				isString(v.startedAt) &&

package/src/domains/session/extension.ts

@@ -282,10 +282,10 @@ export function createSessionBundle(context: DomainContext): DomainBundle<Sessio
 			return snapshotFor(id);
 		},
 		switchBranch(sessionId) {
-			// /tree-driven branch switch currently delegates to resume. Kept as a
-			// distinct contract method so later slices can layer telemetry or
-			// chat-loop rewiring without changing resume's semantics. Same
-			// open-before-close ordering as resume() above and for the same reason.
+			// /tree-driven branch switch delegates to resume. Kept as a distinct
+			// contract method so telemetry or chat-loop rewiring can be layered on
+			// without changing resume's semantics. Same open-before-close ordering
+			// as resume() above and for the same reason.
 			if (state?.meta.id === sessionId) return state.meta;
 			const resumed = resumeSessionState(sessionId);
 			if (state) {

package/src/domains/session/handoff.ts

@@ -22,6 +22,7 @@
  */
 
 import { isAbsolute, normalize, relative, resolve } from "node:path";
+import { decisionRationale } from "./decision-board.js";
 import type { DecisionLedgerEntry, SessionEntry } from "./entries.js";
 import { filterEntriesToActivePath } from "./tree/active-path.js";
 
@@ -480,7 +481,7 @@ export function mergeHandoffDecisions(
 			if (decision.status !== "active") continue;
 			const name = decision.label ?? decision.key;
 			const summary = boundHandoffString(`${name}: ${decision.value}`).text;
-			const rationale = decision.source_question ?? decision.correction;
+			const rationale = decisionRationale(decision);
 			settled.push({
 				summary,
 				...(rationale ? { rationale: boundHandoffString(rationale).text } : {}),

package/src/domains/session/manager.ts

@@ -111,9 +111,8 @@ export function appendTurn(state: SessionManagerState, input: TurnInput): ClioTu
 
 /**
  * Append a rich SessionEntry via the engine writer. Non-message kinds are
- * written as JSON lines to current.jsonl; they do not project into tree.json
- * in slice 12a. Slice 12b extends the tree model so /fork can pick non-message
- * branch points too.
+ * written as JSON lines to current.jsonl and do not project into tree.json;
+ * the /fork picker offers assistant message turns only.
  */
 export function appendEntry(state: SessionManagerState, input: SessionEntryInput): SessionEntry {
 	const turnId = input.turnId ?? newTurnId();

package/src/domains/session/prompt-manifest.ts

@@ -115,15 +115,54 @@ function isPromptManifestFragment(value: unknown): value is PromptManifestFragme
 	);
 }
 
-function isProjectPreloadClass(value: unknown): value is ProjectPreloadClass {
-	if (!isRecord(value)) return false;
+/** Validate additive accounting when present, while accepting historical manifests. */
+export function isProjectPreloadClass(value: unknown): value is ProjectPreloadClass {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const row = value as Record<string, unknown>;
+	const integer = (item: unknown): item is number => typeof item === "number" && Number.isInteger(item) && item >= 0;
+	const optionalInteger = (item: unknown): boolean => item === undefined || integer(item);
+	const range = (item: unknown): boolean =>
+		item === null ||
+		(Array.isArray(item) &&
+			item.length === 2 &&
+			integer(item[0]) &&
+			item[0] >= 1 &&
+			integer(item[1]) &&
+			item[1] >= item[0]);
 	return (
-		(value.mode === "full" || value.mode === "synopsis" || value.mode === "none") &&
-		isNonNegativeInteger(value.chars) &&
-		isNonNegativeInteger(value.lines) &&
-		(value.reason === null || value.reason === "size" || value.reason === "lines" || value.reason === "no-clio-md") &&
-		typeof value.nearLimit === "boolean" &&
-		typeof value.label === "string"
+		typeof row.mode === "string" &&
+		["full", "partial", "synopsis", "none"].includes(row.mode) &&
+		integer(row.chars) &&
+		integer(row.lines) &&
+		(row.reason === null || (typeof row.reason === "string" && ["size", "lines", "no-clio-md"].includes(row.reason))) &&
+		typeof row.nearLimit === "boolean" &&
+		typeof row.label === "string" &&
+		optionalInteger(row.includedChars) &&
+		optionalInteger(row.includedLines) &&
+		optionalInteger(row.omittedSupportFragments) &&
+		(row.providerSupportsTools === undefined ||
+			row.providerSupportsTools === null ||
+			typeof row.providerSupportsTools === "boolean") &&
+		(row.sources === undefined ||
+			(Array.isArray(row.sources) &&
+				row.sources.every((source: unknown) => {
+					if (source === null || typeof source !== "object" || Array.isArray(source)) return false;
+					const s = source as Record<string, unknown>;
+					return (
+						typeof s.path === "string" &&
+						typeof s.contentHash === "string" &&
+						/^[a-f0-9]{64}$/.test(s.contentHash) &&
+						integer(s.availableChars) &&
+						integer(s.availableLines) &&
+						integer(s.includedChars) &&
+						integer(s.includedLines) &&
+						s.includedChars <= s.availableChars &&
+						s.includedLines <= s.availableLines &&
+						range(s.includedRange) &&
+						range(s.omittedRange) &&
+						(s.omissionReason === null || s.omissionReason === "budget")
+					);
+				})))
 	);
 }