cclaw-cli 0.48.4 → 0.48.5

package/dist/content/observe.js

@@ -1289,7 +1289,7 @@ export function codexHooksJsonWithObservation() {
                             command: hookDispatcherCommand("workflow-guard.sh")
                         }, {
                             type: "command",
-                            command: "bash -lc 'if ! command -v cclaw >/dev/null 2>&1; then echo \"[cclaw] codex hook: cclaw binary is required for verify-current-state\" >&2; exit 1; fi; cclaw internal verify-current-state --quiet >/dev/null || true'"
+                            command: "bash -lc 'if ! command -v cclaw >/dev/null 2>&1; then echo \"[cclaw] codex hook: cclaw binary is required for verify-current-state\" >&2; exit 1; fi; MODE=\"${CCLAW_WORKFLOW_GUARD_MODE:-advisory}\"; if [ \"$MODE\" = \"strict\" ]; then cclaw internal verify-current-state --quiet >/dev/null; else cclaw internal verify-current-state --quiet >/dev/null || true; fi'"
                         }]
                 }],
             PreToolUse: [{

package/dist/eval/agents/workflow.js

@@ -29,9 +29,17 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { createSandbox } from "../sandbox.js";
 import { loadStageSkill } from "./single-shot.js";
-import { runWithTools } from "./with-tools.js";
+import { MaxTurnsExceededError, runWithTools } from "./with-tools.js";
 const STAGES_SUBDIR = "stages";
 const ARTIFACT_CANDIDATES = ["artifact.md", "artifact.txt", "ARTIFACT.md"];
+const DEFAULT_WORKFLOW_MAX_TOTAL_TURNS = 40;
+const DEFAULT_STAGE_TURN_CAP = 8;
+function clampPositive(value, fallback) {
+    if (!Number.isInteger(value) || value < 1) {
+        return fallback;
+    }
+    return value;
+}
 export async function runWorkflow(input) {
     const { workflow, config, projectRoot, client } = input;
     const sandboxFactory = input.createSandboxFn ?? createSandbox;
@@ -43,9 +51,17 @@ export async function runWorkflow(input) {
     const artifacts = new Map();
     let totalUsageUsd = 0;
     let totalDurationMs = 0;
+    let totalTurns = 0;
+    const workflowTurnBudget = clampPositive(config.workflowMaxTotalTurns, DEFAULT_WORKFLOW_MAX_TOTAL_TURNS);
     try {
         await fs.mkdir(await sandbox.resolve(STAGES_SUBDIR, { allowMissing: true }), { recursive: true });
         for (const step of workflow.stages) {
+            const remainingWorkflowTurns = workflowTurnBudget - totalTurns;
+            if (remainingWorkflowTurns < 1) {
+                throw new MaxTurnsExceededError(workflowTurnBudget);
+            }
+            const perStageTurnCap = clampPositive(config.toolMaxTurns, DEFAULT_STAGE_TURN_CAP);
+            const stageTurnBudget = Math.min(perStageTurnCap, remainingWorkflowTurns);
             input.onStageStart?.(step.name);
             await clearArtifactFile(sandbox);
             const priorStages = stageResults.map((r) => r.stage);
@@ -58,7 +74,10 @@ export async function runWorkflow(input) {
             };
             const result = await runWithTools({
                 caseEntry,
-                config,
+                config: {
+                    ...config,
+                    toolMaxTurns: stageTurnBudget
+                },
                 projectRoot,
                 client,
                 ...(input.tools ? { tools: input.tools } : {}),
@@ -87,6 +106,7 @@ export async function runWorkflow(input) {
             input.onStageEnd?.(step.name, stageResult);
             totalUsageUsd += result.usageUsd;
             totalDurationMs += result.durationMs;
+            totalTurns += result.toolUse.turns;
         }
         return {
             caseId: workflow.id,

package/dist/gate-evidence.js

@@ -7,6 +7,7 @@ import { readDelegationLedger } from "./delegation.js";
 import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
 import { detectPublicApiChanges } from "./internal/detect-public-api-changes.js";
 import { readFlowState, writeFlowState } from "./runs.js";
+import { parseTddCycleLog, validateTddCycleOrder } from "./tdd-cycle.js";
 import { buildTraceMatrix } from "./trace-matrix.js";
 import { FLOW_STAGES } from "./types.js";
 async function currentStageArtifactExists(projectRoot, stage, track) {
@@ -200,6 +201,7 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
         issues.push(`stale triggered conditional gate "${gateId}" found in stageGateCatalog.triggered for stage "${stage}" (conditional gate DSL removed).`);
     }
     const blockedSet = new Set(catalog.blocked);
+    const passedSet = new Set(catalog.passed);
     for (const gateId of catalog.passed) {
         if (!allowedSet.has(gateId)) {
             issues.push(`passed gate "${gateId}" is not defined for stage "${stage}".`);
@@ -239,6 +241,13 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
             if (!verdictConsistency.ok) {
                 issues.push(`review verdict inconsistency: ${verdictConsistency.errors.join("; ")}`);
             }
+            const reviewCriticalsClaimedResolved = passedSet.has("review_criticals_resolved") || flowState.completedStages.includes("review");
+            const unresolvedCriticals = verdictConsistency.openCriticalCount > 0 || verdictConsistency.shipBlockerCount > 0;
+            if (reviewCriticalsClaimedResolved && unresolvedCriticals) {
+                issues.push(`review criticals gate blocked (review_criticals_resolved): review-army still reports ` +
+                    `${verdictConsistency.openCriticalCount} open critical(s) and ` +
+                    `${verdictConsistency.shipBlockerCount} ship blocker(s).`);
+            }
             const securityAttestation = await checkReviewSecurityNoChangeAttestation(projectRoot);
             if (!securityAttestation.ok) {
                 issues.push(`review security attestation failed: ${securityAttestation.errors.join("; ")}`);
@@ -309,9 +318,29 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
                     issues.push(`tdd docs drift gate blocked (tdd_docs_drift_check): public surface changes detected (${docsDriftDetection.changedFiles.join(", ")}) but no completed doc-updater delegation exists for the active run.`);
                 }
             }
+            const tddLogPath = path.join(projectRoot, RUNTIME_ROOT, "state", "tdd-cycle-log.jsonl");
+            if (await exists(tddLogPath)) {
+                try {
+                    const tddLogRaw = await fs.readFile(tddLogPath, "utf8");
+                    const parsedCycles = parseTddCycleLog(tddLogRaw);
+                    const tddOrderValidation = validateTddCycleOrder(parsedCycles, {
+                        runId: flowState.activeRunId
+                    });
+                    if (!tddOrderValidation.ok) {
+                        const details = [...tddOrderValidation.issues];
+                        if (tddOrderValidation.openRedSlices.length > 0) {
+                            details.push(`open red slices: ${tddOrderValidation.openRedSlices.join(", ")}`);
+                        }
+                        issues.push(`tdd cycle order gate blocked: ${details.join("; ")}`);
+                    }
+                }
+                catch (err) {
+                    const reason = err instanceof Error ? err.message : String(err);
+                    issues.push(`tdd cycle order gate blocked: unable to read tdd-cycle-log.jsonl (${reason}).`);
+                }
+            }
         }
     }
-    const passedSet = new Set(catalog.passed);
     const missingRequired = required.filter((gateId) => !passedSet.has(gateId));
     const missingRecommended = recommended.filter((gateId) => !passedSet.has(gateId));
     const missingTriggeredConditional = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.48.4",
+  "version": "0.48.5",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {