codeloop-mcp-server 0.1.53 → 0.1.55

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",
@@ -1861,10 +1873,40 @@ App logs (stdout, logcat, simctl log) are automatically captured alongside the v
                 autoLaunchSummary = { attempted: true, launched: false, reason: e.message };
             }
         }
+        // 0.1.54 E4 — Binary-vs-source mtime check.
+        // Photometry-DB E2E #11 had bin/Release rebuilt but the recording
+        // ran against publish/PhotometryDB-Beta with stale DLLs. We surface
+        // a HARD directive AND record a binary_mismatch cycle issue so the
+        // gate can block ready_for_review until rebuild + re-record.
+        let binaryFreshnessWarning;
+        let binaryFreshnessDetails;
+        if (targetType === "desktop" && appName) {
+            try {
+                const { checkBinaryFreshness } = await import("./evidence/binary_freshness.js");
+                binaryFreshnessDetails = checkBinaryFreshness({ app_name: appName, cwd });
+                if (binaryFreshnessDetails.stale) {
+                    binaryFreshnessWarning = binaryFreshnessDetails.reason;
+                    const { recordCycleIssue } = await import("./evidence/cycle_issues.js");
+                    await recordCycleIssue(cwd, {
+                        kind: "binary_mismatch",
+                        target_app: binaryFreshnessDetails.binary_path ?? appName,
+                        binary_mtime: binaryFreshnessDetails.binary_mtime ?? "unknown",
+                        newest_source_mtime: binaryFreshnessDetails.newest_source_mtime ?? "unknown",
+                        newest_source_path: binaryFreshnessDetails.newest_source_path,
+                        lag_seconds: binaryFreshnessDetails.lag_seconds ?? 0,
+                    });
+                }
+            }
+            catch { /* best-effort */ }
+        }
         const result = await startBackgroundRecording(videosDir, appName ?? "", params.max_duration_seconds, targetType);
         if (autoLaunchSummary) {
             result.auto_launch = autoLaunchSummary;
         }
+        if (binaryFreshnessWarning) {
+            result.binary_freshness_warning = binaryFreshnessWarning;
+            result.binary_freshness = binaryFreshnessDetails;
+        }
         await trackUsage(apiKey, "visual_review");
         return result;
     }, { tool: "codeloop_start_recording", cwd: resolveCwd(params), input: params });
@@ -2043,9 +2085,20 @@ The agent MUST then write the report to docs/DEVELOPMENT_LOG.md and present it t
                 }
             }
         }
-        // Parse interaction_log.jsonl from each run for the interaction history
+        // Parse interaction_log.jsonl from each run for the interaction history.
+        // 0.1.54 E5 — only count entries that look like real interactions
+        // (must have `action: string` AND `input_args: object`). Photometry-DB
+        // E2E #11 had 27% of action buckets land under "undefined" because
+        // the log mixes interaction entries with replay-frame markers and
+        // browser console_error rollups. Coerce missing/non-string actions
+        // to "unclassified" so the dev-report breakdown stays honest.
         const interactionHistory = [];
         const interactionSummary = { total: 0, succeeded: 0, failed: 0, actions: {}, console_errors: 0 };
+        const isInteractionEntry = (e) => {
+            const hasArgs = e.input_args !== null && typeof e.input_args === "object";
+            const hasAction = typeof e.action === "string" && e.action.length > 0;
+            return hasArgs && hasAction;
+        };
         for (const runId of runs) {
             const runDir = getRunDir(runId, baseDir);
             const iLogPath = join(runDir, "logs", "interaction_log.jsonl");
@@ -2054,15 +2107,21 @@ The agent MUST then write the report to docs/DEVELOPMENT_LOG.md and present it t
                 for (const line of lines) {
                     try {
                         const entry = JSON.parse(line);
+                        if (!isInteractionEntry(entry))
+                            continue;
                         interactionHistory.push({ run_id: runId, ...entry });
                         interactionSummary.total++;
                         if (entry.success)
                             interactionSummary.succeeded++;
                         else
                             interactionSummary.failed++;
-                        interactionSummary.actions[entry.action] = (interactionSummary.actions[entry.action] || 0) + 1;
-                        if (entry.console_errors?.length)
-                            interactionSummary.console_errors += entry.console_errors.length;
+                        const bucket = typeof entry.action === "string" && entry.action.length > 0
+                            ? entry.action
+                            : "unclassified";
+                        interactionSummary.actions[bucket] = (interactionSummary.actions[bucket] || 0) + 1;
+                        const ce = entry.console_errors;
+                        if (Array.isArray(ce))
+                            interactionSummary.console_errors += ce.length;
                     }
                     catch { /* skip malformed lines */ }
                 }
@@ -2071,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 || "",
@@ -2092,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;
@@ -3400,6 +3498,145 @@ 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 + 0.1.55 F1/F3/F4 — Click-effect verification.
+        //
+        // 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.
+        //
+        // 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 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 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,
+                        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 */ }
+        }
         // Log interaction result for post-recording analysis
         const interactionEntry = {
             timestamp: new Date().toISOString(),
@@ -3411,6 +3648,8 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
         };
         if (consoleErrors.length > 0)
             interactionEntry.console_errors = consoleErrors;
