@hienlh/ppm 0.18.9 → 0.18.11

package/.spike/pip-results-terminal.json

@@ -0,0 +1,220 @@
+{
+  "reset": {
+    "hadPip": true,
+    "twInPip": false
+  },
+  "baseline": {
+    "rows": 54,
+    "cols": 197,
+    "echoed": true,
+    "renderer": "2 canvas"
+  },
+  "move": {
+    "phase": "done",
+    "value": {
+      "styles": {
+        "inlineSheets": 9,
+        "clonedLinks": 2,
+        "failed": 0,
+        "rules": 1471
+      },
+      "moved": {
+        "adopted": true,
+        "slotTag": "DIV",
+        "slotHasWrapper": false
+      },
+      "rowsCols": {
+        "rows": 54,
+        "cols": 197
+      },
+      "xtermRect": {
+        "w": 1387,
+        "h": 810
+      },
+      "canvases": [
+        {
+          "w": 1379,
+          "h": 810,
+          "ctx": "n/a"
+        },
+        {
+          "w": 1379,
+          "h": 810,
+          "ctx": "n/a"
+        }
+      ],
+      "pipInner": {
+        "w": 1395,
+        "h": 842
+      },
+      "mainHasFocus": false,
+      "pipHasFocus": true,
+      "themeBg": "rgb(30, 32, 40)",
+      "mainThemeBg": "rgb(21, 22, 28)",
+      "pipHtmlClass": "dark"
+    }
+  },
+  "stillInPipAfterIdle": true,
+  "newTargets": [
+    {
+      "targetId": "F30BC13FB06D945181B894D00452D99E",
+      "type": "page",
+      "title": "about:blank",
+      "url": "about:blank",
+      "attached": false,
+      "openerId": "ABD2ADD39468D5F37A57F99D622368A1",
+      "canAccessOpener": true,
+      "openerFrameId": "ABD2ADD39468D5F37A57F99D622368A1",
+      "browserContextId": "8871A9D7F4E65EDDCED25B9DFAE50EEC"
+    },
+    {
+      "targetId": "69387E9109CA8AB281C29D852AE899B2",
+      "type": "browser_ui",
+      "title": "Omnibox Popup",
+      "url": "chrome://omnibox-popup.top-chrome/omnibox_popup_aim.html",
+      "attached": false,
+      "canAccessOpener": false,
+      "browserContextId": "8871A9D7F4E65EDDCED25B9DFAE50EEC"
+    },
+    {
+      "targetId": "6C54FB1DE5371071C9BA64B3569662BC",
+      "type": "browser_ui",
+      "title": "Omnibox Popup",
+      "url": "chrome://omnibox-popup.top-chrome/",
+      "attached": false,
+      "canAccessOpener": false,
+      "browserContextId": "8871A9D7F4E65EDDCED25B9DFAE50EEC"
+    }
+  ],
+  "pipAttached": true,
+  "pipTargetInfo": {
+    "url": "about:blank",
+    "w": 1395,
+    "h": 842,
+    "hasWrapper": true,
+    "title": ""
+  },
+  "shot1": {
+    "screen": "FAILED (Exception calling \"CopyFromScreen\" with \"3\" argument(s): \"The handle is invalid\")",
+    "pip": "C:/Users/PC/ppm/plans/reports/screenshots/spike-01-terminal-in-pip.png"
+  },
+  "typingTrustedInPip": false,
+  "typingSyntheticInPip": {
+    "echoed": false,
+    "activeInPip": true
+  },
+  "dragSelectTrustedInPip": {
+    "selection": "",
+    "rect": {
+      "x": 4,
+      "y": 33,
+      "w": 1379,
+      "h": 810
+    }
+  },
+  "dragSelectSyntheticInPip": {
+    "viaPipDoc": "",
+    "viaMainDoc": ""
+  },
+  "resizeViaStyle": {
+    "before": {
+      "rows": 54,
+      "cols": 197
+    },
+    "after": {
+      "rows": 54,
+      "cols": 197
+    },
+    "restored": {
+      "rows": 54,
+      "cols": 197
+    },
+    "refit": false
+  },
+  "resizeViaWindow": {
+    "before": {
+      "rows": 54,
+      "cols": 197,
+      "w": 1395,
+      "h": 842
+    },
+    "after": {
+      "rows": 54,
+      "cols": 197,
+      "w": 1395,
+      "h": 842
+    },
+    "err": "NotAllowedError: Failed to execute 'resizeTo' on 'Window': resizeTo() requires user activation in document picture-in-picture"
+  },
+  "reactClick": {
+    "probeBefore": {
+      "mainDocClick": 0,
+      "pipDocClick": 1,
+      "wrapperClick": 1,
+      "reactRootClick": 0
+    },
+    "probeAfter": {
+      "mainDocClick": 0,
+      "pipDocClick": 2,
+      "wrapperClick": 2,
+      "reactRootClick": 0
+    },
+    "toast": "",
+    "synthetic": true
+  },
+  "reactClickTrusted": {
+    "probe": {
+      "mainDocClick": 0,
+      "pipDocClick": 3,
+      "wrapperClick": 3,
+      "reactRootClick": 0
+    },
+    "toast": ""
+  },
+  "pullbackProbe": {
+    "inPipBefore": true,
+    "inPipAfterTabClick": true,
+    "found": true
+  },
+  "shot2": "C:/Users/PC/ppm/plans/reports/screenshots/spike-01b-terminal-pip-after-resize.png",
+  "back": {
+    "wasInPip": true,
+    "back": {
+      "back": true
+    },
+    "rows": 47,
+    "cols": 147,
+    "scrollbackKept": {
+      "before": true,
+      "trusted": false,
+      "synth": false
+    }
+  },
+  "afterReturn": {
+    "echoed": false,
+    "rows": 47,
+    "cols": 147,
+    "reactClickControl": {
+      "probeBefore": {
+        "mainDocClick": 2,
+        "pipDocClick": 3,
+        "wrapperClick": 3,
+        "reactRootClick": 2
+      },
+      "probeAfter": {
+        "mainDocClick": 4,
+        "pipDocClick": 3,
+        "wrapperClick": 4,
+        "reactRootClick": 4
+      },
+      "toast": "Sent to chat"
+    }
+  },
+  "log": [
+    "19:16:07.504 helpers installed",
+    "19:17:40.004 helpers installed",
+    "19:19:47.238 helpers installed",
+    "19:19:47.243 pip pagehide",
+    "19:20:40.863 pip pagehide"
+  ]
+}

package/.spike/pip-results-xterm-trace.json

@@ -0,0 +1,73 @@
+{
+  "roundTripped_setup": {
+    "wrapped": [
+      "ok:keyDown",
+      "ok:keyPress",
+      "ok:inputEvent",
+      "ok:thirdLevel",
+      "ok:composition.keydown",
+      "ok:evaluateKeyDown",
+      "ok:triggerData"
+    ],
+    "state": {
+      "unprocessedDeadKey": false,
+      "keyDownHandled": false,
+      "keyPressHandled": false,
+      "isComposing": false,
+      "isSending": false,
+      "useKitty": false,
+      "useWin32": false,
+      "customHandler": false,
+      "disableStdin": false,
+      "screenReader": false,
+      "textareaOwner": true,
+      "browser": {
+        "isWindows": true,
+        "isMac": false
+      }
+    }
+  },
+  "roundTripped_trace": [],
+  "fresh_setup": {
+    "wrapped": [
+      "ok:keyDown",
+      "ok:keyPress",
+      "ok:inputEvent",
+      "ok:thirdLevel",
+      "ok:composition.keydown",
+      "ok:evaluateKeyDown",
+      "ok:triggerData"
+    ],
+    "state": {
+      "unprocessedDeadKey": false,
+      "keyDownHandled": false,
+      "keyPressHandled": false,
+      "isComposing": false,
+      "isSending": false,
+      "useKitty": false,
+      "useWin32": false,
+      "customHandler": false,
+      "disableStdin": false,
+      "screenReader": false,
+      "textareaOwner": true,
+      "browser": {
+        "isWindows": true,
+        "isMac": false
+      }
+    }
+  },
+  "fresh_trace": [
+    "composition.keydown -> true",
+    "evaluateKeyDown -> {\"type\":0,\"cancel\":false}",
+    "thirdLevel -> false",
+    "keyDown -> true",
+    "triggerData -> undefined",
+    "keyPress -> true",
+    "inputEvent -> false",
+    "composition.keydown -> true",
+    "evaluateKeyDown -> {\"type\":0,\"cancel\":true,\"key\":\"\\r\"}",
+    "thirdLevel -> false",
+    "triggerData -> undefined",
+    "keyDown -> false"
+  ]
+}

package/.spike/pip-spike-common.ts

