@quickchatai/quickreview 0.0.0-stage → 1.1.0

package/extensions/vendor/openviking-pi/patches/0008-pr-derived-recall.patch

@@ -0,0 +1,379 @@
+diff --git a/extensions/vendor/openviking-pi/NOTICE b/extensions/vendor/openviking-pi/NOTICE
+--- a/extensions/vendor/openviking-pi/NOTICE
++++ b/extensions/vendor/openviking-pi/NOTICE
+@@ -46,6 +46,9 @@ Changed by the quickreviewd maintainers, 2026-08-20:
+      fallbacks included, on that one deadline), query expansion is off,
+      retired memory entries are never recalled, and sessions are never
+      committed (2026-10-06).
++  8. A review session's per-prompt recall searches with the query and the
++     memory areas the daemon publishes for its PR, instead of its whole
++     prompt across every scope (2026-10-07).
+ 
+ Plus vendoring scaffolding: build-conformance fixes for this repo's stricter
+ tsconfig, ambient type declarations for uninstalled packages, three unused
+diff --git a/extensions/vendor/openviking-pi/README.md b/extensions/vendor/openviking-pi/README.md
+--- a/extensions/vendor/openviking-pi/README.md
++++ b/extensions/vendor/openviking-pi/README.md
+@@ -1,7 +1,7 @@
+ # openviking-pi — vendored, patched fork
+ 
+ The OpenViking pi extension our sessions load. Vendored, not depended on:
+-upstream ships it as an `examples/` directory, not a package, and we need seven
++upstream ships it as an `examples/` directory, not a package, and we need eight
+ behaviour changes that upstream has no reason to make.
+ 
+ | | |
+@@ -20,7 +20,7 @@ fails on drift between the two.
+ 
+ ## Why a fork rather than configuration
+ 
+-Every one of the seven patches was tried as configuration first and does not
++Every one of the eight patches was tried as configuration first and does not
+ exist there. The evidence is a spike against a **running v0.4.15 server plus
+ the pinned pi 0.84.1** — `assets/findings.md` in the issue tracker,
+ with transcripts. Read it before changing anything here; several of its
+@@ -28,9 +28,9 @@ findings contradict the OpenViking docs, which lead the tag.
+ 
+ ## The patch series
+ 
+-Seven numbered behaviour patches, applied in order over the vendored upstream
++Eight numbered behaviour patches, applied in order over the vendored upstream
+ files, plus one unnumbered scaffolding patch. They live in `patches/` as
+-`git apply`-able diffs — verified by applying all eight, in order, to a
++`git apply`-able diffs — verified by applying all nine, in order, to a
+ pristine `v0.4.15` extraction and diffing the result against this directory:
+ byte-identical. (`patches/` and `upstream.json` are meta and are not themselves
+ part of the reproduced tree.) Every hunk they add carries a greppable marker:
+@@ -320,6 +320,36 @@ search), `sync.ts` (no commit, the replay refusal), `index.ts` (the hook's
+ budget, the retired list, no shutdown commit, the command, the banner),
+ `config.ts` (expansion forced off), `config.json`.
+ 
++### 0008 — PR-derived recall (S5)
++
++The per-prompt recall queried with the WHOLE delivered message. In a PR
++session that is a 55–80k-character round order, and the local embedder (S4)
++embeds a query's first 128 tokens — the round template's fixed header, the
++same for every PR — so every PR recalled the same ops notes and feedback
++events, from every scope. The daemon already builds a PR-derived query for the
++round's own context block (`roundContextQuery`: the PR title plus the areas
++and file kinds the PR touches) and now publishes it, with the memory areas a
++round may search (`experiences/` alone, the §1 layout built in S5), to
++a per-session file (`QCR_OV_RECALL_HINT_FILE`, `src/memory/ovsession.ts`
++`writeRecallHint`, rewritten at every round's dispatch).
++
++* **A PR session recalls for its PR.** `before_agent_start` reads the hint
++  (`qcr-hint.ts` `readRecallHint` — total, and fail-closed to the old
++  behaviour: no file, a garbled one, an empty query or no usable area = no
++  hint) and queues the hint's query instead of the prompt.
++* **…and only where a round may look.** `scopeGuard` sends a context search
++  or the `/search/recall` preset quotas naming the hint's areas alone, drops
++  any recalled entry from outside them (re-rendering the block in the
++  server's envelope), and keeps only in-area memories from the raw-find
++  fallback.
++* **Nothing else changes.** No hint (the overseer, the companion, a session
++  born before its first round): the prompt, unscoped, as upstream. PATCH 7's
++  500 ms budget, retired-entry exclusion and no-commit rules wrap the same
++  chain.
++
++Touches: `qcr-hint.ts` (new), `recall.ts` (`queueSearch`'s scope, the guard
++in the chain), `index.ts` (the hint, the banner).
++
+ ## Rebasing onto a newer upstream
+ 
+ ```sh
+@@ -332,16 +362,16 @@ git -C /tmp/ov checkout <new-tag>
+ for p in extensions/vendor/openviking-pi/patches/0*.patch; do
+   git apply --3way "$p" || echo "RESOLVE: $p"
+ done
+-# 3. Re-verify all seven patches, then:
++# 3. Re-verify all eight patches, then:
+ timeout 900 npm test && npm run build
+ ```
+ 
+ Then update `extension_commit` and `version` in `config.toml [openviking]`,
+ the base commit in `NOTICE` and in the table above, and re-run the live
+-verification below. A bump re-verifies **all seven** patches — a patch that no
++verification below. A bump re-verifies **all eight** patches — a patch that no
+ longer applies is a patch whose reason may have changed, not a patch to drop.
+ 
+-`tests/openviking-fork.test.ts` is the guard rail: it asserts the seven patches
++`tests/openviking-fork.test.ts` is the guard rail: it asserts the eight patches
+ are still present (markers, and the *absence* of what each one removed) and
+ that the pinned commit here matches `config.toml`. It cannot tell you whether
+ upstream grew a *new* compaction handler or a *new* write tool — read the
+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
+@@ -11,7 +11,7 @@
+  *
+  * ── QCR FORK ────────────────────────────────────────────────────────────────
+  * Vendored from volcengine/OpenViking @ v0.4.15, examples/pi-coding-agent-
+- * extension. Seven numbered patches; every hunk carries a `[QCR PATCH n]`
++ * extension. Eight numbered patches; every hunk carries a `[QCR PATCH n]`
+  * marker so a rebase is a search, not an audit. See README.md here.
+  *   PATCH 1 — no session_before_compact handler (extensions/ledger-pin.ts is
+  *             the sole owner of compaction) and takeover forced off.
+@@ -28,6 +28,10 @@
+  *             500 ms for recall (every request of it on one deadline, no
+  *             fallback past it), query expansion is off in code, retired
+  *             entries are never recalled, and nothing commits a session.
++ *   PATCH 8 — PR-derived recall: a PR session recalls with the daemon's hint
++ *             (the round's own query: the PR title plus the areas it touches)
++ *             and only inside the hint's memory areas (`experiences/`), not
++ *             with the whole round order across every scope.
+  * ────────────────────────────────────────────────────────────────────────────
+  */
+ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+@@ -47,6 +51,8 @@ import { isLeafProcess } from "./qcr-leaf.js";
+ import { ownNamespaceName, resolveExtraNamespaces } from "./qcr-namespaces.js";
+ // [QCR PATCH 7]
+ import { readRetiredUris, RECALL_WAIT_MS, RETIRED_FILE_ENV } from "./qcr-recall.js";
++// [QCR PATCH 8]
++import { readRecallHint, RECALL_HINT_FILE_ENV } from "./qcr-hint.js";
+ 
+ export default async function (pi: ExtensionAPI) {
+   // [QCR PATCH 2] Decided once, from argv, before anything else: a
+@@ -225,7 +231,11 @@ export default async function (pi: ExtensionAPI) {
+ 
+     // Queue recall for the context hook. Pi renders the user message before
+     // that hook, so recall latency does not delay the message appearing.
+-    recall.queueSearch(event.prompt);
++    // [QCR PATCH 8] A PR session asks with its PR's query, inside the round's
++    // areas — the daemon's hint, re-read for every prompt (a small local
++    // file). No hint (the overseer, the companion): the prompt, unscoped.
++    const hint = readRecallHint(process.env[RECALL_HINT_FILE_ENV]);
++    recall.queueSearch(hint ? hint.query : event.prompt, hint ? hint.areas : null);
+ 
+     // Compose system prompt additions
+     const parts: string[] = [];
+diff --git a/extensions/vendor/openviking-pi/recall.ts b/extensions/vendor/openviking-pi/recall.ts
+--- a/extensions/vendor/openviking-pi/recall.ts
++++ b/extensions/vendor/openviking-pi/recall.ts
+@@ -3,6 +3,8 @@ import type { OVConfig } from "./config.js";
+ import { buildRecallBlock } from "./shared/recall-core.mjs";
+ // [QCR PATCH 7]
+ import { budgetedFetch, raceBudget, RECALL_WAIT_MS, retiredGuard } from "./qcr-recall.js";
++// [QCR PATCH 8]
++import { scopeGuard } from "./qcr-hint.js";
+ 
+ export interface RecallCache {
+   block: string | null;
+@@ -22,6 +24,9 @@ export class RecallManager {
+   private config: OVConfig;
+   private cache: RecallCache = { block: null, promptText: "" };
+   private pendingPrompt = "";
++  // [QCR PATCH 8] The memory areas the pending recall may draw from; null =
++  // unscoped (upstream's behaviour).
++  private pendingScope: readonly string[] | null = null;
+   // Read lazily: the session manager that owns this id is constructed after the
+   // recall manager, and the id only exists once a session has been opened.
+   private sessionId: () => string | null;
+@@ -42,8 +47,11 @@ export class RecallManager {
+     this.now = opts.now ?? Date.now;
+   }
+ 
+-  queueSearch(userQuery: string): void {
++  /** [QCR PATCH 8] `scope` keeps the recall inside those memory areas (a PR
++   * session's hint: `experiences` alone); omitted = unscoped. */
++  queueSearch(userQuery: string, scope: readonly string[] | null = null): void {
+     this.pendingPrompt = userQuery;
++    this.pendingScope = scope && scope.length > 0 ? [...scope] : null;
+   }
+ 
+   /**
+@@ -60,6 +68,9 @@ export class RecallManager {
+ 
+     const userQuery = this.pendingPrompt;
+     this.pendingPrompt = "";
++    // [QCR PATCH 8]
++    const scope = this.pendingScope;
++    this.pendingScope = null;
+     if (userQuery.trim().length < this.config.minQueryLength) {
+       this.cache = { block: null, promptText: userQuery };
+       return null;
+@@ -67,16 +78,20 @@ export class RecallManager {
+ 
+     const budget = Math.max(0, Math.min(Number(budgetMs) || 0, RECALL_WAIT_MS));
+     const deadline = this.now() + budget;
+-    const fetch = retiredGuard(
+-      budgetedFetch(
+-        // 10s was this extension's own budget for a bare retrieval; the
+-        // deadline above now caps every request at the time left on it.
+-        (path: string, init?: any, options?: any) =>
+-          this.client.fetchJSON(path, init, options?.timeoutMs ?? 10000),
+-        deadline,
+-        this.now,
++    // [QCR PATCH 8] …and kept inside the hint's areas (`scopeGuard`).
++    const fetch = scopeGuard(
++      retiredGuard(
++        budgetedFetch(
++          // 10s was this extension's own budget for a bare retrieval; the
++          // deadline above now caps every request at the time left on it.
++          (path: string, init?: any, options?: any) =>
++            this.client.fetchJSON(path, init, options?.timeoutMs ?? 10000),
++          deadline,
++          this.now,
++        ),
++        this.retiredUris,
+       ),
+-      this.retiredUris,
++      () => scope,
+     );
+     const { value: block } = await raceBudget(
+       buildRecallBlock(fetch, this.config as any, userQuery, {
+@@ -129,5 +144,6 @@ export class RecallManager {
+   invalidate(): void {
+     this.cache = { block: null, promptText: "" };
+     this.pendingPrompt = "";
++    this.pendingScope = null;
+   }
+ }
+diff --git a/extensions/vendor/openviking-pi/qcr-hint.ts b/extensions/vendor/openviking-pi/qcr-hint.ts
+new file mode 100644
+--- /dev/null
++++ b/extensions/vendor/openviking-pi/qcr-hint.ts
+@@ -0,0 +1,144 @@
++// QCR FORK — file added by PATCH 8 (PR-derived recall). Not upstream.
++// a PR session's per-prompt recall searches for ITS PR, and only
++// where a round may look.
++//
++// The pure half, kept free of pi and of the OV client so
++// `tests/openviking-fork.test.ts` can exercise it (`index.ts` cannot be
++// imported from a test).
++//
++// Upstream recalls with the whole delivered prompt. For a PR session that is
++// a 55–80k-character round order, and the local embedder (S4) embeds a query's
++// first 128 tokens — the template's fixed header, the same for every PR, so
++// every PR recalled the same ops notes and feedback events. The daemon already
++// builds a PR-derived query for the round's own context block (the PR title
++// plus the areas and file kinds it touches — `roundContextQuery`,
++// src/memory/context.ts) and publishes it, with the areas a round may search
++// (`experiences/` alone), to a per-session file (`QCR_OV_RECALL_HINT_FILE`).
++// The recall here uses that query and stays inside those areas; with no hint
++// (the overseer, the companion, a session born before its first round) it
++// recalls exactly as before. S3's 500 ms budget is unchanged — the hint
++// changes what is asked, never how long it may take.
++import { readFileSync } from "node:fs";
++import { renderContextEntry, type FetchLike } from "./qcr-recall.js";
++
++/** Where the daemon publishes this session's hint (PR sessions only). */
++export const RECALL_HINT_FILE_ENV = "QCR_OV_RECALL_HINT_FILE";
++
++/** The daemon caps its query at 600 characters (`ROUND_CONTEXT_DEFAULTS`);
++ * a longer one in the file is cut, not refused. */
++export const MAX_HINT_QUERY_CHARS = 600;
++
++/** Items per area when the request names no count of its own. */
++export const DEFAULT_AREA_QUOTA = 10;
++
++export interface RecallHint {
++  query: string;
++  /** Memory areas (`experiences`) — OpenViking quota buckets by name. */
++  areas: string[];
++}
++
++const AREA_RE = /^[a-z][a-z0-9_-]*$/;
++
++/**
++ * The hint the daemon published (`{"query": "...", "areas": ["..."]}`), or
++ * null. Total, and fail-closed toward the old behaviour: no path, no file, a
++ * garbled file, an empty query or no usable area all mean "no hint" — the
++ * recall then uses the prompt, as upstream did.
++ */
++export function readRecallHint(
++  path: string | undefined,
++  read: (p: string) => string = defaultRead,
++): RecallHint | null {
++  if (!path || path.trim() === "") return null;
++  let parsed: unknown;
++  try {
++    parsed = JSON.parse(read(path.trim()));
++  } catch {
++    return null;
++  }
++  const raw = parsed as { query?: unknown; areas?: unknown } | null;
++  const query =
++    typeof raw?.query === "string"
++      ? raw.query.replace(/\s+/g, " ").trim().slice(0, MAX_HINT_QUERY_CHARS)
++      : "";
++  if (query === "") return null;
++  const areas = Array.isArray(raw?.areas)
++    ? [...new Set(raw.areas.filter((a): a is string => typeof a === "string" && AREA_RE.test(a)))]
++    : [];
++  if (areas.length === 0) return null;
++  return { query, areas };
++}
++
++function defaultRead(p: string): string {
++  return readFileSync(p, "utf8");
++}
++
++/** Is this URI inside one of the areas? */
++export function inAreas(uri: unknown, areas: readonly string[]): boolean {
++  return typeof uri === "string" && areas.some((a) => uri.includes(`/memories/${a}/`));
++}
++
++const CONTEXT_PATHS = new Set(["/api/v1/search/search", "/api/v1/search/recall"]);
++const FIND_PATH = "/api/v1/search/find";
++
++/**
++ * Every recall request this fetch carries stays inside `areas`:
++ *   * a context search or the `/search/recall` preset is SENT quotas naming
++ *     those areas alone (the count is the request's own `limit`, else
++ *     `DEFAULT_AREA_QUOTA`) — so the server never fills the block from
++ *     events, preferences or the resources/skills blurbs;
++ *   * whatever comes back from elsewhere anyway is DROPPED, and the rendered
++ *     block is rebuilt from what is left;
++ *   * the raw-find fallback keeps only memories inside the areas, and no
++ *     resources or skills.
++ * `areas()` empty or null = no scoping (the request goes out untouched).
++ */
++export function scopeGuard(inner: FetchLike, areas: () => readonly string[] | null): FetchLike {
++  return async (path, init, options) => {
++    let scope: readonly string[] = [];
++    try {
++      scope = areas() ?? [];
++    } catch {
++      scope = [];
++    }
++    if (scope.length === 0) return inner(path, init, options);
++    let sent = init;
++    if (CONTEXT_PATHS.has(path) && typeof init?.body === "string") {
++      try {
++        const body = JSON.parse(init.body) as Record<string, unknown>;
++        if (path !== "/api/v1/search/search" || body["mode"] === "context") {
++          const n = Math.max(1, Math.floor(Number(body["limit"]) || DEFAULT_AREA_QUOTA));
++          body["quotas"] = Object.fromEntries(scope.map((a) => [a, n]));
++          sent = { ...init, body: JSON.stringify(body) };
++        }
++      } catch {
++        sent = init;
++      }
++    }
++    const res = await inner(path, sent, options);
++    if (!res?.ok || !res.result || typeof res.result !== "object") return res;
++    if (CONTEXT_PATHS.has(path) && Array.isArray(res.result.entries)) {
++      const entries = res.result.entries as Array<Record<string, unknown>>;
++      const kept = entries.filter((e) => inAreas(e?.["uri"], scope));
++      if (kept.length === entries.length) return res;
++      return {
++        ...res,
++        result: {
++          ...res.result,
++          entries: kept,
++          rendered: kept.map(renderContextEntry).join("\n"),
++          digest: "",
++        },
++      };
++    }
++    if (path === FIND_PATH) {
++      const memories = Array.isArray(res.result.memories)
++        ? (res.result.memories as Array<Record<string, unknown>>).filter((m) =>
++            inAreas(m?.["uri"], scope),
++          )
++        : res.result.memories;
++      return { ...res, result: { ...res.result, memories, resources: [], skills: [] } };
++    }
++    return res;
++  };
++}