@besales/ops-framework 0.1.18 → 0.1.21

package/bin/run-check.mjs

@@ -66,6 +66,13 @@ async function runMain() {
   const noCache = getFlag(args, 'no-cache', false) === true;
   const checkerConfig = resolveCheckerConfig(args);
   const runStartedAt = new Date();
+  appendCheckTimeline(taskDir, {
+    event: 'check_started',
+    provider: checkerConfig.provider,
+    model: checkerConfig.model,
+    noCache,
+    dryRun,
+  });
 
   let checkContext = ensureFreshCheckContext(taskDir, taskId);
   const deterministicPrecheck = syncManifestAndStatusBeforeCheck({ taskDir, taskId, checkContext });
@@ -79,6 +86,12 @@ async function runMain() {
       issues: deterministicPrecheck.issues,
       startedAt: runStartedAt,
     });
+    appendCheckTimeline(taskDir, {
+      event: 'deterministic_precheck_blocked',
+      verdict: 'return_to_plan',
+      issues: deterministicPrecheck.issues.map((issue) => issue.message),
+      timing: buildTiming(runStartedAt),
+    });
     runValidator(taskArg);
     console.log(`Checker preflight blocked ${taskId}: return_to_plan`);
     console.log(`- deterministicIssues: ${deterministicPrecheck.issues.length}`);
@@ -146,6 +159,13 @@ async function runMain() {
       cacheKey,
       contextMode,
     });
+    appendCheckTimeline(taskDir, {
+      event: 'llm_input_built',
+      contextMode,
+      cacheKeySha,
+      packMeta: promptPayload.pack.meta,
+      timing: buildTiming(runStartedAt),
+    });
 
     console.log(`Checker LLM input for ${taskId}`);
     for (const line of summarizePackForConsole(promptPayload.pack)) {
@@ -169,6 +189,13 @@ async function runMain() {
         message: `Strict LLM input pack exceeds cap: estimatedTokens=${promptPayload.pack.meta.estimatedTokens}, capTokens=${promptPayload.pack.meta.capTokens}`,
         rawOutput: null,
       });