@@ -0,0 +1,83 @@
+// Shared harness for the Document PiP spike stages (terminal / editor).
+import { join } from "node:path";
+import { CdpClient, sleep } from "./cdp-client";
+
+export const APP = "http://localhost:5173";
+export const SHOTS = "C:/Users/PC/ppm/plans/reports/screenshots";
+export { sleep };
+
+export async function connectApp() {
+  const cdp = await CdpClient.connect(9333);
+  const page = (await cdp.targets()).find((t) => t.type === "page" && t.url.startsWith(APP));
+  if (!page) throw new Error("no app page target");
+  const sid = await cdp.attach(page.targetId);
+  await cdp.send("Page.enable", {}, sid);
+  await cdp.send("Runtime.enable", {}, sid);
+  const helpers = await Bun.file(join(import.meta.dir, "pip-page-helpers.js")).text();
+  await cdp.eval(sid, helpers);
+  const knownTargets = new Set((await cdp.targets()).map((t) => t.targetId));
+
+  const ev = <T = unknown>(expr: string) => cdp.eval<T>(sid, expr);
+  async function waitFor(expr: string, timeoutMs = 20000, label = expr) {
+    const t0 = Date.now();
+    while (Date.now() - t0 < timeoutMs) {
+      if (await ev<boolean>(`!!(${expr})`)) return;
+      await sleep(250);
+    }
+    throw new Error(`timeout waiting: ${label}`);
+  }
+  async function openViaUrl(path: string) {
+    await ev(`history.pushState(null, '', ${JSON.stringify(path)}); dispatchEvent(new PopStateEvent('popstate')); 'ok'`);
+    await sleep(600);
+  }
+  /** Click the injected trusted-gesture button and wait for its async work to settle. */
+  async function runGesture(id: string, fnSource: string, timeoutMs = 20000) {
+    const pt = await ev<{ x: number; y: number }>(`window.__spike.installButton(${JSON.stringify(id)}, ${fnSource})`);
+    await cdp.click(sid, pt.x, pt.y);
+    const t0 = Date.now();
+    while (Date.now() - t0 < timeoutMs) {
+      const r = await ev<any>(`window.__spike.results[${JSON.stringify(id)}]`);
+      if (r && r.phase !== "running") return r;
+      await sleep(200);
+    }
+    throw new Error(`gesture ${id} timed out`);
+  }
+  /** Any CDP target that appeared since connect (candidate PiP window). */
+  async function newTargets() {
+    return (await cdp.targets()).filter((t) => !knownTargets.has(t.targetId));
+  }
+  /** Whole-screen capture via PowerShell (PiP is a separate always-on-top OS window). */
+  async function screenShot(name: string) {
+    const out = `${SHOTS}/${name}`;
+    const ps = `Add-Type -AssemblyName System.Windows.Forms; Add-Type -AssemblyName System.Drawing; $b=[System.Windows.Forms.Screen]::PrimaryScreen.Bounds; $bmp=New-Object System.Drawing.Bitmap $b.Width,$b.Height; $g=[System.Drawing.Graphics]::FromImage($bmp); $g.CopyFromScreen($b.Location,[System.Drawing.Point]::Empty,$b.Size); $bmp.Save('${out}',[System.Drawing.Imaging.ImageFormat]::Png); $g.Dispose(); $bmp.Dispose(); 'saved'`;
+    const p = Bun.spawn(["powershell", "-NoProfile", "-Command", ps], { stdout: "pipe", stderr: "pipe" });
+    await p.exited;
+    const err = await new Response(p.stderr).text();
+    return p.exitCode === 0 && !err ? out : `FAILED (${err.split("\n")[0]?.trim()})`;
+  }
+  /** Attach to the PiP window (an about:blank page target created after connect). */
+  async function attachPip(): Promise<string | null> {
+    const cands = (await newTargets()).filter((t) => t.type === "page");
+    for (const t of cands) {
+      try { return await cdp.attach(t.targetId); } catch { /* try next */ }
+    }
+    return null;
+  }
+  /** Page.captureScreenshot of the PiP target — works even when the OS desktop is not capturable. */
+  async function pipShot(pipSid: string | null, name: string) {
+    if (!pipSid) return "no pip session";
+    const out = `${SHOTS}/${name}`;
+    await cdp.screenshot(pipSid, out);
+    return out;
+  }
+  return { cdp, sid, ev, waitFor, openViaUrl, runGesture, newTargets, screenShot, attachPip, pipShot };
+}
+
+export type Harness = Awaited<ReturnType<typeof connectApp>>;
+
+export async function saveResults(name: string, data: unknown) {
+  const path = join(import.meta.dir, name);
+  await Bun.write(path, JSON.stringify(data, null, 2));
+  console.log(JSON.stringify(data, null, 2));
+  console.log("saved", path);
+}

package/.spike/pip-spike-editor-glue.ts

