@open-agent-toolkit/cli 0.2.24 → 0.2.25

package/dist/review-remote/narrowing.js

@@ -9,16 +9,85 @@
  * range, so a rebased/force-pushed/shallow prior SHA never produces a
  * misleading partial range.
  */
-/** Does a prior review match the current `(rail, project, scope)` tuple? */
+const FULL_COMMIT_SHA = /^[0-9a-f]{40}$/i;
+/**
+ * Normalize one parsed GitHub marker into a narrowing candidate. Unknown
+ * invocation and target-less gate markers preserve their metadata but carry no
+ * lineage, so tuple matching rejects them and fails open.
+ */
+export function priorReviewFromMarker(marker, submittedAt) {
+    const lineage = markerLineage(marker);
+    return {
+        headSha: marker.oat_review_head_sha,
+        scope: marker.oat_review_scope,
+        ...(marker.oat_project ? { project: marker.oat_project } : {}),
+        ...(marker.oat_review_invocation
+            ? { invocation: marker.oat_review_invocation }
+            : {}),
+        ...(lineage ? { lineage } : {}),
+        submittedAt,
+    };
+}
+function markerLineage(marker) {
+    if (marker.oat_review_invocation === 'manual' ||
+        marker.oat_review_invocation === 'auto') {
+        return { kind: 'lifecycle' };
+    }
+    const gateTarget = marker.oat_gate_target?.trim();
+    return marker.oat_review_invocation === 'gate' && gateTarget
+        ? { kind: 'gate', target: gateTarget }
+        : undefined;
+}
+/**
+ * Normalize durable ledger provenance into the same candidate shape used by
+ * artifact-sourced reviews. Both sources then pass through {@link matchesTuple}
+ * and cannot drift into separate lineage predicates.
+ */
+export function priorReviewFromLedger(row) {
+    const invocation = isReviewInvocationKind(row.invocation)
+        ? row.invocation
+        : undefined;
+    const lineage = ledgerLineage(row);
+    return {
+        headSha: row.reviewedHead,
+        scope: row.scope,
+        ...(row.project ? { project: row.project } : {}),
+        ...(invocation ? { invocation } : {}),
+        ...(lineage ? { lineage } : {}),
+        submittedAt: row.submittedAt,
+    };
+}
+function isReviewInvocationKind(invocation) {
+    return (invocation === 'manual' || invocation === 'auto' || invocation === 'gate');
+}
+function ledgerLineage(row) {
+    if (row.invocation === 'manual' || row.invocation === 'auto') {
+        return { kind: 'lifecycle' };
+    }
+    const gateTarget = row.gateTarget?.trim();
+    return row.invocation === 'gate' && gateTarget
+        ? { kind: 'gate', target: gateTarget }
+        : undefined;
+}
+/** Does a prior review match the current rail, project, scope, and lineage? */
 function matchesTuple(review, input) {
+    if (!FULL_COMMIT_SHA.test(review.headSha)) {
+        return false;
+    }
+    const sameLineage = review.lineage !== undefined &&
+        review.lineage.kind === input.lineage.kind &&
+        (input.lineage.kind === 'lifecycle' ||
+            (review.lineage.kind === 'gate' &&
+                review.lineage.target === input.lineage.target));
     if (input.rail === 'ad-hoc') {
         // Ad-hoc: scope sentinel must match AND there must be no project key.
-        return review.scope === 'ad-hoc' && review.project === undefined;
+        return (review.scope === 'ad-hoc' && review.project === undefined && sameLineage);
     }
     // Project rail: same project AND same scope.
     return (review.project !== undefined &&
         review.project === input.project &&
-        review.scope === input.scope);
+        review.scope === input.scope &&
+        sameLineage);
 }
 function mostRecentMatch(input) {
     const matches = input.reviews.filter((r) => matchesTuple(r, input));
@@ -48,16 +117,47 @@ async function guardPasses(priorSha, input) {
     }
     return input.git.isAncestor(priorSha, input.headSha);
 }
+async function classifyRange(priorSha, input) {
+    let files;
+    try {
+        files = await input.git.changedFiles(priorSha, input.headSha);
+    }
+    catch {
+        // Classification is reporting-only, so enumeration failure must not block
+        // dispatch. Treat unknown work as substantive and disclose the fallback.
+        return {
+            classification: 'substantive',
+            classificationReason: 'changed-files-unavailable',
+        };
+    }
+    if (files.length === 0) {
+        return { classification: 'empty' };
+    }
+    const projectPrefix = input.project === null ? null : `${input.project.replace(/\/+$/, '')}/`;
+    // Path-only classification is sufficient while it is reporting-only. If it
+    // ever authorizes skipping work, strengthen it with lifecycle corroboration.
+    return {
+        classification: projectPrefix !== null &&
+            files.every((file) => file.startsWith(projectPrefix))
+            ? 'bookkeeping-only'
+            : 'substantive',
+    };
+}
 /**
  * Pick the narrowing target for the current re-review pass.
  */
 export async function pickNarrowingTarget(input) {
+    if (input.narrowingPreference === false && !input.forceNarrow) {
+        return {
+            kind: 'full-scope-fallback',
+            reason: 'narrowing-disabled',
+        };
+    }
     const prior = mostRecentMatch(input);
     if (!prior) {
         return {
             kind: 'full-scope-fallback',
             reason: 'no-prior-review',
-            prompted: false,
         };
     }
     const passed = await guardPasses(prior.headSha, input);
@@ -66,8 +166,7 @@ export async function pickNarrowingTarget(input) {
             kind: 'narrow-range',
             priorSha: prior.headSha,
             headSha: input.headSha,
-            // Auto-narrow skips the prompt; otherwise the caller still confirms.
-            prompted: !input.autoNarrow,
+            ...(await classifyRange(prior.headSha, input)),
         };
     }
     // Guard failed. The user explicitly asked to narrow → hard error.
@@ -78,13 +177,10 @@ export async function pickNarrowingTarget(input) {
             priorSha: prior.headSha,
         };
     }
-    // Otherwise fall back to full scope. Auto-narrow surfaces this as the
-    // auto-fallback notice (no prompt); manual mode does not prompt here either —
-    // the fallback is informational.
+    // Otherwise fail open to full scope and preserve the guard failure reason.
     return {
         kind: 'full-scope-fallback',
         reason: 'stale-sha',
         priorSha: prior.headSha,
-        prompted: false,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-agent-toolkit/cli",
-  "version": "0.2.24",
+  "version": "0.2.25",
   "private": false,
   "description": "Open Agent Toolkit CLI",
   "homepage": "https://github.com/voxmedia/open-agent-toolkit/tree/main/packages/cli",
@@ -34,7 +34,7 @@
     "ora": "^9.0.0",
     "yaml": "2.8.2",
     "zod": "^3.25.76",
-    "@open-agent-toolkit/control-plane": "0.2.24"
+    "@open-agent-toolkit/control-plane": "0.2.25"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",