@remembrance-ai/opencode-plugin 0.2.3 → 0.2.5

package/servers/remembrance-mcp.mjs

@@ -4798,8 +4798,8 @@ function parseSurfaceReleases(value) {
   );
 }
 function isCanonicalIsoTimestamp(value) {
-  const timestamp = Date.parse(value);
-  return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;
+  const timestamp2 = Date.parse(value);
+  return Number.isFinite(timestamp2) && new Date(timestamp2).toISOString() === value;
 }
 
 // ../core/src/client-health-alerts.ts
@@ -9900,6 +9900,9 @@ var MAX_RSA_FACTOR_SEARCH_MODULUS = 1n << 4096n;
 var MAX_RSA_ARITHMETIC_WORK = 2 ** 32;
 var MAX_REQUEST_RSA_ARITHMETIC_WORK = 2 ** 34;
 var currentRedactionRequest = () => void 0;
+function trackRedactionRequests(current) {
+  currentRedactionRequest = current;
+}
 var MIN_DETACHED_RSA_CONTINUATION_BYTES = 16;
 var MAX_DETACHED_RSA_CONTINUATION_READS = 1 << 20;
 var detachedRsaContinuationReads = /* @__PURE__ */ new WeakMap();
@@ -10506,9 +10509,137 @@ function serializedPublicRsaKeyValueIsValid2(value, metrics) {
 function rsaPublicNumbersArePlausible2(modulus, exponent, metrics) {
   return rsaPublicNumbersArePlausible(modulus, exponent, metrics);
 }
+function redactPayload(payload) {
+  const analysis = analyzeSensitivePayload(payload);
+  return redactAnalyzedPayload(payload, analysis);
+}
+function redactAnalyzedPayload(payload, analysis) {
+  if (!payload || typeof payload !== "object") {
+    if (typeof payload !== "string") return payload;
+    const baseline = redactStringValue(payload, analysis.metrics);
+    const ranges = lateStringOverlapRanges(payload, analysis.metrics);
+    analysis.sensitiveMaterial ||= ranges.length > 0;
+    return applyLateOverlapRanges(baseline, ranges, analysis.metrics);
+  }
+  const valuePlans = /* @__PURE__ */ new Map();
+  const keyPlans = /* @__PURE__ */ new Map();
+  const outputKeys = /* @__PURE__ */ new Map();
+  const clones = analysis.graph.containers.map(
+    (container) => analysis.numericPrivateContainers.has(container) ? "[redacted]" : container.kind === "array" ? new Array(container.value.length) : {}
+  );
+  for (const container of analysis.graph.containers) {
+    if (analysis.numericPrivateContainers.has(container)) continue;
+    const target = clones[container.id];
+    if (container.kind === "array") {
+      for (const edge of container.edges) {
+        target[edge.index] = redactedEdgeValue(
+          edge,
+          analysis,
+          clones,
+          valuePlans
+        );
+      }
+      continue;
+    }
+    const objectTarget = target;
+    const redactedKeys = analysis.sensitiveObjectKeys.get(container.value);
+    const reservedKeys = new Set(
+      container.edges.filter((edge) => !redactedKeys?.has(edge.key)).map((edge) => edge.key)
+    );
+    const usedKeys = /* @__PURE__ */ new Set();
+    const nextSuffix = /* @__PURE__ */ new Map();
+    for (const edge of container.edges) {
+      const keyPlan = redactedKeys?.has(edge.key) ? redactStringValue(edge.key, analysis.metrics) : unchangedStringProjection(edge.key);
+      const forcedKey = redactedKeys?.has(edge.key) && !keyPlan.changed;
+      keyPlans.set(edge, forcedKey ? fullyRedactedStringProjection() : keyPlan);
+      const outputKey = redactedKeys?.has(edge.key) ? uniqueRedactedObjectKey(
+        reservedKeys,
+        usedKeys,
+        nextSuffix,
+        forcedKey ? "[redacted]" : keyPlan.value
+      ) : edge.key;
+      outputKeys.set(edge, outputKey);
+      usedKeys.add(outputKey);
+      const value = isSensitiveKey(edge.key) && edge.value !== null && edge.value !== void 0 ? "[redacted]" : redactedEdgeValue(edge, analysis, clones, valuePlans);
+      Object.defineProperty(objectTarget, outputKey, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+  }
+  const claims = latePayloadOverlapRanges(analysis, valuePlans, keyPlans);
+  for (const container of analysis.graph.containers) {
+    if (analysis.numericPrivateContainers.has(container)) continue;
+    const target = clones[container.id];
+    const renamed = /* @__PURE__ */ new Map();
+    for (const edge of container.edges) {
+      const valuePlan = valuePlans.get(edge);
+      const valueRanges = edge.valueToken && claims.get(edge.valueToken);
+      if (valuePlan && valueRanges) {
+        const key = container.kind === "array" ? edge.index : outputKeys.get(edge);
+        target[key] = applyLateOverlapRanges(
+          valuePlan,
+          valueRanges,
+          analysis.metrics
+        );
+      }
+      const keyPlan = keyPlans.get(edge);
+      const keyRanges = edge.keyToken && claims.get(edge.keyToken);
+      if (keyPlan && keyRanges) {
+        const oldKey = outputKeys.get(edge);
+        const candidate = applyLateOverlapRanges(
+          { ...keyPlan, value: oldKey },
+          keyRanges,
+          analysis.metrics
+        );
+        if (candidate !== oldKey) renamed.set(edge, candidate);
+      }
+    }
+    if (renamed.size === 0) continue;
+    const reserved = new Set(
+      container.edges.filter((edge) => !renamed.has(edge)).map((edge) => outputKeys.get(edge))
+    );
+    const used = /* @__PURE__ */ new Set();
+    const suffixes = /* @__PURE__ */ new Map();
+    const entries = container.edges.map((edge) => {
+      const oldKey = outputKeys.get(edge);
+      const candidate = renamed.get(edge);
+      const key = candidate === void 0 ? oldKey : uniqueRedactedObjectKey(reserved, used, suffixes, candidate);
+      used.add(key);
+      return { oldKey, key, value: target[oldKey] };
+    });
+    for (const { oldKey } of entries) delete target[oldKey];
+    for (const { key, value } of entries)
+      Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+  }
+  return clones[analysis.graph.root.id];
+}
 function containsSensitiveMaterial(payload) {
   return inspectPayloadForSensitiveMaterial(payload).sensitiveMaterial;
 }
+function redactedEdgeValue(edge, analysis, clones, plans) {
+  if (edge.child) return clones[edge.child.id];
+  if (typeof edge.value !== "string") return edge.value;
+  const ranges = analysis.privateKeyBodyRanges.get(edge.owner.value)?.get(edge.key);
+  const native = ranges ? projectedTextRanges(edge.value, ranges, analysis.metrics) : unchangedStringProjection(edge.value);
+  const lexical = redactStringValue(native.value, analysis.metrics);
+  plans.set(edge, {
+    ...lexical,
+    retained: composeRetainedSourceSpans(
+      native.retained,
+      lexical.retained,
+      analysis.metrics
+    )
+  });
+  return lexical.value;
+}
 function inspectPayloadForSensitiveMaterial(payload) {
   const analysis = analyzeSensitivePayload(payload);
   latePayloadOverlapRanges(analysis);
@@ -12058,7 +12189,7 @@ function findIndependentlyEncodedPrivateKeyFrameProof(tokens, metrics) {
       const recoverableLength = recoverableProof?.length ?? null;
       const length = completeLength ?? recoverableLength;
       if (length === null) continue;
-      const continuation = recoverableProof?.basis === "factors" ? independentlyEncodedRsaCrtContinuationRanges(
+      const continuation2 = recoverableProof?.basis === "factors" ? independentlyEncodedRsaCrtContinuationRanges(
         tokens,
         frames,
         bytes,
@@ -12073,10 +12204,10 @@ function findIndependentlyEncodedPrivateKeyFrameProof(tokens, metrics) {
         bytes,
         encoding,
         frames,
-        continuationRanges: continuation.ranges,
+        continuationRanges: continuation2.ranges,
         start: frame.start,
         end: frame.start + length,
-        ambiguous: continuation.ambiguous,
+        ambiguous: continuation2.ambiguous,
         complete: completeLength !== null,
         factorBacked: recoverableProof?.basis === "factors",
         recoverable: completeLength === null
@@ -14713,19 +14844,19 @@ function recordCryptographicMatchedTerminalOwnership(tokens, assessment, metrics
 }
 function matchedTerminalSourcePieceRanges(tokens, assessment) {
   const sourceStart = assessment.sourcePieceRanges[0].start;
-  const continuation = assessment.rsaCrtContinuations.filter(
+  const continuation2 = assessment.rsaCrtContinuations.filter(
     (candidate) => candidate.start === sourceStart && candidate.status === "match" && candidate.mismatchAt === null
   ).sort((left, right) => right.matchedEnd - left.matchedEnd)[0];
-  if (!continuation) return [];
+  if (!continuation2) return [];
   const ranges = [];
   for (const [pieceIndex, token] of tokens.entries()) {
     const source = assessment.sourcePieceRanges[pieceIndex];
-    if (source.end <= continuation.matchedEnd) {
+    if (source.end <= continuation2.matchedEnd) {
       ranges.push({ pieceIndex, start: 0, end: token.value.length });
       continue;
     }
-    if (source.start >= continuation.matchedEnd) continue;
-    const matchedLength = continuation.matchedEnd - source.start;
+    if (source.start >= continuation2.matchedEnd) continue;
+    const matchedLength = continuation2.matchedEnd - source.start;
     if (matchedLength > 0 && /^=+$/u.test(token.value.slice(matchedLength))) {
       ranges.push({ pieceIndex, start: 0, end: token.value.length });
     }
@@ -15604,13 +15735,13 @@ function assessEncodedPieceSequence(pieces, textOf, metrics, requireBoundedRecov
         (completeRange) => completeRange.start < end && start < completeRange.end
       );
       const authenticatedFactorRange = scanned.rsaCrtContinuations.some(
-        (continuation) => {
-          const ownedEnd = Math.min(end, continuation.matchedEnd);
-          if (continuation.start >= ownedEnd || start >= continuation.matchedEnd) {
+        (continuation2) => {
+          const ownedEnd = Math.min(end, continuation2.matchedEnd);
+          if (continuation2.start >= ownedEnd || start >= continuation2.matchedEnd) {
             return false;
           }
-          if (position.start < continuation.factorEnd) return true;
-          return ownedEnd - Math.max(position.start, continuation.factorEnd) >= continuation.minimumAuthenticatedCharacters;
+          if (position.start < continuation2.factorEnd) return true;
+          return ownedEnd - Math.max(position.start, continuation2.factorEnd) >= continuation2.minimumAuthenticatedCharacters;
         }
       );
       if (!authoritativeComplete2 && !authenticatedFactorRange) continue;
@@ -15774,7 +15905,7 @@ function encodedAssessmentHasMatchedCrtContinuationThroughEnd(assessment, pieceC
   const sourceStart = assessment.sourcePieceRanges[0].start;
   const sourceEnd = assessment.sourcePieceRanges[pieceCount - 1].end;
   return assessment.rsaCrtContinuations.some(
-    (continuation) => continuation.start === sourceStart && continuation.status === "match" && continuation.mismatchAt === null && continuation.matchedEnd <= sourceEnd && sourceEnd - continuation.matchedEnd <= MAX_ADJACENT_ENCODED_PREFIX_CHARACTERS
+    (continuation2) => continuation2.start === sourceStart && continuation2.status === "match" && continuation2.mismatchAt === null && continuation2.matchedEnd <= sourceEnd && sourceEnd - continuation2.matchedEnd <= MAX_ADJACENT_ENCODED_PREFIX_CHARACTERS
   );
 }
 function encodedAssessmentOwnsEverySourcePiece(assessment, pieceCount) {
@@ -15796,7 +15927,7 @@ function encodedAssessmentOwnsEverySourcePiece(assessment, pieceCount) {
   }
   const terminalSource = assessment.sourcePieceRanges[terminalIndex];
   return assessment.rsaCrtContinuations.some(
-    (continuation) => continuation.status === "match" && continuation.mismatchAt === null && continuation.factorEnd < terminalSource.end && continuation.matchedEnd === terminalSource.end
+    (continuation2) => continuation2.status === "match" && continuation2.mismatchAt === null && continuation2.factorEnd < terminalSource.end && continuation2.matchedEnd === terminalSource.end
   );
 }
 function encodedAssessmentAllowsFactorOmission(assessment, pieceIndex) {
@@ -15807,11 +15938,11 @@ function encodedAssessmentAllowsFactorOmission(assessment, pieceIndex) {
   )) {
     return false;
   }
-  return assessment.rsaCrtContinuations.every((continuation) => {
-    if (piece.end <= continuation.start || piece.start >= continuation.end) {
+  return assessment.rsaCrtContinuations.every((continuation2) => {
+    if (piece.end <= continuation2.start || piece.start >= continuation2.end) {
       return true;
     }
-    return continuation.mismatchAt !== null && continuation.mismatchAt < piece.end && continuation.matchedEnd <= piece.start;
+    return continuation2.mismatchAt !== null && continuation2.mismatchAt < piece.end && continuation2.matchedEnd <= piece.start;
   });
 }
 function encodedAssessmentAllowsRecognizableFactorOmission(assessment, pieceIndex) {
@@ -15819,11 +15950,11 @@ function encodedAssessmentAllowsRecognizableFactorOmission(assessment, pieceInde
     return true;
   }
   const piece = assessment.sourcePieceRanges[pieceIndex];
-  return assessment.rsaCrtContinuations.every((continuation) => {
-    if (piece.end <= continuation.start || piece.start >= continuation.end) {
+  return assessment.rsaCrtContinuations.every((continuation2) => {
+    if (piece.end <= continuation2.start || piece.start >= continuation2.end) {
       return true;
     }
-    return continuation.factorEnd <= piece.start && (continuation.matchedEnd <= piece.start || continuation.mismatchAt !== null && continuation.mismatchAt < piece.end);
+    return continuation2.factorEnd <= piece.start && (continuation2.matchedEnd <= piece.start || continuation2.mismatchAt !== null && continuation2.mismatchAt < piece.end);
   });
 }
 function encodedAssessmentStartsAtSource(assessment) {
@@ -17368,7 +17499,7 @@ function scanEncodedPrivateKeyRanges(value, metrics, allowAdjacentPrefix = true,
           if (recoverableProof?.basis === "factors") {
             const sourceStart = offsets ? offsets[cursor] : cursor;
             const sourceEnd = offsets ? offsets[segment.end - 1] + 1 : segment.end;
-            const continuation = rsaPrivateKeyCrtContinuationConsistency(
+            const continuation2 = rsaPrivateKeyCrtContinuationConsistency(
               recoverableProof,
               text,
               cursor,
@@ -17385,9 +17516,9 @@ function scanEncodedPrivateKeyRanges(value, metrics, allowAdjacentPrefix = true,
               bitOffset
             );
             const sourceFactorEnd = offsets ? offsets[exactEnd - 1] + 1 : exactEnd;
-            const sourceMatchedEnd = offsets ? offsets[continuation.matchedEnd - 1] + 1 : continuation.matchedEnd;
+            const sourceMatchedEnd = offsets ? offsets[continuation2.matchedEnd - 1] + 1 : continuation2.matchedEnd;
             const minimumAuthenticatedCharacters = minimumRsaCrtContinuationSourceCharacters(framing);
-            const authenticatedMatchedEnd = continuation.matchedEnd - exactEnd >= minimumAuthenticatedCharacters ? continuation.matchedEnd : exactEnd;
+            const authenticatedMatchedEnd = continuation2.matchedEnd - exactEnd >= minimumAuthenticatedCharacters ? continuation2.matchedEnd : exactEnd;
             matchedFactorEnd = Math.max(exactEnd, authenticatedMatchedEnd);
             rsaCrtContinuations.push({
               start: sourceStart,
@@ -17395,8 +17526,8 @@ function scanEncodedPrivateKeyRanges(value, metrics, allowAdjacentPrefix = true,
               factorEnd: sourceFactorEnd,
               matchedEnd: sourceMatchedEnd,
               minimumAuthenticatedCharacters,
-              mismatchAt: continuation.mismatchAt === null ? null : offsets ? offsets[continuation.mismatchAt] : continuation.mismatchAt,
-              status: continuation.status
+              mismatchAt: continuation2.mismatchAt === null ? null : offsets ? offsets[continuation2.mismatchAt] : continuation2.mismatchAt,
+              status: continuation2.status
             });
           }
           const exactFactorEnd = recoverableProof?.basis === "factors" && recoverableLength !== null ? encodedPrivateKeyInteriorEnd(
@@ -20513,6 +20644,16 @@ function isShortPemBoundaryFragment(value) {
   if (isCompletePemBoundary(trimmed)) return true;
   return trimmed.length <= 32 && /^-{5}(?:BEGIN|END)[A-Z0-9_-]{0,18}$/iu.test(trimmed) && exactPrivateKeyMarker2(trimmed) === null;
 }
+function uniqueRedactedObjectKey(reserved, used, nextSuffixByBase, candidate) {
+  const base = candidate === "[redacted]" ? "[redacted-key]" : candidate;
+  if (!reserved.has(base) && !used.has(base)) return base;
+  let suffix = nextSuffixByBase.get(base) ?? 2;
+  while (reserved.has(`${base}-${suffix}`) || used.has(`${base}-${suffix}`)) {
+    suffix += 1;
+  }
+  nextSuffixByBase.set(base, suffix + 1);
+  return `${base}-${suffix}`;
+}
 function createRedactionWorkMetrics() {
   return {
     nodesVisited: 0,
@@ -21891,7 +22032,7 @@ function strictIndependentPrivateSourceRanges(scope, metrics, document) {
           );
         claims.push({ token: frame.token, ...range });
       }
-      const continuation = complete ? completeRsaPrivateKeyCopies(
+      const continuation2 = complete ? completeRsaPrivateKeyCopies(
         scope,
         frames,
         bytes,
@@ -21912,16 +22053,16 @@ function strictIndependentPrivateSourceRanges(scope, metrics, document) {
         tokenIndexes,
         metrics
       ) : completion;
-      if (!continuation) continue;
-      if (continuation.ambiguous || detachedRsaContinuationReadsSpent(metrics) > MAX_DETACHED_RSA_CONTINUATION_READS) {
+      if (!continuation2) continue;
+      if (continuation2.ambiguous || detachedRsaContinuationReadsSpent(metrics) > MAX_DETACHED_RSA_CONTINUATION_READS) {
         for (const frame of frames) {
           metrics.ownershipSteps += 1;
           claims.push(wholeTokenSourceRange(frame.token));
         }
-        claims.push(...continuation.closed);
-        if (continuation.ambiguous) continue;
+        claims.push(...continuation2.closed);
+        if (continuation2.ambiguous) continue;
       }
-      for (const range of continuation.ranges) {
+      for (const range of continuation2.ranges) {
         if (range.token === detached) continue;
         claims.push(range);
       }
@@ -22612,6 +22753,9 @@ function unchangedStringProjection(value) {
     retained: value.length ? [{ start: 0, end: value.length, outputStart: 0 }] : []
   };
 }
+function fullyRedactedStringProjection() {
+  return { value: "[redacted]", changed: true, retained: [] };
+}
 function appendRetainedSourceSpan(spans, span) {
   spans.push(span);
 }
@@ -22651,6 +22795,67 @@ function retainedAfterRedactionRanges(retained, ranges, metrics, replacementLeng
   }
   return result;
 }
+function projectedTextRanges(value, ranges, metrics) {
+  if (ranges.length === 1 && ranges[0].start === 0 && ranges[0].end === value.length) {
+    return fullyRedactedStringProjection();
+  }
+  const original = unchangedStringProjection(value);
+  return {
+    value: redactTextRanges(value, ranges),
+    changed: ranges.length > 0,
+    retained: retainedAfterRedactionRanges(original.retained, ranges, metrics)
+  };
+}
+function composeRetainedSourceSpans(first, second, metrics) {
+  if (first.length === 0 || second.length === 0) return [];
+  const result = [];
+  let leftIndex = 0;
+  let rightIndex = 0;
+  while (leftIndex < first.length && rightIndex < second.length) {
+    metrics.ownershipSteps += 1;
+    const left = first[leftIndex];
+    const right = second[rightIndex];
+    const leftEnd = left.outputStart + left.end - left.start;
+    const start = Math.max(left.outputStart, right.start);
+    const end = Math.min(leftEnd, right.end);
+    if (start < end)
+      appendRetainedSourceSpan(result, {
+        start: left.start + start - left.outputStart,
+        end: left.start + end - left.outputStart,
+        outputStart: right.outputStart + start - right.start
+      });
+    if (leftEnd <= right.end) leftIndex += 1;
+    if (right.end <= leftEnd) rightIndex += 1;
+  }
+  return result;
+}
+function applyLateOverlapRanges(baseline, claims, metrics) {
+  if (claims.length === 0 || baseline.retained.length === 0)
+    return baseline.value;
+  const projected = [];
+  let claimIndex = 0;
+  for (const [index, span] of baseline.retained.entries()) {
+    metrics.ownershipSteps += 1;
+    while (claimIndex < claims.length && claims[claimIndex].end <= span.start) {
+      metrics.ownershipSteps += 1;
+      claimIndex += 1;
+    }
+    let current = claimIndex;
+    while (current < claims.length && claims[current].start < span.end) {
+      metrics.ownershipSteps += 1;
+      const claim = claims[current++];
+      const start = Math.max(span.start, claim.start);
+      const end = Math.min(span.end, claim.end);
+      const previous = baseline.retained[index - 1];
+      const next = baseline.retained[index + 1];
+      projected.push({
+        start: start === span.start ? previous ? previous.outputStart + previous.end - previous.start : 0 : span.outputStart + start - span.start,
+        end: end === span.end ? next ? next.outputStart : baseline.value.length : span.outputStart + end - span.start
+      });
+    }
+  }
+  return projected.length === 0 ? baseline.value : redactTextRanges(baseline.value, mergeOrderedTextRanges([], projected));
+}
 function latePayloadOverlapRanges(analysis, valuePlans, keyPlans) {
   const { graph, metrics } = analysis;
   const claims = /* @__PURE__ */ new Map();
@@ -23446,7 +23651,8 @@ var remembrance_mcp_consent_lanes_default = {
   propose_skill_idea: "skill_candidate",
   submit_suggestion: "skill_suggestion",
   submit_resource: "resource_submission",
-  submit_resource_review: "resource_review"
+  submit_resource_review: "resource_review",
+  repair_review_draft: "admin_review_repair"
 };
 
 // ../core/src/remembrance-mcp-policy.ts
@@ -23487,6 +23693,10 @@ var REMEMBRANCE_MCP_OPTIONAL_SHARED_CONTRIBUTION_TOOLS = Object.freeze(
     "register_agent_key"
   ]
 );
+var REMEMBRANCE_MCP_OPTIONAL_ADMIN_REVIEW_TOOLS = Object.freeze([
+  "get_review_comparison",
+  "repair_review_draft"
+]);
 var REMEMBRANCE_MCP_LOCAL_ONLY_TOOLS = Object.freeze([
   "bootstrap_agent_identity",
   "acknowledge_feedback_denial",
@@ -23526,6 +23736,7 @@ var REMEMBRANCE_MCP_RECOMMENDED_LOCAL_ORG_TOOLS = Object.freeze([
 var REMEMBRANCE_MCP_ALL_TOOLS = Object.freeze([
   ...REMEMBRANCE_MCP_RECOMMENDED_ORG_TOOLS,
   ...REMEMBRANCE_MCP_OPTIONAL_SHARED_CONTRIBUTION_TOOLS,
+  ...REMEMBRANCE_MCP_OPTIONAL_ADMIN_REVIEW_TOOLS,
   ...REMEMBRANCE_MCP_LOCAL_ONLY_TOOLS
 ]);
 var REMEMBRANCE_MCP_BOUNDED_WRITE_POLICY_MAX_BYTES_BY_PAYLOAD_CLASS = Object.freeze({
@@ -23621,6 +23832,8 @@ var REMEMBRANCE_MCP_TOOL_SECURITY = freezeMcpToolSecurityManifest({
   link_current_installation: bounded("bounded_metadata"),
   get_skill: read(),
   get_resource: read(),
+  get_review_comparison: read(),
+  repair_review_draft: content("repair_review_draft", "private_skill"),
   bootstrap_agent_identity: bounded("bounded_metadata"),
   acknowledge_feedback_denial: local("bounded_feedback"),
   decline_pending_action: local("bounded_metadata"),
@@ -23849,6 +24062,501 @@ ${geminiRule(tool)}`;
   ].join("\n\n")
 });
 
+// ../core/src/private-skill-completion.ts
+var PRIVATE_SKILL_COMPLETION_VERSION = "private-skill-completion-v1";
+var opaqueId = external_exports.string().min(1).max(MAX_SHORT_TEXT_LENGTH);
+var privateSkillCompletionRevisionIdSchema = external_exports.string().regex(/^pscr_[a-f0-9]{18}$/u);
+var privateSkillCompletionRequestIdSchema = external_exports.string().regex(/^pscc_[a-f0-9]{32}$/u);
+var privateSkillCompletionStatusRequestSchema = external_exports.object({
+  contract_version: external_exports.literal(PRIVATE_SKILL_COMPLETION_VERSION),
+  public_id: opaqueId
+}).strict();
+var privateSkillCompletionSourceRequestSchema = privateSkillCompletionStatusRequestSchema.extend({
+  revision_id: privateSkillCompletionRevisionIdSchema
+}).strict();
+var privateSkillCompletionApprovedSourceSchema = privateSkillIdeaRequestSchema.omit({ agent: true, idempotency_key: true, enterprise_encryption: true }).strict();
+var privateSkillCompletionSourceResponseSchema = privateSkillCompletionSourceRequestSchema.extend({
+  capture: privateSkillCompletionApprovedSourceSchema.describe("Current approved submission; proposed_skill_md may be null or absent. New revisions still require a complete skill body.")
+}).strict();
+var privateSkillCompletionRequestStatusSchema = privateSkillCompletionStatusRequestSchema.extend({
+  request_id: privateSkillCompletionRequestIdSchema
+}).strict();
+var continuation = privateSkillCompletionRequestStatusSchema.extend({
+  expected: external_exports.object({
+    completion_id: opaqueId,
+    revision_id: privateSkillCompletionRevisionIdSchema,
+    version: external_exports.number().int().nonnegative()
+  }).strict()
+});
+var revisedCapture = privateSkillCaptureSchema.superRefine((capture2, context) => {
+  const pending = [{ value: capture2.proposed_metadata, path: ["proposed_metadata"] }];
+  while (pending.length) {
+    const { value, path } = pending.pop();
+    if (!value || typeof value !== "object") continue;
+    for (const [key, entry] of Object.entries(value)) {
+      if (key.startsWith("_remembrance_")) {
+        context.addIssue({ code: "custom", path: [...path, key], message: "Server provenance fields are reserved." });
+        return;
+      }
+      pending.push({ value: entry, path: [...path, key] });
+    }
+  }
+});
+var privateSkillCompletionContinuationSchema = external_exports.discriminatedUnion("operation", [
+  continuation.extend({ operation: external_exports.literal("declare_intent"), intent: external_exports.literal("skill_output") }).strict(),
+  continuation.extend({ operation: external_exports.literal("revise"), capture: revisedCapture }).strict(),
+  continuation.extend({ operation: external_exports.literal("resume"), mode: external_exports.literal("changed_revision"), deadline_at: external_exports.number().int().positive() }).strict()
+]);
+
+// ../core/src/verifier.ts
+var duplicateCandidateSchema = external_exports.object({
+  type: external_exports.enum(["skill", "resource", "remembrance"]),
+  id: external_exports.string().min(1).max(MAX_SHORT_TEXT_LENGTH),
+  slug: external_exports.string().min(1).max(MAX_SHORT_TEXT_LENGTH).optional(),
+  similarity: external_exports.number().min(0).max(1)
+});
+var PROPOSED_METADATA_MAX_KEYWORDS = 25;
+var PROPOSED_METADATA_MAX_TAGS = 15;
+var PROPOSED_METADATA_MAX_DOMAINS = 8;
+var PROPOSED_METADATA_MAX_TERM_LENGTH = 64;
+var PROPOSED_METADATA_MAX_RATIONALE_LENGTH = 2e3;
+var PROPOSED_METADATA_MAX_MODEL_LENGTH = MAX_SHORT_TEXT_LENGTH;
+var LOW_VALUE_PROPOSED_METADATA_EXACT_TERMS = /* @__PURE__ */ new Set([
+  "agent",
+  "agents",
+  "agent-skill",
+  "agent-skills",
+  "backfill",
+  "candidate",
+  "candidates",
+  "leaderboard",
+  "import",
+  "imported",
+  "rank",
+  "ranking",
+  "skill",
+  "skills",
+  "skills-sh",
+  "skill-candidate",
+  "skill-candidates"
+]);
+var LOW_VALUE_PROPOSED_METADATA_PATTERNS = [
+  /\bagent\s+skills?\b/i,
+  /\bagentspace\b/i,
+  /\bskill\s+candidates?\b/i,
+  /\bskills?[\s.-]*sh\b/i,
+  /\bleaderboard\s+rank\b/i,
+  /\bnpx\s+skills\s+add\b/i
+];
+function sanitizeProposedMetadataTerm(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim().slice(0, PROPOSED_METADATA_MAX_TERM_LENGTH);
+  if (!trimmed) {
+    return null;
+  }
+  const normalized2 = trimmed.toLowerCase().replace(/[_/.]+/g, "-").replace(/\s+/g, " ").replace(/^-+|-+$/g, "");
+  if (LOW_VALUE_PROPOSED_METADATA_EXACT_TERMS.has(normalized2)) {
+    return null;
+  }
+  if (LOW_VALUE_PROPOSED_METADATA_PATTERNS.some(
+    (pattern) => pattern.test(trimmed)
+  )) {
+    return null;
+  }
+  return trimmed;
+}
+var proposedMetadataTermArraySchema = (max) => external_exports.preprocess(
+  (value) => {
+    if (!Array.isArray(value)) {
+      return value;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const terms = [];
+    for (const entry of value) {
+      const trimmed = sanitizeProposedMetadataTerm(entry);
+      if (!trimmed) {
+        continue;
+      }
+      const key = trimmed.toLowerCase();
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      terms.push(trimmed);
+    }
+    return terms.slice(0, max);
+  },
+  external_exports.array(external_exports.string().min(1).max(PROPOSED_METADATA_MAX_TERM_LENGTH)).max(max)
+);
+var proposedSkillMetadataSchema = external_exports.object({
+  keywords: proposedMetadataTermArraySchema(PROPOSED_METADATA_MAX_KEYWORDS),
+  tags: proposedMetadataTermArraySchema(PROPOSED_METADATA_MAX_TAGS),
+  domains: proposedMetadataTermArraySchema(PROPOSED_METADATA_MAX_DOMAINS),
+  rationale: external_exports.string().trim().min(1).max(PROPOSED_METADATA_MAX_RATIONALE_LENGTH),
+  model: external_exports.string().trim().min(1).max(PROPOSED_METADATA_MAX_MODEL_LENGTH)
+});
+var verifierOutputSchema = external_exports.object({
+  recommended_action: verifierActionSchema,
+  confidence: external_exports.number().min(0).max(1),
+  duplicate_candidates: external_exports.array(duplicateCandidateSchema).max(20).default([]),
+  safety_flags: external_exports.array(external_exports.string().min(1).max(MAX_SHORT_TEXT_LENGTH)).max(40).default([]),
+  summary: external_exports.string().min(1).max(MAX_LONG_TEXT_LENGTH),
+  proposed_patch: external_exports.string().max(MAX_LONG_TEXT_LENGTH).nullable().default(null),
+  score_updates: external_exports.record(external_exports.unknown()).superRefine((value, ctx) => {
+    if (serializedJsonBytes(value) > MAX_JSON_FIELD_BYTES) {
+      addSerializedJsonBytesIssue(
+        ctx,
+        MAX_JSON_FIELD_BYTES,
+        `score_updates must be ${MAX_JSON_FIELD_BYTES} bytes or smaller`
+      );
+    }
+  }).nullable().default(null),
+  // Advisory retrieval enrichment (see proposedSkillMetadataSchema). Optional
+  // and defaults to null so existing verifier outputs remain valid.
+  proposed_metadata: proposedSkillMetadataSchema.nullable().default(null),
+  // Advisory evidence-routing assessment. Deterministic routing and the
+  // existing safety/review gates decide whether it can create a candidate.
+  // Topology is advisory and newer than the base verifier contract. A legacy
+  // or malformed topology fragment must not discard an otherwise valid safety
+  // verdict; it degrades to null, which the topology router retains as
+  // evidence-only rather than allowing an unclassified mutation.
+  topology_assessment: skillTopologyAssessmentSchema.nullable().default(null).catch(null)
+});
+
+// ../core/src/verification-policy.ts
+var verificationReviewReasonCodeSchema = external_exports.enum([
+  "safe_useful",
+  "insufficient_evidence",
+  "duplicate",
+  "strategy_divergence",
+  "quality_regression",
+  "out_of_scope",
+  "policy_preference",
+  "sensitive_data",
+  "prompt_injection",
+  "malware_or_phishing",
+  "spam",
+  "invalid_submission",
+  "unsupported_operation",
+  "other"
+]);
+var verifierAssessmentSchema = external_exports.object({
+  evidence_quality: external_exports.number().min(0).max(1),
+  safety_risk: external_exports.number().min(0).max(1),
+  quality_confidence: external_exports.number().min(0).max(1),
+  duplicate_likelihood: external_exports.number().min(0).max(1),
+  applicability: external_exports.number().min(0).max(1),
+  novelty: external_exports.number().min(0).max(1)
+}).strict();
+var verificationRubricPackSchema = external_exports.object({
+  version: external_exports.string().min(1).max(MAX_SHORT_TEXT_LENGTH),
+  evidence_standard: external_exports.enum(["strict", "balanced", "permissive"]),
+  duplicate_strategy: external_exports.enum(["human", "merge_when_clear"]),
+  quality_regression_tolerance: external_exports.enum(["none", "minor"]),
+  external_dependency_handling: external_exports.enum(["human", "verified_only"])
+}).strict();
+var verificationPolicyVerifierOutputSchema = verifierOutputSchema.extend({
+  // Existing and external approvers remain compatible when this is absent.
+  assessment: verifierAssessmentSchema.nullable().default(null)
+});
+var verificationAdminReviewActionSchema = adminReviewActionSchema.extend({
+  reason_code: verificationReviewReasonCodeSchema.optional(),
+  topology_action: skillTopologyActionSchema.optional()
+}).superRefine((value, ctx) => {
+  if (value.reason_code === "other" && !value.note) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      message: "A note is required when the review reason is other",
+      path: ["note"]
+    });
+  }
+  if (value.topology_action && value.action !== "accept" && value.action !== "merge" && value.action !== "fork") {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      message: "A topology route may be selected only when accepting, merging, or forking the reviewed evidence",
+      path: ["topology_action"]
+    });
+  }
+});
+var BENIGN_REVIEW_FLAGS = /* @__PURE__ */ new Set([
+  "public_skill_change_requires_human_review",
+  "public_skill_change_duplicate_requires_human_review",
+  "public_evidence_requires_human_review",
+  "score_updates_discarded"
+]);
+var SAFE_VERIFICATION_POLICY_FLAG_CATEGORIES = /* @__PURE__ */ new Set([
+  ...BENIGN_REVIEW_FLAGS,
+  "verification_unavailable",
+  "prompt_injection",
+  "sensitive_data",
+  "malware_or_phishing",
+  "spam",
+  "other_safety_signal"
+]);
+
+// ../core/src/admin-review-decision-contract.ts
+var identifier = external_exports.string().min(1).max(MAX_SHORT_TEXT_LENGTH);
+var nullableIdentifier = identifier.nullable();
+var timestamp = external_exports.string().datetime();
+var targetTypes = external_exports.enum([
+  "remembrance",
+  "resource",
+  "resource_review",
+  "skill_idea",
+  "suggestion"
+]);
+var reviewDecisionPreviewSelectorSchema = external_exports.object({
+  action: adminReviewActionValueSchema.nullable().default(null),
+  topology_action: skillTopologyActionSchema.nullable().default(null),
+  reason_code: verificationReviewReasonCodeSchema.nullable().default(null)
+}).strict().superRefine((value, ctx) => {
+  if (value.topology_action && !["accept", "merge", "fork"].includes(value.action ?? "")) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["topology_action"],
+      message: "A topology route requires an accepting, merging, or forking preview."
+    });
+  }
+});
+var overlayRevisionSchema = external_exports.object({
+  id: identifier,
+  status: identifier,
+  version: identifier,
+  revision: external_exports.number().int().nonnegative().nullable(),
+  updated_at: timestamp,
+  private_content_ref: nullableIdentifier,
+  private_catalog_ref: nullableIdentifier,
+  private_catalog_revision_id: nullableIdentifier,
+  private_catalog_version_id: nullableIdentifier,
+  evolution_mode: nullableIdentifier
+}).strict();
+var skillRevisionSchema = external_exports.object({
+  id: identifier,
+  slug: identifier,
+  status: identifier,
+  visibility: identifier,
+  version: identifier,
+  current_version_id: nullableIdentifier,
+  updated_at: timestamp
+}).strict();
+var versionRevisionSchema = external_exports.object({
+  id: identifier,
+  skill_id: identifier,
+  version: identifier,
+  status: identifier,
+  updated_at: timestamp,
+  private_content_ref: nullableIdentifier,
+  private_content_revision_id: nullableIdentifier,
+  private_content_org_id: nullableIdentifier
+}).strict();
+var consumedBaselineSchema = external_exports.object({
+  kind: external_exports.enum(["bundled_seed", "skill_metadata", "public_sync"]),
+  digest: identifier
+}).strict();
+var reviewDecisionSnapshotSchema = external_exports.object({
+  schema_version: external_exports.literal("admin-review-decision-snapshot-v1"),
+  org_id: identifier,
+  public_skill_access_policy: external_exports.enum(["allow", "org_only"]),
+  selected_route: reviewDecisionPreviewSelectorSchema,
+  actor: external_exports.object({
+    type: identifier,
+    id: identifier,
+    org_id: identifier,
+    api_key_id: nullableIdentifier,
+    token_id: nullableIdentifier
+  }).strict(),
+  job: external_exports.object({
+    id: identifier,
+    target_type: targetTypes,
+    target_id: identifier,
+    status: identifier,
+    updated_at: timestamp,
+    verifier_input_hash: nullableIdentifier,
+    private_verification_artifact_id: nullableIdentifier,
+    private_verification_result_digest: nullableIdentifier,
+    private_semantic_context_ref: nullableIdentifier,
+    private_context_ref: nullableIdentifier,
+    private_context_revision_id: nullableIdentifier
+  }).strict(),
+  target: external_exports.object({
+    id: identifier,
+    updated_at: timestamp,
+    payload_ref: nullableIdentifier,
+    superseded_by_submission_id: nullableIdentifier,
+    disposition_job_id: nullableIdentifier
+  }).strict(),
+  private_payload: external_exports.object({
+    id: identifier,
+    updated_at: timestamp,
+    encryption_mode: identifier,
+    inspection_status: nullableIdentifier,
+    inspection_updated_at: timestamp.nullable(),
+    inspection_projection_digest: nullableIdentifier,
+    inspection_inspector_digest: nullableIdentifier
+  }).strict().nullable(),
+  protected_source_binding: external_exports.object({
+    schema_version: external_exports.literal("protected-submission-source-v1"),
+    source_type: external_exports.enum(["skill_idea", "suggestion", "remembrance"]),
+    source_id: identifier,
+    source_public_id: identifier,
+    content_digest: identifier,
+    inline_job_digest: identifier.nullable()
+  }).strict().optional(),
+  legacy_public_payload: external_exports.object({
+    schema_version: external_exports.literal("legacy-public-remembrance-payload-v1"),
+    id: identifier,
+    updated_at: timestamp,
+    source_public_id: identifier,
+    raw_digest: identifier,
+    redacted_digest: identifier,
+    target_digest: identifier,
+    inline_job_digest: identifier.nullable()
+  }).strict().optional(),
+  current_skill: external_exports.object({
+    slug: identifier,
+    overlay: overlayRevisionSchema.nullable(),
+    version: versionRevisionSchema.nullable(),
+    consumed_baseline: consumedBaselineSchema.nullable()
+  }).strict().nullable(),
+  source_skill: external_exports.object({
+    skill: skillRevisionSchema,
+    version: versionRevisionSchema.nullable(),
+    consumed_baseline: consumedBaselineSchema.nullable()
+  }).strict().nullable(),
+  parent_skill: external_exports.object({
+    skill: skillRevisionSchema,
+    version: versionRevisionSchema,
+    overlay: overlayRevisionSchema.nullable()
+  }).strict().nullable()
+}).strict();
+
+// ../core/src/review-workflows.ts
+var PRIVATE_SKILL_REVIEW_REPAIR_VERSION = "private-skill-review-repair-v1";
+var REVIEW_COMPARISON_TOOL_DESCRIPTION = "Organization admin:review only. Read complete exact source, parent and current skill versions already linked to one pending review job. Supply no action, route, organization or arbitrary skill ID. This does not select a route or grant decision authority: inspect the current review detail and its fresh snapshot separately before any decision. An unavailable, held, changed or foreign reference refuses the whole comparison; nothing is truncated or silently substituted.";
+var REVIEW_DRAFT_REPAIR_TOOL_DESCRIPTION = "Organization admin:review only; explicit delegated AI review authority, not routine learning permission. Create one complete protected replacement for a pending private skill draft using its current unselected review snapshot. Use a stable psrr_ plus 32 lowercase hex request_id; the transport sets Idempotency-Key to that exact ID. Exact replay returns the original replacement receipt; changed input under that ID conflicts. All normal secret inspection, protection, routing, verification and review checks apply. The local client requires inspection to leave the authored capture unchanged before sending. A local hold returns content-free recovery, never an alternate transport or a rewritten original. Creation preserves the original and never approves, rejects or supersedes it. Review the replacement normally, then close the original separately only after proving an accepted, tenant-readable active replacement skill. No public or cross-organization fallback.";
+var REVIEW_DRAFT_REPAIR_NEXT_INSTRUCTION = "Review the replacement normally. Keep the original open until an accepted, tenant-readable active skill version proves the replacement usable.";
+var reviewWorkflowJobIdSchema = external_exports.string().regex(/^job_[a-f0-9]{18}$/u);
+var privateSkillReviewRepairRequestIdSchema = external_exports.string().regex(/^psrr_[a-f0-9]{32}$/u);
+var referenceIdentifier = external_exports.string().min(1).max(MAX_SHORT_TEXT_LENGTH);
+var MAX_REVIEW_REFERENCE_BODY_BYTES = 1048576;
+var reviewReferenceSkillSchema = external_exports.object({
+  skill_id: referenceIdentifier,
+  slug: referenceIdentifier,
+  version_id: referenceIdentifier,
+  version: referenceIdentifier,
+  skill_md: external_exports.string().min(1).max(MAX_REVIEW_REFERENCE_BODY_BYTES).refine((value) => new TextEncoder().encode(value).length <= MAX_REVIEW_REFERENCE_BODY_BYTES),
+  content_hash: referenceIdentifier
+}).strict();
+var reviewReferenceComparisonSchema = external_exports.object({
+  schema_version: external_exports.literal("review-reference-comparison-v1"),
+  job_id: reviewWorkflowJobIdSchema,
+  source_skill: reviewReferenceSkillSchema.nullable(),
+  parent_skill: reviewReferenceSkillSchema.nullable(),
+  current_skill: reviewReferenceSkillSchema.nullable()
+}).strict();
+function reviewWorkflowResponseBound(tool, body, request) {
+  if (tool === "get_review_comparison") {
+    const parsed2 = reviewReferenceComparisonSchema.safeParse(body);
+    return parsed2.success && parsed2.data.job_id === request.job_id;
+  }
+  if (tool !== "repair_review_draft") return false;
+  const parsed = external_exports.object({
+    contract_version: external_exports.literal(PRIVATE_SKILL_REVIEW_REPAIR_VERSION),
+    request_id: privateSkillReviewRepairRequestIdSchema,
+    original_job_id: reviewWorkflowJobIdSchema,
+    replacement: external_exports.object({
+      public_id: external_exports.string().regex(/^ipub_[a-f0-9]{18}$/u),
+      job_id: reviewWorkflowJobIdSchema,
+      status: external_exports.enum(["submitted", "duplicate", "accepted", "rejected", "merged", "forked", "needs_review", "quarantined"]),
+      visibility: external_exports.literal("organization_private")
+    }).strict(),
+    replayed: external_exports.boolean(),
+    original_disposition: external_exports.literal("unchanged"),
+    verification: external_exports.object({
+      verification_job: external_exports.object({
+        id: reviewWorkflowJobIdSchema,
+        status: verificationJobStatusSchema,
+        target_type: external_exports.literal("skill_idea"),
+        target_id: external_exports.string().regex(/^idea_[a-f0-9]{18}$/u)
+      }).strict(),
+      queue: external_exports.object({ queued: external_exports.boolean(), queueJobId: reviewWorkflowJobIdSchema.nullable() }).strict()
+    }).strict().nullable(),
+    verification_status: verificationJobStatusSchema,
+    dispatch_state: external_exports.enum(["existing_persisted_job", "queued", "mongo_poll_fallback"]),
+    next_action: external_exports.object({
+      method: external_exports.literal("GET"),
+      path: external_exports.literal("/api/v1/admin/review-queue"),
+      query: external_exports.object({ job_id: reviewWorkflowJobIdSchema, review_provenance: external_exports.literal("delegated_ai") }).strict(),
+      instruction: external_exports.literal(REVIEW_DRAFT_REPAIR_NEXT_INSTRUCTION)
+    }).strict()
+  }).strict().safeParse(body);
+  if (!parsed.success) return false;
+  const receipt = parsed.data;
+  if (receipt.request_id !== request.request_id || receipt.original_job_id !== request.job_id || receipt.replacement.job_id === receipt.original_job_id || receipt.next_action.query.job_id !== receipt.replacement.job_id) return false;
+  if (receipt.replayed) return receipt.verification === null && receipt.dispatch_state === "existing_persisted_job";
+  const verification = receipt.verification;
+  return verification !== null && verification.verification_job.id === receipt.replacement.job_id && verification.verification_job.status === receipt.verification_status && (verification.queue.queued ? receipt.dispatch_state === "queued" && verification.queue.queueJobId === receipt.replacement.job_id : receipt.dispatch_state === "mongo_poll_fallback" && verification.queue.queueJobId === null);
+}
+var reviewReferenceComparisonRequestSchema = external_exports.object({
+  job_id: reviewWorkflowJobIdSchema,
+  review_provenance: external_exports.literal("delegated_ai").default("delegated_ai")
+}).strict();
+function checkJsonGraph(value, context, reservedKeys) {
+  const pending = [{ value, depth: 0 }];
+  const seen = /* @__PURE__ */ new Set();
+  let nodes = 0;
+  while (pending.length) {
+    const entry = pending.pop();
+    if (++nodes > 1e4 || entry.depth > 32) {
+      context.addIssue({ code: "custom", message: "JSON structure exceeds the bounded review request limits." });
+      return false;
+    }
+    const current = entry.value;
+    if (current === null || typeof current === "string" || typeof current === "boolean" || typeof current === "number" && Number.isFinite(current)) continue;
+    if (typeof current !== "object" || seen.has(current)) {
+      context.addIssue({ code: "custom", message: "Review requests must contain finite, acyclic JSON values." });
+      return false;
+    }
+    seen.add(current);
+    for (const [key, child] of Object.entries(current)) {
+      if (reservedKeys && key.startsWith("_remembrance_")) {
+        context.addIssue({ code: "custom", message: "Server provenance fields are reserved." });
+        return false;
+      }
+      pending.push({ value: child, depth: entry.depth + 1 });
+    }
+  }
+  return true;
+}
+var reviewSnapshot = reviewDecisionSnapshotSchema.superRefine((value, context) => {
+  if (!checkJsonGraph(value, context, false)) return;
+  if (serializedJsonBytes(value) > MAX_JSON_FIELD_BYTES) {
+    addSerializedJsonBytesIssue(context, MAX_JSON_FIELD_BYTES, "Review snapshot exceeds its JSON byte limit.");
+  }
+});
+var repairCapture = privateSkillCaptureSchema.superRefine((capture2, context) => {
+  checkJsonGraph(capture2.proposed_metadata, context, true);
+});
+var privateSkillReviewRepairRequest = external_exports.object({
+  contract_version: external_exports.literal(PRIVATE_SKILL_REVIEW_REPAIR_VERSION),
+  job_id: reviewWorkflowJobIdSchema,
+  request_id: privateSkillReviewRepairRequestIdSchema,
+  review_provenance: external_exports.literal("delegated_ai").default("delegated_ai"),
+  expected_review_snapshot: reviewSnapshot,
+  capture: repairCapture
+}).strict().superRefine((value, context) => {
+  if (!checkJsonGraph(value, context, false)) return;
+  if (serializedJsonBytes(value) > DEFAULT_MUTATION_BODY_LIMIT_BYTES) {
+    addSerializedJsonBytesIssue(context, DEFAULT_MUTATION_BODY_LIMIT_BYTES, "Review repair exceeds its JSON byte limit; nothing is truncated.");
+  }
+});
+var privateSkillReviewRepairRequestSchema = external_exports.preprocess((value, context) => {
+  if (!checkJsonGraph(value, context, false)) return external_exports.NEVER;
+  return value;
+}, privateSkillReviewRepairRequest);
+
 // ../core/src/seed.ts
 var siteUrl = "https://remembrance.dev";
 var feedbackUrl = `${siteUrl}/api/v1/agent/remembrances`;
@@ -26357,122 +27065,33 @@ function invalidToolArgumentsMessage(error, schema) {
   ).join("; ")}${more > 0 ? ` (+${more} more)` : ""}.`;
 }
 
-// ../core/src/verifier.ts
-var duplicateCandidateSchema = external_exports.object({
-  type: external_exports.enum(["skill", "resource", "remembrance"]),
-  id: external_exports.string().min(1).max(MAX_SHORT_TEXT_LENGTH),
-  slug: external_exports.string().min(1).max(MAX_SHORT_TEXT_LENGTH).optional(),
-  similarity: external_exports.number().min(0).max(1)
-});
-var PROPOSED_METADATA_MAX_KEYWORDS = 25;
-var PROPOSED_METADATA_MAX_TAGS = 15;
-var PROPOSED_METADATA_MAX_DOMAINS = 8;
-var PROPOSED_METADATA_MAX_TERM_LENGTH = 64;
-var PROPOSED_METADATA_MAX_RATIONALE_LENGTH = 2e3;
-var PROPOSED_METADATA_MAX_MODEL_LENGTH = MAX_SHORT_TEXT_LENGTH;
-var LOW_VALUE_PROPOSED_METADATA_EXACT_TERMS = /* @__PURE__ */ new Set([
-  "agent",
-  "agents",
-  "agent-skill",
-  "agent-skills",
-  "backfill",
-  "candidate",
-  "candidates",
-  "leaderboard",
-  "import",
-  "imported",
-  "rank",
-  "ranking",
-  "skill",
-  "skills",
-  "skills-sh",
-  "skill-candidate",
-  "skill-candidates"
-]);
-var LOW_VALUE_PROPOSED_METADATA_PATTERNS = [
-  /\bagent\s+skills?\b/i,
-  /\bagentspace\b/i,
-  /\bskill\s+candidates?\b/i,
-  /\bskills?[\s.-]*sh\b/i,
-  /\bleaderboard\s+rank\b/i,
-  /\bnpx\s+skills\s+add\b/i
-];
-function sanitizeProposedMetadataTerm(value) {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const trimmed = value.trim().slice(0, PROPOSED_METADATA_MAX_TERM_LENGTH);
-  if (!trimmed) {
-    return null;
-  }
-  const normalized2 = trimmed.toLowerCase().replace(/[_/.]+/g, "-").replace(/\s+/g, " ").replace(/^-+|-+$/g, "");
-  if (LOW_VALUE_PROPOSED_METADATA_EXACT_TERMS.has(normalized2)) {
-    return null;
+// src/private-skill-protection-recovery.ts
+var PRIVATE_SKILL_CONFIGURATION_REFUSAL = "private_admission_configuration_error";
+var PRIVATE_SKILL_PERMANENT_SERVICE_REFUSAL = "private_skill_permanent_service_refusal";
+function isPrivateSkillConfigurationHold(draft) {
+  return draft.state === "held_validation" && draft.last_error_code === PRIVATE_SKILL_CONFIGURATION_REFUSAL;
+}
+function privateSkillPermanentRefusalGuidance(draft) {
+  if (isPrivateSkillConfigurationHold(draft)) {
+    return {
+      next_action: null,
+      action_required: "Private protection configuration refused this submission. Keep the exact encrypted draft. Ask the organization administrator to correct the selected protection configuration; customer-held submissions require a valid customer-encrypted envelope. Do not change key ownership, protection mode, destination, or consent automatically. Only after an authorized correction, explicitly retry this same draft once with retry_private_skill_candidate. An unchanged refusal remains held; no replacement or acceptance is claimed.",
+      recovery_after_correction: {
+        automatic_retry: false,
+        condition: "organization_administrator_corrected_private_protection_configuration",
+        tool: "retry_private_skill_candidate",
+        arguments: { draft_id: draft.draft_id }
+      }
+    };
   }
-  if (LOW_VALUE_PROPOSED_METADATA_PATTERNS.some(
-    (pattern) => pattern.test(trimmed)
-  )) {
-    return null;
+  if (draft.state === "held_validation" && draft.last_error_code === PRIVATE_SKILL_PERMANENT_SERVICE_REFUSAL) {
+    return {
+      next_action: null,
+      action_required: "The private service explicitly refused unchanged retries. Keep the encrypted draft and inspect this retained hold. No automatic retry, alternate transport, replacement, or successful recovery is authorized by this unknown refusal."
+    };
   }
-  return trimmed;
+  return {};
 }
-var proposedMetadataTermArraySchema = (max) => external_exports.preprocess(
-  (value) => {
-    if (!Array.isArray(value)) {
-      return value;
-    }
-    const seen = /* @__PURE__ */ new Set();
-    const terms = [];
-    for (const entry of value) {
-      const trimmed = sanitizeProposedMetadataTerm(entry);
-      if (!trimmed) {
-        continue;
-      }
-      const key = trimmed.toLowerCase();
-      if (seen.has(key)) {
-        continue;
-      }
-      seen.add(key);
-      terms.push(trimmed);
-    }
-    return terms.slice(0, max);
-  },
-  external_exports.array(external_exports.string().min(1).max(PROPOSED_METADATA_MAX_TERM_LENGTH)).max(max)
-);
-var proposedSkillMetadataSchema = external_exports.object({
-  keywords: proposedMetadataTermArraySchema(PROPOSED_METADATA_MAX_KEYWORDS),
-  tags: proposedMetadataTermArraySchema(PROPOSED_METADATA_MAX_TAGS),
-  domains: proposedMetadataTermArraySchema(PROPOSED_METADATA_MAX_DOMAINS),
-  rationale: external_exports.string().trim().min(1).max(PROPOSED_METADATA_MAX_RATIONALE_LENGTH),
-  model: external_exports.string().trim().min(1).max(PROPOSED_METADATA_MAX_MODEL_LENGTH)
-});
-var verifierOutputSchema = external_exports.object({
-  recommended_action: verifierActionSchema,
-  confidence: external_exports.number().min(0).max(1),
-  duplicate_candidates: external_exports.array(duplicateCandidateSchema).max(20).default([]),
-  safety_flags: external_exports.array(external_exports.string().min(1).max(MAX_SHORT_TEXT_LENGTH)).max(40).default([]),
-  summary: external_exports.string().min(1).max(MAX_LONG_TEXT_LENGTH),
-  proposed_patch: external_exports.string().max(MAX_LONG_TEXT_LENGTH).nullable().default(null),
-  score_updates: external_exports.record(external_exports.unknown()).superRefine((value, ctx) => {
-    if (serializedJsonBytes(value) > MAX_JSON_FIELD_BYTES) {
-      addSerializedJsonBytesIssue(
-        ctx,
-        MAX_JSON_FIELD_BYTES,
-        `score_updates must be ${MAX_JSON_FIELD_BYTES} bytes or smaller`
-      );
-    }
-  }).nullable().default(null),
-  // Advisory retrieval enrichment (see proposedSkillMetadataSchema). Optional
-  // and defaults to null so existing verifier outputs remain valid.
-  proposed_metadata: proposedSkillMetadataSchema.nullable().default(null),
-  // Advisory evidence-routing assessment. Deterministic routing and the
-  // existing safety/review gates decide whether it can create a candidate.
-  // Topology is advisory and newer than the base verifier contract. A legacy
-  // or malformed topology fragment must not discard an otherwise valid safety
-  // verdict; it degrades to null, which the topology router retains as
-  // evidence-only rather than allowing an unclassified mutation.
-  topology_assessment: skillTopologyAssessmentSchema.nullable().default(null).catch(null)
-});
 
 // src/server.ts
 import { existsSync as existsSync6 } from "node:fs";
@@ -28229,6 +28848,19 @@ var remembranceToolSchema = remembrancePayloadSchema.extend({
   )
 });
 var declaredToolDefinitions = [
+  readTool(
+    "get_review_comparison",
+    REVIEW_COMPARISON_TOOL_DESCRIPTION,
+    "/api/v1/admin/review-queue/comparison",
+    reviewReferenceComparisonRequestSchema,
+    "GET"
+  ),
+  contentWriteTool(
+    "repair_review_draft",
+    REVIEW_DRAFT_REPAIR_TOOL_DESCRIPTION,
+    "/api/v1/admin/review-queue/repairs",
+    privateSkillReviewRepairRequestSchema
+  ),
   readTool(
     "get_connection_status",
     REMEMBRANCE_CONNECTION_STATUS_TOOL_DESCRIPTION,
@@ -28391,7 +29023,7 @@ var declaredToolDefinitions = [
   ),
   localNetworkTool(
     "retry_private_skill_candidate",
-    "Retry one retained private-skill draft through the same private_skill approval lane as submit_private_skill_candidate. Network access is allowed only for authorization-pending or due transient retry states, and for a draft an older server refused only for length: that waits out any delay the server set, then reads its signed capability and resends the exact draft only if it admits it. A fresh ready draft is rejected locally. It never switches transport or visibility.",
+    "Retry one retained private-skill draft through the same private_skill approval lane as submit_private_skill_candidate. Network access is allowed only for authorization-pending or due transient retry states, an explicit same-draft retry after an administrator corrected a private-protection configuration hold, and for a draft an older server refused only for length: that waits out any delay the server set, then reads its signed capability and resends the exact draft only if it admits it. Configuration holds never schedule automatic retries; an unchanged refusal remains held. A fresh ready draft is rejected locally. It never switches transport, visibility, key ownership, or protection mode.",
     "retry_private_skill_candidate",
     privateSkillDraftReferenceSchema,
     "content_write"
@@ -28978,13 +29610,13 @@ function validateServedToolDefinition(definition) {
   canonicalToolDefinitionForDispatch(definition);
 }
 function annotationsForTool(name) {
-  const readOnly = name === "list_skills" || name === "get_effective_preferences" || name === "get_value_proof" || name === "run_connection_doctor" || name === "get_private_lesson_policy" || name === "inspect_private_lesson_outbox" || name === "inspect_private_learning_outbox" || name === "get_pending_action_payload";
+  const readOnly = name === "get_review_comparison" || name === "list_skills" || name === "get_effective_preferences" || name === "get_value_proof" || name === "run_connection_doctor" || name === "get_private_lesson_policy" || name === "inspect_private_lesson_outbox" || name === "inspect_private_learning_outbox" || name === "get_pending_action_payload";
   const openWorld = name === "submit_feedback" || name === "submit_remembrance" || name === "propose_skill_idea" || name === "submit_suggestion" || name === "submit_resource" || name === "submit_resource_review";
   return {
     readOnlyHint: readOnly,
     openWorldHint: openWorld,
     destructiveHint: name === "delete_private_lesson_candidate" || name === "delete_private_skill_candidate",
-    ...readOnly || name === "queue_private_skill_import" || name === "acknowledge_feedback_denial" || name === "decline_pending_action" || name === "submit_private_lesson_candidate" || name === "retry_private_lesson_candidate" || name === "submit_private_skill_candidate" || name === "retry_private_skill_candidate" ? { idempotentHint: true } : {}
+    ...readOnly || name === "queue_private_skill_import" || name === "acknowledge_feedback_denial" || name === "decline_pending_action" || name === "submit_private_lesson_candidate" || name === "retry_private_lesson_candidate" || name === "submit_private_skill_candidate" || name === "retry_private_skill_candidate" || name === "repair_review_draft" ? { idempotentHint: true } : {}
   };
 }
 var ROUTINE_PRIVATE_CAPTURE_REPLACED_TOOLS = /* @__PURE__ */ new Set([
@@ -45270,7 +45902,7 @@ var require_timestamp = __commonJS({
       resolve: (str) => parseSexagesimal(str, false),
       stringify: stringifySexagesimal
     };
-    var timestamp = {
+    var timestamp2 = {
       identify: (value) => value instanceof Date,
       default: true,
       tag: "tag:yaml.org,2002:timestamp",
@@ -45279,7 +45911,7 @@ var require_timestamp = __commonJS({
       // assumed to be 00:00:00Z (start of day, UTC).
       test: RegExp("^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})(?:(?:t|T|[ \\t]+)([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?)?$"),
       resolve(str) {
-        const match = str.match(timestamp.test);
+        const match = str.match(timestamp2.test);
         if (!match)
           throw new Error("!!timestamp expects a date, starting with yyyy-mm-dd");
         const [, year, month, day, hour, minute, second] = match.map(Number);
@@ -45298,7 +45930,7 @@ var require_timestamp = __commonJS({
     };
     exports.floatTime = floatTime;
     exports.intTime = intTime;
-    exports.timestamp = timestamp;
+    exports.timestamp = timestamp2;
   }
 });
 var require_schema3 = __commonJS({
@@ -45316,7 +45948,7 @@ var require_schema3 = __commonJS({
     var omap = require_omap();
     var pairs = require_pairs();
     var set = require_set();
-    var timestamp = require_timestamp();
+    var timestamp2 = require_timestamp();
     var schema = [
       map.map,
       seq.seq,
@@ -45336,9 +45968,9 @@ var require_schema3 = __commonJS({
       omap.omap,
       pairs.pairs,
       set.set,
-      timestamp.intTime,
-      timestamp.floatTime,
-      timestamp.timestamp
+      timestamp2.intTime,
+      timestamp2.floatTime,
+      timestamp2.timestamp
     ];
     exports.schema = schema;
   }
@@ -45361,7 +45993,7 @@ var require_tags = __commonJS({
     var pairs = require_pairs();
     var schema$2 = require_schema3();
     var set = require_set();
-    var timestamp = require_timestamp();
+    var timestamp2 = require_timestamp();
     var schemas = /* @__PURE__ */ new Map([
       ["core", schema.schema],
       ["failsafe", [map.map, seq.seq, string.string]],
@@ -45375,11 +46007,11 @@ var require_tags = __commonJS({
       float: float.float,
       floatExp: float.floatExp,
       floatNaN: float.floatNaN,
-      floatTime: timestamp.floatTime,
+      floatTime: timestamp2.floatTime,
       int: int.int,
       intHex: int.intHex,
       intOct: int.intOct,
-      intTime: timestamp.intTime,
+      intTime: timestamp2.intTime,
       map: map.map,
       merge: merge.merge,
       null: _null.nullTag,
@@ -45387,7 +46019,7 @@ var require_tags = __commonJS({
       pairs: pairs.pairs,
       seq: seq.seq,
       set: set.set,
-      timestamp: timestamp.timestamp
+      timestamp: timestamp2.timestamp
     };
     var coreKnownTags = {
       "tag:yaml.org,2002:binary": binary.binary,
@@ -45395,7 +46027,7 @@ var require_tags = __commonJS({
       "tag:yaml.org,2002:omap": omap.omap,
       "tag:yaml.org,2002:pairs": pairs.pairs,
       "tag:yaml.org,2002:set": set.set,
-      "tag:yaml.org,2002:timestamp": timestamp.timestamp
+      "tag:yaml.org,2002:timestamp": timestamp2.timestamp
     };
     function getTags(customTags, schemaName, addMergeTag) {
       const schemaTags = schemas.get(schemaName);
@@ -62461,7 +63093,8 @@ async function reinspectPrivateSkillSubmissionCandidate(draftId, options = {}) {
       const resumingReinspectionHold = isPrivateSkillSubmissionReinspectionHold(current);
       const resumingDestinationHold = isPrivateSkillDestinationHold(current) && !isPrivateSkillDestinationRecoveryBlocked(current, destination);
       const resumingResolution = current.delivery_resolution !== null;
-      const resumingHold = resumingReinspectionHold || resumingDestinationHold || resumingResolution;
+      const resumingConfigurationHold = options.resumeConfigurationHold === true && isPrivateSkillConfigurationHold(current);
+      const resumingHold = resumingReinspectionHold || resumingDestinationHold || resumingResolution || resumingConfigurationHold;
       if (resumingReinspectionHold && !resumingResolution && current.inspection?.inspector_digest === PRIVATE_LEARNING_INSPECTOR_DIGEST && current.inspection.outcome !== "unchanged" && current.inspection.outcome !== "redacted") {
         return Object.freeze({ status: "held", draft: current });
       }
@@ -65328,6 +65961,7 @@ async function inspectPrivateLearningOutbox(input, persistence) {
     status: skillResult.value.recovery_items.length > 0 ? "recovery_required" : "ok",
     drafts: skillResult.value.drafts.map((draft) => ({
       ...draft,
+      ...privateSkillPermanentRefusalGuidance(draft),
       recovery_context: { status: "context_unavailable" },
       agent_recovery: privateSkillExactInspectionRecovery(draft)
     })),
@@ -65633,6 +66267,7 @@ function privateSkillSelectedDraftResult(draft) {
       draft,
       PRIVATE_LEARNING_CAPTURE_VERSION
     ),
+    ...privateSkillPermanentRefusalGuidance(draft),
     recovery_context: recoveryContext,
     native_recovery_context: nativeContext ? {
       ...nativeContext,
@@ -66153,9 +66788,68 @@ function createLocalPersistenceCapabilities(dependencies = {}) {
   });
 }
 
-// src/network-transport.ts
+// ../core/src/redaction-request-budget.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-var networkExecutionAuthority = new AsyncLocalStorage2();
+var requests = new AsyncLocalStorage2();
+trackRedactionRequests(() => requests.getStore());
+function withRedactionRequestBudget(run) {
+  return requests.getStore() ? run() : requests.run({}, run);
+}
+
+// src/review-repair-inspection.ts
+function inspectReviewRepairForTransport(value) {
+  const request = privateSkillReviewRepairRequestSchema.parse(value);
+  const inspection = inspectPrivateSkillCandidate(request.capture);
+  if (inspection.status === "complete" && inspection.decision.outcome === "unchanged") {
+    const values = [];
+    const pending = [request.expected_review_snapshot];
+    while (pending.length) {
+      const entry = pending.pop();
+      if (entry !== null && typeof entry === "object") pending.push(...Object.values(entry));
+      else values.push(entry);
+    }
+    try {
+      if (canonicalJson(withRedactionRequestBudget(() => redactPayload(values))) !== canonicalJson(values)) {
+        return { ready: false, refusal: {
+          status: "held",
+          code: "review_repair_wire_inspection_hold",
+          delivery: "not_delivered",
+          candidate_sent: false,
+          candidate_stored: false,
+          original_disposition: "unchanged",
+          next_action: "Retain the original. Read a fresh normal content-free review snapshot; do not send suspected secrets, rewrite the held request, or use another transport."
+        } };
+      }
+    } catch {
+      return { ready: false, refusal: {
+        status: "held",
+        code: "review_repair_wire_inspection_failure",
+        delivery: "not_delivered",
+        candidate_sent: false,
+        candidate_stored: false,
+        original_disposition: "unchanged",
+        next_action: "Retain the original. Correct the local inspection failure before retrying; do not reformulate around an operational failure."
+      } };
+    }
+    return { ready: true, request };
+  }
+  const reason = inspection.status === "complete" ? "authored_capture_changed_by_inspection" : inspection.status === "incomplete" ? inspection.reason : inspection.error_code;
+  return { ready: false, refusal: {
+    status: "held",
+    code: "review_repair_local_inspection_hold",
+    delivery: "not_delivered",
+    candidate_sent: false,
+    candidate_stored: false,
+    original_disposition: "unchanged",
+    reason_code: reason,
+    inspection: inspection.decision,
+    next_action: inspection.status === "invalid" ? "Retain the original. Correct the local inspection failure before retrying the same unchanged request; do not reformulate around an operational failure or use another transport." : "Retain the original. Prepare a complete safe replacement from authenticated task context and inspect it again. Do not recover suspected secrets, invent missing instructions, or bypass a host denial."
+  } };
+}
+
+// src/network-transport.ts
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+var networkExecutionAuthority = new AsyncLocalStorage3();
 var guardedFetches = /* @__PURE__ */ new WeakSet();
 function installRuntimeFetchGuard() {
   const delegate = globalThis.fetch;
@@ -67868,7 +68562,7 @@ function inspectPrivateLearningOutbox2(input, dependencies = {}) {
 }
 var MAX_REMOTE_RESPONSE_BYTES = 4 * 1024 * 1024;
 var DOCTOR_PROBE_TIMEOUT_MS = 7500;
-var SERVER_VERSION = true ? "0.2.3" : "0.0.0-dev";
+var SERVER_VERSION = true ? "0.2.5" : "0.0.0-dev";
 var tools2 = toolDefinitions;
 var doctorCliRequested = process.argv[2] === "doctor";
 var nativeContextCliRequested = process.argv[2] === "--native-context";
@@ -68227,6 +68921,11 @@ async function callToolWithinExecution(runtimeDefinition, rawArguments, dependen
   );
 }
 async function callNetworkToolWithinExecution(definition, payload, access, transport) {
+  if (definition.name === "repair_review_draft") {
+    const inspection = inspectReviewRepairForTransport(payload);
+    if (!inspection.ready) return inspection.refusal;
+    payload = inspection.request;
+  }
   if (definition.local === "bootstrap_agent_identity") {
     return bootstrapAgentIdentity(payload, access, transport);
   }
@@ -68288,7 +68987,11 @@ async function callNetworkToolWithinExecution(definition, payload, access, trans
     access.credential.source,
     access.configuration.issue
   );
-  const result = definition.name === "get_connection_status" && localConfigurationError ? { ok: false, status: 0, error: localConfigurationError } : await callRemembrance(definition, payload, { access, transport });
+  const result = definition.name === "get_connection_status" && localConfigurationError ? { ok: false, status: 0, error: localConfigurationError } : await callRemembrance(definition, payload, {
+    access,
+    transport,
+    ...["get_review_comparison", "repair_review_draft"].includes(definition.name) ? { redirect: "manual" } : {}
+  });
   if (definition.name === "get_connection_status") {
     const status = localConnectionStatus(result, {
       apiBase: access.configuration.baseUrl,
@@ -68503,11 +69206,11 @@ function retryAfterDelayMs(value, nowMs = Date.now()) {
       Number(trimmed) * 1e3
     );
   }
-  const timestamp = Date.parse(trimmed);
-  if (!Number.isFinite(timestamp)) return null;
+  const timestamp2 = Date.parse(trimmed);
+  if (!Number.isFinite(timestamp2)) return null;
   return Math.min(
     PRIVATE_LEARNING_MAX_RETRY_DELAY_MS,
-    Math.max(0, timestamp - nowMs)
+    Math.max(0, timestamp2 - nowMs)
   );
 }
 function privateLessonDestinationForAccess(access) {
@@ -68570,6 +69273,10 @@ async function deliverPrivateSkillDraft(draftId, access, mode, transport) {
     });
   }
   let draft = await readPrivateSkillDraft(draftId);
+  const resumingConfigurationHold = mode === "retry" && isPrivateSkillConfigurationHold(draft);
+  if (isPrivateSkillConfigurationHold(draft) && !resumingConfigurationHold) {
+    return privateSkillDraftActionResult2(draft, { status: "not_submitted" });
+  }
   const destination = privateSkillDestinationForAccess(access);
   const resumingReinspectionHold = isPrivateSkillSubmissionReinspectionHold(draft);
   const resumingDestinationHold = isPrivateSkillDestinationHold(draft) && !isPrivateSkillDestinationRecoveryBlocked(draft, destination);
@@ -68582,10 +69289,10 @@ async function deliverPrivateSkillDraft(draftId, access, mode, transport) {
       next_action: null
     });
   }
-  const resumingLocalHold = resumingReinspectionHold || resumingDestinationHold || resumingResolution;
+  const resumingLocalHold = resumingReinspectionHold || resumingDestinationHold || resumingResolution || resumingConfigurationHold;
   const deferredDestinationProof = draft.state === "retry_scheduled" && draft.last_error_code === "private_skill_destination_audience_proof_unavailable";
   const awaitingDestinationCapability = isPrivateSkillDestinationCapabilityHold(draft) && !resumingResolution;
-  if ((mode === "retry" && !resumingResolution || deferredDestinationProof || resumingResolution && draft.state === "retry_scheduled") && !resumingReinspectionHold && !resumingDestinationHold && !awaitingDestinationCapability) {
+  if ((mode === "retry" && !resumingResolution || deferredDestinationProof || resumingResolution && draft.state === "retry_scheduled") && !resumingReinspectionHold && !resumingDestinationHold && !resumingConfigurationHold && !awaitingDestinationCapability) {
     const retryGate = privateSkillRetryGate(draft);
     if (retryGate) {
       return privateSkillDraftActionResult2(draft, retryGate);
@@ -68614,7 +69321,8 @@ async function deliverPrivateSkillDraft(draftId, access, mode, transport) {
     });
   }
   const reinspection = await reinspectPrivateSkillSubmissionCandidate(draftId, {
-    destination
+    destination,
+    resumeConfigurationHold: resumingConfigurationHold
   });
   draft = reinspection.draft;
   if (reinspection.status === "held") {
@@ -68927,6 +69635,16 @@ async function holdPrivateSkillDestination(draft, errorCode) {
 async function persistPrivateSkillFailure(draft, result, destinationBodyLimit) {
   return updatePrivateSkillDraft(draft.draft_id, (current) => {
     const attempts = current.attempts;
+    const failure = remembranceMcpToolFailure(result, "propose_private_skill");
+    if (failure && failure.http_status >= 500 && failure.http_status <= 599 && !failure.retryable) {
+      return {
+        ...current,
+        state: "held_validation",
+        next_retry_at: null,
+        last_error_code: failure.code === PRIVATE_SKILL_CONFIGURATION_REFUSAL ? PRIVATE_SKILL_CONFIGURATION_REFUSAL : PRIVATE_SKILL_PERMANENT_SERVICE_REFUSAL,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
     if (destinationBodyLimit !== null) {
       const nextRetryAt = privateSkillRetryAt(attempts);
       return {
@@ -69255,7 +69973,8 @@ function privateSkillDraftActionResult2(draft, extra = {}) {
     last_error_code: draft.last_error_code,
     retained_locally: true,
     next_action: privateSkillDraftNextAction(draft),
-    ...extra
+    ...extra,
+    ...privateSkillPermanentRefusalGuidance(draft)
   };
 }
 function privateSkillDraftNextAction(draft) {
@@ -69693,8 +70412,8 @@ function privateLessonRetryGate(draft) {
 }
 function retryDue(nextRetryAt) {
   if (!nextRetryAt) return true;
-  const timestamp = Date.parse(nextRetryAt);
-  return !Number.isFinite(timestamp) || timestamp <= Date.now();
+  const timestamp2 = Date.parse(nextRetryAt);
+  return !Number.isFinite(timestamp2) || timestamp2 <= Date.now();
 }
 async function submitPrivateLessonHoldTelemetry(initialDraft, access, allowPolicyRefresh, transport) {
   let draft = initialDraft;
@@ -70856,6 +71575,9 @@ async function callRemembrance(definition, rawArguments, options) {
     throw new McpPublicError(configurationError);
   }
   const apiKey = credential.apiKey;
+  if (definition.name === "repair_review_draft") {
+    headers["Idempotency-Key"] = String(parsed.request_id);
+  }
   if (apiKey) {
     headers["x-remembrance-api-key"] = apiKey;
   }
@@ -70899,6 +71621,7 @@ async function callRemembrance(definition, rawArguments, options) {
   let response;
   let body;
   let redirectRejected = false;
+  let reviewWorkflowStatus = 0;
   try {
     const execute = async () => {
       const nextResponse = await transport.request(
@@ -70911,6 +71634,7 @@ async function callRemembrance(definition, rawArguments, options) {
           signal: controller.signal
         }
       );
+      reviewWorkflowStatus = nextResponse.status;
       if (options.redirect === "manual" && (nextResponse.redirected || nextResponse.status >= 300 && nextResponse.status < 400)) {
         void nextResponse.body?.cancel().catch(() => void 0);
         return {
@@ -70925,7 +71649,13 @@ async function callRemembrance(definition, rawArguments, options) {
       let nextBody;
       try {
         nextBody = await readBoundedResponseJson(nextResponse);
+        if (nextResponse.ok && ["get_review_comparison", "repair_review_draft"].includes(definition.name) && !reviewWorkflowResponseBound(definition.name, nextBody, parsed)) {
+          throw new McpPublicError("The review response did not match this request.");
+        }
       } catch {
+        if (["get_review_comparison", "repair_review_draft"].includes(definition.name)) {
+          throw new McpPublicError("The review response is unreadable or unbound.");
+        }
         if (controller.signal.aborted) {
           throw new DOMException("Request timed out", "AbortError");
         }
@@ -70964,6 +71694,26 @@ async function callRemembrance(definition, rawArguments, options) {
       }
     }
   } catch (error) {
+    if (definition.name === "repair_review_draft") {
+      return {
+        ok: false,
+        status: reviewWorkflowStatus,
+        error: "The review repair outcome is unknown. Reconcile by repeating only this exact request with the same request_id; do not create another replacement.",
+        body: {
+          code: "review_repair_outcome_unknown",
+          delivery: "unknown",
+          request_id: parsed.request_id,
+          next_action: "Keep the original and repeat only the identical request_id, capture and snapshot to recover the committed receipt. Do not change input or use a new ID while this outcome is unknown."
+        }
+      };
+    }
+    if (definition.name === "get_review_comparison") {
+      return {
+        ok: false,
+        status: reviewWorkflowStatus,
+        body: { code: "review_comparison_unreadable", error: "No valid comparison was returned for this exact review job. Keep it unchanged and read its current references again." }
+      };
+    }
     return {
       ok: false,
       status: 0,
@@ -70972,6 +71722,25 @@ async function callRemembrance(definition, rawArguments, options) {
   } finally {
     clearTimeout(timeout);
   }
+  if (["get_review_comparison", "repair_review_draft"].includes(definition.name) && (!response.ok || redirectRejected)) {
+    const failure = remembranceMcpToolFailure({
+      ok: false,
+      status: response.status,
+      body,
+      retry_after: response.headers.get("retry-after"),
+      redirect_rejected: redirectRejected
+    }, definition.name);
+    body = {
+      error: failure?.message ?? "The review operation failed.",
+      code: failure?.code ?? "review_workflow_failed",
+      retryable: failure?.retryable ?? false,
+      delivery: failure?.delivery ?? "unknown",
+      ...definition.name === "repair_review_draft" ? {
+        request_id: parsed.request_id,
+        next_action: "If delivery is unknown, repeat only the identical request_id, capture and snapshot to reconcile it. Never create a new replacement for an unresolved write."
+      } : {}
+    };
+  }
   const verifiedBody = definition.name === "get_value_proof" && response.ok ? await verifySignedValueProofWithKeyRefresh(
     body,
     (forceRefresh) => fetchValueProofKeySet(forceRefresh, access, transport)
@@ -71490,7 +72259,7 @@ function endpointFor(definition, payload) {
     const query2 = privateLessonPolicyQuery(payload);
     return query2 ? `${endpoint}?${query2}` : endpoint;
   }
-  const queryKeys = definition.name === "list_skills" ? ["q", "slug", "cursor", "limit"] : ["query_id", "result_id"];
+  const queryKeys = definition.name === "list_skills" ? ["q", "slug", "cursor", "limit"] : definition.name === "get_review_comparison" ? ["job_id", "review_provenance"] : ["query_id", "result_id"];
   for (const key of queryKeys) {
     const value = payload[key];
     if (typeof value === "string" && value || typeof value === "number" && Number.isFinite(value)) {