@besales/ops-framework 0.1.23 → 0.1.24

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.24
+
+- Raised `standard_plus` Check/Verify context cap so near-cap plans stay in compact mode instead of jumping to slow strict context.
+- Stabilized Check LLM `taskManifest` input by removing volatile `llmInput`, `lastCheckResult`, timestamps and verbose loop history from the prompt payload.
+- Reduced duplicate external Check reruns after `task-manifest.json` refreshes by keeping prompt input stable when plan, memory and risk inputs have not changed.
+
 ## 0.1.23
 
 - Added deterministic import/ingestion planning gates for representative real fixtures, raw downstream metadata extraction and explicit duplicate-import behavior.

package/bin/lib/llm-input-pack-utils.mjs

@@ -12,8 +12,8 @@ export const LLM_CONTEXT_MODES = ['fast', 'standard', 'standard_plus', 'strict']
 export const LLM_CONTEXT_CAPS = {
   fast: 8000,
   standard: 20000,
-  standard_plus: 26000,
-  strict: 45000,
+  standard_plus: 30000,
+  strict: 50000,
 };
 
 const TOKEN_ESTIMATE_CHARS_PER_TOKEN = 1.8;
@@ -225,7 +225,7 @@ export function buildCheckerLlmInputPack({
     relevantPlaybooks: selectedMode === 'strict'
       ? renderRelevantPlaybooks(readRelevantPlaybooks(checkContext.riskTriggers || []), { mode: 'strict' })
       : renderRelevantPlaybooks(readRelevantPlaybooks(checkContext.riskTriggers || []), { mode: 'compact' }),
-    taskManifest,
+    taskManifest: stableTaskManifestForCheck(taskManifest),
     projectMemory: compactProjectMemory(projectMemory, selectedMode),
     taskArtifacts: artifacts,
     outputContract: {
@@ -249,6 +249,61 @@ export function buildCheckerLlmInputPack({
   return withPackMetadata(input, selectedMode);
 }
 
+export function stableTaskManifestForCheck(taskManifest) {
+  let parsed = null;
+  if (typeof taskManifest === 'string') {
+    try {
+      parsed = JSON.parse(taskManifest);
+    } catch {
+      return taskManifest;
+    }
+  } else if (taskManifest && typeof taskManifest === 'object' && !Array.isArray(taskManifest)) {
+    parsed = taskManifest;
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    return taskManifest || '';
+  }
+
+  const stable = {
+    schemaVersion: parsed.schemaVersion,
+    taskId: parsed.taskId,
+    mode: parsed.mode,
+    phase: parsed.phase,
+    gates: parsed.gates,
+    context: {
+      planSha: parsed.context?.planSha,
+      planFingerprintVersion: parsed.context?.planFingerprintVersion,
+      memorySha: parsed.context?.memorySha,
+      riskProfile: parsed.context?.riskProfile,
+      riskTriggers: parsed.context?.riskTriggers,
+      riskWarnings: parsed.context?.riskWarnings,
+      checkContextCurrent: parsed.context?.checkContextCurrent,
+    },
+    requiredEvidenceIssues: parsed.requiredEvidenceIssues,
+    qualitySignals: parsed.qualitySignals,
+    loopDetector: {
+      threshold: parsed.loopDetector?.threshold,
+      requiresConsolidatedRemediation: parsed.loopDetector?.requiresConsolidatedRemediation,
+      repeatedReasons: parsed.loopDetector?.repeatedReasons,
+    },
+    consolidatedRemediationAccepted: parsed.consolidatedRemediationAccepted,
+    consolidatedRemediationArtifact: parsed.consolidatedRemediationArtifact,
+  };
+  return JSON.stringify(pruneUndefined(stable), null, 2);
+}
+
+function pruneUndefined(value) {
+  if (Array.isArray(value)) {
+    return value.map(pruneUndefined);
+  }
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+  return Object.fromEntries(Object.entries(value)
+    .filter(([, item]) => item !== undefined)
+    .map(([key, item]) => [key, pruneUndefined(item)]));
+}
+
 export function buildVerifierLlmInputPack({
   taskDir,
   taskId,

package/bin/lib/llm-input-pack-utils.test.mjs

@@ -112,12 +112,61 @@ describe('llm input pack utilities', () => {
     });
 
     expect(pack.meta.mode).toBe('standard_plus');
-    expect(pack.meta.capTokens).toBe(26000);
+    expect(pack.meta.capTokens).toBe(30000);
     expect(pack.input.llmInputPolicy.contextInsufficientFallback).toBe('rerun_strict');
     expect(pack.input.taskArtifacts['plan.md']).toContain('<!-- compacted:plan.md');
     expect(pack.meta.compactedArtifacts).toContain('plan.md');
   });
 
+  it('stabilizes checker task manifest by excluding volatile check telemetry', () => {
+    const taskDir = createTask();
+    const pack = buildCheckerLlmInputPack({
+      taskDir,
+      taskId: 'TASK-999-token-pack',
+      checkerPromptSha: 'sha256:test',
+      cacheKey: { test: true },
+      checkContext: {
+        planSha: 'sha256:plan',
+        memorySha: 'sha256:memory',
+        riskProfile: 'high',
+        riskTriggers: ['source-sync-provider'],
+      },
+      checkEvidence: '# Evidence\n\nok',
+      checkerContextPack: '# Checker Context Pack\n\nok',
+      taskManifest: JSON.stringify({
+        schemaVersion: 1,
+        taskId: 'TASK-999-token-pack',
+        mode: 'standard',
+        phase: 'check',
+        gates: { sourceSyncProvider: { required: true, planComplete: true } },
+        context: {
+          planSha: 'sha256:plan',
+          memorySha: 'sha256:memory',
+          riskProfile: 'high',
+          riskTriggers: ['source-sync-provider'],
+          checkContextCurrent: true,
+        },
+        llmInput: { check: { updatedAt: 'volatile', attempts: [{ mode: 'strict' }] } },
+        lastCheckResult: { verdict: 'ready_for_human_gate', createdAt: 'volatile' },
+        timestamps: { updatedAt: 'volatile' },
+        loopDetector: {
+          threshold: 2,
+          requiresConsolidatedRemediation: true,
+          repeatedReasons: [{ normalizedReason: 'context_overflow', count: 3 }],
+          reasons: { noisy: { normalizedReason: 'verbose history' } },
+        },
+      }, null, 2),
+      projectMemory: [],
+      mode: 'standard',
+    });
+
+    expect(pack.input.taskManifest).toContain('"requiresConsolidatedRemediation": true');
+    expect(pack.input.taskManifest).not.toContain('lastCheckResult');
+    expect(pack.input.taskManifest).not.toContain('llmInput');
+    expect(pack.input.taskManifest).not.toContain('timestamps');
+    expect(pack.input.taskManifest).not.toContain('verbose history');
+  });
+
   it('preserves protected verification sections when compacting long plans', () => {
     const taskDir = createTask();
     const longPlan = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@besales/ops-framework",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "type": "module",
   "bin": {
     "ops-agent": "bin/ops-agent.mjs"