@@ -0,0 +1,82 @@
+// Stage 3b: Monaco glue candidates — editContext:false for typing, explicit editor.layout() on pip resize, suggest widget placement.
+import { connectApp, saveResults, sleep } from "./pip-spike-common";
+
+const W = `window.__spike.ew`, E = `window.__spike.ed`;
+const R: Record<string, unknown> = {};
+const h = await connectApp();
+const { ev, cdp, sid } = h;
+await cdp.send("Emulation.setFocusEmulationEnabled", { enabled: true }, sid);
+await ev(`(() => { const S = window.__spike; if (S.pip && !S.pip.closed) { if (S.ew && S.ew.ownerDocument !== document) S.moveBack(S.ew); S.pip.close(); } S.pip = null; S.results = {}; return 'reset'; })()`);
+await h.openViaUrl("/project/ppm/editor/.spike/scratch-editor-target.ts");
+await sleep(800);
+await ev(`window.__spike.ew = document.querySelector('[data-tab-pool-id="editor:.spike/scratch-editor-target.ts"]'); window.__spike.ed = window.__spike.findEditor(window.__spike.ew); 'held'`);
+R.mainState = await ev(`({ layout: [${E}.getLayoutInfo().width, ${E}.getLayoutInfo().height], slot: [${W}.offsetWidth, ${W}.offsetHeight], editContextOpt: ${E}.getOption(window.monaco.editor.EditorOption.editContext), nativeEditContextEl: !!${W}.querySelector('.native-edit-context'), editContextApi: 'EditContext' in window, minimapEnabled: ${E}.getOption(window.monaco.editor.EditorOption.minimap).enabled })`);
+R.layoutFixInMain = await ev(`(() => { ${E}.layout(); return [${E}.getLayoutInfo().width, ${E}.getLayoutInfo().height]; })()`);
+
+R.move = await h.runGesture("pip-editor-glue", `async () => {
+  const S = window.__spike; const w = ${W}; const ed = ${E};
+  const pip = await documentPictureInPicture.requestWindow({ width: 900, height: 600 }); S.pip = pip; S.copyStyles(pip.document); S.moveToPip(pip, w); S.pinToPip(w);
+  S.pipResizes = 0; pip.addEventListener('resize', () => { S.pipResizes++; ed.layout(); });
+  await new Promise(r => setTimeout(r, 600));
+  const before = [ed.getLayoutInfo().width, ed.getLayoutInfo().height]; ed.layout();
+  return { pipSize: [pip.innerWidth, pip.innerHeight], layoutBeforeExplicit: before, layoutAfterExplicit: [ed.getLayoutInfo().width, ed.getLayoutInfo().height], wrapper: [w.offsetWidth, w.offsetHeight] };
+}`);
+const pipSid = await h.attachPip();
+await cdp.send("Emulation.setFocusEmulationEnabled", { enabled: true }, pipSid!);
+await sleep(400);
+
+// Typing with EditContext (default)
+await ev(`${E}.setPosition({ lineNumber: 2, column: 1 }); 'p'`);
+R.pipFocusTarget = await cdp.eval(pipSid!, `(() => { const nec = document.querySelector('.native-edit-context'); const ta = document.querySelector('.monaco-editor textarea'); (nec || ta).focus(); return { focused: document.activeElement.className, hasEditContext: !!(nec && nec.editContext) }; })()`);
+await cdp.typeText(pipSid!, "EC ");
+await sleep(300);
+R.typingEditContext = await ev(`({ line2: ${E}.getModel().getLineContent(2), pass: ${E}.getModel().getLineContent(2).startsWith('EC ') })`);
+// Also try Input.insertText (IME-style commit) with EditContext
+await cdp.send("Input.insertText", { text: "IT " }, pipSid!);
+await sleep(300);
+R.insertTextEditContext = await ev(`({ line2: ${E}.getModel().getLineContent(2), pass: ${E}.getModel().getLineContent(2).includes('IT ') })`);
+
+// Switch to textarea input and type again
+R.switchToTextarea = await ev(`(async () => { ${E}.updateOptions({ editContext: false }); await new Promise(r => setTimeout(r, 300)); return { editContextOpt: ${E}.getOption(window.monaco.editor.EditorOption.editContext), textarea: !!${W}.querySelector('.monaco-editor textarea'), nec: !!${W}.querySelector('.native-edit-context') }; })()`);
+await ev(`${E}.setPosition({ lineNumber: 2, column: 1 }); 'p'`);
+await cdp.eval(pipSid!, `document.querySelector('.monaco-editor textarea').focus(); document.activeElement.className`);
+await cdp.typeText(pipSid!, "TA ");
+await sleep(300);
+R.typingTextarea = await ev(`({ line2: ${E}.getModel().getLineContent(2), pass: ${E}.getModel().getLineContent(2).startsWith('TA ') })`);
+await h.pipShot(pipSid, "spike-02c-editor-in-pip-typed.png");
+
+// Suggest widget placement (textarea mode): type "spi" on a new line then Ctrl+Space
+await ev(`${E}.setPosition({ lineNumber: 8, column: 1 }); 'p'`);
+await cdp.eval(pipSid!, `document.querySelector('.monaco-editor textarea').focus(); 'f'`);
+await cdp.pressKey(pipSid!, "Enter", "Enter", 13, "\r");
+await cdp.typeText(pipSid!, "spi");
+await cdp.pressKey(pipSid!, " ", "Space", 32, undefined, 2); // Ctrl+Space
+await sleep(1200);
+R.suggestWidget = await ev(`(() => { const w = ${W}; const sw = w.querySelector('.suggest-widget'); return { inWrapper: !!sw, visible: sw ? sw.classList.contains('visible') : null, inMainDoc: !!document.querySelector('.suggest-widget'), items: sw ? sw.querySelectorAll('.monaco-list-row').length : 0 }; })()`);
+await h.pipShot(pipSid, "spike-02e-editor-in-pip-suggest.png");
+await cdp.pressKey(pipSid!, "Escape", "Escape", 27);
+
+// Resize via resizeTo with the pip 'resize' → editor.layout() glue
+R.resizeGlue = await (async () => {
+  const pt = await cdp.eval<any>(pipSid!, `(() => { const b = document.createElement('button'); b.id = 'rz'; b.textContent = 'rz'; b.style.cssText = 'position:fixed;right:4px;bottom:4px;z-index:99999'; b.onclick = () => window.resizeTo(700, 450); document.body.append(b); const r = b.getBoundingClientRect(); return { x: r.x + r.width / 2, y: r.y + r.height / 2 }; })()`);
+  await cdp.click(pipSid!, pt.x, pt.y);
+  await sleep(600);
+  const r = await ev(`({ pipResizes: window.__spike.pipResizes, layout: [${E}.getLayoutInfo().width, ${E}.getLayoutInfo().height], pip: [window.__spike.pip.innerWidth, window.__spike.pip.innerHeight] })`);
+  await cdp.eval(pipSid!, `document.getElementById('rz').remove(); 'x'`);
+  return r;
+})();
+await h.pipShot(pipSid, "spike-02d-editor-in-pip-resized.png");
+
+// Return: explicit layout + undo of pip-typed text
+R.back = await ev(`(async () => { const S = window.__spike; const w = ${W}; const ed = ${E}; const r = S.moveBack(w); await new Promise(res => setTimeout(res, 800));
+  const stale = [ed.getLayoutInfo().width, ed.getLayoutInfo().height]; ed.layout(); ed.updateOptions({ editContext: true });
+  return { ...r, layoutStaleAfterReturn: stale, layoutAfterExplicit: [ed.getLayoutInfo().width, ed.getLayoutInfo().height], slot: [w.offsetWidth, w.offsetHeight] }; })()`);
+await ev(`window.__spike.pip.close(); 'c'`);
+await sleep(400);
+await ev(`${E}.focus(); 'f'`);
+const undoSteps: string[] = [];
+for (let i = 0; i < 6; i++) { await cdp.pressKey(sid, "z", "KeyZ", 90, undefined, 2); await sleep(150); undoSteps.push(await ev(`${E}.getModel().getLineContent(2) + ' || L8=' + (${E}.getModel().getLineCount() >= 9 ? ${E}.getModel().getLineContent(9) : '')`)); }
+R.undoAfterReturn = { steps: undoSteps, line2Restored: await ev(`${E}.getModel().getLineContent(2) === 'export const spikeLine1 = "one";'`) };
+await cdp.screenshot(sid, "C:/Users/PC/ppm/plans/reports/screenshots/spike-04-editor-after-return.png");
+await saveResults("pip-results-editor-glue.json", R);
+cdp.close();

