@quickchatai/quickreview 0.0.0-stage → 1.2.0

package/extensions/vendor/openviking-pi/patches/0001-remove-session-before-compact-handler.patch

@@ -0,0 +1,101 @@
+diff --git a/extensions/vendor/openviking-pi/config.json b/extensions/vendor/openviking-pi/config.json
+--- a/extensions/vendor/openviking-pi/config.json
++++ b/extensions/vendor/openviking-pi/config.json
+@@ -12,7 +12,7 @@
+   "commitKeepRecentCount": 10,
+   "_qcr_fork": "Vendored + patched fork of the OpenViking pi extension; see README.md. takeover.enabled below is belt-and-braces only — config.ts forces it off in code (PATCH 1).",
+   "takeover": {
+-    "enabled": true,
++    "enabled": false,
+     "tokenThreshold": 30000,
+     "keepRecentTurns": 3,
+     "overviewBudget": 3000,
+diff --git a/extensions/vendor/openviking-pi/config.ts b/extensions/vendor/openviking-pi/config.ts
+--- a/extensions/vendor/openviking-pi/config.ts
++++ b/extensions/vendor/openviking-pi/config.ts
+@@ -191,7 +191,15 @@
+   config.resumeContextBudget = clampInt(config.resumeContextBudget, 1024, 128000, DEFAULT_CONFIG.resumeContextBudget);
+   config.commitTokenThreshold = clampInt(config.commitTokenThreshold, 1000, 1000000, DEFAULT_CONFIG.commitTokenThreshold);
+   config.commitKeepRecentCount = clampInt(config.commitKeepRecentCount, 0, 1000, DEFAULT_CONFIG.commitKeepRecentCount);
+-  config.takeoverEnabled = config.takeoverEnabled !== false;
++  // [QCR PATCH 1] was `config.takeoverEnabled !== false` — i.e. ON unless the
++  // config file explicitly said otherwise. Takeover REPLACES pi's compaction
++  // (it rewrites the context window from a server-side archive overview), and
++  // this fork removed the compaction handler outright so ledger-pin owns that
++  // event alone. A half-wired takeover — advancing its boundary on turn_end
++  // and transforming context — with no compaction handler behind it is worse
++  // than either end state, so it is forced off in CODE, not in config.json:
++  // a config knob is a thing an operator can flip, and this one is structural.
++  config.takeoverEnabled = false;
+   config.takeoverTokenThreshold = clampInt(config.takeoverTokenThreshold, 1, 1000000, DEFAULT_CONFIG.takeoverTokenThreshold);
+   config.takeoverKeepRecentTurns = clampInt(config.takeoverKeepRecentTurns, 0, 100, DEFAULT_CONFIG.takeoverKeepRecentTurns);
+   config.takeoverOverviewBudget = clampInt(config.takeoverOverviewBudget, 100, 50000, DEFAULT_CONFIG.takeoverOverviewBudget);
+diff --git a/extensions/vendor/openviking-pi/index.ts b/extensions/vendor/openviking-pi/index.ts
+--- a/extensions/vendor/openviking-pi/index.ts
++++ b/extensions/vendor/openviking-pi/index.ts
+@@ -61,7 +61,8 @@
+   let profileBlock = "";
+   let archiveOverview = "";
+   let toolsRegistered = false;
+-  let compacted = false;
++  // [QCR PATCH 1] `compacted` is gone with the session_before_compact handler
++  // that was the only thing setting it.
+   let started = false;
+   let startPromise: Promise<void> | null = null;
+ 
+@@ -155,7 +156,8 @@
+     // Compose system prompt additions
+     const parts: string[] = [];
+     if (profileBlock) parts.push(profileBlock);
+-    if (!config.takeoverEnabled && archiveOverview && (compacted || archiveOverview.trim())) {
++    // [QCR PATCH 1] was `(compacted || archiveOverview.trim())`.
++    if (!config.takeoverEnabled && archiveOverview && archiveOverview.trim()) {
+       parts.push(archiveOverview);
+     }
+     parts.push("OpenViking tools: viking_search, viking_read, viking_browse, viking_remember, viking_forget, viking_add_resource, viking_archive_expand.");
+@@ -202,28 +204,23 @@
+   });
+ 
+   // --- session_before_compact ---
+-  pi.on("session_before_compact", async (event, _ctx) => {
+-    if (!connected || bypassed) return;
+-
+-    if (config.takeoverEnabled) {
+-      const prep = (event as any)?.preparation ?? {};
+-      return await takeover.handleBeforeCompact({
+-        firstKeptEntryId: prep.firstKeptEntryId,
+-        tokensBefore: prep.tokensBefore ?? 0,
+-      });
+-    }
+-
+-    const archiveId = await sync.commit();
+-    compacted = true;
+-
+-    // Cache archive overview for rehydration after compaction
+-    if (archiveId && sync.sessionId) {
+-      archiveOverview = await fetchArchiveOverview(
+-        client, sync.sessionId, config,
+-      );
+-    }
+-    // Return nothing → pi proceeds with default compaction
+-  });
++  //
++  // [QCR PATCH 1] DELETED. `extensions/ledger-pin.ts` is the sole owner of
++  // this event: it re-pins the review ledger block that pi's token-driven
++  // compaction would otherwise summarise away, and pi does not document how
++  // two registered handlers merge. Upstream registered its handler
++  // UNCONDITIONALLY — `takeover.enabled: false` only changed what the handler
++  // did (a synchronous sync.commit() instead of a takeover), it did not
++  // unhook it (verified on a running v0.4.15 + pi 0.84.1:
++  // assets/findings.md §4.2). So the knob is NOT a substitute for
++  // this deletion; do not "restore and disable".
++  //
++  // Nothing replaces it. Losing an archive-overview refresh at compaction
++  // costs a stale rehydration block; losing the ledger costs the review.
++  //
++  // Consequences kept in sync elsewhere in this file: `compacted` is gone,
++  // and config.ts forces takeoverEnabled=false so takeover — which exists
++  // only to REPLACE compaction — can never rewrite the context either.
+ 
+   // --- session_shutdown ---
+   pi.on("session_shutdown", async (_event, ctx) => {

package/extensions/vendor/openviking-pi/patches/0002-no-ambient-work-in-subagent-leaves.patch

@@ -0,0 +1,202 @@
+diff --git a/extensions/vendor/openviking-pi/index.ts b/extensions/vendor/openviking-pi/index.ts
+--- a/extensions/vendor/openviking-pi/index.ts
++++ b/extensions/vendor/openviking-pi/index.ts
+@@ -31,8 +31,14 @@
+ import { guardVikingUriToolCall } from "./lib/uri-guard-adapter.mjs";
+ import { registerTools } from "./tools.js";
+ import { createTakeoverManager } from "./takeover.js";
++// [QCR PATCH 2]
++import { isLeafProcess } from "./qcr-leaf.js";
+ 
+ export default async function (pi: ExtensionAPI) {
++  // [QCR PATCH 2] Decided once, from argv, before anything else: a
++  // pi-subagents leaf gets the tools and nothing ambient. See qcr-leaf.ts.
++  const leaf = isLeafProcess();
++
+   // --- Load config ---
+   const config = loadConfigFromModuleUrl(import.meta.url);
+   if (!config.enabled) return;
+@@ -94,6 +100,18 @@
+         return;
+       }
+ 
++      // [QCR PATCH 2] A leaf stops here: tools register (read-only — see
++      // tools.ts), nothing ambient runs. No OV session, no profile block, no
++      // recall injection, no turn sync, no commit.
++      if (leaf) {
++        if (!toolsRegistered) {
++          registerTools(pi, client, sync, { leaf: true });
++          toolsRegistered = true;
++        }
++        started = true;
++        return;
++      }
++
+       // Ensure OV session
+       const piSessionId = ctx.sessionManager.getSessionId();
+       const ok = await sync.ensureSession(piSessionId);
+@@ -121,7 +139,7 @@
+ 
+       // Register tools (also needed for pi -c continuations).
+       if (!toolsRegistered) {
+-        registerTools(pi, client, sync);
++        registerTools(pi, client, sync, { leaf: false });
+         toolsRegistered = true;
+       }
+       updateStatus(ctx, connected, 0, sync.sessionId, config, takeover.state);
+@@ -148,6 +166,8 @@
+     await start(ctx);
+ 
+     if (!connected || bypassed) return;
++    // [QCR PATCH 2] No recall queue and no injected profile inside a leaf.
++    if (leaf) return;
+ 
+     // Queue recall for the context hook. Pi renders the user message before
+     // that hook, so recall latency does not delay the message appearing.
+@@ -173,6 +193,8 @@
+   // --- context ---
+   pi.on("context", async (event, _ctx) => {
+     if (!connected || bypassed) return;
++    // [QCR PATCH 2] A leaf's context is exactly the pass prompt it was given.
++    if (leaf) return;
+ 
+     // Keep recall synchronous with the provider request so the current prompt
+     // still receives current-query memory, without blocking user-message UI.
+@@ -195,6 +217,9 @@
+   // --- turn_end ---
+   pi.on("turn_end", async (event, ctx) => {
+     if (!connected || bypassed || !config.syncTurns) return;
++    // [QCR PATCH 2] No turn sync and therefore no threshold auto-commit from
++    // a leaf — a commit there would archive the SHEPHERD's session.
++    if (leaf) return;
+ 
+     const branch = ctx.sessionManager.getBranch();
+     const result = await sync.syncBranch(branch);
+@@ -225,6 +250,8 @@
+   // --- session_shutdown ---
+   pi.on("session_shutdown", async (_event, ctx) => {
+     if (!connected || bypassed) return;
++    // [QCR PATCH 2] A leaf exits after every pass; it commits nothing.
++    if (leaf) return;
+ 
+     await sync.shutdown();
+     if (config.takeoverEnabled) {
+diff --git a/extensions/vendor/openviking-pi/qcr-leaf.ts b/extensions/vendor/openviking-pi/qcr-leaf.ts
+new file mode 100644
+--- /dev/null
++++ b/extensions/vendor/openviking-pi/qcr-leaf.ts
+@@ -0,0 +1,70 @@
++// QCR FORK — file added by PATCH 2 (leaf isolation). Not upstream.
++//
++// A "leaf" is a pi process that is NOT the shepherd session: a pi-subagents
++// child running one lens pass. Leaves must never do ambient OpenViking work —
++// no recall injection into their context, no turn sync, no commit — because:
++//
++//   * the single-shepherd invariant (AGENTS.md invariant 7) says the PR's ONE
++//     main pi owns the review; a leaf is a stateless evaluator of a diff, and
++//     memory injected under it is unaccounted context;
++//   * a commit from a leaf would archive the SHEPHERD's session (the OV
++//     session id is inherited through the environment), reordering the one
++//     conversation the daemon owns.
++//
++// pi-subagents already builds child argv with `--no-extensions`
++// (assets/findings.md §4.3), so a leaf structurally never loads this
++// file. That is one layer. This is the second: the child inherits the parent
++// ENVIRONMENT, so anything keyed off env alone would read as "main" inside a
++// leaf. Detection therefore keys off ARGV, which pi-subagents builds from
++// scratch:
++//
++//   [...piBin.baseArgs, "--mode", "json", "-p", "--no-session", "--no-skills",
++//    "--no-extensions", ...allowlisted custom-tool extensions]
++//
++// None of those flags appear in the shepherd argv that `src/sessions.ts`
++// buildPiCommand emits (--approve/--model/--session-dir/--system-prompt/
++// --theme/--extension/--name), so the two are cleanly separable.
++//
++// VERIFY-ON-PIN: the flag set above is pi-subagents @1f54189 as read at the
++// pinned pi 0.84.1. A pi or pi-subagents bump re-verifies it.
++
++/** Flags that only ever appear on a pi-subagents child command line. */
++export const LEAF_ARGV_FLAGS: readonly string[] = [
++  "--no-extensions",
++  "--no-session",
++  "--no-skills",
++  "--print",
++  "-p",
++];
++
++/** Env var that FORCES leaf mode. There is deliberately no env var that forces
++ * MAIN mode: env is inherited by children, so a "this is the shepherd" marker
++ * would be inherited by every leaf and defeat the whole check. */
++export const FORCE_LEAF_ENV = "QCR_OV_LEAF";
++
++function truthy(value: string | undefined): boolean {
++  const v = (value ?? "").trim().toLowerCase();
++  return v === "1" || v === "true" || v === "yes" || v === "on";
++}
++
++/**
++ * True when this process is a pi-subagents leaf (or has been forced to behave
++ * as one). Fail direction: an UNKNOWN argv reads as "main", which is the
++ * shepherd's behaviour — the leaf never loads this extension anyway, so a
++ * false negative costs nothing while a false positive would silently disable
++ * memory for the review session.
++ */
++export function isLeafProcess(
++  argv: readonly string[] = process.argv,
++  env: Record<string, string | undefined> = process.env,
++): boolean {
++  if (truthy(env[FORCE_LEAF_ENV])) return true;
++  for (let i = 0; i < argv.length; i++) {
++    const arg = argv[i];
++    if (arg === undefined) continue;
++    if (LEAF_ARGV_FLAGS.includes(arg)) return true;
++    if (arg === "--mode=json") return true;
++    if (arg === "--mode" && argv[i + 1] === "json") return true;
++  }
++  return false;
++}
+diff --git a/extensions/vendor/openviking-pi/tools.ts b/extensions/vendor/openviking-pi/tools.ts
+--- a/extensions/vendor/openviking-pi/tools.ts
++++ b/extensions/vendor/openviking-pi/tools.ts
+@@ -3,7 +3,20 @@
+ import type { OVClient } from "./client.js";
+ import type { SyncManager } from "./sync.js";
+ 
+-export function registerTools(pi: any, client: OVClient, sync?: SyncManager): void {
++export interface RegisterToolsOptions {
++  /** [QCR PATCH 2] A pi-subagents leaf gets the READ tools only. A lens pass
++   * evaluates a diff; authoring memory is the shepherd session's job, and a
++   * leaf has no session identity to author under. */
++  leaf?: boolean;
++}
++
++export function registerTools(
++  pi: any,
++  client: OVClient,
++  sync?: SyncManager,
++  opts: RegisterToolsOptions = {},
++): void {
++  const leaf = opts.leaf === true;
+ 
+   // --- viking_search ---
+   pi.registerTool({
+@@ -111,6 +124,9 @@
+     },
+   });
+ 
++  // [QCR PATCH 2] Every WRITE tool is gated behind `leaf`; the read tools
++  // above stay available everywhere.
++  if (!leaf) {
+   // --- viking_remember ---
+   pi.registerTool({
+     name: "viking_remember",
+@@ -214,6 +230,8 @@
+     },
+   });
+ 
++  }
++
+   // --- viking_archive_expand ---
+   pi.registerTool({
+     name: "viking_archive_expand",

package/extensions/vendor/openviking-pi/patches/0003-never-auto-create-openviking-sessions.patch

@@ -0,0 +1,120 @@
+diff --git a/extensions/vendor/openviking-pi/client.ts b/extensions/vendor/openviking-pi/client.ts
+--- a/extensions/vendor/openviking-pi/client.ts
++++ b/extensions/vendor/openviking-pi/client.ts
+@@ -157,20 +157,21 @@
+ 
+   // ========== Sessions ==========
+ 
+-  /** POST /api/v1/sessions — create or reuse session */
+-  async createSession(sessionId: string): Promise<boolean> {
+-    const res = await this.fetchJSON<any>("/api/v1/sessions", {
+-      method: "POST",
+-      body: JSON.stringify({ session_id: sessionId }),
+-    });
+-    return res.ok;
+-  }
++  // [QCR PATCH 3] `createSession()` (POST /api/v1/sessions) is DELETED and the
++  // `auto_create` query parameter is gone from getSession. This client cannot
++  // bring an OpenViking session into existence by any route.
++  //
++  // The daemon owns session lifecycle because creation carries a payload only
++  // it knows: the extraction-disabling memory_policy
++  // (`{self,peer,working_memory}.enabled = false`). A session created without
++  // it leaves a FAILED background task on every single commit, since our
++  // deployment configures no `vlm` (assets/findings.md §2.3/§2.5).
++  // An extension-created session would look identical and quietly rot.
+ 
+-  /** GET /api/v1/sessions/{id} — session metadata */
+-  async getSession(sessionId: string, autoCreate = false): Promise<OVSessionMeta | null> {
+-    const q = autoCreate ? "?auto_create=true" : "";
++  /** GET /api/v1/sessions/{id} — session metadata. Never creates. */
++  async getSession(sessionId: string): Promise<OVSessionMeta | null> {
+     const res = await this.fetchJSON<OVSessionMeta>(
+-      `/api/v1/sessions/${encodeURIComponent(sessionId)}${q}`,
++      `/api/v1/sessions/${encodeURIComponent(sessionId)}`,
+       undefined, 5000,
+     );
+     return res.ok ? res.result : null;
+diff --git a/extensions/vendor/openviking-pi/index.ts b/extensions/vendor/openviking-pi/index.ts
+--- a/extensions/vendor/openviking-pi/index.ts
++++ b/extensions/vendor/openviking-pi/index.ts
+@@ -112,16 +112,16 @@
+         return;
+       }
+ 
+-      // Ensure OV session
++      // [QCR PATCH 3] Attach to the session the DAEMON created; never mint
++      // one. No session is a normal, non-fatal state: the tools still work,
++      // only ambient turn-sync is off.
+       const piSessionId = ctx.sessionManager.getSessionId();
+-      const ok = await sync.ensureSession(piSessionId);
+-      if (!ok) {
+-        if (config.logLevel !== "silent") {
+-          ctx.ui.notify("OpenViking: failed to create session", "error");
+-        }
+-        return;
++      const attached = await sync.ensureSession();
++      if (attached) {
++        await sync.replayPending();
++      } else if (config.logLevel === "info") {
++        ctx.ui.notify("OpenViking: no daemon session — memory tools only", "info");
+       }
+-      await sync.replayPending();
+ 
+       // Profile injection
+       profileBlock = await buildSessionProfileBlock(client, config);
+diff --git a/extensions/vendor/openviking-pi/sync.ts b/extensions/vendor/openviking-pi/sync.ts
+--- a/extensions/vendor/openviking-pi/sync.ts
++++ b/extensions/vendor/openviking-pi/sync.ts
+@@ -2,7 +2,8 @@
+ import { appendFileSync, mkdirSync } from "node:fs";
+ import { dirname } from "node:path";
+ import type { OVConfig } from "./config.js";
+-import { deriveHarnessSessionId } from "./shared/session-model.mjs";
++// [QCR PATCH 3] `deriveHarnessSessionId` is no longer imported — minting an OV
++// session id from pi's is exactly what this fork must not do.
+ import { enqueue, listPending, replayPending } from "./shared/pending-queue.mjs";
+ import { extractBranchCapturePayloads } from "./lib/capture-adapter.mjs";
+ import { countUndeliveredForSession, estimatePayloadTokens } from "./lib/takeover-core.mjs";
+@@ -50,10 +51,39 @@
+     this.syncedEntryCount = next;
+   }
+ 
+-  async ensureSession(piSessionId: string): Promise<boolean> {
++  /**
++   * [QCR PATCH 3] ATTACH to the session the daemon created — never create one,
++   * and never derive an id from pi's own session id (upstream did:
++   * `deriveHarnessSessionId("pi-", piSessionId)`, which mints a fresh OV
++   * session on first message and gets extraction-enabled defaults).
++   *
++   * The id rides the environment, which is how everything else per-session
++   * reaches a pi in this daemon (`env K=V … pi …` — tmux panes inherit the
++   * tmux SERVER env, not the client's). `OPENVIKING_SESSION_ID` is the
++   * upstream-shaped name; `QCR_OV_SESSION_ID` is the one that survives
++   * `src/sessions.ts`'s QCR_-only argv prefix, so both are read.
++   *
++   * Returns false — a normal, non-fatal state — when there is no id, or when
++   * the named session does not exist server-side. False means "no ambient
++   * sync"; the memory tools are unaffected.
++   */
++  async ensureSession(env: Record<string, string | undefined> = process.env): Promise<boolean> {
+     if (this.ovSessionId) return true;
+ 
+-    const id = deriveHarnessSessionId("pi-", piSessionId);
++    const id = (env.OPENVIKING_SESSION_ID ?? env.QCR_OV_SESSION_ID ?? "").trim();
++    if (!id) {
++      debugLog("ensureSession: no daemon-provided session id; ambient sync disabled");
++      return false;
++    }
++
++    // Existence check, not a creation: getSession no longer has an
++    // auto_create route (client.ts, PATCH 3).
++    const meta = await this.client.getSession(id);
++    if (!meta) {
++      debugLog(`ensureSession: session=${id} does not exist; ambient sync disabled`);
++      return false;
++    }
++
+     this.ovSessionId = id;
+     return true;
+   }