codeloop-mcp-server 0.1.54 → 0.1.56

package/dist/index.js

@@ -162,6 +162,18 @@ warmCliCache();
 // to restart their IDE. See auth/update_check.ts for the full
 // rationale and opt-out env vars.
 startUpdateCheck();
+/**
+ * 0.1.55 F1/F3 — In-process tracker for "is the same modal description
+ * surviving consecutive desktop interactions?". Keyed by the lower-cased
+ * app_name (or "<default>" when none). Cleared whenever detectModal
+ * returns is_modal_present: false.
+ *
+ * Lives only as long as the MCP server process. We deliberately do NOT
+ * persist this across restarts because a server restart is itself a
+ * meaningful event that resets the recurrence-class signal — the cycle
+ * issues we've already written to disk continue to gate ready_for_review.
+ */
+const modalPersistenceTracker = new Map();
 const server = new McpServer({
     name: "codeloop",
     version: "0.1.14",
@@ -2118,6 +2130,42 @@ The agent MUST then write the report to docs/DEVELOPMENT_LOG.md and present it t
         // Check for interaction replay results
         const replayDir = join(baseDir, "replay_frames");
         const hasReplayFrames = existsSync(replayDir) && readdirSync(replayDir).length > 0;
+        // 0.1.55 F5 — surface cycle_issues to the dev report so the agent's
+        // generated DEVELOPMENT_LOG.md can't open with "All gates green"
+        // when recurrence-class issues happened mid-cycle. We expose:
+        //   - cycle_issues_summary: per-kind counts and resolved/unresolved breakdown
+        //   - cycle_issues: full per-issue list (with summaries pre-rendered)
+        //   - cycle_issues_directive: a HARD instruction that the report
+        //     MUST include a "Bugs Found & Fixed" row per unresolved issue
+        const { loadCycleIssues, summariseCycleIssue } = await import("./evidence/cycle_issues.js");
+        const ci = await loadCycleIssues(cwd);
+        const cycleSummary = ci.issues.reduce((acc, issue) => {
+            const k = issue.kind;
+            if (!acc[k])
+                acc[k] = { total: 0, unresolved: 0 };
+            acc[k].total++;
+            if (ci.unresolved.some((u) => u === issue))
+                acc[k].unresolved++;
+            return acc;
+        }, {});
+        const cycleIssuesEntries = ci.issues.map((issue) => ({
+            kind: issue.kind,
+            summary: summariseCycleIssue(issue),
+            resolved: !ci.unresolved.includes(issue),
+            raw: issue,
+        }));
+        const cycleIssuesDirective = ci.issues.length === 0
+            ? undefined
+            : `[CodeLoop F5] HARD: ${ci.issues.length} recurrence-class issue(s) were recorded during this cycle (` +
+                Object.entries(cycleSummary)
+                    .map(([k, v]) => `${k}: ${v.total} total / ${v.unresolved} unresolved`)
+                    .join(", ") +
+                `). The DEVELOPMENT_LOG.md you produce MUST include a "CodeLoop Cycle Issues" subsection under "Bugs Found & Fixed" that lists each entry from cycle_issues with: kind, summary, resolution (or "UNRESOLVED — escalated"). ` +
+                `Do NOT open the report with "all gates green" / "everything looks good" — those phrases match the C6 anti-rationalisation scan when cycle_issues exist and will fail the cycle_issues_acknowledged gate. ` +
+                `Specifically enumerate: ${ci.issues
+                    .slice(0, 5)
+                    .map((i) => `(${i.kind}) ${summariseCycleIssue(i)}`)
+                    .join(" | ")}${ci.issues.length > 5 ? " | … (see logs/cycle_issues.jsonl for the full list)" : ""}`;
         const report = {
             project_name: params.project_name,
             project_description: params.project_description || "",
@@ -2139,6 +2187,9 @@ The agent MUST then write the report to docs/DEVELOPMENT_LOG.md and present it t
             interaction_summary: interactionSummary,
             interaction_history: interactionHistory.slice(-50),
             run_timeline: runSummaries,
+            cycle_issues_summary: cycleSummary,
+            cycle_issues: cycleIssuesEntries,
+            cycle_issues_directive: cycleIssuesDirective,
         };
         await trackUsage(apiKey, "verification_run");
         return report;
@@ -3447,54 +3498,141 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
         }
         // Drain browser console errors that occurred during this interaction
         const consoleErrors = tt === "browser" ? bi.drainRecentConsoleErrors() : [];
-        // 0.1.54 E3 — Click-effect verification.
+        // 0.1.54 E3 + 0.1.55 F1/F3/F4 — Click-effect verification.
         //
-        // Photometry-DB E2E #11 had clicks marked `success: true` (they
-        // dispatched cleanly) that nonetheless missed the "X" close button
-        // on a stuck OpenFolderDialog — the agent then thought the modal
-        // was gone and burned cycles trying to interact with what was
-        // really a still-blocked main window.
+        // Photometry-DB E2E #11 had:
+        //  - clicks marked `success: true` (the dispatch landed) that
+        //    nonetheless missed the X close button on a stuck
+        //    OpenFolderDialog,
+        //  - the same OpenFolderDialog persisting across MULTIPLE clicks
+        //    without ever triggering codeloop_handle_modal,
+        //  - many of those clicks coming through with NO intent /
+        //    description field so the 0.1.54 E3 close-keyword check
+        //    silently never fired.
         //
-        // When the agent's intent / description / purpose / step explicitly
-        // says "close" / "dismiss" / "cancel" we re-detect the modal after
-        // a 500ms grace window. If a modal is still present (and matches
-        // the description if we had one), we override `success` to false,
-        // attach a verification field to the log entry, and record a
-        // `click_missed_target` cycle issue so the gate-check picks it up.
+        // 0.1.55 widens the verification to fire on EVERY desktop click /
+        // double-click / right-click / escape-keystroke during recording,
+        // tracks per-app modal persistence in-process, and:
+        //  1. Always attaches `modal_present_after` to the log entry when
+        //     a modal is detected after the action so the user-journey
+        //     gate can score the signal.
+        //  2. Overrides success=false when the agent's intent IS close-y
+        //     (preserves 0.1.54 E3 behaviour).
+        //  3. Records a `click_missed_target` cycle issue WHENEVER the
+        //     same modal description survives consecutive interactions —
+        //     2 in a row writes the issue regardless of intent, because
+        //     two clicks against an unchanged modal is the recurrence
+        //     signature from E2E #11.
+        //  4. Records a `modal_close_failed` cycle issue at 3+ consecutive
+        //     persistences so cycle_issues_acknowledged blocks the gate
+        //     even if the agent never called codeloop_handle_modal.
+        //  5. Escalates the post-interact directive (built later) to a
+        //     HARD instruction so the agent must call codeloop_handle_modal
+        //     or codeloop_kill_modal_window before the next interact.
         //
-        // Scope: desktop click + escape-keystroke during recording. Browser
-        // and mobile flows already get rich post-action signal from
-        // Playwright / adb so we don't double-fire there.
+        // Scope: desktop only. Browser and mobile flows have their own
+        // signal channels (Playwright console errors, adb dumpsys).
         let clickEffectVerification;
+        let modalPersistenceDirective;
         const closingIntent = (params.intent ?? params.description ?? params.purpose ?? params.step ?? "").toLowerCase();
         const isClosingIntent = /\b(close|dismiss|cancel|escape|exit)\b/.test(closingIntent);
-        const isCloseAction = (action === "click" && isClosingIntent) ||
-            (action === "keystroke" && (params.key ?? "").toLowerCase() === "escape");
-        if (success && isCloseAction && tt === "desktop") {
+        const isClickyAction = action === "click" || action === "double_click" || action === "right_click";
+        const isEscapeKeystroke = action === "keystroke" && (params.key ?? "").toLowerCase() === "escape";
+        const shouldVerifyClickEffect = success && tt === "desktop" && (isClickyAction || isEscapeKeystroke);
+        if (shouldVerifyClickEffect) {
             try {
                 await new Promise((resolve) => setTimeout(resolve, 500));
                 const { detectModal } = await import("./runners/modal_detector.js");
+                const trackerKey = (params.app_name || vr.getActiveRecordingAppName() || "<default>").toLowerCase();
                 const detection = await detectModal({
                     target_type: "desktop",
                     app_name: params.app_name || vr.getActiveRecordingAppName() || undefined,
                     cwd,
                 });
+                const { recordCycleIssue } = await import("./evidence/cycle_issues.js");
                 if (detection.is_modal_present) {
+                    const desc = detection.modal_description ?? "(unnamed)";
+                    const existing = modalPersistenceTracker.get(trackerKey);
+                    let consecutive;
+                    if (existing && existing.description === desc) {
+                        consecutive = existing.consecutive + 1;
+                        modalPersistenceTracker.set(trackerKey, {
+                            description: desc,
+                            consecutive,
+                            firstSeenMs: existing.firstSeenMs,
+                            modal_kind: detection.modal_kind,
+                        });
+                    }
+                    else {
+                        consecutive = 1;
+                        modalPersistenceTracker.set(trackerKey, {
+                            description: desc,
+                            consecutive,
+                            firstSeenMs: Date.now(),
+                            modal_kind: detection.modal_kind,
+                        });
+                    }
                     clickEffectVerification = {
                         intent: closingIntent,
                         modal_still_present: true,
                         modal_description: detection.modal_description,
-                    };
-                    success = false;
-                    detail = `${detail} | verification: modal still present after intended-close action (${detection.modal_description ?? "unnamed"})`;
-                    const { recordCycleIssue } = await import("./evidence/cycle_issues.js");
-                    await recordCycleIssue(cwd, {
-                        kind: "click_missed_target",
-                        selector: params.selector,
-                        coords: params.x != null && params.y != null ? [params.x, params.y] : undefined,
-                        description: closingIntent,
                         modal_kind: detection.modal_kind,
-                    });
+                        consecutive_persistences: consecutive,
+                    };
+                    // 0.1.54 E3 — close-intent override (unchanged).
+                    const isCloseAction = (isClickyAction && isClosingIntent) || isEscapeKeystroke;
+                    if (isCloseAction) {
+                        success = false;
+                        detail = `${detail} | verification: modal still present after intended-close action (${desc})`;
+                        await recordCycleIssue(cwd, {
+                            kind: "click_missed_target",
+                            selector: params.selector,
+                            coords: params.x != null && params.y != null ? [params.x, params.y] : undefined,
+                            description: closingIntent || `persisted modal: ${desc}`,
+                            modal_kind: detection.modal_kind,
+                        });
+                    }
+                    else if (consecutive >= 2) {
+                        // 0.1.55 F1 — same modal survived two interactions in a row
+                        // even though the agent didn't tag the click with a close
+                        // intent. That's the E2E #11 signature: many coordinate
+                        // clicks with no intent against a stuck OpenFolderDialog.
+                        await recordCycleIssue(cwd, {
+                            kind: "click_missed_target",
+                            selector: params.selector,
+                            coords: params.x != null && params.y != null ? [params.x, params.y] : undefined,
+                            description: `persisted modal across ${consecutive} consecutive interactions: ${desc}`,
+                            modal_kind: detection.modal_kind,
+                        });
+                    }
+                    // 0.1.55 F3 — at 3+ consecutive persistences, treat the modal
+                    // as actively stuck and write a modal_close_failed entry so
+                    // the cycle_issues_acknowledged gate fails even when the
+                    // agent never called codeloop_handle_modal.
+                    if (consecutive >= 3) {
+                        await recordCycleIssue(cwd, {
+                            kind: "modal_close_failed",
+                            modal_kind: detection.modal_kind ?? "custom",
+                            modal_description: desc,
+                            strategies_tried: [
+                                "raw_codeloop_interact_clicks_or_escape_x" + String(consecutive),
+                            ],
+                            hwnd: detection.hwnd,
+                        });
+                    }
+                    // 0.1.55 F4 — HARD directive for the post-interact postscript.
+                    modalPersistenceDirective =
+                        `\n\n[CodeLoop F4] HARD: A ${detection.modal_kind ?? "modal"} dialog (${desc}) is STILL present after this interaction ` +
+                            `(${consecutive} consecutive interactions have not cleared it). ` +
+                            `Stop sending raw clicks / Escape keystrokes against it and call codeloop_handle_modal with decision: "cancel" or "dismiss" — ` +
+                            `the multi-strategy ladder (Escape → Alt+F4 → UIA Invoke "Close" → EndDialog) handles file dialogs the keystroke path cannot. ` +
+                            `If codeloop_handle_modal returns escalation: "kill_window_required", call codeloop_kill_modal_window with the returned hwnd. ` +
+                            `Continuing to ignore this modal will fail the cycle_issues_acknowledged gate and block ready_for_review.`;
+                }
+                else {
+                    // Modal cleared — reset the tracker for this app so the next
+                    // appearance is counted from 1.
+                    modalPersistenceTracker.delete(trackerKey);
                 }
             }
             catch { /* best-effort verification */ }
@@ -3529,7 +3667,17 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
             }
         }
         catch { /* best-effort logging */ }