package/.spike/pip-spike-editor.ts

@@ -0,0 +1,129 @@
+// Stage 3: move the live Monaco editor tab wrapper into a Document PiP window and test it.
+import { connectApp, saveResults, sleep } from "./pip-spike-common";
+
+const TAB = "editor:.spike/scratch-editor-target.ts";
+const Q = `document.querySelector('[data-tab-pool-id="${TAB}"]')`;
+const W = `window.__spike.ew`;
+const E = `window.__spike.ed`;
+const R: Record<string, unknown> = {};
+const h = await connectApp();
+const { ev, cdp, sid } = h;
+await cdp.send("Emulation.setFocusEmulationEnabled", { enabled: true }, sid);
+
+await ev(`(() => { const S = window.__spike; if (S.pip && !S.pip.closed) { if (S.ew && S.ew.ownerDocument !== document) S.moveBack(S.ew); S.pip.close(); } S.pip = null; S.results = {}; return 'reset'; })()`);
+await h.openViaUrl("/project/ppm/editor/.spike/scratch-editor-target.ts");
+await h.waitFor(`${Q} && ${Q}.style.display !== 'none' && ${Q}.querySelector('.monaco-editor .view-lines') && window.__spike.findEditor(${Q})`, 30000, "editor visible");
+await ev(`window.__spike.ew = ${Q}; window.__spike.ed = window.__spike.findEditor(window.__spike.ew); 'held'`);
+const wordWrapExpr = `${E}.getOption(window.monaco.editor.EditorOption.wordWrap)`;
+
+async function typeAt(targetSid: string, text: string) {
+  await cdp.typeText(targetSid, text);
+  await sleep(300);
+}
+// Baseline in main: put cursor at 1:1, type marker (trusted)
+await ev(`${E}.setPosition({ lineNumber: 1, column: 1 }); ${E}.focus(); 'f'`);
+await typeAt(sid, "MAIN1 ");
+await sleep(2000); // let the 1s autosave + dirty-title re-render settle before the move
+R.baseline = await ev(`({ line1: ${E}.getModel().getLineContent(1), layoutW: ${E}.getLayoutInfo().width, layoutH: ${E}.getLayoutInfo().height, wordWrap: ${wordWrapExpr}, minimapCanvases: ${W}.querySelectorAll('.minimap canvas').length })`);
+
+R.move = await h.runGesture("pip-editor", `async () => {
+  const S = window.__spike; const w = ${W}; const ed = ${E};
+  const pip = await documentPictureInPicture.requestWindow({ width: 900, height: 600 }); S.pip = pip;
+  const styles = S.copyStyles(pip.document); const moved = S.moveToPip(pip, w); S.pinToPip(w); S.installClickProbes(pip, w);
+  await new Promise(r => setTimeout(r, 800));
+  const vl = w.querySelector('.view-lines'); const mm = w.querySelector('.minimap canvas');
+  return { styles, moved, pipSize: [pip.innerWidth, pip.innerHeight], viewLines: vl.children.length, firstLineText: vl.children[0]?.textContent, layout: [ed.getLayoutInfo().width, ed.getLayoutInfo().height],
+    minimap: mm ? { w: mm.width, h: mm.height } : null, editorRect: (() => { const r = ed.getDomNode().getBoundingClientRect(); return [r.width, r.height]; })(), monacoTheme: pip.getComputedStyle(w.querySelector('.monaco-editor')).backgroundColor, mainBg: getComputedStyle(document.body).backgroundColor };
+}`);
+const pipSid = await h.attachPip();
+R.pipAttached = !!pipSid;
+if (!pipSid) throw new Error("no pip target");
+await cdp.send("Emulation.setFocusEmulationEnabled", { enabled: true }, pipSid);
+await sleep(600);
+R.shotInPip = await h.pipShot(pipSid, "spike-02-editor-in-pip.png");
+
+// Mouse: trusted click at line 3 in the PiP → cursor moves? then drag-select on line 2
+R.mouseInPip = await (async () => {
+  const geo = await cdp.eval<any>(pipSid, `(() => { const lines = [...document.querySelectorAll('.view-line')]; const l3 = lines.find(l => l.textContent.includes('spikeLine3')) || lines[2]; if (!l3) return null; const r = l3.getBoundingClientRect(); return { x: r.x + 40, y: r.y + r.height / 2, text: l3.textContent }; })()`);
+  if (!geo) return { error: "no .view-line in pip doc", inPip: await ev(`${W}.ownerDocument !== document`) };
+  await cdp.click(pipSid, geo.x, geo.y);
+  await sleep(300);
+  const pos = await ev<any>(`(() => { const p = ${E}.getPosition(); return [p.lineNumber, p.column]; })()`);
+  const g2 = await cdp.eval<any>(pipSid, `(() => { const l = [...document.querySelectorAll('.view-line')].find(l => l.textContent.includes('spikeLine2')); const r = l.getBoundingClientRect(); return { x: r.x + 4, y: r.y + r.height / 2 }; })()`);
+  await cdp.send("Input.dispatchMouseEvent", { type: "mousePressed", x: g2.x, y: g2.y, button: "left", clickCount: 1 }, pipSid);
+  for (let i = 1; i <= 8; i++) await cdp.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: g2.x + i * 20, y: g2.y, button: "left", buttons: 1 }, pipSid);
+  await cdp.send("Input.dispatchMouseEvent", { type: "mouseReleased", x: g2.x + 160, y: g2.y, button: "left", clickCount: 1 }, pipSid);
+  await sleep(300);
+  const sel = await ev<string>(`${E}.getModel().getValueInRange(${E}.getSelection())`);
+  await h.pipShot(pipSid, "spike-02b-editor-in-pip-selection.png");
+  return { clickedLineText: geo.text, positionAfterClick: pos, dragSelection: sel, dragPass: sel.length > 0 };
+})();
+
+// Keyboard: trusted typing in PiP at 1:1
+await ev(`${E}.setPosition({ lineNumber: 1, column: 1 }); 'p'`);
+await cdp.eval(pipSid, `document.querySelector('.monaco-editor textarea').focus(); document.activeElement.className`);
+await typeAt(pipSid, "PIP2 ");
+R.typingInPip = await ev(`({ line1: ${E}.getModel().getLineContent(1), pass: ${E}.getModel().getLineContent(1).startsWith('PIP2 MAIN1 ') })`);
+R.shotTyped = await h.pipShot(pipSid, "spike-02c-editor-in-pip-typed.png");
+
+// Resize: wrapper style (automaticLayout RO path) + pip resizeTo via trusted click
+R.resizeViaStyle = await ev(`(async () => { const w = ${W}; const ed = ${E}; const before = [ed.getLayoutInfo().width, ed.getLayoutInfo().height]; w.style.height = '50%'; w.style.width = '70%';
+  await new Promise(r => setTimeout(r, 800)); const after = [ed.getLayoutInfo().width, ed.getLayoutInfo().height]; w.style.height = '100%'; w.style.width = '100%'; await new Promise(r => setTimeout(r, 800));
+  return { before, after, restored: [ed.getLayoutInfo().width, ed.getLayoutInfo().height], relayout: before[0] !== after[0] }; })()`);
+R.resizeViaWindow = await (async () => {
+  const pt = await cdp.eval<any>(pipSid, `(() => { const b = document.createElement('button'); b.id = 'rz'; b.textContent = 'rz'; b.style.cssText = 'position:fixed;right:4px;bottom:4px;z-index:99999'; b.onclick = () => window.resizeTo(700, 450); document.body.append(b); const r = b.getBoundingClientRect(); return { x: r.x + r.width / 2, y: r.y + r.height / 2 }; })()`);
+  const before = await ev<any>(`[${E}.getLayoutInfo().width, ${E}.getLayoutInfo().height]`);
+  await cdp.click(pipSid, pt.x, pt.y);
+  const s: unknown[] = [];
+  for (const ms of [300, 1000, 3000]) { await sleep(ms); s.push(await ev(`({ afterMs: ${ms}, layout: [${E}.getLayoutInfo().width, ${E}.getLayoutInfo().height], pip: [window.__spike.pip.innerWidth, window.__spike.pip.innerHeight] })`)); }
+  await cdp.eval(pipSid, `document.getElementById('rz').remove(); 'x'`);
+  return { before, samples: s };
+})();
+R.shotResized = await h.pipShot(pipSid, "spike-02d-editor-in-pip-resized.png");
+
+// React onClick in PiP: the toolbar "Wrap" button toggles wordWrap through a zustand store → Monaco option
+R.reactClickInPip = await (async () => {
+  const pt = await cdp.eval<any>(pipSid, `(() => { const b = [...document.querySelectorAll('button')].find(b => b.textContent.trim() === 'Wrap'); if (!b) return null; const r = b.getBoundingClientRect(); return { x: r.x + r.width / 2, y: r.y + r.height / 2 }; })()`);
+  if (!pt) return "no Wrap button in pip";
+  const before = await ev(wordWrapExpr);
+  await ev(`window.__spike.probe = { mainDocClick: 0, pipDocClick: 0, wrapperClick: 0, reactRootClick: 0 }; 'r'`);
+  await cdp.click(pipSid, pt.x, pt.y);
+  await sleep(600);
+  return { wordWrapBefore: before, wordWrapAfter: await ev(wordWrapExpr), probe: await ev(`({ ...window.__spike.probe })`) };
+})();
+
+// Widgets: trigger suggest (Ctrl+Space) in PiP and see where the widget renders
+R.suggestWidget = await (async () => {
+  await ev(`${E}.setPosition({ lineNumber: 7, column: 1 }); 'p'`);
+  await cdp.eval(pipSid, `document.querySelector('.monaco-editor textarea').focus(); 'f'`);
+  await cdp.typeText(pipSid, "spi");
+  await sleep(1200);
+  const r = await ev(`(() => { const w = ${W}; const sw = w.querySelector('.suggest-widget'); const mainSw = document.querySelector('.suggest-widget');
+    return { inWrapper: !!sw, visible: sw ? sw.classList.contains('visible') : null, inMainDoc: !!mainSw, overflowContainer: !!w.querySelector('.overflowingContentWidgets'), fixedOverflow: ${E}.getOption(window.monaco.editor.EditorOption.fixedOverflowWidgets) }; })()`);
+  await h.pipShot(pipSid, "spike-02e-editor-in-pip-suggest.png");
+  await cdp.pressKey(pipSid, "Escape", "Escape", 27);
+  for (let i = 0; i < 3; i++) await cdp.pressKey(pipSid, "Backspace", "Backspace", 8);
+  return r;
+})();
+
+// Move back, then undo history: Ctrl+Z x2 should remove "PIP2 " then "MAIN1 "
+R.pullbackAttemptsWhileInPip = await ev(`({ attempts: window.__spike.pullbackAttempts, stillInPip: ${W}.ownerDocument !== document })`);
+R.back = await ev(`(async () => { const S = window.__spike; const w = ${W}; const r = S.moveBack(w); await new Promise(res => setTimeout(res, 800)); return { ...r, layout: [${E}.getLayoutInfo().width, ${E}.getLayoutInfo().height], line1: ${E}.getModel().getLineContent(1) }; })()`);
+await ev(`window.__spike.pip.close(); 'c'`);
+await sleep(500);
+await ev(`${E}.focus(); 'f'`);
+await cdp.pressKey(sid, "z", "KeyZ", 90, undefined, 2); // Ctrl+Z
+await sleep(300);
+const afterUndo1 = await ev(`${E}.getModel().getLineContent(1)`);
+await cdp.pressKey(sid, "z", "KeyZ", 90, undefined, 2);
+await sleep(300);
+const afterUndo2 = await ev(`${E}.getModel().getLineContent(1)`);
+await ev(`${E}.setPosition({ lineNumber: 1, column: 1 }); ${E}.focus(); 'f'`);
+await typeAt(sid, "BACK3 ");
+R.afterReturn = await ev(`(async () => { const S = window.__spike; const w = ${W}; const ed = ${E}; const btn = [...w.querySelectorAll('button')].find(b => b.textContent.trim() === 'Wrap'); const ww0 = ${wordWrapExpr}; btn && btn.click(); await new Promise(r => setTimeout(r, 500));
+  return { afterUndo1: ${JSON.stringify(afterUndo1)}, afterUndo2: ${JSON.stringify(afterUndo2)}, undoPass: ${JSON.stringify(afterUndo2)}.startsWith('export const spikeLine1'), line1AfterTyping: ed.getModel().getLineContent(1), typingPass: ed.getModel().getLineContent(1).startsWith('BACK3 '), reactWrapToggle: { before: ww0, after: ${wordWrapExpr} } }; })()`);
+// restore wordWrap + undo the BACK3 edit so the scratch file autosaves clean-ish
+await ev(`(async () => { const w = ${W}; const btn = [...w.querySelectorAll('button')].find(b => b.textContent.trim() === 'Wrap'); if (${wordWrapExpr} !== 'off' && btn) btn.click(); ${E}.trigger('spike', 'undo', null); return 'ok'; })()`);
+await cdp.screenshot(sid, "C:/Users/PC/ppm/plans/reports/screenshots/spike-04-editor-after-return.png");
+await saveResults("pip-results-editor.json", R);
+cdp.close();

