dsh-completion-guard 0.4.3 → 0.5.1

package/dist/index.js

@@ -1,8 +1,8 @@
-import { $ as ALPHA2_HOST_PACKAGES, $t as SEMANTIC_ACTIONS, A as verifiedLinearCommitReadback, At as evidenceAvailabilityReason, B as supersedeItem, Bt as captureClause, C as commitIndexSnapshotDigest, Ct as certifyCheckpoint, D as gitCommandMatchesTarget, Dt as openItems, E as executeRevalidatedGitEffect, Et as closingHint, F as latestAssistantText, Ft as evidenceMatchesItem, G as withDurability, Gt as extractOperation, H as extractTextContent, Ht as classifyClause, I as observeAssistantOutcome, It as isVerifyingCapability, J as parsePwshCommand, Jt as canonicalRegistryBase, K as canonicalArgvFromCommand, Kt as isInformationalMessage, L as CAPTURE_V042_NOTICE, Lt as currentContractDigest, M as decideTurnBoundary, Mt as relevantEvidence, N as decideTurnStopping, Nt as bindingSatisfies, O as parseGitCommandManifest, Ot as recoveryDigest, P as isWholeTaskCompletionClaim, Pt as evidenceCoverage, Q as ALPHA2_DSHMARKET_139_HOST_PACKAGES, Qt as CERTIFICATE_VERSION, R as PROTOCOL_V3_NOTICE, Rt as createProjection, S as GIT_COMMAND_MANIFEST_IDS, St as qualifyBoundary, T as createGitPrestateEnvelope, Tt as MIN_RECOVERY_CHAR_BUDGET, U as extractToolSubject, Ut as extractArtifactPaths, V as evidenceFromPersistedToolResult, Vt as captureItem, W as isDeterministicCheck, Wt as extractMethod, X as goalCompletionDenial, Xt as ACTION_MANIFEST, Y as parseShellCommand, Yt as npmEscapedPackageName, Z as hasCurrentCertificate, Zt as ACTION_MANIFEST_VERSION, _ as readActiveHostGraph, _n as sanitizeUrl, _t as segmentAuthorityBlocks, a as createProofManifest, an as requestedTargetAuthorizesMutation, at as HOST_COHORTS, b as verifyComposedHostLockDump, bt as effectuateBoundary, c as sessionQuery, cn as semanticActionFromText, ct as bindLiveGoalCapability, d as hostLockContextFromComposedDump, dn as COMMAND_SURFACE_MANIFEST, dt as evaluateHostLock, en as STATEFUL_ACTIONS, et as BASE_HOST_PACKAGES, f as hostLockRowsFromComposedDump, fn as validateManifest, ft as evaluateToolSurfaceCapability, g as packageRowsFromPnpmLock, gn as sanitizeClauseText, gt as authorityCaptureCounts, h as packageRowsFromActiveGraph, hn as normalizeClause, ht as ALPHA3_HOST_PACKAGES, i as canonicalProjection, in as isStatefulAction, it as HOST_CAPABILITY_PACKAGE_GROUPS, j as classifyCompletionClaim, jt as itemDiagnosis, k as revalidateGitPrestate, kt as renderRecoveryPacket, l as validateProofManifest, ln as validateActionManifest, lt as evaluateExternalWaitCapability, m as inspectTargetHostGraph, mn as digestStrings, mt as RC1_HOST_PACKAGES, n as PROOF_PROTOCOL_VERSION, nn as SUPPORTED_EVIDENCE_ADAPTERS, nt as EXPECTED_HOST_PACKAGES, o as proofDigest, on as requestedTargetMatchesResolved, ot as LEGACY_HOST_COHORTS, p as injectActiveProfileHostLock, pn as canonicalizePath, pt as selectHostCohort, q as isRunExecutable, qt as segmentClauses, r as bindProofToProjection, rn as actionCompatible, rt as GOAL_HOST_PACKAGES, s as proofEvidenceConstraints, sn as semanticActionFromCommand, st as bindExecutableIdentity, t as PROOF_KINDS, tn as STOP_PROTOCOL_VERSION, tt as DEFAULT_HOST_LOCK, u as HostProfileError, un as validateActionTarget, ut as evaluateHostCapability, v as resolveActiveProfileHostLock, vn as sha256, vt as classifyUserInteraction, w as commitTreeSnapshotDigest, wt as DEFAULT_RECOVERY_CHAR_BUDGET, x as snapshotSessionEvents, xt as isCurrentAcceptedBoundary, y as resolveInstalledHostLock, yt as availableBoundaryQualifications, z as deriveProjection, zt as rebindResponse } from "./domain-DebMrpyX.js";
+import { $ as parseShellCommand, $n as requestedTargetMatchesResolved, $t as latestRootInstruction, A as createGitPrestateEnvelope, An as isInformationalMessage, At as authorityCaptureCounts, B as CAPTURE_V042_NOTICE, Bn as statefulActionsOfScope, Bt as evidenceCoverage, C as SESSION_EVENT_ENVELOPE_INVALID, Cn as relevantEvidence, Ct as evaluateMinimumHostVersion, D as GIT_COMMAND_TEMPLATES, Dn as extractArtifactPaths, Dt as RC015_HOST_PACKAGES, E as GIT_COMMAND_MANIFEST_IDS, En as classifyClause, Et as RC015_RC2_HOST_PACKAGES, F as verifiedLinearCommitReadback, Fn as isOpenObligation, Ft as closingHint, G as evidenceFromPersistedToolResult, Gn as CERTIFICATE_VERSION, Gt as NO_PROGRESS_TURNS_BEFORE_STOP, H as PROTOCOL_V4_NOTICE, Hn as npmEscapedPackageName, Ht as isVerifyingCapability, I as FIRST_STEP_GUIDANCE, In as kindOfScope, It as openItems, J as isDeterministicCheck, Jn as STOP_PROTOCOL_VERSION, Jt as decideTurnStopping, K as extractTextContent, Kn as SEMANTIC_ACTIONS, Kt as classifyCompletionClaim, L as claimedBatchHasRealRootInput, Ln as maskCodeSpans, Lt as recoveryDigest, M as gitCommandMatchesTarget, Mn as interpretClause, Mt as certifyCheckpoint, N as parseGitCommandManifest, Nn as interpretMessage, Nt as DEFAULT_RECOVERY_CHAR_BUDGET, O as commitIndexSnapshotDigest, On as extractMethod, Ot as RC1_HOST_PACKAGES, P as revalidateGitPrestate, Pn as isExecutableItem, Pt as MIN_RECOVERY_CHAR_BUDGET, Q as parsePwshCommand, Qn as requestedTargetAuthorizesMutation, Qt as latestAssistantText, R as lifecyclePhase, Rn as namedActions, Rt as renderRecoveryPacket, S as SESSION_API_UNSUPPORTED, Sn as itemDiagnosis, St as compareHostVersions, T as snapshotSessionEvents, Tn as captureItem, Tt as satisfiesSupportedHostRange, U as deriveProjection, Un as ACTION_MANIFEST, Ut as CONTROL_RECORD_PREFIX, V as PROTOCOL_V3_NOTICE, Vn as canonicalRegistryBase, Vt as evidenceMatchesItem, W as supersedeItem, Wn as ACTION_MANIFEST_VERSION, Wt as NO_PROGRESS_RECORD_PREFIX, X as canonicalArgvFromCommand, Xn as actionCompatible, Xt as isRootPauseRequest, Y as withDurability, Yn as SUPPORTED_EVIDENCE_ADAPTERS, Yt as decisionBoundaryKey, Z as isRunExecutable, Zn as isStatefulAction, Zt as isWholeTaskCompletionClaim, _ as packageRowsFromPnpmLock, _n as CONFIRM_LINE_PATTERN, _t as evaluateToolSurfaceCapability, a as createProofManifest, an as effectuateBoundary, ar as validateManifest, at as BASE_HOST_PACKAGES, b as resolveInstalledHostLock, bn as deriveItemDiagnosis, bt as MIN_SUPPORTED_HOST_VERSION, c as sessionQuery, cn as currentContractDigest, cr as canonicalizePath, ct as GOAL_HOST_PACKAGES, d as combineHostPolicy, dn as proposeRebind, dr as sanitizeClauseText, dt as LEGACY_HOST_COHORTS, en as observeAssistantOutcome, er as semanticActionFromCommand, et as ACTIVE_HOST_COHORT_ID, f as hostLockContextFromComposedDump, fn as proposeRebindOutcome, fr as sanitizeUrl, ft as bindExecutableIdentity, g as packageRowsFromActiveGraph, gn as replayRebindResult, gt as evaluateHostLock, h as inspectTargetHostGraph, hn as rebindResponse, ht as evaluateHostCapability, i as canonicalProjection, in as availableBoundaryQualifications, ir as COMMAND_SURFACE_MANIFEST, it as ALPHA2_HOST_PACKAGES, j as executeRevalidatedGitEffect, jn as segmentClauses, jt as segmentAuthorityBlocks, k as commitTreeSnapshotDigest, kn as extractOperation, kt as ALPHA3_HOST_PACKAGES, l as validateProofManifest, ln as createProjection, lr as digestStrings, lt as HOST_CAPABILITY_PACKAGE_GROUPS, m as injectActiveProfileHostLock, mn as rebindAttemptKey, mt as evaluateExternalWaitCapability, n as PROOF_PROTOCOL_VERSION, nn as goalCompletionDenial, nr as validateActionManifest, nt as ACTIVE_HOST_LAUNCHER_VERSION, o as proofDigest, on as isCurrentAcceptedBoundary, or as classifyTaskIntent, ot as DEFAULT_HOST_LOCK, p as hostLockRowsFromComposedDump, pn as proposeRebindV042, pr as sha256, pt as bindLiveGoalCapability, q as extractToolSubject, qn as STATEFUL_ACTIONS, qt as decideTurnBoundary, r as bindProofToProjection, rn as hasCurrentCertificate, rr as validateActionTarget, rt as ALPHA2_DSHMARKET_139_HOST_PACKAGES, s as proofEvidenceConstraints, sn as qualifyBoundary, sr as classifyUserInteraction, st as EXPECTED_HOST_PACKAGES, t as PROOF_KINDS, tn as progressFingerprint, tr as semanticActionFromText, tt as ACTIVE_HOST_COHORT_IDS, u as HostProfileError, un as confirmRebind, ur as normalizeClause, ut as HOST_COHORTS, v as readActiveHostGraph, vn as isFrozenV042RebindResponse, vt as hostVersionFromPackages, w as SessionApiError, wn as captureClause, wt as parseHostVersion, x as verifyComposedHostLockDump, xn as evidenceAvailabilityReason, xt as SUPPORTED_HOST_RANGE, y as resolveActiveProfileHostLock, yn as parseConfirmationMessage, yt as selectHostCohort, z as previewFirstStepInjection, zn as semanticActionOfScope, zt as bindingSatisfies } from "./domain-BqmJLHcu.js";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import { createHash } from "node:crypto";
 import { basename, delimiter, dirname, isAbsolute, join, resolve } from "node:path";
