@iowarp/clio-coder 0.5.0 → 0.5.2

package/dist/{chunk-TDGYTWM6.js → chunk-F4I3H56H.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-L7G7K4I2.js";
 import {
   ToolNames
-} from "./chunk-V4XJWDHR.js";
+} from "./chunk-6UKFRTXI.js";
 import {
   typebox_exports
 } from "./chunk-GH5ZR6JP.js";
@@ -46,4 +46,4 @@ export {
   clioDocsToolSurface,
   clioLibraryToolSurface
 };
-//# sourceMappingURL=chunk-TDGYTWM6.js.map
+//# sourceMappingURL=chunk-F4I3H56H.js.map

package/dist/chunk-F6KCJO3U.js

@@ -0,0 +1,523 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  AUTONOMY_EXPOSURES
+} from "./chunk-UZVYEF57.js";
+import {
+  isSkillActivation
+} from "./chunk-MMZMM6SW.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/session/continuity/operator-request.ts
+init_esm_shims();
+var HANDOFF_RECOVERY_REQUEST_CUSTOM_TYPE = "contextHandoffRecoveryRequest";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isNullableString(value) {
+  return value === null || isNonEmptyString(value);
+}
+function isHandoffRecoveryRequestData(value) {
+  if (!isRecord(value)) return false;
+  return value.version === 1 && value.requestKind === "handoff_recovery" && isNonEmptyString(value.handoffId) && (value.action === "reduce" || value.action === "deliver") && isNonEmptyString(value.sessionId) && Object.hasOwn(value, "branchAnchorTurnId") && isNullableString(value.branchAnchorTurnId) && Object.hasOwn(value, "selectedLeafTurnId") && isNullableString(value.selectedLeafTurnId) && isNonEmptyString(value.pausedOrFailedEntryId);
+}
+function isHandoffRecoveryRequestEntry(value) {
+  if (!isRecord(value)) return false;
+  return value.kind === "custom" && value.customType === HANDOFF_RECOVERY_REQUEST_CUSTOM_TYPE && isNonEmptyString(value.turnId) && isNullableString(value.parentTurnId) && isNonEmptyString(value.timestamp) && // §3.1 specifies `display: false`. A control record that renders is a
+  // different thing from the one the contract adopted, and the flag is part
+  // of the adopted envelope rather than a presentation preference: an
+  // authority carrier must not also be transcript text.
+  value.display === false && isHandoffRecoveryRequestData(value.data);
+}
+
+// src/domains/session/continuity/contract.ts
+init_esm_shims();
+var HANDOFF_SCHEMA_VERSION = 1;
+var HANDOFF_NOTE_MAX_BYTES = 8192;
+var HANDOFF_MAX_WINDOW_MS = 9e5;
+var HANDOFF_POLICY_LIMITS = Object.freeze({
+  maxAttempts: 2,
+  maxSummaryCallsPerAttempt: 2,
+  additionalSummaryRetriesPerCall: 0,
+  maxSummaryStreamInvocations: 4,
+  flushRetryLimit: 3
+});
+var HANDOFF_MAX_FLUSH_RETRIES = 3;
+
+// src/domains/session/continuity/validate.ts
+init_esm_shims();
+var OUTCOMES = /* @__PURE__ */ new Set(["summarized", "evicted", "continuity_only"]);
+var PAUSE_REASONS = /* @__PURE__ */ new Set([
+  "operator_cancelled",
+  "origin_changed",
+  "delivery_uncertain"
+]);
+var FAILURE_REASONS = /* @__PURE__ */ new Set([
+  "invalid_note",
+  "note_exceeds_replay_budget",
+  "budget_unsafe_no_material",
+  "durability_unresolved",
+  "state_root_removed",
+  "origin_changed",
+  "provider_failed",
+  "attempts_exhausted",
+  "deadline_exceeded"
+]);
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString2(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isNullableString2(value) {
+  return value === null || isNonEmptyString2(value);
+}
+function isFiniteInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value);
+}
+function isNonNegativeInteger(value) {
+  return isFiniteInteger(value) && value >= 0;
+}
+function isPositiveInteger(value) {
+  return isFiniteInteger(value) && value > 0;
+}
+function hasEntryEnvelope(value, kind) {
+  if (!isRecord2(value)) return false;
+  return value.kind === kind && isNonEmptyString2(value.turnId) && isNullableString2(value.parentTurnId) && isNonEmptyString2(value.timestamp);
+}
+function isAcceptedNote(value) {
+  if (!isRecord2(value)) return false;
+  return typeof value.note === "string" && value.note.length > 0 && isPositiveInteger(value.noteBytes) && value.noteBytes <= HANDOFF_NOTE_MAX_BYTES && typeof value.noteSha256 === "string" && /^[0-9a-f]{64}$/.test(value.noteSha256);
+}
+function isHandoffIdentity(value) {
+  if (!isRecord2(value)) return false;
+  return isNonEmptyString2(value.handoffId) && isNonEmptyString2(value.preparedEntryId) && isNonEmptyString2(value.commitId) && isNonEmptyString2(value.commitEntryId) && isNonEmptyString2(value.originSessionId) && isNullableString2(value.branchAnchorTurnId) && isNonEmptyString2(value.initiatingTurnId) && isNonEmptyString2(value.toolCallId) && typeof value.sourceRevision === "string";
+}
+function isHandoffPolicy(value) {
+  if (!isRecord2(value)) return false;
+  if (!isNonNegativeInteger(value.preparedAtMs)) return false;
+  if (!isPositiveInteger(value.automaticDeadlineAtMs)) return false;
+  if (value.automaticDeadlineAtMs <= value.preparedAtMs) return false;
+  if (!isPositiveInteger(value.maxAttempts) || value.maxAttempts > HANDOFF_POLICY_LIMITS.maxAttempts) return false;
+  if (!isPositiveInteger(value.maxSummaryCallsPerAttempt) || value.maxSummaryCallsPerAttempt > HANDOFF_POLICY_LIMITS.maxSummaryCallsPerAttempt) {
+    return false;
+  }
+  if (value.additionalSummaryRetriesPerCall !== HANDOFF_POLICY_LIMITS.additionalSummaryRetriesPerCall) return false;
+  if (!isPositiveInteger(value.maxSummaryStreamInvocations) || value.maxSummaryStreamInvocations > HANDOFF_POLICY_LIMITS.maxSummaryStreamInvocations) {
+    return false;
+  }
+  return isNonNegativeInteger(value.flushRetryLimit) && value.flushRetryLimit <= HANDOFF_POLICY_LIMITS.flushRetryLimit;
+}
+function canonicalJson(value) {
+  if (value === void 0) return "undefined";
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "undefined";
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  const fields = Object.entries(value).filter(([, field]) => field !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return `{${fields.map(([key, field]) => `${JSON.stringify(key)}:${canonicalJson(field)}`).join(",")}}`;
+}
+function isTransitionLink(value) {
+  if (!isRecord2(value)) return false;
+  return isNonEmptyString2(value.entryId) && isNullableString2(value.prevEntryId) && isNonNegativeInteger(value.sequence) && isNonNegativeInteger(value.attempt);
+}
+function isResumeAuthority(value) {
+  if (!isRecord2(value)) return false;
+  return isNonEmptyString2(value.operatorRequestEntryId) && isNonEmptyString2(value.pausedOrFailedEntryId) && (value.action === "reduce" || value.action === "deliver") && isPositiveInteger(value.automaticDeadlineAtMs);
+}
+function isHandoffEvent(value) {
+  if (!isRecord2(value)) return false;
+  switch (value.phase) {
+    case "prepared":
+      return isAcceptedNote(value.accepted) && isHandoffPolicy(value.policy);
+    case "reducing":
+      return value.resumeRef === void 0 || isNonEmptyString2(value.resumeRef);
+    case "delivered":
+      return isNonEmptyString2(value.deliveryId) && isNonEmptyString2(value.continuationTurnId) && (value.resumeRef === void 0 || isNonEmptyString2(value.resumeRef));
+    case "acknowledged":
+      return isNonEmptyString2(value.deliveryId) && isNonEmptyString2(value.terminalResponseEntryId);
+    case "paused":
+      return typeof value.reason === "string" && PAUSE_REASONS.has(value.reason);
+    case "failed":
+      return typeof value.reason === "string" && FAILURE_REASONS.has(value.reason);
+    case "resumed":
+      return isResumeAuthority(value.authority);
+    default:
+      return false;
+  }
+}
+function isHandoffTransactionEntry(value) {
+  if (!hasEntryEnvelope(value, "handoffTransaction")) return false;
+  if (value.schemaVersion !== HANDOFF_SCHEMA_VERSION) return false;
+  if (!isHandoffIdentity(value.identity)) return false;
+  if (!isTransitionLink(value.transition)) return false;
+  if (!isHandoffEvent(value.event)) return false;
+  if (value.transition.entryId !== value.turnId) return false;
+  if (value.event.phase === "prepared") {
+    return value.transition.entryId === value.identity.preparedEntryId && value.transition.prevEntryId === null && value.transition.sequence === 0 && value.transition.attempt === 0;
+  }
+  return value.transition.prevEntryId !== null && value.transition.sequence > 0;
+}
+function isCommitData(value) {
+  if (!isRecord2(value)) return false;
+  if (typeof value.outcome !== "string" || !OUTCOMES.has(value.outcome)) return false;
+  if (!isRecord2(value.entry)) return false;
+  if (!isNonEmptyString2(value.entry.turnId)) return false;
+  if (!isNullableString2(value.entry.parentTurnId)) return false;
+  if (!isNonEmptyString2(value.entry.timestamp)) return false;
+  if (!isTransitionLink(value.transition)) return false;
+  if (value.transition.entryId !== value.entry.turnId) return false;
+  if (!isNonNegativeInteger(value.tokensBefore) || !isNonNegativeInteger(value.tokensAfter)) return false;
+  if (value.outcome === "summarized") {
+    return isNonEmptyString2(value.summaryRef) && value.evictionRef === void 0;
+  }
+  if (value.outcome === "evicted") {
+    return isNonEmptyString2(value.evictionRef) && value.summaryRef === void 0;
+  }
+  return value.summaryRef === void 0 && value.evictionRef === void 0;
+}
+function isCarriedState(value) {
+  if (!isRecord2(value)) return false;
+  if (!isTransitionLink(value.transition)) return false;
+  if (!isRecord2(value.event)) return false;
+  if (value.event.phase !== "ready" && !isHandoffEvent(value.event)) return false;
+  if (value.event.phase === "ready" && Object.keys(value.event).length !== 1) return false;
+  if (value.activeResume !== null) {
+    if (!isRecord2(value.activeResume)) return false;
+    if (!isNonEmptyString2(value.activeResume.entryId)) return false;
+    if (!isResumeAuthority(value.activeResume.authority)) return false;
+  }
+  if (value.delivery !== null) {
+    if (!isRecord2(value.delivery)) return false;
+    if (!isNonEmptyString2(value.delivery.deliveryId)) return false;
+    if (!isNonEmptyString2(value.delivery.continuationTurnId)) return false;
+  }
+  if (value.event.phase === "resumed") {
+    const resume = value.activeResume;
+    if (!isRecord2(resume)) return false;
+    if (resume.entryId !== value.transition.entryId) return false;
+    if (canonicalJson(resume.authority) !== canonicalJson(value.event.authority)) return false;
+  }
+  if (value.event.phase === "delivered") {
+    const delivery = value.delivery;
+    if (!isRecord2(delivery)) return false;
+    if (delivery.deliveryId !== value.event.deliveryId) return false;
+    if (delivery.continuationTurnId !== value.event.continuationTurnId) return false;
+  }
+  return true;
+}
+function isContinuityCheckpointPayload(value) {
+  if (!isRecord2(value)) return false;
+  if (value.schemaVersion !== HANDOFF_SCHEMA_VERSION) return false;
+  if (!isHandoffIdentity(value.identity)) return false;
+  if (!isAcceptedNote(value.accepted)) return false;
+  if (!isHandoffPolicy(value.policy)) return false;
+  if (!isCommitData(value.commit)) return false;
+  if (!isCarriedState(value.state)) return false;
+  if (value.commit.entry.turnId !== value.identity.commitEntryId) return false;
+  if (value.commit.transition.attempt < 1 || value.commit.transition.attempt > value.policy.maxAttempts) return false;
+  if (value.state.transition.attempt > value.policy.maxAttempts) return false;
+  if (value.state.transition.sequence < value.commit.transition.sequence) return false;
+  if (value.state.event.phase === "ready") {
+    return canonicalJson(value.state.transition) === canonicalJson(value.commit.transition);
+  }
+  return value.state.transition.attempt >= value.commit.transition.attempt;
+}
+function isContinuityCommitEntry(value) {
+  if (!hasEntryEnvelope(value, "continuityCommit")) return false;
+  if (!isContinuityCheckpointPayload(value.continuity)) return false;
+  const payload = value.continuity;
+  if (payload.state.event.phase !== "ready") return false;
+  if (payload.state.activeResume !== null || payload.state.delivery !== null) return false;
+  return value.turnId === payload.commit.entry.turnId && value.parentTurnId === payload.commit.entry.parentTurnId && value.timestamp === payload.commit.entry.timestamp;
+}
+function isContinuityCarryingSummary(value) {
+  if (!hasEntryEnvelope(value, "compactionSummary")) return false;
+  return isContinuityCheckpointPayload(value.continuity);
+}
+
+// src/domains/session/entries.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+var SKILL_CONTEXT_STATE = "skillContextState";
+function skillContextContentHash(content) {
+  return createHash("sha256").update(JSON.stringify(content)).digest("hex");
+}
+function isSkillContextState(value) {
+  return isRecord3(value) && value.version === 1 && (value.unknown === void 0 || value.unknown === true) && Array.isArray(value.activationRefs) && value.activationRefs.every((ref) => typeof ref === "string");
+}
+function isSkillContextCheckpoint(value) {
+  return isRecord3(value) && value.version === 1 && Array.isArray(value.skills) && value.skills.every(
+    (skill) => isRecord3(skill) && [skill.activationRef, skill.requestRef, skill.callRef, skill.resultRef, skill.requestText, skill.contentHash].every(
+      isString
+    ) && isSkillActivation(skill.activation) && Array.isArray(skill.content) && skill.content.every((block) => isRecord3(block) && block.type === "text" && typeof block.text === "string")
+  );
+}
+function verifiedSkillContextCheckpoint(value) {
+  if (!isSkillContextCheckpoint(value)) return false;
+  const refs = /* @__PURE__ */ new Set();
+  const names = /* @__PURE__ */ new Set();
+  return value.skills.every((skill) => {
+    const activation = skill.activation;
+    if (![skill.activationRef, skill.requestRef, skill.callRef, skill.resultRef].every((ref) => ref.length > 0) || activation.runId !== void 0 || activation.triggeredBy !== "tool" || activation.turnId !== skill.requestRef || !activation.name || !activation.filePath || !activation.source || !activation.sourceOrigin || !/^[a-f0-9]{64}$/.test(activation.hash) || activation.drift !== void 0 && activation.drift !== "match" || skill.content.length === 0 || skill.content.every((block) => block.text.length === 0) || skill.contentHash !== skillContextContentHash(skill.content) || refs.has(skill.activationRef) || names.has(activation.name))
+      return false;
+    refs.add(skill.activationRef);
+    names.add(activation.name);
+    return true;
+  });
+}
+function isPreservedUserContext(value) {
+  return isRecord3(value) && isString(value.turnId) && isString(value.text);
+}
+function mainSkillContextState(entries, policy) {
+  if (!policy) return latestSkillContextState(entries);
+  if (policy.modelActivation === true && policy.carriedSurface !== true && policy.requests.length === 0 && policy.loadedSkillNames.size === 0 && policy.loadedSkillPolicies.size === 0)
+    return latestSkillContextState(entries);
+  if (policy.requests.some((request) => !policy.loadedSkillNames.has(request.name))) return null;
+  const names = [...policy.loadedSkillNames];
+  if (names.length === 0) return null;
+  const activationRefs = [];
+  for (const name of names) {
+    const entry = [...entries].reverse().find(
+      (candidate) => candidate.kind === "skillActivation" && candidate.activation.runId === void 0 && candidate.activation.name === name
+    );
+    if (!entry) return null;
+    activationRefs.push(entry.turnId);
+  }
+  return { version: 1, activationRefs };
+}
+function latestSkillContextState(entries) {
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (entry?.kind === "custom" && entry.customType === SKILL_CONTEXT_STATE) {
+      return isSkillContextState(entry.data) ? entry.data : void 0;
+    }
+    if (entry?.kind === "compactionSummary" && entry.skillContext !== void 0) {
+      return verifiedSkillContextCheckpoint(entry.skillContext) ? { version: 1, activationRefs: entry.skillContext.skills.map((skill) => skill.activationRef) } : void 0;
+    }
+  }
+  return void 0;
+}
+function decisionRef(interviewId, key) {
+  return `${interviewId}/${key}`;
+}
+var EVICTION_REASONS = [
+  "superseded_read",
+  "stale_after_mutation",
+  "listing_consumed",
+  "failure_resolved",
+  "thinking_turn_closed",
+  "age_horizon",
+  "operator"
+];
+var EVICTION_TRIGGERS = ["pressure", "operator"];
+var RECALL_TRIGGERS = ["tool", "operator"];
+var SESSION_ENTRY_KINDS = [
+  "message",
+  "bashExecution",
+  "custom",
+  "modelChange",
+  "thinkingLevelChange",
+  "fileEntry",
+  "branchSummary",
+  "compactionSummary",
+  "sessionInfo",
+  "label",
+  "protectedArtifact",
+  "skillActivation",
+  "taskLedger",
+  "decisionLedger",
+  "workerRun",
+  "contextEviction",
+  "contextRecall",
+  // Durable continuity (CONTRACTS §3). Both are bookkeeping sidecars: they
+  // never become model messages by themselves, never move the message leaf,
+  // and never become a cut point. The accepted note reaches the model exactly
+  // once, through the continuity replay projection.
+  "handoffTransaction",
+  "continuityCommit"
+];
+function isRecord3(value) {
+  return !!value && typeof value === "object";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isOptionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+function isOptionalBoolean(value) {
+  return value === void 0 || typeof value === "boolean";
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isPositiveInteger2(value) {
+  return isNumber(value) && Number.isInteger(value) && value > 0;
+}
+function isOptionalNumber(value) {
+  return value === void 0 || isNumber(value);
+}
+function isNullableString3(value) {
+  return value === null || typeof value === "string";
+}
+function isOneOf(value, allowed) {
+  return typeof value === "string" && allowed.includes(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function hasBaseSessionEntryFields(v) {
+  return isString(v.turnId) && isNullableString3(v.parentTurnId) && isString(v.timestamp);
+}
+var MESSAGE_ROLES = ["user", "assistant", "tool_call", "tool_result", "system", "checkpoint"];
+var FILE_OPERATIONS = ["read", "write", "edit", "create", "delete"];
+var COMPACTION_TRIGGERS = ["auto", "force", "overflow"];
+var PROTECTED_ARTIFACT_SOURCES = [
+  "validation",
+  "middleware",
+  "user",
+  "session"
+];
+var TASK_LEDGER_STATUSES = ["pending", "active", "completed", "blocked", "cancelled"];
+var TASK_LEDGER_EVIDENCE_STATUSES = [
+  "required",
+  "pending",
+  "passed",
+  "failed",
+  "missing"
+];
+var DECISION_STATUSES = ["active", "superseded"];
+var DECISION_INTERVIEW_STATUSES = ["complete", "cancelled"];
+var WORKER_RUN_ORIGINS = ["user", "agent"];
+var WORKER_RUN_RUNTIME_KINDS = ["clio", "acp", "claude-sdk", "claude-code"];
+function isWorkerRunRuntime(value) {
+  if (!isRecord3(value)) return false;
+  return isOneOf(value.kind, WORKER_RUN_RUNTIME_KINDS) && isOptionalString(value.targetId) && isOptionalString(value.wireModelId) && isOptionalString(value.peerId);
+}
+function isTaskLedgerGoal(value) {
+  if (!isRecord3(value)) return false;
+  if (!isString(value.id) || !isString(value.title)) return false;
+  if (!isOneOf(value.status, TASK_LEDGER_STATUSES)) return false;
+  if (value.parentGoalId !== void 0 && !isNullableString3(value.parentGoalId)) return false;
+  const hasPairedProvenance = value.origin === "user" ? isString(value.userTaskId) && /^u[1-9]\d*$/.test(value.userTaskId) : (value.origin === void 0 || value.origin === "agent") && value.userTaskId === void 0;
+  return isOptionalString(value.description) && hasPairedProvenance;
+}
+function isTaskLedgerEvidence(value) {
+  if (!isRecord3(value)) return false;
+  if (!isString(value.id) || !isString(value.description)) return false;
+  if (!isOneOf(value.status, TASK_LEDGER_EVIDENCE_STATUSES)) return false;
+  return isOptionalString(value.command) && isOptionalString(value.artifactPath) && isOptionalString(value.observedAt) && isOptionalString(value.notes);
+}
+function isDecisionRecord(value) {
+  if (!isRecord3(value)) return false;
+  if (!isString(value.key) || !/^[a-z0-9]+(?:[_-][a-z0-9]+)*$/.test(value.key)) return false;
+  if (!isString(value.value) || !isOneOf(value.status, DECISION_STATUSES) || !isString(value.decidedAt)) return false;
+  if (!isOptionalString(value.label) || !isOptionalString(value.source_question)) return false;
+  if (value.source !== void 0 && !isOneOf(value.source, ["operator", "agent"])) return false;
+  if (value.revisionSource !== void 0 && !isOneOf(value.revisionSource, ["operator", "agent"])) return false;
+  if (value.alternatives !== void 0 && !isStringArray(value.alternatives)) return false;
+  if (!isOptionalString(value.rationale)) return false;
+  if (!isOptionalString(value.revisedAt) || !isOptionalString(value.correction)) return false;
+  return value.status === "superseded" ? isString(value.revisedAt) : value.revisedAt === void 0 && value.revisionSource === void 0 && value.correction === void 0;
+}
+function isOptionalCompactionUsage(value) {
+  if (value === void 0) return true;
+  if (!isRecord3(value)) return false;
+  const cost = value.cost;
+  return isOptionalString(value.targetId) && isOptionalString(value.modelId) && isNumber(value.input) && isNumber(value.output) && isNumber(value.cacheRead) && isNumber(value.cacheWrite) && isNumber(value.reasoning) && isNumber(value.totalTokens) && isNumber(value.apiCalls) && isRecord3(cost) && isNumber(cost.total);
+}
+function isProtectedArtifact(value) {
+  if (!isRecord3(value)) return false;
+  return isString(value.path) && isString(value.protectedAt) && isString(value.reason) && isOneOf(value.source, PROTECTED_ARTIFACT_SOURCES) && isOptionalString(value.validationCommand) && isOptionalNumber(value.validationExitCode);
+}
+function isSessionHeader(value) {
+  if (!isRecord3(value)) return false;
+  return value.type === "session" && isPositiveInteger2(value.version) && isString(value.id) && isString(value.timestamp) && isString(value.cwd) && isOptionalString(value.parentSession) && isOptionalString(value.parentTurnId);
+}
+function isWorkingSetRef(value) {
+  return isRecord3(value) && isString(value.entry);
+}
+function isEvictedItem(value) {
+  return isRecord3(value) && isWorkingSetRef(value.ref) && isOneOf(value.reason, EVICTION_REASONS) && isNumber(value.tokensFreed) && isString(value.marker) && (value.alias === void 0 || typeof value.alias === "string" && /^r[1-9]\d*$/.test(value.alias)) && isOptionalString(value.by);
+}
+function isSessionEntry(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (!hasBaseSessionEntryFields(v)) return false;
+  if (!isOneOf(v.kind, SESSION_ENTRY_KINDS)) return false;
+  switch (v.kind) {
+    case "message":
+      return Object.hasOwn(v, "payload") && isOneOf(v.role, MESSAGE_ROLES);
+    case "bashExecution":
+      return isString(v.command) && isString(v.output) && (v.exitCode === null || isNumber(v.exitCode)) && typeof v.cancelled === "boolean" && typeof v.truncated === "boolean" && isOptionalString(v.fullOutputPath) && isOptionalBoolean(v.excludeFromContext);
+    case "custom":
+      return isString(v.customType) && isOptionalBoolean(v.display) && (v.customType !== SKILL_CONTEXT_STATE || isSkillContextState(v.data)) && // A reserved control subtype is strictly validated, because opaque
+      // custom data must never become resume authority by claiming the name.
+      (v.customType !== HANDOFF_RECOVERY_REQUEST_CUSTOM_TYPE || isHandoffRecoveryRequestData(v.data));
+    case "modelChange":
+      return isString(v.provider) && isString(v.modelId) && isOptionalString(v.target);
+    case "thinkingLevelChange":
+      return isString(v.thinkingLevel);
+    case "fileEntry":
+      return isString(v.path) && isOneOf(v.operation, FILE_OPERATIONS) && isOptionalNumber(v.bytes) && isOptionalString(v.hash);
+    case "branchSummary":
+      return isString(v.fromTurnId) && isString(v.summary);
+    case "compactionSummary":
+      return isString(v.summary) && isNumber(v.tokensBefore) && isString(v.firstKeptTurnId) && isOptionalCompactionUsage(v.usage) && (v.trigger === void 0 || isOneOf(v.trigger, COMPACTION_TRIGGERS)) && isOptionalNumber(v.tokensAfter) && isOptionalNumber(v.messagesSummarized) && isOptionalBoolean(v.isSplitTurn) && (v.skillContext === void 0 || isSkillContextCheckpoint(v.skillContext)) && (v.userContext === void 0 || isPreservedUserContext(v.userContext)) && (v.continuity === void 0 || isContinuityCheckpointPayload(v.continuity));
+    case "sessionInfo":
+      return isOptionalString(v.name) && isOptionalString(v.targetTurnId) && isOptionalString(v.label);
+    case "label":
+      return isString(v.targetTurnId) && isOptionalString(v.label);
+    case "protectedArtifact":
+      return v.action === "protect" && isProtectedArtifact(v.artifact) && isOptionalString(v.toolName) && isOptionalString(v.toolCallId) && isOptionalString(v.runId) && isOptionalString(v.correlationId);
+    case "skillActivation":
+      return isSkillActivation(v.activation);
+    case "taskLedger":
+      return isOptionalString(v.boardId) && Array.isArray(v.goals) && v.goals.every(isTaskLedgerGoal) && Array.isArray(v.subgoals) && v.subgoals.every(isTaskLedgerGoal) && isStringArray(v.activeRunIds) && Array.isArray(v.requiredValidationEvidence) && v.requiredValidationEvidence.every(isTaskLedgerEvidence);
+    case "decisionLedger":
+      return (v.origin === void 0 || isOneOf(v.origin, ["interview", "agent"])) && isString(v.interviewId) && isOneOf(v.interviewStatus, DECISION_INTERVIEW_STATUSES) && isString(v.startedAt) && isString(v.endedAt) && isNumber(v.roundCount) && Number.isInteger(v.roundCount) && v.roundCount >= 0 && isOptionalString(v.summary) && isOptionalString(v.transcriptPath) && (v.exposure === void 0 || isOneOf(v.exposure, AUTONOMY_EXPOSURES)) && Array.isArray(v.decisions) && v.decisions.every(isDecisionRecord);
+    case "workerRun":
+      return (v.helper === void 0 || v.helper === true) && isOptionalString(v.task) && isString(v.assignmentId) && isString(v.runId) && isOneOf(v.origin, WORKER_RUN_ORIGINS) && isString(v.agentId) && isWorkerRunRuntime(v.runtime) && isOptionalString(v.parentToolCallId);
+    case "contextEviction":
+      return isString(v.policyId) && isOneOf(v.trigger, EVICTION_TRIGGERS) && Array.isArray(v.evicted) && v.evicted.every(isEvictedItem) && isNumber(v.tokensBefore) && isNumber(v.tokensAfter) && (v.pressureBefore === null || isNumber(v.pressureBefore)) && (v.snapshotIdBefore === null || isString(v.snapshotIdBefore));
+    case "contextRecall":
+      return isWorkingSetRef(v.ref) && isOneOf(v.trigger, RECALL_TRIGGERS) && isNumber(v.tokensReadmitted) && isOptionalString(v.toolCallId);
+    // The continuity guards check payload structure and the identity/link
+    // equalities the chain depends on, not just the kind string. A record
+    // that says `continuityCommit` and carries nothing usable is rejected
+    // here rather than surfacing later as an empty-but-present commit.
+    case "handoffTransaction":
+      return isHandoffTransactionEntry(v);
+    case "continuityCommit":
+      return isContinuityCommitEntry(v);
+  }
+  return false;
+}
+
+export {
+  HANDOFF_RECOVERY_REQUEST_CUSTOM_TYPE,
+  isHandoffRecoveryRequestEntry,
+  HANDOFF_SCHEMA_VERSION,
+  HANDOFF_NOTE_MAX_BYTES,
+  HANDOFF_MAX_WINDOW_MS,
+  HANDOFF_POLICY_LIMITS,
+  HANDOFF_MAX_FLUSH_RETRIES,
+  canonicalJson,
+  isHandoffTransactionEntry,
+  isContinuityCheckpointPayload,
+  isContinuityCommitEntry,
+  isContinuityCarryingSummary,
+  SKILL_CONTEXT_STATE,
+  skillContextContentHash,
+  verifiedSkillContextCheckpoint,
+  mainSkillContextState,
+  latestSkillContextState,
+  decisionRef,
+  isDecisionRecord,
+  isSessionHeader,
+  isSessionEntry
+};
+//# sourceMappingURL=chunk-F6KCJO3U.js.map

package/dist/{chunk-FGSQHUCK.js → chunk-F6VKWTTY.js}

@@ -1,10 +1,10 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   compileFleetExecutionPlan
-} from "./chunk-NFSK2VNU.js";
+} from "./chunk-LZMTVVN4.js";
 import {
   discoverAgentRecipes
-} from "./chunk-ZARZ4POR.js";
+} from "./chunk-G5ZDQQE3.js";
 import {
   loadFleetCommands,
   loadFleetContract,
@@ -13,10 +13,10 @@ import {
 import {
   requestExecutionRole,
   withAttemptRole
-} from "./chunk-BRCOSE7O.js";
+} from "./chunk-SZUO5BSE.js";
 import {
   normalizeAgentSpec
-} from "./chunk-LNOXCGN2.js";
+} from "./chunk-7UFDIOBT.js";
 import {
   readSettings
 } from "./chunk-56XP4FJU.js";
@@ -107,4 +107,4 @@ function inspectFleet(name, vars) {
 export {
   inspectFleet
 };
-//# sourceMappingURL=chunk-FGSQHUCK.js.map
+//# sourceMappingURL=chunk-F6VKWTTY.js.map

package/dist/{chunk-UJD5MPP6.js → chunk-FLNXQQ5B.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-L7G7K4I2.js";
 import {
   ToolNames
-} from "./chunk-V4XJWDHR.js";
+} from "./chunk-6UKFRTXI.js";
 import {
   typebox_exports
 } from "./chunk-GH5ZR6JP.js";
@@ -49,4 +49,4 @@ export {
   CODE_NAV_MAX_LIMIT,
   codeNavToolSurface
 };
-//# sourceMappingURL=chunk-UJD5MPP6.js.map
+//# sourceMappingURL=chunk-FLNXQQ5B.js.map

package/dist/{chunk-EX57VVWW.js → chunk-FOSRJ2VZ.js}

@@ -36,7 +36,7 @@ import {
   declineInteropAgents,
   interopProposals,
   renderProposalEntry
-} from "./chunk-T2MDZES3.js";
+} from "./chunk-EBMTBE76.js";
 import {
   detectInteropAgents,
   resolveOnPath
@@ -80,7 +80,7 @@ import {
   probeCapabilitiesForModel,
   readTargetModelSnapshot,
   recordTargetModelSnapshot
-} from "./chunk-EYTLV3W3.js";
+} from "./chunk-HTWTORF7.js";
 import {
   credentialsPresent
 } from "./chunk-DVTBERFY.js";
@@ -3151,7 +3151,7 @@ var DIAGNOSTICS_SECTION = {
       label: "Run doctor",
       hint: "read-only health check",
       run: async (io) => {
-        const { runDoctorCommand } = await import("./doctor-S5KZ2GTN.js");
+        const { runDoctorCommand } = await import("./doctor-53AVQXAO.js");
         await runDoctorCommand([]);
         await io.rl.text("Press Enter to return");
       }
@@ -4154,4 +4154,4 @@ export {
   runTargetRename,
   runConfigureCommand
 };
-//# sourceMappingURL=chunk-EX57VVWW.js.map
+//# sourceMappingURL=chunk-FOSRJ2VZ.js.map

package/dist/{chunk-ZARZ4POR.js → chunk-G5ZDQQE3.js}

@@ -3,7 +3,7 @@ import {
   loadSkills,
   parseAgentRecipeSchema,
   recipeIdFromPath
-} from "./chunk-LAR7DX5E.js";
+} from "./chunk-B5TASTCK.js";
 import {
   enabledPluginResourceRoots,
   parseFrontmatter,
@@ -13,7 +13,7 @@ import {
   assertAgentSpecPolicy,
   isShadowAgent,
   normalizeAgentSpec
-} from "./chunk-LNOXCGN2.js";
+} from "./chunk-7UFDIOBT.js";
 import {
   readSettings
 } from "./chunk-56XP4FJU.js";
@@ -207,4 +207,4 @@ function discoverAgentRecipes(cwd = process.cwd(), diagnostics = []) {
 export {
   discoverAgentRecipes
 };
-//# sourceMappingURL=chunk-ZARZ4POR.js.map
+//# sourceMappingURL=chunk-G5ZDQQE3.js.map