+      appendCheckTimeline(taskDir, {
+        event: 'context_overflow',
+        contextMode,
+        cacheKeySha,
+        packMeta: promptPayload.pack.meta,
+        timing: buildTiming(runStartedAt),
+      });
       recordLlmInputUsage({
         taskDir,
         stage: 'check',
@@ -184,6 +211,13 @@ async function runMain() {
 
     if (!noCache && restoreFromCache({ taskDir, taskArg, cacheKeySha })) {
       llmInputAttempts.push(buildAttemptRecord(promptPayload.pack.meta, 'cache_hit'));
+      appendCheckTimeline(taskDir, {
+        event: 'cache_hit',
+        contextMode,
+        cacheKeySha,
+        packMeta: promptPayload.pack.meta,
+        timing: buildTiming(runStartedAt),
+      });
       recordLlmInputUsage({
         taskDir,
         stage: 'check',
@@ -197,11 +231,32 @@ async function runMain() {
     }
 
     try {
+      const providerStartedAt = new Date();
+      appendCheckTimeline(taskDir, {
+        event: 'provider_started',
+        provider: checkerConfig.provider,
+        model: checkerConfig.model,
+        reasoningEffort: checkerConfig.reasoningEffort,
+        contextMode,
+        cacheKeySha,
+        packMeta: promptPayload.pack.meta,
+        timing: buildTiming(runStartedAt),
+      });
       providerOutput = await runProvider({
         checkerConfig,
         messages: promptPayload.messages,
         prompt: promptPayload.prompt,
       });
+      appendCheckTimeline(taskDir, {
+        event: 'provider_completed',
+        provider: checkerConfig.provider,
+        model: checkerConfig.model,
+        contextMode,
+        cacheKeySha,
+        verdict: providerOutput.checkResultJson?.verdict || null,
+        providerTiming: buildTiming(providerStartedAt),
+        timing: buildTiming(runStartedAt),
+      });
     } catch (error) {
       const failureReason = error.failureReason || 'unknown';
       writeFailureArtifacts({
@@ -215,6 +270,16 @@ async function runMain() {
         message: error.message,
         rawOutput: error.rawOutput || null,
       });
+      appendCheckTimeline(taskDir, {
+        event: 'provider_failed',
+        provider: checkerConfig.provider,
+        model: checkerConfig.model,
+        contextMode,
+        cacheKeySha,
+        failureReason,
+        message: error.message,
+        timing: buildTiming(runStartedAt),
+      });
       llmInputAttempts.push(buildAttemptRecord(promptPayload.pack.meta, `provider_failed:${failureReason}`));
       recordLlmInputUsage({
         taskDir,
@@ -246,6 +311,13 @@ async function runMain() {
     cacheKey,
     providerOutput,
   });
+  appendCheckTimeline(taskDir, {
+    event: 'check_completed',
+    verdict: providerOutput.checkResultJson?.verdict || null,
+    contextMode: promptPayload.pack.meta.mode,
+    cacheKeySha,
+    timing: buildTiming(runStartedAt),
+  });
   if (!isContextInsufficientResult(providerOutput.checkResultJson)) {
     storeInCache({ taskDir, cacheKeySha });
   }
@@ -263,6 +335,26 @@ async function runMain() {
   console.log(`- finalEstimatedInputTokens: ${promptPayload.pack.meta.estimatedTokens}`);
 }
 
+function appendCheckTimeline(taskDir, event) {
+  const timelinePath = path.join(taskDir, 'check-timeline.json');
+  let existing = [];
+  if (fs.existsSync(timelinePath)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(timelinePath, 'utf8'));
+      if (Array.isArray(parsed)) {
+        existing = parsed;
+      }
+    } catch {
+      existing = [];
+    }
+  }
+  existing.push({
+    at: new Date().toISOString(),
+    ...event,
+  });
+  writeTaskFile(taskDir, 'check-timeline.json', JSON.stringify(existing, null, 2));
+}
+
 function buildAttemptRecord(packMeta, outcome) {
   return {
     mode: packMeta.mode,

package/bin/run-verify.mjs

@@ -45,6 +45,13 @@ async function runMain() {
   const taskDir = resolveTaskDir(taskArg);
   const taskId = path.basename(taskDir);
   const verifierConfig = resolveVerifierConfig(args);
+  const runStartedAt = new Date();
+  appendVerifyTimeline(taskDir, {
+    event: 'verify_started',
+    mode: verifierConfig.mode,
+    provider: verifierConfig.provider,
+    model: verifierConfig.model,
+  });
   const planSha = hashTaskMarkdown(taskDir, 'plan.md');
   const executionSha = hashTaskMarkdown(taskDir, 'execution.md');
   const taskManifest = readOptionalJson(taskDir, 'task-manifest.json');
@@ -66,6 +73,12 @@ async function runMain() {
       executionSha,
       evidenceIssues,
     });
+    appendVerifyTimeline(taskDir, {
+      event: 'deterministic_preverify_blocked',
+      verdict: 'return_to_execute',
+      issues: evidenceIssues.map((issue) => issue.message),
+      timing: buildTiming(runStartedAt),
+    });
     console.log(`Verifier preflight blocked ${taskId}: return_to_execute`);
     console.log(`- evidenceIssues: ${evidenceIssues.length}`);
     return;
@@ -79,6 +92,11 @@ async function runMain() {
       planSha,
       executionSha,
     });
+    appendVerifyTimeline(taskDir, {
+      event: 'internal_supervisor_completed',
+      verdict: 'pass_with_notes',
+      timing: buildTiming(runStartedAt),
+    });
     console.log(`Internal supervisor Verify artifact written for ${taskId}: pass_with_notes`);
     return;
   }
@@ -109,12 +127,26 @@ async function runMain() {
       contextMode,
     });
     finalPack = promptPayload.pack;
+    appendVerifyTimeline(taskDir, {
+      event: 'llm_input_built',
+      contextMode,
+      verifierRunId,
+      packMeta: promptPayload.pack.meta,
+      timing: buildTiming(runStartedAt),
+    });
     console.log(`Verifier LLM input for ${taskId}`);
     for (const line of summarizePackForConsole(promptPayload.pack)) {
       console.log(line);
     }
     if (promptPayload.pack.meta.overCap && contextMode !== 'strict') {
       llmInputAttempts.push(buildAttemptRecord(promptPayload.pack.meta, 'skipped_over_cap'));
+      appendVerifyTimeline(taskDir, {
+        event: 'llm_input_over_cap_escalating',
+        contextMode,
+        verifierRunId,
+        packMeta: promptPayload.pack.meta,
+        timing: buildTiming(runStartedAt),
+      });
       appendOrchestrationLog(taskDir, `verifier LLM input exceeded ${contextMode} cap; rerunning pack builder with expanded context`);
       continue;
     }
@@ -131,6 +163,13 @@ async function runMain() {
         message: `Strict LLM input pack exceeds cap: estimatedTokens=${promptPayload.pack.meta.estimatedTokens}, capTokens=${promptPayload.pack.meta.capTokens}`,
         rawOutput: null,
       });
+      appendVerifyTimeline(taskDir, {
+        event: 'context_overflow',
+        contextMode,
+        verifierRunId,
+        packMeta: promptPayload.pack.meta,
+        timing: buildTiming(runStartedAt),
+      });
       recordLlmInputUsage({
         taskDir,
         stage: 'verify',
@@ -143,6 +182,17 @@ async function runMain() {
     }
 
     try {
+      const providerStartedAt = new Date();
+      appendVerifyTimeline(taskDir, {
+        event: 'provider_started',
+        provider: verifierConfig.provider,
+        model: verifierConfig.model,
+        reasoningEffort: verifierConfig.reasoningEffort,
+        contextMode,
+        verifierRunId,
+        packMeta: promptPayload.pack.meta,
+        timing: buildTiming(runStartedAt),
+      });
       output = await runExternalCliChecker({
         providerName: verifierConfig.provider,
         providerConfig: verifierConfig.providerConfig,
@@ -151,6 +201,15 @@ async function runMain() {
         prompt: promptPayload.prompt,
         cwd: repoRoot,
       });
+      appendVerifyTimeline(taskDir, {
+        event: 'provider_completed',
+        provider: verifierConfig.provider,
+        model: verifierConfig.model,
+        contextMode,
+        verifierRunId,
+        providerTiming: buildTiming(providerStartedAt),
+        timing: buildTiming(runStartedAt),
+      });
     } catch (error) {
       writeVerifierFailure({
         taskDir,
@@ -163,6 +222,16 @@ async function runMain() {
         message: error.message,
         rawOutput: error.rawOutput || null,
       });
+      appendVerifyTimeline(taskDir, {
+        event: 'provider_failed',
+        provider: verifierConfig.provider,
+        model: verifierConfig.model,
+        contextMode,
+        verifierRunId,
+        failureReason: error.failureReason || 'unknown',
+        message: error.message,
+        timing: buildTiming(runStartedAt),
+      });
       llmInputAttempts.push(buildAttemptRecord(promptPayload.pack.meta, `provider_failed:${error.failureReason || 'unknown'}`));
       recordLlmInputUsage({
         taskDir,
@@ -205,8 +274,17 @@ async function runMain() {
       packMeta: finalPack.meta,
       attempts: llmInputAttempts,
       rerunCount,
+      timing: buildTiming(runStartedAt),
     });
   }
+  appendVerifyTimeline(taskDir, {
+    event: 'verify_completed',
+    verdict: verifyResultJson.verdict,
+    verifierRunId,
+    finalMode: finalPack?.meta?.mode || null,
+    finalEstimatedTokens: finalPack?.meta?.estimatedTokens || null,
+    timing: buildTiming(runStartedAt),
+  });
   appendOrchestrationLog(taskDir, `external CLI verifier completed via ${verifierConfig.provider}; verdict=${verifyResultJson.verdict}; runId=${verifierRunId}`);
   console.log(`Verifier run completed for ${taskId}: ${verifyResultJson.verdict}`);
   console.log(`- verifierRunId: ${verifierRunId}`);
@@ -216,6 +294,34 @@ async function runMain() {
   }
 }
 
+function buildTiming(startedAt, completedAt = new Date()) {
+  return {
+    startedAt: startedAt.toISOString(),
+    completedAt: completedAt.toISOString(),
+    durationMs: Math.max(0, completedAt.getTime() - startedAt.getTime()),
+  };
+}
+
+function appendVerifyTimeline(taskDir, event) {
+  const timelinePath = path.join(taskDir, 'verify-timeline.json');
+  let existing = [];
+  if (fs.existsSync(timelinePath)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(timelinePath, 'utf8'));
+      if (Array.isArray(parsed)) {
+        existing = parsed;
+      }
+    } catch {
+      existing = [];
+    }
+  }
+  existing.push({
+    at: new Date().toISOString(),
+    ...event,
+  });
+  writeTaskFile(taskDir, 'verify-timeline.json', JSON.stringify(existing, null, 2));
+}
+
 function buildAttemptRecord(packMeta, outcome) {
   return {
     mode: packMeta.mode,

package/package.json

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