package/.spike/pip-spike-input-isolation.ts

@@ -0,0 +1,38 @@
+// Debug: isolate "keys ignored" — round-tripped terminal vs fresh terminal, term.input() vs keyboard.
+import { connectApp, saveResults, sleep } from "./pip-spike-common";
+
+const R: Record<string, unknown> = {};
+const h = await connectApp();
+const { ev, cdp, sid } = h;
+await cdp.send("Emulation.setFocusEmulationEnabled", { enabled: true }, sid);
+
+const T1 = `window.__spike.findTerminal(window.__spike.tw)`;
+// 1. term.input on the round-tripped terminal
+await h.openViaUrl("/project/ppm/terminal/1");
+await sleep(500);
+R.inputApiRoundTripped = await ev(`(async () => { const S = window.__spike; const t = ${T1}; S.dataLog = []; t.input('echo VIA-INPUT-API\\r', true);
+  await new Promise(r => setTimeout(r, 1500)); return { dataLog: S.dataLog, echoed: S.termText(t, 80).includes('VIA-INPUT-API'), tail: S.termText(t, 3), rows: t.rows, cols: t.cols, visible: t.element.getBoundingClientRect().height }; })()`);
+
+// 2. Fresh terminal tab (never moved): trusted keys
+await h.openViaUrl("/project/ppm/terminal/2");
+const Q2 = `document.querySelector('[data-tab-pool-id^="terminal:2"]')`;
+await h.waitFor(`${Q2} && ${Q2}.querySelector('.xterm-helper-textarea')`, 15000, "terminal 2");
+await sleep(3000); // shell boot
+await ev(`window.__spike.tw2 = ${Q2}; window.__spike.t2 = window.__spike.findTerminal(window.__spike.tw2); window.__spike.dataLog2 = []; window.__spike.t2.onData(d => window.__spike.dataLog2.push(d)); 'ok'`);
+await ev(`window.__spike.tw2.querySelector('.xterm-helper-textarea').focus(); 'f'`);
+await cdp.typeText(sid, "echo FRESH-TERM");
+await cdp.pressKey(sid, "Enter", "Enter", 13, "\r");
+await sleep(1500);
+R.freshTerminalTrustedKeys = await ev(`(() => { const S = window.__spike; const t = S.t2; return { id: S.tw2.dataset.tabPoolId, dataLog: S.dataLog2.join(''), echoed: S.termText(t, 80).includes('FRESH-TERM'), tail: S.termText(t, 3), rows: t.rows, cols: t.cols }; })()`);
+
+// 3. Back to the round-tripped terminal: trusted keys with focus emulation on
+await h.openViaUrl("/project/ppm/terminal/1");
+await sleep(500);
+await ev(`window.__spike.dataLog = []; window.__spike.tw.querySelector('.xterm-helper-textarea').focus(); 'f'`);
+await cdp.typeText(sid, "echo RT-KEYS");
+await cdp.pressKey(sid, "Enter", "Enter", 13, "\r");
+await sleep(1500);
+R.roundTrippedTrustedKeys = await ev(`(() => { const S = window.__spike; const t = ${T1}; return { dataLog: S.dataLog.join(''), echoed: S.termText(t, 80).includes('RT-KEYS'), tail: S.termText(t, 3),
+  textareaIsTermTextarea: t.textarea === S.tw.querySelector('.xterm-helper-textarea'), textareaDoc: t.textarea.ownerDocument === document, elementDoc: t.element.ownerDocument === document }; })()`);
+await saveResults("pip-results-input-isolation.json", R);
+cdp.close();