@vypdev/copilot 3.10.8 → 3.10.10

package/build/deployment_recovery/index.js

@@ -32572,6 +32572,16 @@ const ENGLISH_RECOVERY_CONTENT = Object.freeze({
         action: 'Inspect the original issue and the supported assessment protocol. The unchanged 8,000-code-point field limit must include every citation and a nonempty fact. Details: phase {phase}, reason {reason}, field {field}, requirement {requirementId}, original issue line {sourceLineId}. none means no verified identity is available. An identical retry cannot add capacity; preserve every requirement and verification gate when reviewing a supported protocol.',
         retainedState: 'Existing progress labels and published assessments were preserved. No partial result or passing verification is authorized.',
     }),
+    'progress-sdd-seed-unverified': Object.freeze({
+        impact: 'Commit could not verify the selected SDD draft for this issue and head.',
+        action: 'Check the draft markers and confirm the current selection and verified SDD publication on the linked branch, then rerun Commit.',
+        retainedState: 'Existing progress was retained.',
+    }),
+    'progress-batch-retained': Object.freeze({
+        impact: 'Progress retained. Verified {verified} of {expected} batches. Complete evidence for the evaluated head is required.',
+        action: 'Inspect the current run and requirement {requirementId}, batch {batch}, reason {reason}. Resolve missing or mismatched evidence and retry a complete assessment within the fixed budget.',
+        retainedState: 'Existing progress labels and published assessments were preserved. No partial percentage was authorized.',
+    }),
     'progress-scope-clause-limit': Object.freeze({
         impact: 'The complete human scope classification selected {observed} {clauseKind} lines; the supported limit is {limit}. Progress was not published.',
         action: 'Inspect the original human scope and classifier result at source {sourceLineId}, phase scope. A fresh valid classification may help; do not remove requirements, promote generated state or raise limits to pass. Genuine over-limit human scope requires a reviewed supported protocol.',
@@ -32778,6 +32788,16 @@ const SPANISH_RECOVERY_CONTENT = Object.freeze({
         action: 'Inspecciona la issue original y el protocolo de evaluación admitido. El límite fijo de 8,000 puntos de código por campo debe incluir cada cita y un dato no vacío. Detalles: fase {phase}, motivo {reason}, campo {field}, requisito {requirementId}, línea original de la issue {sourceLineId}. none indica que no hay una identidad verificada. Repetir el intento no añade capacidad; conserva todos los requisitos y controles de verificación al revisar un protocolo compatible.',
         retainedState: 'Se conservaron las etiquetas de progreso y las evaluaciones publicadas. No se autoriza un resultado parcial ni una verificación aprobada.',
     }),
+    'progress-sdd-seed-unverified': Object.freeze({
+        impact: 'Commit no pudo verificar el borrador de SDD seleccionado para esta issue y revisión.',
+        action: 'Comprueba los marcadores del borrador y confirma la selección y la publicación verificada del SDD en la rama vinculada. Después, vuelve a ejecutar Commit.',
+        retainedState: 'Se conservó el progreso anterior.',
+    }),
+    'progress-batch-retained': Object.freeze({
+        impact: 'Progreso conservado. Se verificaron {verified} de {expected} lotes. Se exige evidencia completa de la revisión evaluada.',
+        action: 'Inspecciona la ejecución y el requisito {requirementId}, lote {batch}, motivo {reason}. Resuelve la evidencia ausente o incompatible y repite la evaluación completa dentro del presupuesto fijo.',
+        retainedState: 'Se conservaron las etiquetas y evaluaciones de progreso anteriores. No se autorizó un porcentaje parcial.',
+    }),
     'progress-scope-clause-limit': Object.freeze({
         impact: 'La clasificación completa del alcance humano seleccionó {observed} líneas de tipo {clauseKind}; el límite admitido es {limit}. No se publicó el progreso.',
         action: 'Inspecciona el alcance humano original y la clasificación en la línea {sourceLineId}, fase scope. Una nueva clasificación válida puede ayudar; no elimines requisitos, conviertas estado generado en requisitos ni aumentes límites para aprobar. El alcance humano que excede el límite necesita un protocolo compatible revisado.',
@@ -33740,11 +33760,13 @@ exports.ENGLISH_PROGRESS_CAPACITY_LABELS = {
     capacityAggregateEnvelope: 'receipt envelope and minimum payload reservation', capacityMinimumFacts: 'minimum complete fact reservation',
     capacityUnitCount: 'evidence-unit count', capacityAggregateFacts: 'complete aggregate facts', capacityInvalidAllocation: 'invalid capacity allocation',
     capacitySourceUnitCount: 'source-unit count',
+    capacityAssessmentSummary: 'progress summary field', capacityAssessmentRemaining: 'progress remaining field',
     capacityMaximumMeasurement: 'Measured or required: {observedCount} {unit}; maximum available: {supportedLimit} {unit} ({countKind}).',
     capacityMinimumMeasurement: 'Measured: {observedCount} {unit}; minimum required: {supportedLimit} {unit} ({countKind}).',
     capacityUnavailableMeasurement: 'Usage and applicable allocation are unavailable.',
     capacityContextUnavailable: 'Source and path-coverage context are unavailable.',
     capacitySourceLine: 'Original physical source line: {sourceLineId}.',
+    capacityAssessmentContext: 'Complete inventory: {requirementCount} requirements. Batch: {batch}; requirement: {requirementId}. Batch 0 identifies complete reduction; none means no single requirement is attributed.',
     capacityManifestUnavailable: 'not available at this boundary', capacityNoPaths: 'no uncovered paths',
     capacityComparison: 'Pinned comparison: {baseSha} → {headSha}. Required-path inventory: {requiredPathsDigest}; source manifest: {manifestDigest}. Accepted progress path receipts: {reviewedPathCount}/{requiredPathCount}; uncovered: {uncoveredPathCount}. Receipt-path inventory: {reviewedPathsDigest}; uncovered-path inventory: {uncoveredPathsDigest}. Paths: {paths}.',
 };
@@ -33761,11 +33783,13 @@ exports.SPANISH_PROGRESS_CAPACITY_LABELS = {
     capacityAggregateEnvelope: 'envoltura de recibos y reserva mínima de contenido', capacityMinimumFacts: 'reserva mínima de hechos completos',
     capacityUnitCount: 'cantidad de unidades de evidencia', capacityAggregateFacts: 'hechos completos del agregado', capacityInvalidAllocation: 'asignación de capacidad no válida',
     capacitySourceUnitCount: 'cantidad de unidades de origen',
+    capacityAssessmentSummary: 'campo de resumen del progreso', capacityAssessmentRemaining: 'campo de trabajo pendiente del progreso',
     capacityMaximumMeasurement: 'Medido o requerido: {observedCount} {unit}; máximo disponible: {supportedLimit} {unit} ({countKind}).',
     capacityMinimumMeasurement: 'Medido: {observedCount} {unit}; mínimo requerido: {supportedLimit} {unit} ({countKind}).',
     capacityUnavailableMeasurement: 'El uso y la asignación aplicable no están disponibles.',
     capacityContextUnavailable: 'El contexto de origen y cobertura de rutas no está disponible.',
     capacitySourceLine: 'Línea física de origen: {sourceLineId}.',
+    capacityAssessmentContext: 'Inventario completo: {requirementCount} requisitos. Lote: {batch}; requisito: {requirementId}. El lote 0 identifica la reducción completa; none indica que no se atribuye a un único requisito.',
     capacityManifestUnavailable: 'no disponible en este límite', capacityNoPaths: 'ninguna ruta sin cubrir',
     capacityComparison: 'Comparación fijada: {baseSha} → {headSha}. Inventario de rutas requeridas: {requiredPathsDigest}; manifiesto de origen: {manifestDigest}. Recibos de rutas de progreso aceptados: {reviewedPathCount}/{requiredPathCount}; sin cubrir: {uncoveredPathCount}. Inventario de rutas con recibo: {reviewedPathsDigest}; inventario de rutas sin cubrir: {uncoveredPathsDigest}. Rutas: {paths}.',
 };
@@ -34005,6 +34029,7 @@ var _ApplicationError_cause;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.ApplicationError = exports.APPLICATION_ERROR_METADATA = exports.APPLICATION_ERROR_RECOVERY_IDS = void 0;
 exports.isApplicationErrorCorrelationId = isApplicationErrorCorrelationId;
+const progress_batch_diagnostic_1 = __nccwpck_require__(9486);
 const branch_sync_publication_1 = __nccwpck_require__(7857);
 const framed_review_1 = __nccwpck_require__(3750);
 const progress_response_diagnostic_1 = __nccwpck_require__(6289);
@@ -34068,6 +34093,8 @@ exports.APPLICATION_ERROR_RECOVERY_IDS = Object.freeze([
     'progress-partition-length-invalid',
     'progress-assessment-capacity-exceeded',
     'progress-scope-clause-limit',
+    'progress-sdd-seed-unverified',
+    'progress-batch-retained',
     'progress-completion-recovery-exhausted',
     'stored-configuration-schema-missing',
     'stored-configuration-schema-unsupported',
@@ -34329,6 +34356,8 @@ const RECOVERY_VARIABLE_KEYS = Object.freeze({
     'progress-result-contract-invalid': Object.freeze(['phase', 'reason', 'field', 'requirementId', 'sourceLineId']),
     'progress-partition-length-invalid': Object.freeze(['partitionId', 'filePath', 'unitId', 'field', 'maximum', 'observed']),
     'progress-assessment-capacity-exceeded': Object.freeze(['phase', 'reason', 'field', 'requirementId', 'sourceLineId']),
+    'progress-batch-retained': Object.freeze(['reason', 'verified', 'expected', 'batch', 'requirementId']),
+    'progress-sdd-seed-unverified': Object.freeze([]),
     'progress-scope-clause-limit': Object.freeze(['clauseKind', 'observed', 'limit', 'sourceLineId']),
     'progress-completion-recovery-exhausted': Object.freeze(['reportedProgress', 'requirementCount', 'supportedCount', 'missingCount', 'unknownCount']),
     'deployment-publication-context-missing': Object.freeze([]),
@@ -34428,6 +34457,8 @@ function normalizeApplicationErrorRecovery(recovery) {
         && (!(0, progress_response_diagnostic_2.isProgressResponseDiagnosticFacts)(variables) || variables.phase !== 'assessment' || variables.reason !== 'assessment-text-limit')) {
         throw new TypeError('Progress assessment capacity diagnostic is invalid.');
     }
+    if (recovery.id === 'progress-batch-retained' && !(0, progress_batch_diagnostic_1.isProgressBatchDiagnostic)(variables))
+        throw new TypeError('Progress batch diagnostic is invalid.');
     if (recovery.id === 'progress-scope-clause-limit' && !(0, progress_response_diagnostic_1.isProgressScopeCapacityFacts)(variables))
         throw new TypeError('Progress scope capacity diagnostic is invalid.');
     if (recovery.id === 'progress-result-contract-invalid' && !(0, progress_response_diagnostic_2.isProgressResponseDiagnosticFacts)(variables))
@@ -37348,6 +37379,32 @@ function parsePositiveSafeInteger(value) {
 }
 
 
+/***/ }),
+
+/***/ 9486:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.PROGRESS_BATCH_REASONS = void 0;
+exports.isProgressBatchDiagnostic = isProgressBatchDiagnostic;
+exports.PROGRESS_BATCH_REASONS = [
+    'source-coverage', 'scope-capacity', 'manifest-identity', 'batch-identity', 'receipt-coverage',
+    'evidence-identity', 'evidence-missing', 'receipt-conflict', 'call-budget', 'time-budget', 'aggregate-capacity',
+];
+function isProgressBatchDiagnostic(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const facts = value;
+    return Object.keys(facts).sort().join(',') === 'batch,expected,reason,requirementId,verified'
+        && exports.PROGRESS_BATCH_REASONS.includes(facts.reason)
+        && [facts.verified, facts.expected, facts.batch].every(count => Number.isSafeInteger(count) && count >= 0 && count <= 1024)
+        && facts.verified <= facts.expected
+        && typeof facts.requirementId === 'string' && /^(?:none|R[1-9]\d{0,5})$/u.test(facts.requirementId);
+}
+
+
 /***/ }),
 
 /***/ 364:
@@ -37423,6 +37480,8 @@ exports.PROGRESS_CAPACITY_DIMENSIONS = Object.freeze({
     'minimum-fact-bytes': rule(['aggregate'], 'bytes'),
     'evidence-unit-count': rule(['aggregate'], 'units', ['minimum']),
     'aggregate-fact-bytes': rule(['aggregate'], 'bytes'),
+    'assessment-summary-points': rule(['assessment', 'aggregate'], 'code-points'),
+    'assessment-remaining-points': rule(['assessment', 'aggregate'], 'code-points'),
     'invalid-allocation': rule(['input', 'source', 'scope', 'partition', 'aggregate', 'assessment'], 'bytes', ['unavailable']),
 });
 const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
@@ -37447,6 +37506,15 @@ function normalizeProgressCapacityContext(value) {
             return invalid();
         return Object.freeze({ kind: 'source-line', sourceLineId: value.sourceLineId });
     }
+    if (value.kind === 'assessment') {
+        if (!exact(value, ['kind', 'requirementCount', 'batch', 'requirementId'])
+            || !count(value.requirementCount) || value.requirementCount < 1 || value.requirementCount > 256
+            || !count(value.batch) || value.batch > value.requirementCount
+            || !(value.requirementId === 'none' || (0, progress_response_diagnostic_1.isProgressRequirementId)(value.requirementId))
+            || (value.batch === 0 && value.requirementId !== 'none'))
+            return invalid();
+        return Object.freeze({ kind: 'assessment', requirementCount: value.requirementCount, batch: value.batch, requirementId: value.requirementId });
+    }
     if (value.kind !== 'comparison' || !exact(value, ['kind', 'baseSha', 'headSha', 'manifestDigest', 'requiredPathsDigest',
         'reviewedPathsDigest', 'uncoveredPathsDigest', 'requiredPathCount', 'reviewedPathCount', 'uncoveredPathCount', 'paths', 'sourceLineId'])
         || !oid(value.baseSha) || !oid(value.headSha) || !(value.manifestDigest === 'none' || digest(value.manifestDigest))
@@ -37485,6 +37553,9 @@ function normalizeProgressCapacityDiagnostic(value) {
         && (value.bound === 'minimum' ? value.observedCount >= value.supportedLimit : value.observedCount <= value.supportedLimit))
         return invalid();
     const context = normalizeProgressCapacityContext(value.context);
+    if (context.kind === 'assessment' && (!['assessment-summary-points', 'assessment-remaining-points'].includes(dimension)
+        || (value.phase === 'aggregate' ? context.batch !== 0 : context.batch === 0)))
+        return invalid();
     const sourceLineId = context.kind === 'source-line' || context.kind === 'comparison' ? context.sourceLineId : 'none';
     if (sourceLineId !== 'none' && (value.phase !== 'scope'
         || !['source-line-count', 'source-line-points'].includes(dimension)))
@@ -37676,10 +37747,12 @@ exports.PROGRESS_RESPONSE_REASONS = Object.freeze({
         'partition-file-invalid', 'partition-unit-invalid', 'partition-facts-invalid']),
     assessment: Object.freeze([...schemaReasons, 'requirements-incomplete', 'progress-invalid', 'requirement-shape-invalid', 'requirement-id-invalid',
         'requirement-id-duplicate', 'scope-uncertain', 'requirement-status-invalid', 'requirement-evidence-invalid', 'requirement-summary-invalid',
-        'requirement-remaining-invalid', 'requirement-evidence-mismatch', 'progress-completion-mismatch', 'assessment-text-limit']),
+        'requirement-remaining-invalid', 'requirement-remaining-null-required', 'requirement-remaining-string-required',
+        'requirement-remaining-blank', 'requirement-remaining-too-long',
+        'requirement-evidence-mismatch', 'progress-completion-mismatch', 'assessment-text-limit']),
 });
 const fieldPatterns = Object.freeze({
-    scope: /^\$(?:\.outputLocale|\.lines(?:\[(0|[1-9]\d{0,3})\](?:\.(?:id|kind))?)?)?$/u,
+    scope: /^\$(?:\.outputLocale|\.lines(?:\[(0|[1-9]\d{0,3})\](?:\.(?:id|kind|sameAs))?)?)?$/u,
     partition: /^\$(?:\.outputLocale|\.partitionId|\.files(?:\[(0|[1-9]\d{0,3})\](?:\.(?:path|unitId|implemented|remaining))?)?)?$/u,
     assessment: /^\$(?:\.outputLocale|\.progress|\.requirements(?:\[(0|[1-9]\d{0,3})\](?:\.(?:id|status|evidence|summary|remaining))?)?)?$/u,
 });
@@ -37690,7 +37763,7 @@ function knownId(value, prefix, maximum) {
     const match = value.match(/^([RL])([1-9]\d{0,5})$/u);
     return match !== null && match[0] === value && match[1] === prefix && Number(match[2]) <= maximum;
 }
-const isProgressRequirementId = (value) => knownId(value, 'R', 32);
+const isProgressRequirementId = (value) => knownId(value, 'R', agent_execution_plan_1.AGENT_PROMPT_MAX_BYTES + 1);
 exports.isProgressRequirementId = isProgressRequirementId;
 const isProgressSourceLineId = (value) => knownId(value, 'L', agent_execution_plan_1.AGENT_PROMPT_MAX_BYTES + 1);
 exports.isProgressSourceLineId = isProgressSourceLineId;