dsh-completion-guard 0.6.0 → 0.6.2

package/dist/index.js

@@ -1,4 +1,4 @@
-import { $ as isDeterministicCheck, $n as deriveItemDiagnosis, $t as proofDigestV2, A as previewFirstStepInjection, An as isWholeTaskCompletionClaim, Ar as STOP_PROTOCOL_VERSION_V2, At as evaluateMinimumHostVersion, B as RELEASE_SETTLEMENT_PREFIX, Bn as qualifyBoundary, Br as validateActionManifest, Bt as PROOF_CAPABILITY_MATRIX, C as gitCommandMatchesTarget, Cn as NO_PROGRESS_RECORD_PREFIX, Cr as ACTION_MANIFEST_VERSION, Ct as hostVersionFromPackages, D as FIRST_STEP_GUIDANCE, Dn as decideTurnStopping, Dr as SEMANTIC_ACTIONS, Dt as SUPPORTED_HOST_RANGE, E as verifiedLinearCommitReadback, En as decideTurnBoundary, Er as CERTIFICATE_VERSION_V2, Et as MIN_SUPPORTED_HOST_VERSION, F as PROTOCOL_V5_NOTICE, Fn as goalCompletionDenial, Fr as requestedIdentityKey, Ft as RC1_HOST_PACKAGES, G as releaseContractFor, Gn as proposeRebindOutcome, Gr as classifyUserInteraction, Gt as PROOF_PROTOCOL_VERSION_V2, H as inFlightReservation, Hn as createProjection, Hr as COMMAND_SURFACE_MANIFEST, Ht as PROOF_KINDS_V2, I as deriveProjection, In as hasCurrentCertificate, Ir as requestedTargetAuthorizesMutation, It as ALPHA3_HOST_PACKAGES, J as reservationFor, Jn as rebindResponse, Jr as normalizeClause, Jt as canonicalProjection, K as releaseCoverage, Kn as proposeRebindV042, Kr as canonicalizePath, Kt as bindProofToProjection, L as RELEASE_OPERATIONS, Ln as availableBoundaryQualifications, Lr as requestedTargetMatchesResolved, Lt as authorityCaptureCounts, M as DEFAULT_DELEGATION_TOOL_NAMES, Mn as latestRootInstruction, Mr as actionCompatible, Mt as satisfiesSupportedHostRange, N as PROTOCOL_V3_NOTICE, Nn as observeAssistantOutcome, Nr as boundedArtifactChoiceMatches, Nt as RC015_RC2_HOST_PACKAGES, O as claimedBatchHasRealRootInput, On as decisionBoundaryKey, Or as STATEFUL_ACTIONS, Ot as SUPPORTED_HOST_VERSIONS, P as PROTOCOL_V4_NOTICE, Pn as progressFingerprint, Pr as isStatefulAction, Pt as RC015_HOST_PACKAGES, Q as extractToolSubject, Qn as parseConfirmationMessage, Qt as proofDigest, R as RELEASE_OPERATION_SURFACES, Rn as effectuateBoundary, Rr as semanticActionFromCommand, Rt as segmentAuthorityBlocks, S as executeRevalidatedGitEffect, Sn as CONTROL_RECORD_PREFIX, Sr as ACTION_MANIFEST, St as evaluateToolSurfaceCapability, T as revalidateGitPrestate, Tn as classifyCompletionClaim, Tr as CERTIFICATE_VERSION, Tt as LATEST_SUPPORTED_HOST_VERSION, U as normalizeReleaseContract, Un as confirmRebind, Ur as validateManifest, Ut as PROOF_MANIFEST_DOMAIN_V2, V as contractById, Vn as currentContractDigest, Vr as validateActionTarget, Vt as PROOF_KINDS, W as readbackSettlesContract, Wn as proposeRebind, Wr as classifyTaskIntent, Wt as PROOF_PROTOCOL_VERSION, X as evidenceFromPersistedToolResult, Xn as CONFIRM_LINE_PATTERN, Xr as sanitizeUrl, Xt as createProofManifestV2, Y as supersedeItem, Yn as replayRebindResult, Yr as sanitizeClauseText, Yt as createProofManifest, Z as extractTextContent, Zn as isFrozenV042RebindResponse, Zr as sha256, Zt as proofCapabilityReport, _ as GIT_COMMAND_MANIFEST_IDS, _n as renderRecoveryPacket, _r as namedActions, _t as bindExecutableIdentity, a as injectActiveProfileHostLock, an as scopeCoverageDigest, ar as classifyClause, at as ACTIVE_HOST_COHORT_ID, b as commitTreeSnapshotDigest, bn as evidenceMatchesItem, br as canonicalRegistryBase, bt as evaluateHostCapability, c as packageRowsFromPnpmLock, cn as validateProofManifest, cr as extractOperation, ct as ALPHA2_DSHMARKET_139_HOST_PACKAGES, d as resolveInstalledHostLock, dn as certificateClosure, dr as interpretClause, dt as DEFAULT_HOST_LOCK, en as proofEvidenceConstraints, er as evidenceAvailabilityReason, et as withDurability, f as verifyComposedHostLockDump, fn as DEFAULT_RECOVERY_CHAR_BUDGET, fr as interpretMessage, ft as EXPECTED_HOST_PACKAGES, g as snapshotSessionEvents, gn as recoveryDigest, gr as maskCodeSpans, gt as LEGACY_HOST_COHORTS, h as SessionApiError, hn as openItems, hr as kindOfScope, ht as HOST_COHORTS, i as hostLockRowsFromComposedDump, in as requiredSubjectsOf, ir as captureItem, it as parseShellCommand, j as CAPTURE_V042_NOTICE, jn as latestAssistantText, jr as SUPPORTED_EVIDENCE_ADAPTERS, jt as parseHostVersion, k as lifecyclePhase, kn as isRootPauseRequest, kr as STOP_PROTOCOL_VERSION, kt as compareHostVersions, l as readActiveHostGraph, ln as validateProofManifestV2, lr as isInformationalMessage, lt as ALPHA2_HOST_PACKAGES, m as SESSION_EVENT_ENVELOPE_INVALID, mn as closingHint, mr as isOpenObligation, mt as HOST_CAPABILITY_PACKAGE_GROUPS, n as combineHostPolicy, nn as proofOperationMatches, nr as relevantEvidence, nt as isRunExecutable, o as inspectTargetHostGraph, on as sessionQuery, or as extractArtifactPaths, ot as ACTIVE_HOST_COHORT_IDS, p as SESSION_API_UNSUPPORTED, pn as MIN_RECOVERY_CHAR_BUDGET, pr as isExecutableItem, pt as GOAL_HOST_PACKAGES, q as releasePreEffectDecision, qn as rebindAttemptKey, qr as digestStrings, qt as bindProofV2ToProjection, r as hostLockContextFromComposedDump, rn as proofV2Rejection, rr as captureClause, rt as parsePwshCommand, s as packageRowsFromActiveGraph, sn as sessionQueryV2, sr as extractMethod, st as ACTIVE_HOST_LAUNCHER_VERSION, t as HostProfileError, tn as proofHostSurfacesOf, tr as itemDiagnosis, tt as canonicalArgvFromCommand, u as resolveActiveProfileHostLock, un as certifiableOpenItems, ur as segmentClauses, ut as BASE_HOST_PACKAGES, v as GIT_COMMAND_TEMPLATES, vn as bindingSatisfies, vr as semanticActionOfScope, vt as bindLiveGoalCapability, w as parseGitCommandManifest, wn as NO_PROGRESS_TURNS_BEFORE_STOP, wr as BOUNDED_ARTIFACT_TYPES, wt as selectHostCohort, x as createGitPrestateEnvelope, xn as isVerifyingCapability, xr as npmEscapedPackageName, xt as evaluateHostLock, y as commitIndexSnapshotDigest, yn as evidenceCoverage, yr as statefulActionsOfScope, yt as evaluateExternalWaitCapability, z as RELEASE_RESERVATION_PREFIX, zn as isCurrentAcceptedBoundary, zr as semanticActionFromText, zt as certifyCheckpoint } from "./domain-COehX7MB.js";
+import { $ as extractToolSubject, $n as proposeRebindV042, $r as requestedTargetMatchesResolved, $t as proofDigest, A as lifecyclePhase, An as NO_PROGRESS_RECORD_PREFIX, Ar as isOpenObligation, At as compareHostVersions, B as RELEASE_RESERVATION_PREFIX, Bn as observeAssistantOutcome, Br as BOUNDED_ARTIFACT_TYPES, Bt as certifyCheckpoint, C as gitCommandMatchesTarget, Cn as recoveryDigest, Cr as extractMethod, Ct as evaluateToolSurfaceCapability, D as FIRST_STEP_GUIDANCE, Dn as evidenceMatchesItem, Dr as interpretClause, Dt as MIN_SUPPORTED_HOST_VERSION, E as verifiedLinearCommitReadback, En as evidenceCoverage, Er as segmentClauses, Et as LATEST_SUPPORTED_HOST_VERSION, F as PROTOCOL_V4_NOTICE, Fn as decisionBoundaryKey, Fr as statefulActionsOfScope, Ft as RC015_HOST_PACKAGES, G as readbackSettlesContract, Gn as effectuateBoundary, Gr as STOP_PROTOCOL_VERSION, Gt as PROOF_PROTOCOL_VERSION, H as contractById, Hn as goalCompletionDenial, Hr as CERTIFICATE_VERSION_V2, Ht as PROOF_KINDS, I as PROTOCOL_V5_NOTICE, In as isRootPauseRequest, Ir as canonicalRegistryBase, It as RC1_HOST_PACKAGES, J as releasePreEffectDecision, Jn as currentContractDigest, Jr as actionCompatible, Jt as bindProofV2ToProjection, K as releaseContractFor, Kn as isCurrentAcceptedBoundary, Kr as STOP_PROTOCOL_VERSION_V2, Kt as PROOF_PROTOCOL_VERSION_V2, L as deriveProjection, Ln as isWholeTaskCompletionClaim, Lr as npmEscapedPackageName, Lt as ALPHA3_HOST_PACKAGES, M as CAPTURE_V042_NOTICE, Mn as classifyCompletionClaim, Mr as maskCodeSpans, Mt as parseHostVersion, N as DEFAULT_DELEGATION_TOOL_NAMES, Nn as decideTurnBoundary, Nr as namedActions, Nt as satisfiesSupportedHostRange, O as claimedBatchHasRealRootInput, On as isVerifyingCapability, Or as interpretMessage, Ot as SUPPORTED_HOST_RANGE, P as PROTOCOL_V3_NOTICE, Pn as decideTurnStopping, Pr as semanticActionOfScope, Pt as RC015_RC2_HOST_PACKAGES, Q as extractTextContent, Qn as proposeRebindOutcome, Qr as requestedTargetAuthorizesMutation, Qt as proofCapabilityReport, R as RELEASE_OPERATIONS, Rn as latestAssistantText, Rr as ACTION_MANIFEST, Rt as authorityCaptureCounts, S as executeRevalidatedGitEffect, Sn as openItems, Sr as extractArtifactPaths, St as evaluateHostLock, T as revalidateGitPrestate, Tn as bindingSatisfies, Tr as isInformationalMessage, Tt as selectHostCohort, U as inFlightReservation, Un as hasCurrentCertificate, Ur as SEMANTIC_ACTIONS, Ut as PROOF_KINDS_V2, V as RELEASE_SETTLEMENT_PREFIX, Vn as progressFingerprint, Vr as CERTIFICATE_VERSION, Vt as PROOF_CAPABILITY_MATRIX, W as normalizeReleaseContract, Wn as availableBoundaryQualifications, Wr as STATEFUL_ACTIONS, Wt as PROOF_MANIFEST_DOMAIN_V2, X as supersedeItem, Xn as confirmRebind, Xr as isStatefulAction, Xt as createProofManifest, Y as reservationFor, Yn as createProjection, Yr as boundedArtifactChoiceMatches, Yt as canonicalProjection, Z as evidenceFromPersistedToolResult, Zn as proposeRebind, Zr as requestedIdentityKey, Zt as createProofManifestV2, _ as GIT_COMMAND_MANIFEST_IDS, _n as DEFAULT_RECOVERY_CHAR_BUDGET, _r as removalIsComplete, _t as LEGACY_HOST_COHORTS, a as injectActiveProfileHostLock, ai as validateManifest, an as requiredSubjectsOf, ar as parseConfirmationMessage, at as parseShellCommand, b as commitTreeSnapshotDigest, bn as cleanupConditionFor, br as captureItem, bt as evaluateExternalWaitCapability, c as packageRowsFromPnpmLock, ci as canonicalizePath, cn as sessionQueryV2, cr as evidenceAvailabilityReason, ct as ACTIVE_HOST_LAUNCHER_VERSION, d as resolveInstalledHostLock, di as sanitizeClauseText, dn as certifiableOpenItems, dr as DEPENDENCY_FREE_ONLY_CONDITION, dt as BASE_HOST_PACKAGES, ei as semanticActionFromCommand, en as proofDigestV2, er as rebindAttemptKey, et as isDeterministicCheck, f as verifyComposedHostLockDump, fi as sanitizeUrl, fn as certificateClosure, fr as actionHasCertificationPath, ft as DEFAULT_HOST_LOCK, g as snapshotSessionEvents, gn as CLEANUP_CONDITION_RULE_SHORT, gr as partialFailureOf, gt as HOST_COHORTS, h as SessionApiError, hn as CLEANUP_CONDITION_RULE_COMPACT, hr as capabilityFactOf, ht as HOST_CAPABILITY_PACKAGE_GROUPS, i as hostLockRowsFromComposedDump, ii as COMMAND_SURFACE_MANIFEST, in as proofV2Rejection, ir as isFrozenV042RebindResponse, it as parsePwshCommand, j as previewFirstStepInjection, jn as NO_PROGRESS_TURNS_BEFORE_STOP, jr as kindOfScope, jt as evaluateMinimumHostVersion, k as firstStepGuidance, kn as CONTROL_RECORD_PREFIX, kr as isExecutableItem, kt as SUPPORTED_HOST_VERSIONS, l as readActiveHostGraph, li as digestStrings, ln as validateProofManifest, lr as itemDiagnosis, lt as ALPHA2_DSHMARKET_139_HOST_PACKAGES, m as SESSION_EVENT_ENVELOPE_INVALID, mn as CLEANUP_CONDITION_RULE, mr as capabilityConsequence, mt as GOAL_HOST_PACKAGES, n as combineHostPolicy, ni as validateActionManifest, nn as proofHostSurfacesOf, nr as replayRebindResult, nt as canonicalArgvFromCommand, o as inspectTargetHostGraph, oi as classifyTaskIntent, on as scopeCoverageDigest, or as capabilityRemedyPhrase, ot as ACTIVE_HOST_COHORT_ID, p as SESSION_API_UNSUPPORTED, pi as sha256, pn as unitDescendantIds, pr as admissibleForRemoval, pt as EXPECTED_HOST_PACKAGES, q as releaseCoverage, qn as qualifyBoundary, qr as SUPPORTED_EVIDENCE_ADAPTERS, qt as bindProofToProjection, r as hostLockContextFromComposedDump, ri as validateActionTarget, rn as proofOperationMatches, rr as CONFIRM_LINE_PATTERN, rt as isRunExecutable, s as packageRowsFromActiveGraph, si as classifyUserInteraction, sn as sessionQuery, sr as deriveItemDiagnosis, st as ACTIVE_HOST_COHORT_IDS, t as HostProfileError, ti as semanticActionFromText, tn as proofEvidenceConstraints, tr as rebindResponse, tt as withDurability, u as resolveActiveProfileHostLock, ui as normalizeClause, un as validateProofManifestV2, ur as relevantEvidence, ut as ALPHA2_HOST_PACKAGES, v as GIT_COMMAND_TEMPLATES, vn as MIN_RECOVERY_CHAR_BUDGET, vr as removalIsPartiallyKnown, vt as bindExecutableIdentity, w as parseGitCommandManifest, wn as renderRecoveryPacket, wr as extractOperation, wt as hostVersionFromPackages, x as createGitPrestateEnvelope, xn as closingHint, xr as classifyClause, xt as evaluateHostCapability, y as commitIndexSnapshotDigest, yn as carriesCleanupCondition, yr as captureClause, yt as bindLiveGoalCapability, z as RELEASE_OPERATION_SURFACES, zn as latestRootInstruction, zr as ACTION_MANIFEST_VERSION, zt as segmentAuthorityBlocks } from "./domain-BtR3J5aL.js";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import { createHash } from "node:crypto";
 import { basename, delimiter, dirname, isAbsolute, join, resolve } from "node:path";