-import { boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { boundContextSummary, createToolResultMessage, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { execFile } from "node:child_process";
 import { constants, existsSync, readFileSync } from "node:fs";
 import { access, readFile, realpath } from "node:fs/promises";
@@ -10,6 +10,7 @@ import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { gunzip } from "node:zlib";
+import { SESSION_FORMAT_VERSION } from "@deepseek-ai/dsh-session";
 
 //#region src/tools/rebind.ts
 function createRebindTool(getProjection, prepare) {
@@ -414,6 +415,33 @@ function createCheckpointTool(getProjection, onRejected, prepare = async () => t
 						state_evidence_ids: {
 							type: "array",
 							items: { type: "string" }
+						},
+						action_bindings: {
+							type: "array",
+							items: {
+								type: "object",
+								additionalProperties: false,
+								properties: {
+									action: {
+										type: "string",
+										required: true
+									},
+									evidence_ids: {
+										type: "array",
+										required: true,
+										items: { type: "string" }
+									},
+									resolved_target: {
+										type: "object",
+										required: true,
+										additionalProperties: true
+									},
+									order: {
+										type: "integer",
+										required: true
+									}
+								}
+							}
 						}
 					}
 				}
@@ -619,7 +647,13 @@ function createCheckpointTool(getProjection, onRejected, prepare = async () => t
 				} } : {},
 				...binding.resolution_evidence_id ? { resolutionEvidenceId: binding.resolution_evidence_id } : {},
 				...binding.effect_evidence_id ? { effectEvidenceId: binding.effect_evidence_id } : {},
-				...binding.state_evidence_ids ? { stateEvidenceIds: binding.state_evidence_ids } : {}
+				...binding.state_evidence_ids ? { stateEvidenceIds: binding.state_evidence_ids } : {},
+				...binding.action_bindings ? { actionBindings: binding.action_bindings.map((closure) => ({
+					action: closure.action,
+					evidenceIds: closure.evidence_ids,
+					resolvedTarget: closure.resolved_target,
+					order: closure.order
+				})) } : {}
 			})), `C${projection.checkpoints.length + 1}`, false);
 			if (!result.checkpoint) onRejected();
 			const available_evidence = [...projection.evidence.values()].filter((evidence) => evidence.epoch === projection.epoch && (args.evidence_scope === "history" || [...projection.items.values()].some((item) => item.status === "pending" && relevantEvidence(projection, item, evidence)))).sort((a, b) => b.toolResultSeq - a.toolResultSeq || (a.id < b.id ? -1 : 1)).map((evidence) => ({
@@ -689,7 +723,7 @@ function createCheckpointTool(getProjection, onRejected, prepare = async () => t
 function createBoundaryTool(getProjection, prepare, onRejected) {
 	return defineTool({
 		name: "context_guard_boundary",
-		description: "Persist a qualified user_wait, external_wait, or deferred boundary. Free-form notes never qualify a boundary.",
+		description: "Persist a qualified user_wait, external_wait, deferred, or guard_bounded_stop boundary. Free-form notes never qualify a boundary.",
 		parameters: {
 			disposition: {
 				type: "string",
@@ -697,7 +731,8 @@ function createBoundaryTool(getProjection, prepare, onRejected) {
 				enum: [
 					"user_wait",
 					"external_wait",
-					"deferred"
+					"deferred",
+					"guard_bounded_stop"
 				]
 			},
 			qualification_kind: {
@@ -707,7 +742,8 @@ function createBoundaryTool(getProjection, prepare, onRejected) {
 					"user_decision_item",
 					"root_explicit_wait",
 					"external_operation_pending",
-					"root_explicit_defer"
+					"root_explicit_defer",
+					"guard_no_progress"
 				]
 			},
 			qualification_ids: {
@@ -812,6 +848,103 @@ function createBoundaryTool(getProjection, prepare, onRejected) {
 	});
 }
 
+//#endregion
+//#region src/tools/prepare.ts
+/**
+* Thin READ-ONLY preparation surface (v0.5): before any stateful action it
+* reports the supported command shape, the required resolution/effect/state
+* evidence order, existing reusable references, and the exact missing fields.
+* It never executes, installs, commits, pushes, restarts, or probes authority
+* through side effects, and it never upgrades a default into user authority.
+*/
+function createPrepareTool(options) {
+	return defineTool({
+		name: "context_guard_prepare",
+		description: "Read-only pre-action preparation: report the supported command shape, required resolution/effect/state evidence order, existing references, and exact missing target fields for one contract item. Performs no action and grants no authority.",
+		parameters: {
+			item_id: {
+				type: "string",
+				required: true
+			},
+			item_revision: { type: "number" },
+			semantic_action: { type: "string" },
+			requested_target: {
+				type: "object",
+				additionalProperties: true
+			},
+			planned_operation: { type: "string" }
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: true
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: JSON.stringify(value)
+			}]
+		},
+		async execute(rawArgs) {
+			const args = rawArgs;
+			const p = options.getProjection();
+			if (!p || !p.enabled || p.integrity !== "valid") return {
+				status: "unknown",
+				reason_code: "guard_unavailable"
+			};
+			const item = p.items.get(args.item_id ?? "");
+			if (!item) return {
+				status: "rejected",
+				reason_code: "item_not_found"
+			};
+			if (args.item_revision !== void 0 && item.revision !== args.item_revision) return {
+				status: "rejected",
+				reason_code: "item_revision_mismatch",
+				item_revision: item.revision
+			};
+			const diagnosis = deriveItemDiagnosis(p, item);
+			const plannedAction = args.semantic_action ?? item.semanticAction;
+			const manifestEntry = plannedAction ? ACTION_MANIFEST.actions[plannedAction] : void 0;
+			if (plannedAction && !manifestEntry) return {
+				status: "rejected",
+				reason_code: "unsupported_action"
+			};
+			const reusable = [...p.evidence.values()].filter((evidence) => relevantEvidence(p, item, evidence) && evidenceAvailabilityReason(evidence) === void 0).sort((a, b) => b.toolResultSeq - a.toolResultSeq).slice(0, 8).map((evidence) => ({
+				evidence_id: evidence.id,
+				role: evidence.evidenceRole,
+				semantic_action: evidence.semanticAction,
+				resolved_target: evidence.resolvedTarget,
+				tool_result_seq: evidence.toolResultSeq
+			}));
+			const requiredOrder = manifestEntry?.stateful ? [
+				"resolution (prestate facts from a trusted read)",
+				"effect (the exact planned change)",
+				"state (independent post-state readback)"
+			] : ["state (matching durable evidence for the requested verification)"];
+			const missingTargetFields = manifestEntry?.stateful && plannedAction ? manifestEntry.resolvedTargetKeys.filter((key) => !(item.requestedTarget?.[key] !== void 0 || args.requested_target?.[key] !== void 0)) : [];
+			const capability = plannedAction && options.hostCapability ? options.hostCapability(plannedAction) : void 0;
+			const commandShape = options.commandTemplate && plannedAction ? options.commandTemplate(plannedAction) : void 0;
+			return {
+				status: "prepared",
+				item: {
+					id: item.id,
+					revision: item.revision
+				},
+				diagnosis,
+				...plannedAction !== void 0 ? { planned_action: plannedAction } : {},
+				...commandShape !== void 0 ? { supported_command_shape: commandShape } : {},
+				required_evidence_order: requiredOrder,
+				reusable_references: reusable,
+				missing_target_fields: missingTargetFields,
+				...capability ? { host_capability: {
+					status: capability.status,
+					reason_code: capability.reasonCode
+				} } : {},
+				note: "Preparation performs no action. A default or guessed target is not user authority; explicit root instruction is required for missing target fields."
+			};
+		}
+	});
+}
+
 //#endregion
 //#region src/tools/evidence.ts
 const execFileAsync = promisify(execFile);
@@ -2411,7 +2544,7 @@ function createExternalOperationTool(read, capability) {
 function pendingCount(projection) {
 	return [...projection.items.values()].filter((item) => item.status === "pending").length;
 }
-function createContextGuardCommand(projectionFor, setEnabled, clearContract) {
+function createContextGuardCommand(projectionFor, setEnabled, clearContract, lifecycleFor) {
 	return {
 		name: "context-guard",
 		description: "Enable, disable, clear, inspect, or diagnose Context Guard for this session.",
@@ -2449,12 +2582,26 @@ function createContextGuardCommand(projectionFor, setEnabled, clearContract) {
 				text: "Usage: /context-guard on|off|clear|status|diagnose"
 			};
 			const passed = [...projection.items.values()].filter((item) => item.status === "passed").length;
+			let certifiable_missing_evidence = 0;
+			let unsupported = 0;
+			for (const item of projection.items.values()) {
+				if (item.status !== "pending") continue;
+				const diagnosis = deriveItemDiagnosis(projection, item);
+				if (diagnosis.repairability === "agent_repairable") certifiable_missing_evidence += 1;
+				else if (diagnosis.certification === "unsupported") unsupported += 1;
+			}
 			const response = {
 				enabled: projection.enabled,
+				lifecycle: lifecycleFor?.(agent) ?? (projection.enabled ? "active" : "disabled"),
 				epoch: projection.epoch,
 				contract_revision: projection.contractRevision,
 				pending: pendingCount(projection),
 				passed,
+				diagnosis: {
+					certified: passed,
+					certifiable_missing_evidence,
+					unsupported
+				},
 				evidence: projection.evidence.size,
 				integrity: projection.integrity,
 				last_source_seq: projection.lastObservedSourceSeq
@@ -2468,7 +2615,7 @@ function createContextGuardCommand(projectionFor, setEnabled, clearContract) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.2/node_modules/@deepseek-ai/cosmokit/lib/index.js
+//#region node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.3/node_modules/@deepseek-ai/cosmokit/lib/index.js
 /** Return true when a value is `null` or `undefined`. */
 function isNullable(value) {
 	return value === null || value === void 0;
@@ -2669,7 +2816,7 @@ var Time;
 })(Time || (Time = {}));
 
 //#endregion
-//#region node_modules/.pnpm/@deepseek-ai+schemastery@3.18.1/node_modules/@deepseek-ai/schemastery/lib/index.mjs
+//#region node_modules/.pnpm/@deepseek-ai+schemastery@3.18.2/node_modules/@deepseek-ai/schemastery/lib/index.mjs
 const kSchema = Symbol.for("schemastery");
 const kValidationError = Symbol.for("ValidationError");
 globalThis.__schemastery_index__ ??= 0;
@@ -3352,6 +3499,14 @@ function authorizeMutationFromProjection(projection, request) {
 		status: "denied",
 		reasonCode: "mutation_contract_item_not_pending"
 	};
+	if (item.authorityDisposition === "conditional_wait" || item.waitAuthorization) return {
+		status: "denied",
+		reasonCode: item.authorityDisposition === "conditional_wait" ? "mutation_awaiting_root_condition" : "mutation_awaiting_root_wait"
+	};
+	if (item.authorityDisposition === "human_actor") return {
+		status: "denied",
+		reasonCode: "mutation_human_executor"
+	};
 	if (item.kind !== "requirement" || item.verification.enforced !== true) return {
 		status: "denied",
 		reasonCode: "mutation_contract_item_not_authorizing"
@@ -3393,13 +3548,159 @@ function authorizeMutationFromProjection(projection, request) {
 	};
 }
 const PROTOCOL_CORRECTION_NOTICE = "Context Guard protocol correction: root-authorized work remains pending; continue with tools or obtain a typed boundary.";
+/**
+* Establish a boundary Guard itself owns, through the same durable record the
+* boundary tool writes.
+*
+* Replay reads boundaries from the `context_guard_boundary` call/result pair, so
+* a Guard-created boundary is written in exactly that wire shape rather than in
+* a private side channel — otherwise it would not survive a reload, and a
+* boundary that only exists in memory is not a persisted wait or stop.
+*
+* Returns the boundary only after the durable flush succeeded. A failed flush
+* reports the failure instead of a boundary, because an unflushed record must
+* never be read back as an established boundary.
+*/
+async function establishBoundary(agent, runtime, flush, request) {
+	const projection = runtime.projection;
+	const candidate = qualifyBoundary(projection, request);
+	if (candidate.persistedResult !== "accepted") return { reasonCode: candidate.reasonCode };
+	const session = agent.session;
+	const callId = `guard-boundary-${candidate.id}`;
+	session.append("tool/call", {
+		turn: 0,
+		step: session.seq,
+		callId,
+		name: "context_guard_boundary",
+		arguments: JSON.stringify({
+			disposition: request.disposition,
+			qualification_kind: request.qualificationKind,
+			qualification_ids: request.qualificationIds
+		})
+	});
+	session.append("tool/result", {
+		turn: 0,
+		step: session.seq,
+		message: createToolResultMessage({
+			callId,
+			content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: candidate.persistedResult,
+					reason_code: candidate.reasonCode,
+					boundary: { candidate_sha256: candidate.candidateSha256 }
+				})
+			}],
+			isError: false
+		})
+	}, { surfaceOp: "append" });
+	let durable = false;
+	try {
+		durable = await flush();
+	} catch {
+		durable = false;
+	}
+	runtime.setDurability(durable);
+	runtime.sync();
+	if (!durable) return { reasonCode: "boundary_flush_failed" };
+	return {
+		boundary: candidate,
+		reasonCode: candidate.reasonCode
+	};
+}
+/**
+* Effectuate a boundary Guard established in this turn, with the Goal revision
+* re-checked at the moment of the side effect.
+*
+* The progress fingerprint deliberately ignores the Goal revision, because an
+* edited Goal text is not progress. That is a statement about *detecting*
+* progress, not permission to act on a stale reference: before disarming, the
+* boundary's own Goal identity and revision are compared with the live readback,
+* so a Goal that changed under the boundary is refused rather than disarmed.
+*/
+async function effectuateOwnBoundary(runtime, boundary, access$1) {
+	const goalAccess = access$1.goalAccess ?? {
+		get: async () => void 0,
+		disarm: async () => void 0
+	};
+	const recorded = boundary.goalRef;
+	const effect = await effectuateBoundary(boundary, {
+		...goalAccess,
+		requalify: async () => {
+			const live = await goalAccess.get();
+			if (!live || !recorded) return false;
+			return live.id === recorded.id && live.revision === recorded.revision && live.activation === "armed";
+		}
+	});
+	if (effect.resumeRequired) {
+		runtime.projection.integrity = "unknown";
+		runtime.projection.integrityViolations.push(effect.reasonCode);
+	}
+	return effect.reasonCode;
+}
 /** Production Stop boundary: durable replay first, then immutable/live checks. */
 async function handleGuardTurnStopping(agent, runtime, access$1) {
-	const durable = await access$1.flush();
+	let durable = false;
+	try {
+		durable = await access$1.flush();
+	} catch {
+		durable = false;
+	}
 	runtime.setDurability(durable);
 	runtime.sync();
 	if (!durable) return "boundary_flush_failed";
+	const rootInstruction = latestRootInstruction(agent.session?.snapshotEvents?.() ?? []);
+	if (rootInstruction !== void 0 && isRootPauseRequest(rootInstruction.text) && !runtime.projection.handledControlSeqs.has(rootInstruction.seq) && access$1.pauseAccess) {
+		agent.session.append("user/message", createUserMessage({
+			content: [{
+				type: "text",
+				text: `${CONTROL_RECORD_PREFIX}${JSON.stringify({
+					kind: "root_pause",
+					rootSeq: rootInstruction.seq
+				})}`
+			}],
+			source: {
+				kind: "plugin",
+				plugin: "context-guard",
+				form: "notice",
+				summary: boundContextSummary("carrying the root pause request to the host")
+			}
+		}), { surfaceOp: "append" });
+		const current = await access$1.pauseAccess.get();
+		const paused = current?.phase === "paused" && current.activation === "disarmed" ? current : await access$1.pauseAccess.pause();
+		const readback$1 = await access$1.pauseAccess.get();
+		if (!paused || paused.activation !== "disarmed" || readback$1?.activation !== "disarmed") {
+			runtime.projection.integrity = "unknown";
+			runtime.projection.integrityViolations.push("root_pause_readback_failed");
+			return "root_pause_readback_failed";
+		}
+		return "root_pause_routed";
+	}
 	const decision = decideTurnBoundary(runtime.projection);
+	if (decision.noProgressClaim) {
+		const record$1 = `${NO_PROGRESS_RECORD_PREFIX}${JSON.stringify(decision.noProgressClaim)}`;
+		agent.session.append("user/message", createUserMessage({
+			content: [{
+				type: "text",
+				text: record$1
+			}],
+			source: {
+				kind: "plugin",
+				plugin: "context-guard",
+				form: "notice",
+				summary: boundContextSummary("recording a turn boundary without relevant progress")
+			}
+		}), { surfaceOp: "append" });
+		let recorded = false;
+		try {
+			recorded = await access$1.flush();
+		} catch {
+			recorded = false;
+		}
+		runtime.setDurability(recorded);
+		runtime.sync();
+		if (!recorded) return "boundary_flush_failed";
+	}
 	if (decision.action === "continue") {
 		agent.steer(createUserMessage({
 			content: [{
@@ -3415,6 +3716,39 @@ async function handleGuardTurnStopping(agent, runtime, access$1) {
 		}));
 		return decision.reason ?? "protocol_correction_steer";
 	}
+	if (decision.reason === "no_progress_bounded_disarm") {
+		if (!access$1.goalAccess || !access$1.hostSupported) {
+			runtime.projection.integrity = "unknown";
+			runtime.projection.integrityViolations.push("boundary_host_lock_unsupported");
+			return "boundary_host_lock_unsupported";
+		}
+		const established = await establishBoundary(agent, runtime, access$1.flush, {
+			disposition: "guard_bounded_stop",
+			qualificationKind: "guard_no_progress",
+			qualificationIds: [progressFingerprint(runtime.projection)]
+		});
+		if (!established.boundary) return established.reasonCode;
+		return await effectuateOwnBoundary(runtime, established.boundary, access$1);
+	}
+	if (decision.reason === "goal_round_driver_owns_continuation" && access$1.goalAccess) {
+		const waiting = [...runtime.projection.items.values()].filter((item) => item.status === "pending" && item.waitAuthorization).map((item) => item.waitAuthorization.id).sort();
+		const current = runtime.projection.boundaries.at(-1);
+		const alreadyCurrent = current && isCurrentAcceptedBoundary(runtime.projection, current) && current.disposition === "user_wait" && current.qualificationIds.slice().sort().join(",") === waiting.join(",");
+		if (waiting.length > 0 && !alreadyCurrent) {
+			if (!access$1.hostSupported) {
+				runtime.projection.integrity = "unknown";
+				runtime.projection.integrityViolations.push("boundary_host_lock_unsupported");
+				return "boundary_host_lock_unsupported";
+			}
+			const established = await establishBoundary(agent, runtime, access$1.flush, {
+				disposition: "user_wait",
+				qualificationKind: "root_explicit_wait",
+				qualificationIds: waiting
+			});
+			if (established.boundary) return await effectuateOwnBoundary(runtime, established.boundary, access$1);
+			return established.reasonCode;
+		}
+	}
 	if (decision.reason !== "accepted_boundary_pending_effectuation") return decision.reason ?? "safe_yield_pending_preserved";
 	const boundary = runtime.projection.boundaries.at(-1);
 	if (!boundary || !isCurrentAcceptedBoundary(runtime.projection, boundary)) return "boundary_candidate_stale";
@@ -3443,15 +3777,29 @@ async function handleGuardTurnStopping(agent, runtime, access$1) {
 function createHostCapabilityEvaluator(hostLock) {
 	return (action) => evaluateHostCapability(hostLock, { action });
 }
+/**
+* Durable session identity for the certificate binding, read from the
+* DSH Session V3 header plus the Session-owned inherited prefix length.
+*
+* Session V3 stamps `version: 3`, requires the `isSeeded` fork-lineage marker,
+* and moved the inherited-prefix length off the header onto the `Session`
+* (`inheritedEventCount`). Anything else is not a V3 identity: returning
+* `undefined` makes the projection report `session_ref_unavailable` instead of
+* certifying against a guessed identity.
+*/
 function sessionHeaderForDigest(session) {
 	const raw = session.header;
-	if (!raw || typeof raw.version !== "number" || typeof raw.id !== "string" || typeof raw.createdAt !== "number") return void 0;
+	if (!raw || raw.version !== SESSION_FORMAT_VERSION) return void 0;
+	if (typeof raw.id !== "string" || typeof raw.createdAt !== "number") return void 0;
+	if (typeof raw.isSeeded !== "boolean") return void 0;
+	const inherited = session.inheritedEventCount;
+	if (typeof inherited !== "number" || !Number.isSafeInteger(inherited) || inherited < 0) return void 0;
 	return {
 		version: raw.version,
 		id: raw.id,
 		createdAt: raw.createdAt,
 		...typeof raw.parentSession === "string" ? { parentSession: raw.parentSession } : {},
-		...typeof raw.seedLength === "number" ? { seedLength: raw.seedLength } : {},
+		seedLength: inherited,
 		...typeof raw.agentPreset === "string" ? { agentPreset: raw.agentPreset } : {},
 		...typeof raw.origin === "string" ? { origin: raw.origin } : {},
 		delegationDepth: typeof raw.delegationDepth === "number" ? raw.delegationDepth : 0
@@ -3465,17 +3813,34 @@ function createRuntime(agent, config, hostLock = DEFAULT_HOST_LOCK, readGoalStat
 	let observedEpoch = -1;
 	let observedCompactionSeq = -1;
 	let observedContractRevision = -1;
+	let protocolV4Present = false;
+	let realRootInputSeen = false;
+	let lifecycle = "armed";
 	const continuationAttempts = projection.continuationAttempts;
 	const persistenceCorrectionAttempts = projection.persistenceCorrectionAttempts;
 	const rebuild = () => {
 		if (refreshHostLock) hostLock = refreshHostLock();
 		const header = session.header;
 		const priorRecoveryDigest = projection.lastRecoveryDigest;
-		const derived = deriveProjection(snapshotSessionEvents(session), { activation: config.activation }, {
+		const sessionHeader = sessionHeaderForDigest(session);
+		let events;
+		try {
+			events = snapshotSessionEvents(session);
+		} catch (error) {
+			const code = error instanceof SessionApiError ? error.code : "session_snapshot_failed";
+			projection.integrity = "unknown";
+			if (!projection.integrityViolations.includes(code)) projection.integrityViolations.push(code);
+			return;
+		}
+		const derived = deriveProjection(events, { activation: config.activation }, {
 			cwd: typeof header?.cwd === "string" ? header.cwd : "",
-			sessionHeader: sessionHeaderForDigest(session)
+			sessionHeader
 		}, durabilityConfirmed, hostLock);
 		Object.assign(projection, derived.projection);
+		if (!sessionHeader) {
+			projection.integrity = "unknown";
+			if (!projection.integrityViolations.includes("session_ref_unavailable")) projection.integrityViolations.push("session_ref_unavailable");
+		}
 		if (readGoalState) try {
 			const state = normalizeGoalState(readGoalState());
 			if (state && projection.currentGoalRef?.id === state.id && projection.currentGoalRef.revision === state.revision) {
@@ -3489,6 +3854,12 @@ function createRuntime(agent, config, hostLock = DEFAULT_HOST_LOCK, readGoalStat
 		projection.continuationAttempts = continuationAttempts;
 		projection.persistenceCorrectionAttempts = persistenceCorrectionAttempts;
 		projection.lastRecoveryDigest = priorRecoveryDigest;
+		protocolV4Present = derived.protocolV4Present;
+		realRootInputSeen = derived.realRootInputSeen;
+		lifecycle = lifecyclePhase({
+			enabled: projection.enabled,
+			realInputSeen: realRootInputSeen
+		});
 		if (observedEpoch >= 0 && derived.projection.epoch > observedEpoch) {
 			pendingRecovery = true;
 			projection.lastRecoveryDigest = void 0;
@@ -3523,6 +3894,12 @@ function createRuntime(agent, config, hostLock = DEFAULT_HOST_LOCK, readGoalStat
 	return {
 		projection,
 		session,
+		get lifecycle() {
+			return lifecycle;
+		},
+		get protocolV4Present() {
+			return protocolV4Present;
+		},
 		sync,
 		setEnabled,
 		setDurability,
@@ -3530,6 +3907,11 @@ function createRuntime(agent, config, hostLock = DEFAULT_HOST_LOCK, readGoalStat
 		consumeRecovery
 	};
 }
+/** Delegated/subagent sessions never receive root-conversation injections. */
+function isDelegatedSession(session) {
+	const header = session.header;
+	return header?.origin === "subagent" || typeof header?.delegationDepth === "number" && header.delegationDepth > 0 || typeof header?.parentSession === "string";
+}
 /** Never reinterpret a legacy injected snapshot as freshly accepted core/v1. */
 function revalidateCoreLock(config, expected) {
 	if (config.hostLockPolicy !== "dsh-core/v1" || !config.hostLockRuntimeRoot || !config.hostLockProfileRoot) return {
@@ -3585,10 +3967,8 @@ function apply(ctx, rawConfig = {}) {
 		}
 		return runtime;
 	};
-	ctx.commands.register(createContextGuardCommand((agent) => ensure(agent).projection, (agent, enabled) => ensure(agent).setEnabled(enabled), (agent) => ensure(agent).sync()));
+	ctx.commands.register(createContextGuardCommand((agent) => ensure(agent).projection, (agent, enabled) => ensure(agent).setEnabled(enabled), (agent) => ensure(agent).sync(), (agent) => ensure(agent).lifecycle));
 	ctx.on("agent/session-start", ({ agent, source }) => {
-		ensureProtocolBoundary(agent);
-		ensureProtocolBoundary(agent, CAPTURE_V042_NOTICE);
 		const runtime = ensure(agent);
 		runtime.sync();
 		if (source === "resume" || source === "compact") {
@@ -3655,6 +4035,17 @@ function apply(ctx, rawConfig = {}) {
 		};
 		agent.ctx.tools.register(createEvidenceTool(evidenceOptions));
 		agent.ctx.tools.register(createActionTool(evidenceOptions));
+		agent.ctx.tools.register(createPrepareTool({
+			getProjection: () => runtime.projection,
+			hostCapability: (action) => {
+				const evaluation = createHostCapabilityEvaluator(hostLocks.get(agent) ?? installedHostLock)(action);
+				return {
+					status: evaluation.status,
+					reasonCode: evaluation.reasonCode
+				};
+			},
+			commandTemplate: (action) => GIT_COMMAND_TEMPLATES[action]
+		}));
 		agent.ctx.tools.register(createExternalOperationTool((id, toolAgent) => readExternalOperation(ctx, toolAgent, id), () => evaluateExternalWaitCapability(hostLocks.get(agent) ?? installedHostLock)));
 		agent.ctx.tools.guard((exec) => goalCompletionDenial(runtime.projection, exec.name, exec.arguments));
 	});
@@ -3664,12 +4055,33 @@ function apply(ctx, rawConfig = {}) {
 		runtime.setDurability(durability);
 		runtime.sync();
 		const decision = await next();
-		if (decision.kind === "enter" && runtime.projection.enabled && runtime.consumeRecovery()) {
-			const recovery = renderRecoveryPacket(runtime.projection, { charBudget: 4e3 });
+		if (decision.kind !== "enter") return decision;
+		const injected = [];
+		const delegated = isDelegatedSession(agent.session);
+		let boundaryPending = !runtime.protocolV4Present;
+		const firstStep = previewFirstStepInjection({
+			activation: config.activation,
+			enabled: runtime.projection.enabled,
+			boundaryPresent: runtime.protocolV4Present,
+			delegated
+		}, claimedBatchHasRealRootInput(decision.messages));
+		if (firstStep) {
+			injected.push(pluginNoticeMessage(firstStep.boundary, "Context Guard recorded a replay version boundary"));
+			if (runtime.lifecycle === "armed") injected.push(pluginNoticeMessage(firstStep.guidance, "Context Guard first-step protection guidance"));
+			boundaryPending = false;
+		}
+		if (runtime.projection.enabled && runtime.consumeRecovery()) {
+			const hasOpenWork = [...runtime.projection.items.values()].some((item) => item.status === "pending");
+			const hasRejections = (runtime.projection.lastCheckpointRejections?.length ?? 0) > 0;
+			const recovery = hasOpenWork || hasRejections ? renderRecoveryPacket(runtime.projection, { charBudget: 4e3 }) : void 0;
 			const digest$2 = recovery ? recoveryDigest(recovery, runtime.projection) : void 0;
 			if (recovery && digest$2 !== runtime.projection.lastRecoveryDigest) {
 				runtime.projection.lastRecoveryDigest = digest$2;
-				decision.messages = [...decision.messages, createUserMessage({
+				if (boundaryPending && !delegated) {
+					injected.push(pluginNoticeMessage(PROTOCOL_V4_NOTICE, "Context Guard recorded a replay version boundary"));
+					boundaryPending = false;
+				}
+				injected.push(createUserMessage({
 					content: [{
 						type: "text",
 						text: `Open task requirements (recovered after compaction or resume):\n${recovery}`
@@ -3680,9 +4092,10 @@ function apply(ctx, rawConfig = {}) {
 						form: "notice",
 						summary: boundContextSummary("recovering open task requirements")
 					}
-				})];
+				}));
 			}
 		}
+		if (injected.length > 0) decision.messages = [...injected, ...decision.messages];
 		return decision;
 	});
 	ctx.on("agent/turn-stopping", async ({ agent }) => {
@@ -3724,26 +4137,20 @@ function optionalMarketOrigin(ctx, agent) {
 		return `http://${service.host === "::1" ? "[::1]" : "127.0.0.1"}:${service.port}`;
 	} catch {}
 }
-function ensureProtocolBoundary(agent, notice = PROTOCOL_V3_NOTICE) {
-	if (snapshotSessionEvents(agent.session).some((event) => {
-		if (event.type !== "user/message" || !event.data || typeof event.data !== "object") return false;
-		const data = event.data;
-		const source = data.source && typeof data.source === "object" ? data.source : void 0;
-		const content = Array.isArray(data.content) ? data.content : [];
-		return (content.length === 1 && content[0] && typeof content[0] === "object" ? content[0].text : void 0) === notice && source?.kind === "plugin" && source.plugin === "context-guard" && source.form === "notice";
-	})) return;
-	agent.session.append.bind(agent.session)("user/message", createUserMessage({
+/** Build one host-approved plugin notice user/message for step-batch delivery. */
+function pluginNoticeMessage(text, summaryLabel) {
+	return createUserMessage({
 		content: [{
 			type: "text",
-			text: notice
+			text
 		}],
 		source: {
 			kind: "plugin",
 			plugin: "context-guard",
 			form: "notice",
-			summary: boundContextSummary("Context Guard recorded a replay version boundary")
+			summary: boundContextSummary(summaryLabel)
 		}
-	}), { surfaceOp: "append" });
+	});
 }
 function hasPinnedUpdateGoalTool(agent) {
 	try {
@@ -3815,4 +4222,4 @@ function normalizeGoalState(value) {
 }
 
 //#endregion
-export { ACTION_MANIFEST, ACTION_MANIFEST_VERSION, ALPHA2_DSHMARKET_139_HOST_PACKAGES, ALPHA2_HOST_PACKAGES, ALPHA3_HOST_PACKAGES, BASE_HOST_PACKAGES, CAPTURE_V042_NOTICE, CERTIFICATE_VERSION, COMMAND_SURFACE_MANIFEST, Config, DEFAULT_HOST_LOCK, DEFAULT_RECOVERY_CHAR_BUDGET, EXPECTED_HOST_PACKAGES, GIT_COMMAND_MANIFEST_IDS, GOAL_HOST_PACKAGES, HOST_CAPABILITY_PACKAGE_GROUPS, HOST_COHORTS, HostProfileError, LEGACY_HOST_COHORTS, MIN_RECOVERY_CHAR_BUDGET, PROOF_KINDS, PROOF_PROTOCOL_VERSION, PROTOCOL_V3_NOTICE, RC1_HOST_PACKAGES, SEMANTIC_ACTIONS, STATEFUL_ACTIONS, STOP_PROTOCOL_VERSION, SUPPORTED_EVIDENCE_ADAPTERS, actionCompatible, apply, authorityCaptureCounts, availableBoundaryQualifications, bindExecutableIdentity, bindLiveGoalCapability, bindProofToProjection, bindingSatisfies, canonicalArgvFromCommand, canonicalProjection, canonicalizePath, captureClause, captureItem, certifyCheckpoint, classifyClause, classifyCompletionClaim, classifyUserInteraction, closingHint, commitIndexSnapshotDigest, commitTreeSnapshotDigest, createGitPrestateEnvelope, createProjection, createProofManifest, currentContractDigest, decideTurnBoundary, decideTurnStopping, deriveProjection, digestStrings, effectuateBoundary, evaluateExternalWaitCapability, evaluateHostCapability, evaluateHostLock, evaluateToolSurfaceCapability, evidenceCoverage, evidenceFromPersistedToolResult, evidenceMatchesItem, executeRevalidatedGitEffect, extractArtifactPaths, extractMethod, extractOperation, extractTextContent, extractToolSubject, gitCommandMatchesTarget, goalCompletionDenial, hasCurrentCertificate, hostLockContextFromComposedDump, hostLockRowsFromComposedDump, inject, injectActiveProfileHostLock, inspectTargetHostGraph, isCurrentAcceptedBoundary, isDeterministicCheck, isInformationalMessage, isRunExecutable, isStatefulAction, isVerifyingCapability, isWholeTaskCompletionClaim, latestAssistantText, name, normalizeClause, observeAssistantOutcome, openItems, packageRowsFromActiveGraph, packageRowsFromPnpmLock, parseGitCommandManifest, parsePwshCommand, parseShellCommand, proofDigest, proofEvidenceConstraints, qualifyBoundary, readActiveHostGraph, recoveryDigest, renderRecoveryPacket, requestedTargetAuthorizesMutation, requestedTargetMatchesResolved, resolveActiveProfileHostLock, resolveInstalledHostLock, revalidateGitPrestate, sanitizeClauseText, sanitizeUrl, segmentAuthorityBlocks, segmentClauses, selectHostCohort, semanticActionFromCommand, semanticActionFromText, sessionQuery, sha256, snapshotSessionEvents, supersedeItem, validateActionManifest, validateActionTarget, validateManifest, validateProofManifest, verifiedLinearCommitReadback, verifyComposedHostLockDump, withDurability };
+export { ACTION_MANIFEST, ACTION_MANIFEST_VERSION, ACTIVE_HOST_COHORT_ID, ACTIVE_HOST_COHORT_IDS, ACTIVE_HOST_LAUNCHER_VERSION, ALPHA2_DSHMARKET_139_HOST_PACKAGES, ALPHA2_HOST_PACKAGES, ALPHA3_HOST_PACKAGES, BASE_HOST_PACKAGES, CAPTURE_V042_NOTICE, CERTIFICATE_VERSION, COMMAND_SURFACE_MANIFEST, CONFIRM_LINE_PATTERN, CONTROL_RECORD_PREFIX, Config, DEFAULT_HOST_LOCK, DEFAULT_RECOVERY_CHAR_BUDGET, EXPECTED_HOST_PACKAGES, FIRST_STEP_GUIDANCE, GIT_COMMAND_MANIFEST_IDS, GIT_COMMAND_TEMPLATES, GOAL_HOST_PACKAGES, HOST_CAPABILITY_PACKAGE_GROUPS, HOST_COHORTS, HostProfileError, LEGACY_HOST_COHORTS, MIN_RECOVERY_CHAR_BUDGET, MIN_SUPPORTED_HOST_VERSION, NO_PROGRESS_RECORD_PREFIX, NO_PROGRESS_TURNS_BEFORE_STOP, PROOF_KINDS, PROOF_PROTOCOL_VERSION, PROTOCOL_V3_NOTICE, PROTOCOL_V4_NOTICE, RC015_HOST_PACKAGES, RC015_RC2_HOST_PACKAGES, RC1_HOST_PACKAGES, SEMANTIC_ACTIONS, SESSION_API_UNSUPPORTED, SESSION_EVENT_ENVELOPE_INVALID, STATEFUL_ACTIONS, STOP_PROTOCOL_VERSION, SUPPORTED_EVIDENCE_ADAPTERS, SUPPORTED_HOST_RANGE, SessionApiError, actionCompatible, apply, authorityCaptureCounts, availableBoundaryQualifications, bindExecutableIdentity, bindLiveGoalCapability, bindProofToProjection, bindingSatisfies, canonicalArgvFromCommand, canonicalProjection, canonicalizePath, captureClause, captureItem, certifyCheckpoint, claimedBatchHasRealRootInput, classifyClause, classifyCompletionClaim, classifyTaskIntent, classifyUserInteraction, closingHint, combineHostPolicy, commitIndexSnapshotDigest, commitTreeSnapshotDigest, compareHostVersions, confirmRebind, createGitPrestateEnvelope, createProjection, createProofManifest, currentContractDigest, decideTurnBoundary, decideTurnStopping, decisionBoundaryKey, deriveItemDiagnosis, deriveProjection, digestStrings, effectuateBoundary, evaluateExternalWaitCapability, evaluateHostCapability, evaluateHostLock, evaluateMinimumHostVersion, evaluateToolSurfaceCapability, evidenceAvailabilityReason, evidenceCoverage, evidenceFromPersistedToolResult, evidenceMatchesItem, executeRevalidatedGitEffect, extractArtifactPaths, extractMethod, extractOperation, extractTextContent, extractToolSubject, gitCommandMatchesTarget, goalCompletionDenial, hasCurrentCertificate, hostLockContextFromComposedDump, hostLockRowsFromComposedDump, hostVersionFromPackages, inject, injectActiveProfileHostLock, inspectTargetHostGraph, interpretClause, interpretMessage, isCurrentAcceptedBoundary, isDeterministicCheck, isExecutableItem, isFrozenV042RebindResponse, isInformationalMessage, isOpenObligation, isRootPauseRequest, isRunExecutable, isStatefulAction, isVerifyingCapability, isWholeTaskCompletionClaim, itemDiagnosis, kindOfScope, latestAssistantText, latestRootInstruction, lifecyclePhase, maskCodeSpans, name, namedActions, normalizeClause, observeAssistantOutcome, openItems, packageRowsFromActiveGraph, packageRowsFromPnpmLock, parseConfirmationMessage, parseGitCommandManifest, parseHostVersion, parsePwshCommand, parseShellCommand, previewFirstStepInjection, progressFingerprint, proofDigest, proofEvidenceConstraints, proposeRebind, proposeRebindOutcome, proposeRebindV042, qualifyBoundary, readActiveHostGraph, rebindAttemptKey, rebindResponse, recoveryDigest, relevantEvidence, renderRecoveryPacket, replayRebindResult, requestedTargetAuthorizesMutation, requestedTargetMatchesResolved, resolveActiveProfileHostLock, resolveInstalledHostLock, revalidateGitPrestate, sanitizeClauseText, sanitizeUrl, satisfiesSupportedHostRange, segmentAuthorityBlocks, segmentClauses, selectHostCohort, semanticActionFromCommand, semanticActionFromText, semanticActionOfScope, sessionQuery, sha256, snapshotSessionEvents, statefulActionsOfScope, supersedeItem, validateActionManifest, validateActionTarget, validateManifest, validateProofManifest, verifiedLinearCommitReadback, verifyComposedHostLockDump, withDurability };