+        if (clickEffectVerification)
+            interactionEntry.verification = clickEffectVerification;
         try {
             const activeIds = vr.getActiveRecordingIds();
             if (activeIds.length > 0) {
@@ -3428,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
@@ -3446,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
@@ -3520,6 +3783,51 @@ Returns: detected modal description + result of the chosen decision.`, {
                     : undefined,
             };
         }
+        // 0.1.54 E1 — file dialogs get the multi-strategy close ladder.
+        // Photometry-DB E2E #11 had three .NET 8 OpenFolderDialog instances
+        // that ignored single-keystroke close attempts; the ladder runs
+        // Escape → Alt+F4 → UIA Invoke "Close" → EndDialog and re-detects
+        // between steps. If all 4 fail it surfaces a HARD escalation hint
+        // pointing at codeloop_kill_modal_window.
+        if ((params.decision === "cancel" || params.decision === "dismiss") &&
+            detection.modal_kind === "file_dialog" &&
+            detection.target_type === "desktop") {
+            const { closeModalWithStrategies } = await import("./runners/modal_close_strategies.js");
+            const { recordCycleIssue } = await import("./evidence/cycle_issues.js");
+            const close = await closeModalWithStrategies({
+                initial_detection: detection,
+                app_name: params.app_name,
+                cwd,
+            });
+            if (!close.closed) {
+                await recordCycleIssue(cwd, {
+                    kind: "modal_close_failed",
+                    modal_kind: detection.modal_kind ?? "custom",
+                    modal_description: detection.modal_description,
+                    strategies_tried: close.strategies_tried.map((a) => a.strategy),
+                    hwnd: close.hwnd,
+                });
+                return {
+                    decision_taken: params.decision,
+                    detection,
+                    close_attempt: close,
+                    escalation: "kill_window_required",
+                    next_step: `HARD: All 4 close strategies failed (escape, alt_f4, uia_invoke_close, end_dialog). ` +
+                        `Call codeloop_kill_modal_window with hwnd="${close.hwnd ?? "<rerun_detect_modal>"}" ` +
+                        `to escalate to PostMessage(WM_CLOSE) → TerminateProcess. After kill-window succeeds, ` +
+                        `you MUST also call codeloop_start_recording again because the app process was terminated. ` +
+                        `This stuck-modal cycle has been written to cycle_issues.jsonl and the gate-check will require you to acknowledge it before reporting ready_for_review.`,
+                };
+            }
+            return {
+                decision_taken: params.decision,
+                detection,
+                close_attempt: close,
+                escalation: "none",
+                next_step: `Modal closed successfully via strategy "${close.strategies_tried.find((a) => a.success)?.strategy ?? "unknown"}". ` +
+                    `Continue with codeloop_interact against the application.`,
+            };
+        }
         // For confirm / cancel / dismiss we delegate to codeloop_interact
         // semantics by issuing a key press that maps to the right OS
         // convention. dismiss ⇒ Escape, cancel ⇒ Escape (most modals
@@ -3539,6 +3847,53 @@ Returns: detected modal description + result of the chosen decision.`, {
         content: withInitHint([{ type: "text", text: JSON.stringify(authResult, null, 2) }], resolveCwd(params)),
     };
 });
+// 0.1.54 E1 — codeloop_kill_modal_window: last-resort modal escalation
+server.tool("codeloop_kill_modal_window", TOOL_BOOTSTRAP + `Last-resort escalation to kill a stuck modal that codeloop_handle_modal could not close with its 4-strategy ladder (Escape → Alt+F4 → UIA Invoke "Close" → EndDialog).
+
+This tool is ONLY for the case where codeloop_handle_modal returned escalation: "kill_window_required". It will:
+1. PostMessage(WM_CLOSE) to the specific HWND.
+2. Wait 2 s and re-detect.
+3. If the modal is still up, call TerminateProcess on the owning PID.
+
+CRITICAL: TerminateProcess will kill the app you are recording. After this tool succeeds you MUST:
+- Call codeloop_stop_recording (the recording will be partial but evidence is preserved).
+- Rebuild + re-launch the app and call codeloop_start_recording again.
+- Resume the user-journey from the start of the affected flow.
+
+This is a Windows-only tool. macOS / Linux modal handling does not need this escalation.`, {
+    hwnd: z.string().describe("Win32 HWND captured by detectModal / codeloop_handle_modal. Pass the value from detection.hwnd or close_attempt.hwnd."),
+    target_type: targetTypeSchema.optional(),
+    app_name: z.string().optional(),
+    project_dir: z.string().optional(),
+    workspace_root: z.string().optional(),
+}, async (params) => {
+    const authResult = await withAuth(async () => {
+        const { killModalWindow } = await import("./runners/modal_close_strategies.js");
+        const { recordCycleIssue } = await import("./evidence/cycle_issues.js");
+        const cwd = resolveCwd(params);
+        const result = await killModalWindow({
+            hwnd: params.hwnd,
+            app_name: params.app_name,
+            cwd,
+        });
+        if (result.steps.some((s) => s.step === "terminate_process" && s.success)) {
+            await recordCycleIssue(cwd, {
+                kind: "app_restart_during_recording",
+                reason: "TerminateProcess used to clear stuck modal — recording will be partial",
+                hwnd: params.hwnd,
+            });
+        }
+        return {
+            ...result,
+            next_step: result.closed
+                ? "Modal cleared. Call codeloop_stop_recording (current recording is partial), then rebuild + relaunch the app + codeloop_start_recording before resuming the user-journey."
+                : "WARNING: even after PostMessage(WM_CLOSE) + TerminateProcess the modal is still detected. The host UI may be wedged at the OS level. Consider rebooting the workstation or escalating to manual intervention.",
+        };
+    }, { tool: "codeloop_kill_modal_window", cwd: resolveCwd(params), input: params });
+    return {
+        content: withInitHint([{ type: "text", text: JSON.stringify(authResult, null, 2) }], resolveCwd(params)),
+    };
+});
 // ── codeloop_init_project ────────────────────────────────────────
 server.tool("codeloop_init_project", TOOL_BOOTSTRAP + `Initialize CodeLoop in a project that hasn't been set up yet. Creates
 \`.codeloop/config.json\`, agent rules, MCP config, \`artifacts/\`, and