@@ -72,6 +72,8 @@ const LANES = [
 	"available_qualifications"
 ];
 const MAX_BYTES = 12288;
+/** Inline item-row bytes; a larger row is summarized, never silently dropped. */
+const ITEM_ROW_BUDGET = 1850;
 const size = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
 const digest$1 = (value) => sha256(JSON.stringify(value));
 const lookup = (id) => id.length <= 128 ? id : `sha256:${sha256(id)}`;
@@ -178,13 +180,14 @@ function checkpointPage(p, query, full) {
 		detail_query: "Use detail_id and detail_offset; evidence_scope=history includes non-citable evidence."
 	};
 	const summarize = (row) => {
-		if (size(row) <= 1800) return row;
+		if (size(row) <= ITEM_ROW_BUDGET) return row;
 		return {
 			id: String(row.id ?? row.item_id).slice(0, 128),
 			reason_code: row.reason_code,
 			certifiable: row.certifiable,
 			next_step: typeof row.next_step === "string" ? row.next_step.slice(0, 240) : void 0,
 			adapter_disposition: row.adapter_disposition,
+			...row.binding_template !== void 0 ? { binding_template: row.binding_template } : {},
 			omitted: true,
 			detail_id: lookup(String(row.id ?? row.item_id))
 		};
@@ -310,6 +313,8 @@ function openItemForTool(projection, item) {
 	const action = item.semanticAction ?? "generic_run";
 	const spec = ACTION_MANIFEST.actions[action];
 	const template = bindingTemplate(projection, item);
+	const diagnosis = deriveItemDiagnosis(projection, item);
+	const compact = itemDiagnosis(projection, item);
 	return {
 		id: item.id,
 		revision: item.revision,
@@ -321,9 +326,17 @@ function openItemForTool(projection, item) {
 		kind: item.kind,
 		semantic_action: action,
 		requested_target: targetForTool(item.requestedTarget),
-		...itemDiagnosis(projection, item),
-		producer_disposition: ACTION_MANIFEST.actions[action].evidenceProducer,
+		certifiable: compact.certifiable,
+		reason_code: diagnosis.reason_code,
+		next_step: diagnosis.capability.remedy === "await_root_input" ? (diagnosis.next_action.resume_condition ?? capabilityRemedyPhrase(diagnosis.capability.remedy)).slice(0, 240) : capabilityRemedyPhrase(diagnosis.capability.remedy),
 		...item.targetCaptureStatus ? { target_capture_status: item.targetCaptureStatus } : {},
+		capability: {
+			action_supported: diagnosis.capability.actionSupported,
+			certifiable: diagnosis.capability.certifiable,
+			gap: diagnosis.capability.gap,
+			remedy: diagnosis.capability.remedy
+		},
+		producer_disposition: ACTION_MANIFEST.actions[action].evidenceProducer,
 		...item.targetCaptureReasonCode ? { target_capture_reason_code: item.targetCaptureReasonCode } : {},
 		predicate: {
 			predicate_id: spec.predicateId,
@@ -734,7 +747,21 @@ function createCheckpointTool(getProjection, onRejected, prepare = async () => t
 				...evidence.adapterId ? { adapter_id: evidence.adapterId } : {},
 				...evidence.adapterVersion ? { adapter_version: evidence.adapterVersion } : {},
 				adapter_disposition: evidenceAvailabilityReason(evidence) === void 0 ? "citable" : "unavailable",
-				...evidenceAvailabilityReason(evidence) ? { reason_code: evidenceAvailabilityReason(evidence) } : {}
+				...evidenceAvailabilityReason(evidence) ? { reason_code: evidenceAvailabilityReason(evidence) } : {},
+				...evidence.processFacts ? { process_facts: {
+					host_tool_returned: evidence.processFacts.hostToolReturned,
+					declared_exit_code: evidence.processFacts.declaredExitCode === "unknown" ? "unknown" : evidence.processFacts.declaredExitCode,
+					terminal_marker_read: evidence.processFacts.terminalMarkerRead,
+					process_outcome: evidence.processFacts.outcome,
+					outcome_reason: evidence.processFacts.outcomeReason,
+					source: evidence.processFacts.source,
+					frozen_outcome_conflict: evidence.processFacts.frozenOutcomeConflict,
+					operation_attribution: evidence.processFacts.operationAttribution,
+					...evidence.processFacts.declaredOperationResults ? { declared_operation_results: evidence.processFacts.declaredOperationResults.map((row) => ({
+						action: row.action,
+						outcome: row.outcome
+					})) } : {}
+				} } : {}
 			}));
 			return checkpointPage(projection, args, {
 				status: result.status,
@@ -1101,6 +1128,22 @@ function actionPreparation(action) {
 //#region src/tools/prepare.ts
 /** Discovery pages stay bounded like checkpoint pages. */
 const DISCOVERY_ITEM_LIMIT = 8;
+const encodeCursor = (cursor) => Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+/**
+* The items discovery lists for the CURRENT work: under a v5 boundary that is
+* the current unit's closure plus its required descendants (the same scope a
+* v2 certificate answers for, prohibitions included because a standing
+* constraint is never finished work) plus every pre-v5 obligation, which keeps
+* their birth rules and must never be silently dropped. A legacy session lists
+* the whole session. Switched-away sibling units keep their own history and
+* are reached by item ID, not re-listed here (0.6.1, W060-03).
+*/
+function discoveryItemIds(p) {
+	const pending = [...p.items.values()].filter((item) => item.status === "pending").sort((a, b) => a.revision - b.revision || a.id.localeCompare(b.id));
+	if (p.boundaryProtocol !== 5) return pending.map((item) => item.id);
+	const closureUnits = new Set([...p.currentUnitId !== void 0 ? [p.currentUnitId, ...unitDescendantIds(p, p.currentUnitId)] : []]);
+	return pending.filter((item) => item.unitId === void 0 || item.unitId !== void 0 && closureUnits.has(item.unitId)).map((item) => item.id);
+}
 /**
 * Thin READ-ONLY preparation surface (v0.5/0.6): before any stateful action it
 * reports the supported command shape, the required resolution/effect/state
@@ -1113,7 +1156,7 @@ const DISCOVERY_ITEM_LIMIT = 8;
 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. Omit item_id to list current open items with their IDs. Performs no action and grants no authority.",
+		description: "Read-only pre-action preparation: report the supported command shape, required evidence order, existing references, and exact missing target fields for one contract item. Omit item_id to list current open items with their IDs; a stateful change needs resolution/effect/state, a read-only verification needs one matching fact. Pagination follows page_cursor (bound to the contract revision) and semantic_action filters the listing. Performs no action and grants no authority.",
 		parameters: {
 			item_id: { type: "string" },
 			item_revision: { type: "number" },
@@ -1122,7 +1165,8 @@ function createPrepareTool(options) {
 				type: "object",
 				additionalProperties: true
 			},
-			planned_operation: { type: "string" }
+			planned_operation: { type: "string" },
+			page_cursor: { type: "string" }
 		},
 		output: {
 			schema: {
@@ -1154,14 +1198,44 @@ function createPrepareTool(options) {
 				reason_code: "guard_unavailable"
 			};
 			if (args.item_id === void 0) {
-				const open = [...p.items.values()].filter((item$1) => item$1.status === "pending").sort((a, b) => a.revision - b.revision || a.id.localeCompare(b.id));
+				const filter = args.semantic_action ?? null;
+				const invalidCursor = (reason_code, note) => ({
+					status: "rejected",
+					reason_code,
+					mode: "discovery",
+					contract_revision: p.contractRevision,
+					...note !== void 0 ? { note } : { note: "Re-run discovery without page_cursor to list from the first page." }
+				});
+				let startAfter;
+				if (args.page_cursor !== void 0) {
+					let parsed;
+					try {
+						if (args.page_cursor.length <= 1024) {
+							const value = JSON.parse(Buffer.from(args.page_cursor, "base64url").toString("utf8"));
+							if (value?.v === 1 && Number.isSafeInteger(value.r) && (value.f === null || typeof value.f === "string") && Array.isArray(value.k) && Number.isSafeInteger(value.k[0]) && typeof value.k[1] === "string") parsed = value;
+						}
+					} catch {
+						parsed = void 0;
+					}
+					if (!parsed) return invalidCursor("discovery_cursor_malformed");
+					if (parsed.r !== p.contractRevision) return invalidCursor("discovery_cursor_stale", `The contract changed (cursor revision ${parsed.r}, current ${p.contractRevision}). Re-run discovery without page_cursor; items are never skipped by a stale page.`);
+					if ((parsed.f ?? null) !== (filter ?? null)) return invalidCursor("discovery_cursor_filter_mismatch");
+					startAfter = parsed.k;
+				}
+				const eligible = discoveryItemIds(p).map((id) => p.items.get(id)).filter((item$1) => filter === null || (item$1.semanticAction ?? "generic_run") === filter);
+				const startIndex = startAfter === void 0 ? 0 : eligible.findIndex((item$1) => item$1.revision === startAfter[0] && item$1.id === startAfter[1]) + 1;
+				if (startAfter !== void 0 && startIndex <= 0) return invalidCursor("discovery_cursor_stale", "The cursor names an item no longer in the current listing. Re-run discovery without page_cursor.");
+				const page = eligible.slice(startIndex, startIndex + DISCOVERY_ITEM_LIMIT);
+				const hasMore = startIndex + page.length < eligible.length;
 				return {
 					status: "prepared",
 					mode: "discovery",
 					durability: p.durabilityWatermark,
 					contract_revision: p.contractRevision,
-					total_open: open.length,
-					items: open.slice(0, DISCOVERY_ITEM_LIMIT).map((item$1) => {
+					total_open: eligible.length,
+					listed: page.length,
+					has_more: hasMore,
+					items: page.map((item$1) => {
 						const diagnosis$1 = deriveItemDiagnosis(p, item$1);
 						return {
 							id: item$1.id,
@@ -1173,7 +1247,14 @@ function createPrepareTool(options) {
 							text: item$1.normalizedText
 						};
 					}),
-					note: "Re-run with one item_id to prepare that item. Preparation performs no action."
+					...hasMore ? { next_cursor: encodeCursor({
+						v: 1,
+						r: p.contractRevision,
+						f: filter,
+						k: [page[page.length - 1].revision, page[page.length - 1].id]
+					}) } : {},
+					...filter !== null ? { filtered_by: { semantic_action: filter } } : {},
+					note: "Re-run with one item_id to prepare that item, or pass page_cursor for the next page. Preparation performs no action."
 				};
 			}
 			const item = p.items.get(args.item_id ?? "");
@@ -1200,11 +1281,11 @@ function createPrepareTool(options) {
 				resolved_target: evidence.resolvedTarget,
 				tool_result_seq: evidence.toolResultSeq
 			}));
-			const requiredOrder = manifestEntry?.stateful ? [
+			const requiredOrder = plannedAction && isStatefulAction(plannedAction) ? [
 				"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)"];
+			] : ["effect (one matching durable verification fact)"];
 			const recipe = plannedAction && isStatefulAction(plannedAction) ? actionPreparation(plannedAction) : void 0;
 			const missingTargetFields = recipe ? recipe.selector_fields.filter((key) => !(item.requestedTarget?.[key] !== void 0 || args.requested_target?.[key] !== void 0)) : [];
 			const capability = plannedAction && options.hostCapability ? options.hostCapability(plannedAction) : void 0;
@@ -1243,6 +1324,145 @@ function createPrepareTool(options) {
 	});
 }
 
+//#endregion
+//#region src/tools/interpret.ts
+function parsePartition(args, extent) {
+	const read = (key) => {
+		const raw = args[key];
+		if (raw === void 0) return void 0;
+		if (!Array.isArray(raw)) return void 0;
+		const spans = [];
+		for (const entry of raw) {
+			const record$1 = entry;
+			const start = record$1?.start;
+			const end = record$1?.end;
+			if (typeof start !== "number" || !Number.isSafeInteger(start) || typeof end !== "number" || !Number.isSafeInteger(end) || start >= end) return void 0;
+			spans.push({
+				start,
+				end
+			});
+		}
+		return spans;
+	};
+	const information = read("information_spans");
+	const unknown = read("unknown_spans");
+	if (information === void 0 || unknown === void 0) return { error: "interpretation_partition_required" };
+	if (information.length === 0) return { error: "interpretation_partition_required" };
+	const all = [...information, ...unknown];
+	for (const span of all) if (span.start < extent.start || span.end > extent.end) return { error: "interpretation_span_outside_input" };
+	const ordered = [...all].sort((left, right) => left.start - right.start || left.end - right.end);
+	for (let index = 1; index < ordered.length; index += 1) if (ordered[index].start < ordered[index - 1].end) return { error: "interpretation_spans_overlap" };
+	return {
+		information,
+		unknown
+	};
+}
+/** The byte extent that covers every source span of one item. */
+function itemExtent(spans) {
+	return {
+		start: Math.min(...spans.map((span) => span.start)),
+		end: Math.max(...spans.map((span) => span.end))
+	};
+}
+function createInterpretTool(options) {
+	return defineTool({
+		name: "context_guard_interpret",
+		description: "Record the interpretation of one unresolved obligation: pass the item ID from context_guard_prepare plus the partition of its input spans you read as information (information_spans) and the sub-spans you could not resolve (unknown_spans); for an attached asset, the partition is unnecessary. Contract bookkeeping only — performs no action, grants no authority. Information sub-spans close when this turn's host-confirmed final answer is delivered; unknown sub-spans remain pending obligations. Correctness is never certified.",
+		parameters: {
+			item_id: {
+				type: "string",
+				required: true
+			},
+			information_spans: {
+				type: "array",
+				items: {
+					type: "object",
+					additionalProperties: true
+				}
+			},
+			unknown_spans: {
+				type: "array",
+				items: {
+					type: "object",
+					additionalProperties: true
+				}
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: true
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: JSON.stringify(value)
+			}]
+		},
+		async execute(rawArgs) {
+			const args = rawArgs;
+			const reject = (reason_code) => ({
+				status: "rejected",
+				reason_code
+			});
+			if (options.refreshProjection) {
+				let durable = false;
+				try {
+					durable = await options.refreshProjection() === true;
+				} catch {
+					durable = false;
+				}
+				if (!durable) return {
+					status: "unknown",
+					reason_code: "projection_durability_unavailable"
+				};
+			}
+			const p = options.getProjection();
+			if (!p || !p.enabled || p.integrity !== "valid") return reject("guard_unavailable");
+			const itemId = typeof args.item_id === "string" ? args.item_id.trim() : "";
+			if (!itemId) return reject("item_not_found");
+			const item = p.items.get(itemId);
+			if (!item) return reject("item_not_found");
+			if (item.status !== "pending") return reject("item_not_pending");
+			if (!item.asset && item.authorityDisposition !== "unresolved") return reject("not_interpretable");
+			if (item.asset) return {
+				status: "recorded",
+				item_id: item.id,
+				item_revision: item.revision,
+				kind: "asset",
+				asset: {
+					message_seq: item.asset.messageSeq,
+					part_index: item.asset.partIndex,
+					media_sha256: item.asset.mediaSha256
+				},
+				note: "Interpretation recorded for this asset obligation. It closes when the host-confirmed final answer of this interpreting turn is delivered; this record never certifies the interpretation's correctness and never authorizes or proves any execution."
+			};
+			if (!item.spans || item.spans.length === 0) return reject("item_spans_unavailable");
+			const partition = parsePartition(args, itemExtent(item.spans));
+			if ("error" in partition) return reject(partition.error);
+			return {
+				status: "recorded",
+				item_id: item.id,
+				item_revision: item.revision,
+				kind: "clause",
+				spans: item.spans.map((span) => ({
+					part_index: span.partIndex,
+					start: span.start,
+					end: span.end
+				})),
+				information_spans: partition.information.map((span) => ({
+					start: span.start,
+					end: span.end
+				})),
+				unknown_spans: partition.unknown.map((span) => ({
+					start: span.start,
+					end: span.end
+				})),
+				note: "Interpretation partition recorded for this unresolved clause: information sub-spans close when the host-confirmed final answer of this interpreting turn is delivered; every unknown sub-span remains a pending obligation and must still be resolved or performed. This record never certifies correctness and never authorizes any execution."
+			};
+		}
+	});
+}
+
 //#endregion
 //#region src/tools/evidence.ts
 const execFileAsync = promisify(execFile);
@@ -1836,7 +2056,7 @@ async function executeGuardAction(action, resolution, roots, signal, executableI
 	if (action === "install" || action === "apply") {
 		const tgzPath = requireString(resolution.commandManifest, "tgz_path");
 		const identity = tgzPath ? await tgzIdentity(tgzPath) : void 0;
-		if (!executableIdentity$1 || !tgzPath || !identity || identity.name !== target.package_id || identity.version !== target.version || identity.integrity !== target.integrity_digest || roots.profile?.name !== target.profile) return "unavailable";
+		if (!executableIdentity$1 || !tgzPath || !identity || identity.name !== target.package_id || identity.version !== target.version || identity.integrity !== target.integrity_digest || roots.profile?.name !== target.profile) return { status: "unavailable" };
 		await runCommand(roots, executableIdentity$1, [
 			"plugin",
 			"--profile",
@@ -1844,13 +2064,13 @@ async function executeGuardAction(action, resolution, roots, signal, executableI
 			"add",
 			`file:${tgzPath}`
 		], void 0, signal);
-		return "completed";
+		return { status: "completed" };
 	}
 	if (action === "publish") {
 		const tgzPath = requireString(resolution.commandManifest, "tgz_path");
 		const identity = tgzPath ? await tgzIdentity(tgzPath) : void 0;
 		const registry = typeof target.registry === "string" ? canonicalRegistryBase(target.registry, { allowLoopbackHttp: roots.allowLoopbackHttpRegistry }) : void 0;
-		if (!executableIdentity$1 || !tgzPath || !identity || identity.name !== target.artifact_id || identity.version !== target.version || identity.integrity !== target.integrity_digest || !registry || registry !== target.registry) return "unavailable";
+		if (!executableIdentity$1 || !tgzPath || !identity || identity.name !== target.artifact_id || identity.version !== target.version || identity.integrity !== target.integrity_digest || !registry || registry !== target.registry) return { status: "unavailable" };
 		await runCommand(roots, executableIdentity$1, [
 			"publish",
 			tgzPath,
@@ -1858,19 +2078,19 @@ async function executeGuardAction(action, resolution, roots, signal, executableI
 			registry,
 			"--ignore-scripts"
 		], void 0, signal);
-		return "completed";
+		return { status: "completed" };
 	}
 	if (action === "restart") {
 		const capabilities = await marketCapabilities(roots, signal);
-		if (!capabilities || !roots.marketOrigin || !resolutionCallId || !agent) return "unavailable";
-		if (!sameMarketProvider(target.pre_generation, capabilities.generation)) return "unavailable";
-		if (capabilities.generation !== target.pre_generation) return restartIntent(snapshotSessionEvents(agent.session), resolutionCallId, target) ? "completed" : "unavailable";
-		if (restartIntent(snapshotSessionEvents(agent.session), resolutionCallId, target)) return "handoff_pending";
+		if (!capabilities || !roots.marketOrigin || !resolutionCallId || !agent) return { status: "unavailable" };
+		if (!sameMarketProvider(target.pre_generation, capabilities.generation)) return { status: "unavailable" };
+		if (capabilities.generation !== target.pre_generation) return restartIntent(snapshotSessionEvents(agent.session), resolutionCallId, target) ? { status: "completed" } : { status: "unavailable" };
+		if (restartIntent(snapshotSessionEvents(agent.session), resolutionCallId, target)) return { status: "handoff_pending" };
 		if (!roots.persistRestartIntent || !await roots.persistRestartIntent(agent, {
 			resolutionCallId,
 			serviceId: String(target.service_id),
 			preGeneration: String(target.pre_generation)
-		})) return "unavailable";
+		})) return { status: "unavailable" };
 		const response = await (roots.fetcher ?? fetch)(`${roots.marketOrigin}/dsh-market/api/v1/restart`, {
 			method: "POST",
 			signal,
@@ -1882,21 +2102,25 @@ async function executeGuardAction(action, resolution, roots, signal, executableI
 			},
 			body: "{}"
 		});
-		if (!response.ok) return "unavailable";
-		return record(await response.json())?.schema === MARKET_SCHEMA ? "handoff_pending" : "unavailable";
+		if (!response.ok) return { status: "unavailable" };
+		return record(await response.json())?.schema === MARKET_SCHEMA ? { status: "handoff_pending" } : { status: "unavailable" };
 	}
 	if (action === "commit" || action === "push" || action === "pull" || action === "fetch") {
 		const binding = resolution.gitBinding;
 		const repository = requireString(resolution.target, "repository");
-		if (!executableIdentity$1 || !binding || !repository) return "unavailable";
+		if (!executableIdentity$1 || !binding || !repository) return { status: "unavailable" };
 		const targetIdentity = {
 			repository,
 			...typeof resolution.target.remote === "string" ? { remote: resolution.target.remote } : {},
 			...typeof resolution.target.refspec === "string" ? { refspec: resolution.target.refspec } : {}
 		};
 		const current = await gitPrestate(binding.manifest, repository, signal, executableIdentity$1.realpath);
-		if (!current) return "unavailable";
-		if ((await executeRevalidatedGitEffect(binding.envelope, binding.manifest, targetIdentity, current, async (_file, argv, workingDirectory) => runCommand(roots, executableIdentity$1, argv, workingDirectory, signal))).status !== "executed") return "unavailable";
+		if (!current) return { status: "unavailable" };
+		const executed = await executeRevalidatedGitEffect(binding.envelope, binding.manifest, targetIdentity, current, async (_file, argv, workingDirectory) => runCommand(roots, executableIdentity$1, argv, workingDirectory, signal));
+		if (executed.status !== "executed") return {
+			status: "unavailable",
+			reasonCode: executed.reasonCode
+		};
 		if (action === "commit") {
 			const commit = verifiedLinearCommitReadback(await gitBytes(repository, [
 				"rev-list",
@@ -1911,10 +2135,10 @@ async function executeGuardAction(action, resolution, roots, signal, executableI
 				"-z",
 				commit.postHeadOid
 			], signal, executableIdentity$1.realpath)) : void 0;
-			if (!commit || postTree !== resolution.target.change_set_digest) return "unavailable";
+			if (!commit || postTree !== resolution.target.change_set_digest) return { status: "unavailable" };
 		} else if (action === "push") {
 			const remoteOid = binding.manifest.remote && binding.manifest.destinationRef ? await exactRemoteOid(repository, binding.manifest.remote, binding.manifest.destinationRef, signal, executableIdentity$1.realpath) : void 0;
-			if (!remoteOid || remoteOid !== resolution.target.local_oid) return "unavailable";
+			if (!remoteOid || remoteOid !== resolution.target.local_oid) return { status: "unavailable" };
 		} else {
 			const upstream = String(resolution.target.upstream_oid ?? "");
 			const trackingRef = binding.manifest.action === "fetch" ? binding.manifest.trackingRef : binding.manifest.remote && binding.manifest.sourceRef ? `refs/remotes/${binding.manifest.remote}/${binding.manifest.sourceRef.slice(11)}` : void 0;
@@ -1923,13 +2147,13 @@ async function executeGuardAction(action, resolution, roots, signal, executableI
 				"--verify",
 				trackingRef
 			], signal, executableIdentity$1.realpath)) : void 0;
-			if (!tracking || tracking !== upstream) return "unavailable";
-			if (action === "pull" && oid(await git(repository, ["rev-parse", "HEAD"], signal, executableIdentity$1.realpath)) !== upstream) return "unavailable";
-			if (action === "fetch" && oid(await git(repository, ["rev-parse", "HEAD"], signal, executableIdentity$1.realpath)) !== resolution.target.pre_head_oid) return "unavailable";
+			if (!tracking || tracking !== upstream) return { status: "unavailable" };
+			if (action === "pull" && oid(await git(repository, ["rev-parse", "HEAD"], signal, executableIdentity$1.realpath)) !== upstream) return { status: "unavailable" };
+			if (action === "fetch" && oid(await git(repository, ["rev-parse", "HEAD"], signal, executableIdentity$1.realpath)) !== resolution.target.pre_head_oid) return { status: "unavailable" };
 		}
-		return "completed";
+		return { status: "completed" };
 	}
-	return "unavailable";
+	return { status: "unavailable" };
 }
 async function gitBytes(repository, args, signal, file = "git") {
 	const { stdout } = await execFileAsync(file, args, {
@@ -2575,15 +2799,15 @@ function createActionTool(options = {}) {
 				releaseContractId = decision.contractId;
 			}
 			try {
-				const status = await executeGuardAction(action, resolution, roots, exec.signal, currentExecutable, args.resolution_call_id, agent);
+				const outcome = await executeGuardAction(action, resolution, roots, exec.signal, currentExecutable, args.resolution_call_id, agent);
 				if (releaseOperation && releaseGranted && roots.releaseSettle) {
-					const readback$1 = status === "completed" ? await publishReadback(resolution.target, roots, exec.signal) : void 0;
+					const readback$1 = outcome.status === "completed" ? await publishReadback(resolution.target, roots, exec.signal) : void 0;
 					await roots.releaseSettle({
 						agent,
 						operation: releaseOperation,
 						callId: args.resolution_call_id,
 						...releaseContractId !== void 0 ? { contractId: releaseContractId } : {},
-						effect: status === "completed" ? "completed" : status === "unavailable" ? "not_effected" : "unknown",
+						effect: outcome.status === "completed" ? "completed" : outcome.status === "unavailable" ? "not_effected" : "unknown",
 						readback: readback$1 === void 0 ? "unavailable" : {
 							kind: "npm_integrity",
 							identity: readback$1
@@ -2591,8 +2815,8 @@ function createActionTool(options = {}) {
 					});
 				}
 				return {
-					status,
-					reason_code: status === "completed" ? "action_completed" : status === "handoff_pending" ? "restart_handoff_pending" : "action_execution_failed",
+					status: outcome.status,
+					reason_code: outcome.status === "completed" ? "action_completed" : outcome.status === "handoff_pending" ? "restart_handoff_pending" : outcome.reasonCode === "effect_already_applied" ? "action_already_applied" : "action_execution_failed",
 					...identity
 				};
 			} catch {
@@ -3321,13 +3545,27 @@ function createContextGuardCommand(projectionFor, setEnabled, clearContract, lif
 			const passed = [...projection.items.values()].filter((item) => item.status === "passed").length;
 			let certifiable_missing_evidence = 0;
 			let unsupported = 0;
+			let input_required = 0;
+			let capability_limited = 0;
 			const reason_classes = {};
 			for (const item of projection.items.values()) {
 				if (item.status !== "pending") continue;
 				const diagnosis = deriveItemDiagnosis(projection, item);
 				reason_classes[diagnosis.reason_class] = (reason_classes[diagnosis.reason_class] ?? 0) + 1;
-				if (diagnosis.repairability === "agent_repairable") certifiable_missing_evidence += 1;
-				else if (diagnosis.certification === "unsupported") unsupported += 1;
+				switch (diagnosis.capability.remedy) {
+					case "collect_evidence":
+						certifiable_missing_evidence += 1;
+						break;
+					case "supply_target":
+					case "await_root_input":
+						input_required += 1;
+						break;
+					case "fresh_root_instruction":
+					case "restore_host":
+						capability_limited += 1;
+						break;
+					default: unsupported += 1;
+				}
 			}
 			const migration = migrationReport(projection);
 			const response = {
@@ -3341,6 +3579,8 @@ function createContextGuardCommand(projectionFor, setEnabled, clearContract, lif
 				diagnosis: {
 					certified: passed,
 					certifiable_missing_evidence,
+					input_required,
+					capability_limited,
 					unsupported,
 					reason_classes
 				},
@@ -4927,6 +5167,15 @@ function apply(ctx, rawConfig = {}, seams = {}) {
 				return durable;
 			}
 		}));
+		agent.ctx.tools.register(createInterpretTool({
+			getProjection: () => runtime.projection,
+			refreshProjection: async () => {
+				const durable = await ctx.sessions.flush(agent.session);
+				runtime.setDurability(durable);
+				runtime.sync();
+				return durable;
+			}
+		}));
 		agent.ctx.tools.register(createReleaseTool({
 			getProjection: () => runtime.projection,
 			fetcher: evidenceOptions.fetcher,
@@ -4958,7 +5207,8 @@ function apply(ctx, rawConfig = {}, seams = {}) {
 			enabled: runtime.projection.enabled,
 			boundaryV5Present: runtime.protocolV5Present,
 			boundaryPresent: runtime.protocolV4Present,
-			delegated
+			delegated,
+			policy: runtime.projection.policy
 		}, claimedBatchHasRealRootInput(decision.messages));
 		if (firstStep) {
 			injected.push(pluginNoticeMessage(firstStep.boundary, "Context Guard recorded a replay version boundary"));
@@ -5117,4 +5367,4 @@ function normalizeGoalState(value) {
 }
 
 //#endregion
-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, BOUNDED_ARTIFACT_TYPES, CAPTURE_V042_NOTICE, CERTIFICATE_VERSION, CERTIFICATE_VERSION_V2, COMMAND_SURFACE_MANIFEST, CONFIRM_LINE_PATTERN, CONTROL_RECORD_PREFIX, Config, DEFAULT_DELEGATION_TOOL_NAMES, 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, LATEST_SUPPORTED_HOST_VERSION, LEGACY_HOST_COHORTS, MIN_RECOVERY_CHAR_BUDGET, MIN_SUPPORTED_HOST_VERSION, NO_PROGRESS_RECORD_PREFIX, NO_PROGRESS_TURNS_BEFORE_STOP, PROOF_CAPABILITY_MATRIX, PROOF_KINDS, PROOF_KINDS_V2, PROOF_MANIFEST_DOMAIN_V2, PROOF_PROTOCOL_VERSION, PROOF_PROTOCOL_VERSION_V2, PROTOCOL_V3_NOTICE, PROTOCOL_V4_NOTICE, PROTOCOL_V5_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, STOP_PROTOCOL_VERSION_V2, SUPPORTED_EVIDENCE_ADAPTERS, SUPPORTED_HOST_RANGE, SUPPORTED_HOST_VERSIONS, SessionApiError, actionCompatible, apply, authorityCaptureCounts, availableBoundaryQualifications, bindExecutableIdentity, bindLiveGoalCapability, bindProofToProjection, bindProofV2ToProjection, bindingSatisfies, boundedArtifactChoiceMatches, canonicalArgvFromCommand, canonicalProjection, canonicalizePath, captureClause, captureItem, certifyCheckpoint, claimedBatchHasRealRootInput, classifyClause, classifyCompletionClaim, classifyTaskIntent, classifyUserInteraction, closingHint, combineHostPolicy, commitIndexSnapshotDigest, commitTreeSnapshotDigest, compareHostVersions, confirmRebind, createGitPrestateEnvelope, createProjection, createProofManifest, createProofManifestV2, 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, proofCapabilityReport, proofDigest, proofDigestV2, proofEvidenceConstraints, proofHostSurfacesOf, proofOperationMatches, proofV2Rejection, proposeRebind, proposeRebindOutcome, proposeRebindV042, qualifyBoundary, readActiveHostGraph, rebindAttemptKey, rebindResponse, recoveryDigest, relevantEvidence, renderRecoveryPacket, replayRebindResult, requestedIdentityKey, requestedTargetAuthorizesMutation, requestedTargetMatchesResolved, requiredSubjectsOf, resolveActiveProfileHostLock, resolveInstalledHostLock, revalidateGitPrestate, sanitizeClauseText, sanitizeUrl, satisfiesSupportedHostRange, scopeCoverageDigest, segmentAuthorityBlocks, segmentClauses, selectHostCohort, semanticActionFromCommand, semanticActionFromText, semanticActionOfScope, sessionQuery, sessionQueryV2, sha256, snapshotSessionEvents, statefulActionsOfScope, supersedeItem, validateActionManifest, validateActionTarget, validateManifest, validateProofManifest, validateProofManifestV2, 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, BOUNDED_ARTIFACT_TYPES, CAPTURE_V042_NOTICE, CERTIFICATE_VERSION, CERTIFICATE_VERSION_V2, CLEANUP_CONDITION_RULE, CLEANUP_CONDITION_RULE_COMPACT, CLEANUP_CONDITION_RULE_SHORT, COMMAND_SURFACE_MANIFEST, CONFIRM_LINE_PATTERN, CONTROL_RECORD_PREFIX, Config, DEFAULT_DELEGATION_TOOL_NAMES, DEFAULT_HOST_LOCK, DEFAULT_RECOVERY_CHAR_BUDGET, DEPENDENCY_FREE_ONLY_CONDITION, EXPECTED_HOST_PACKAGES, FIRST_STEP_GUIDANCE, GIT_COMMAND_MANIFEST_IDS, GIT_COMMAND_TEMPLATES, GOAL_HOST_PACKAGES, HOST_CAPABILITY_PACKAGE_GROUPS, HOST_COHORTS, HostProfileError, LATEST_SUPPORTED_HOST_VERSION, LEGACY_HOST_COHORTS, MIN_RECOVERY_CHAR_BUDGET, MIN_SUPPORTED_HOST_VERSION, NO_PROGRESS_RECORD_PREFIX, NO_PROGRESS_TURNS_BEFORE_STOP, PROOF_CAPABILITY_MATRIX, PROOF_KINDS, PROOF_KINDS_V2, PROOF_MANIFEST_DOMAIN_V2, PROOF_PROTOCOL_VERSION, PROOF_PROTOCOL_VERSION_V2, PROTOCOL_V3_NOTICE, PROTOCOL_V4_NOTICE, PROTOCOL_V5_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, STOP_PROTOCOL_VERSION_V2, SUPPORTED_EVIDENCE_ADAPTERS, SUPPORTED_HOST_RANGE, SUPPORTED_HOST_VERSIONS, SessionApiError, actionCompatible, actionHasCertificationPath, admissibleForRemoval, apply, authorityCaptureCounts, availableBoundaryQualifications, bindExecutableIdentity, bindLiveGoalCapability, bindProofToProjection, bindProofV2ToProjection, bindingSatisfies, boundedArtifactChoiceMatches, canonicalArgvFromCommand, canonicalProjection, canonicalizePath, capabilityConsequence, capabilityFactOf, capabilityRemedyPhrase, captureClause, captureItem, carriesCleanupCondition, certifyCheckpoint, claimedBatchHasRealRootInput, classifyClause, classifyCompletionClaim, classifyTaskIntent, classifyUserInteraction, cleanupConditionFor, closingHint, combineHostPolicy, commitIndexSnapshotDigest, commitTreeSnapshotDigest, compareHostVersions, confirmRebind, createGitPrestateEnvelope, createProjection, createProofManifest, createProofManifestV2, currentContractDigest, decideTurnBoundary, decideTurnStopping, decisionBoundaryKey, deriveItemDiagnosis, deriveProjection, digestStrings, effectuateBoundary, evaluateExternalWaitCapability, evaluateHostCapability, evaluateHostLock, evaluateMinimumHostVersion, evaluateToolSurfaceCapability, evidenceAvailabilityReason, evidenceCoverage, evidenceFromPersistedToolResult, evidenceMatchesItem, executeRevalidatedGitEffect, extractArtifactPaths, extractMethod, extractOperation, extractTextContent, extractToolSubject, firstStepGuidance, 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, partialFailureOf, previewFirstStepInjection, progressFingerprint, proofCapabilityReport, proofDigest, proofDigestV2, proofEvidenceConstraints, proofHostSurfacesOf, proofOperationMatches, proofV2Rejection, proposeRebind, proposeRebindOutcome, proposeRebindV042, qualifyBoundary, readActiveHostGraph, rebindAttemptKey, rebindResponse, recoveryDigest, relevantEvidence, removalIsComplete, removalIsPartiallyKnown, renderRecoveryPacket, replayRebindResult, requestedIdentityKey, requestedTargetAuthorizesMutation, requestedTargetMatchesResolved, requiredSubjectsOf, resolveActiveProfileHostLock, resolveInstalledHostLock, revalidateGitPrestate, sanitizeClauseText, sanitizeUrl, satisfiesSupportedHostRange, scopeCoverageDigest, segmentAuthorityBlocks, segmentClauses, selectHostCohort, semanticActionFromCommand, semanticActionFromText, semanticActionOfScope, sessionQuery, sessionQueryV2, sha256, snapshotSessionEvents, statefulActionsOfScope, supersedeItem, validateActionManifest, validateActionTarget, validateManifest, validateProofManifest, validateProofManifestV2, verifiedLinearCommitReadback, verifyComposedHostLockDump, withDurability };

package/docs/ARCHITECTURE.md

@@ -43,6 +43,8 @@ Recovery packets keep the existing content-dedup and ride the next entered step.
 
 `deriveItemDiagnosis` is the single pure judge shared by checkpoint, recovery, the rebind item query, `context_guard_prepare`, and `/context-guard status`. Per item it reports a task kind (`inquiry`/`action`/`constraint`/…), certification support (`unsupported`/`needs_target`/`needs_evidence`/`unavailable`/`supported`), repairability (agent-repairable, needs user input, unsupported, historical gap, none), the exact missing target fields and evidence facets, and one concrete next action with a resume condition and a stable attempt fingerprint. Inquiries stay captured obligations whose honest next step is to deliver the answer; they are never prescribed a rebind. An effect recorded without its resolution prestate is a historical gap: read back observed state, never re-execute to mint evidence.
 
+0.6.2 adds the shared capability projection beside that verdict (`src/domain/capability-semantics.ts`). Every lane declares one gap kind — unknown interpretation, missing target, missing adapter, legacy migration, missing historical pre-evidence, unattributable operation, pending condition, pending delivery, unavailable host, or standing constraint — and exactly one reachable remedy. Every consumer reads that projection instead of inferring a root cause from one enum, which is what stops a capability this build lacks from being reported as a user-authorization gap. Shell facts additionally carry a layered reading (`processFacts`): the host tool's own return, the console's declared exit status or `unknown`, how far the effect was attributed to this obligation's operation, and the resulting business outcome. Those fields are derived at replay, are excluded from every digest and certificate domain, and never rewrite a historical `outcome` or `parseStatus`.
+
 `context_guard_prepare` is read-only. Before a stateful action it renders the supported command shape from the same audited parser the executor uses, the required resolution/effect/state order, reusable evidence references, the host capability verdict, and the exact missing target fields. It performs no action and never turns a guessed default into user authority.
 
 A log-derived retry ledger keys each rejected rebind attempt by its stable inputs and outcome. An identical second attempt returns `unchanged` with the resume condition instead of a fresh rejection; new related evidence, a new root instruction, or a changed target produces a new key and re-opens evaluation.