-        return { success, action, detail };
+        // 0.1.55 F4 — surface the modal-persistence directive as a
+        // side-channel so the postscript builder outside withAuth can
+        // append it to the agent-visible response.
+        const ret = {
+            success,
+            action,
+            detail,
+        };
+        if (modalPersistenceDirective)
+            ret._f4_directive = modalPersistenceDirective;
+        return ret;
     }, { tool: "codeloop_interact", cwd: resolveCwd(params), input: params });
     // 0.1.51 H11 — Post-interact modal-awareness directive.
     // After every codeloop_interact call we append a HARD reminder
@@ -3547,6 +3695,20 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
         "(\"confirm\" to proceed / \"cancel\" to abort / \"dismiss\" to close), and " +
         "(4) only then continue the planned journey. " +
         "Do NOT skip modals \"to keep moving\" — an unhandled modal will block every subsequent click and the user_journey_evidence gate will block ready_for_review.";
+    // 0.1.55 F4 — when desktop click-effect verification detected a
+    // modal that has now persisted across one or more interactions, the
+    // F4 directive is stronger than the soft H11 reminder. Append it
+    // and remove the side-channel field from the JSON-serialised result
+    // so the agent doesn't see internals.
+    {
+        const r = result;
+        const f4 = r && typeof r === "object" ? r._f4_directive : undefined;
+        if (f4) {
+            postscript += f4;
+            if (r)
+                delete r._f4_directive;
+        }
+    }
     // 0.1.52 C4 — Empty-state seeding directive. Heuristic runs against
     // the manifest entry the agent claims to be exercising plus the
     // recent interaction log; when the call looks like a row/cell