@zosmaai/pi-llm-wiki 0.12.1 → 0.12.2

package/dist/extensions/llm-wiki/lib/qmd-mirror.js

@@ -0,0 +1,418 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { serializeKnowledgeDocument } from "./knowledge-document.js";
+import { discoverKnowledgeDocuments } from "./vault-format.js";
+export const QMD_MANIFEST_VERSION = 1;
+const CANONICAL_TYPES = new Set([
+    "concept",
+    "entity",
+    "analysis",
+    "synthesis",
+    "requirement",
+    "skill",
+    "case",
+]);
+/** Classify a page type into a QMD collection role. Unknown types are evidence. */
+export function roleForDocumentType(type) {
+    return CANONICAL_TYPES.has(type.trim().toLowerCase()) ? "canonical" : "evidence";
+}
+/** Build the deterministic generated mirror path for a role + page id. */
+export function manifestKey(role, pageId) {
+    return `${["documents", role, ...pageId.split("/")].join("/")}.md`;
+}
+export function hashQmdContent(content) {
+    return createHash("sha256").update(content, "utf8").digest("hex");
+}
+export function hashQmdManifest(manifest) {
+    const entries = Object.fromEntries(Object.entries(manifest.entries).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0));
+    return hashQmdContent(JSON.stringify({ version: manifest.version, vaultId: manifest.vaultId, entries }));
+}
+async function atomicWrite(path, content) {
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
+    await writeFile(temporary, content, { encoding: "utf8", flag: "wx" });
+    await rename(temporary, path);
+}
+/**
+ * Resolve a manifest key to a physical path, rejecting anything that could
+ * escape `paths.qmd` or traverse via `..`. Never trust paths from JSON.
+ */
+function manifestKeyToPath(paths, key) {
+    if (isAbsolute(key)) {
+        throw new Error("qmd_manifest_invalid: manifest key is absolute");
+    }
+    const parts = key.split("/");
+    if (parts.some((part) => part === ".." || part === "" || part.includes("\\"))) {
+        throw new Error("qmd_manifest_invalid: manifest key contains unsafe path segments");
+    }
+    if (parts[0] !== "documents") {
+        throw new Error("qmd_manifest_invalid: manifest key outside documents");
+    }
+    const resolved = resolve(paths.qmd, key);
+    if (!resolved.startsWith(resolve(paths.qmd) + sep)) {
+        throw new Error("qmd_manifest_invalid: manifest key escapes qmd directory");
+    }
+    return resolved;
+}
+/** Load and validate a previously published manifest for this vault. */
+export async function readQmdManifest(paths, expectedVaultId) {
+    let raw;
+    try {
+        raw = await readFile(paths.qmdManifest, "utf8");
+    }
+    catch {
+        return { version: QMD_MANIFEST_VERSION, vaultId: expectedVaultId, entries: {} };
+    }
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("qmd_manifest_invalid: manifest is not valid JSON");
+    }
+    if (typeof data !== "object" ||
+        data === null ||
+        data.version !== QMD_MANIFEST_VERSION) {
+        throw new Error("qmd_manifest_invalid: unsupported manifest version");
+    }
+    const vaultId = data.vaultId;
+    if (typeof vaultId !== "string" || vaultId !== expectedVaultId) {
+        throw new Error("qmd_manifest_invalid: manifest vaultId mismatch");
+    }
+    const rawEntries = data.entries;
+    if (typeof rawEntries !== "object" || rawEntries === null) {
+        throw new Error("qmd_manifest_invalid: manifest entries missing");
+    }
+    const entries = {};
+    const wikiRoot = resolve(paths.wiki) + sep;
+    for (const [key, value] of Object.entries(rawEntries)) {
+        // Reject absolute keys and traversal keys before trusting any entry.
+        if (isAbsolute(key) || key.includes("\\") || key.split("/").includes("..")) {
+            throw new Error("qmd_manifest_invalid: unsafe manifest key");
+        }
+        const entry = value;
+        if (typeof entry !== "object" ||
+            entry === null ||
+            typeof entry.sourcePath !== "string" ||
+            typeof entry.pageId !== "string" ||
+            typeof entry.contentHash !== "string" ||
+            typeof entry.type !== "string" ||
+            (entry.role !== "canonical" && entry.role !== "evidence")) {
+            throw new Error("qmd_manifest_invalid: malformed manifest entry");
+        }
+        // The key is deterministic: documents/<role>/<pageId>.md. The entry must
+        // match both the role and page id encoded in its key.
+        if (!key.startsWith("documents/")) {
+            throw new Error("qmd_manifest_invalid: manifest key outside documents");
+        }
+        const rest = key.slice("documents/".length);
+        const slash = rest.indexOf("/");
+        if (slash <= 0 || !rest.endsWith(".md")) {
+            throw new Error("qmd_manifest_invalid: manifest key lacks role/page id");
+        }
+        const keyRole = rest.slice(0, slash);
+        const keyPageId = rest.slice(slash + 1, -3);
+        if (keyRole !== entry.role || keyPageId !== entry.pageId || keyPageId === "") {
+            throw new Error("qmd_manifest_invalid: manifest key/entry mismatch");
+        }
+        if (entry.vaultId !== vaultId) {
+            throw new Error("qmd_manifest_invalid: entry vaultId mismatch");
+        }
+        if (entry.type.trim() === "") {
+            throw new Error("qmd_manifest_invalid: entry type is empty");
+        }
+        if (!/^[0-9a-f]{64}$/.test(entry.contentHash)) {
+            throw new Error("qmd_manifest_invalid: entry contentHash is not a sha256 hex");
+        }
+        // Source paths are authoritative page files under paths.wiki, therefore
+        // under paths.root and outside paths.qmd.
+        const source = resolve(entry.sourcePath);
+        if (!isAbsolute(entry.sourcePath) || !source.startsWith(wikiRoot)) {
+            throw new Error("qmd_manifest_invalid: entry sourcePath outside wiki");
+        }
+        entries[key] = entry;
+    }
+    return { version: QMD_MANIFEST_VERSION, vaultId, entries };
+}
+function mirrorDiagnostic(code, path, message) {
+    return { severity: "warning", code, path, message };
+}
+/**
+ * Reconcile the generated QMD mirror against parser-valid authoritative pages.
+ * Publishes a validated manifest and only writes/removes generated files.
+ */
+export async function reconcileQmdMirror(paths, vaultId, scope) {
+    const diagnostics = [];
+    const discovery = discoverKnowledgeDocuments(paths);
+    diagnostics.push(...discovery.diagnostics);
+    let prior;
+    try {
+        prior = await readQmdManifest(paths, vaultId);
+    }
+    catch (error) {
+        prior = { version: QMD_MANIFEST_VERSION, vaultId, entries: {} };
+        diagnostics.push(mirrorDiagnostic("qmd_manifest_invalid", paths.qmdManifest, error.message));
+    }
+    // Build the desired manifest from parser-valid documents. Serialize each
+    // document once; the mirror file and its content hash use that exact string.
+    const desired = { version: QMD_MANIFEST_VERSION, vaultId, entries: {} };
+    const serializedByKey = new Map();
+    for (const doc of discovery.documents) {
+        const role = roleForDocumentType(doc.frontmatter.type);
+        const key = manifestKey(role, doc.id);
+        const serialized = serializeKnowledgeDocument(doc);
+        serializedByKey.set(key, serialized);
+        desired.entries[key] = {
+            sourcePath: doc.absolutePath,
+            vaultId,
+            pageId: doc.id,
+            contentHash: hashQmdContent(serialized),
+            role,
+            type: String(doc.frontmatter.type),
+        };
+    }
+    const counts = { indexed: 0, updated: 0, unchanged: 0, removed: 0 };
+    // Determine which prior entries are unsafe (deleted, malformed, or role-moved)
+    // and must be removed from the manifest before files change.
+    const removedEntries = {};
+    for (const [key, entry] of Object.entries(prior.entries)) {
+        const desiredEntry = desired.entries[key];
+        if (!desiredEntry || desiredEntry.pageId !== entry.pageId) {
+            removedEntries[key] = entry;
+        }
+    }
+    if (Object.keys(removedEntries).length > 0) {
+        const intermediate = {
+            version: QMD_MANIFEST_VERSION,
+            vaultId,
+            entries: Object.fromEntries(Object.entries(prior.entries).filter(([key]) => !removedEntries[key])),
+        };
+        await atomicWrite(paths.qmdManifest, JSON.stringify(intermediate, null, 2));
+    }
+    // Write new/changed mirror files.
+    for (const [key, entry] of Object.entries(desired.entries)) {
+        const priorEntry = prior.entries[key];
+        const mirrorPath = manifestKeyToPath(paths, key);
+        const content = serializedByKey.get(key) ?? "";
+        const changed = !priorEntry || priorEntry.contentHash !== entry.contentHash;
+        if (scope === "all" || changed) {
+            // Full scope still rewrites every file; count unchanged pages by their
+            // content identity so the totals reconcile with the final manifest.
+            if (changed) {
+                await atomicWrite(mirrorPath, content);
+                if (!priorEntry)
+                    counts.indexed++;
+                else
+                    counts.updated++;
+            }
+            else {
+                counts.unchanged++;
+            }
+        }
+        else {
+            counts.unchanged++;
+        }
+    }
+    // Remove orphaned generated files that are no longer in the desired manifest.
+    await removeOrphans(paths, desired);
+    // Final desired manifest.
+    await atomicWrite(paths.qmdManifest, JSON.stringify(desired, null, 2));
+    counts.removed = Object.keys(removedEntries).length;
+    // Remove generated mirror files for removed entries.
+    for (const key of Object.keys(removedEntries)) {
+        try {
+            await rm(manifestKeyToPath(paths, key), { force: true });
+        }
+        catch {
+            // Already absent.
+        }
+    }
+    const finalManifest = desired;
+    return {
+        manifest: finalManifest,
+        manifestHash: hashQmdManifest(finalManifest),
+        counts,
+        diagnostics,
+    };
+}
+/**
+ * Remove generated mirror files under documents/ that are not referenced by the
+ * desired manifest, plus empty directories. Does not follow symlinks.
+ */
+async function removeOrphans(paths, desired) {
+    const documentsRoot = join(paths.qmd, "documents");
+    const referenced = new Set(Object.keys(desired.entries));
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        let isEmpty = true;
+        for (const entry of entries) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full);
+                let stillEmpty;
+                try {
+                    stillEmpty = (await readdir(full)).length === 0;
+                }
+                catch {
+                    stillEmpty = true;
+                }
+                if (stillEmpty) {
+                    try {
+                        await rm(full, { recursive: false, force: true });
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+                else {
+                    isEmpty = false;
+                }
+            }
+            else if (entry.name.endsWith(".md")) {
+                // Manifest keys are rooted at paths.qmd (e.g. "documents/canonical/...").
+                const rel = relative(paths.qmd, full).split(sep).join("/");
+                if (!referenced.has(rel)) {
+                    try {
+                        await rm(full, { force: true });
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+                else {
+                    isEmpty = false;
+                }
+            }
+            else {
+                isEmpty = false;
+            }
+        }
+        if (isEmpty && dir !== documentsRoot) {
+            try {
+                await rm(dir, { recursive: false, force: true });
+            }
+            catch {
+                // Ignore
+            }
+        }
+    }
+    try {
+        await stat(documentsRoot);
+        await walk(documentsRoot);
+    }
+    catch {
+        // No documents dir yet.
+    }
+}
+/**
+ * Safety-only path used when metadata projection fails: may only REMOVE mirror
+ * entries for missing or rejected pages. Never adds or updates valid documents.
+ */
+export async function invalidateUnsafeQmdEntries(paths, vaultId) {
+    const diagnostics = [];
+    const discovery = discoverKnowledgeDocuments(paths);
+    diagnostics.push(...discovery.diagnostics);
+    let prior;
+    let priorUnsafe = false;
+    try {
+        prior = await readQmdManifest(paths, vaultId);
+    }
+    catch {
+        // Fail closed in the removal direction: a corrupt prior manifest cannot be
+        // trusted, so treat every previously generated mirror entry as unsafe and
+        // remove only files we can enumerate safely from disk.
+        prior = { version: QMD_MANIFEST_VERSION, vaultId, entries: {} };
+        priorUnsafe = true;
+    }
+    if (priorUnsafe) {
+        // Remove every generated mirror file under documents/ that can be
+        // enumerated safely, so stale deleted-page candidates cannot survive.
+        const documentsRoot = join(paths.qmd, "documents");
+        const removedFiles = [];
+        async function collect(dir) {
+            let entries;
+            try {
+                entries = await readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                const full = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    await collect(full);
+                }
+                else if (entry.isFile() && entry.name.endsWith(".md")) {
+                    removedFiles.push(full);
+                }
+            }
+        }
+        await collect(documentsRoot);
+        for (const file of removedFiles) {
+            try {
+                await rm(file, { force: true });
+            }
+            catch {
+                // Already absent.
+            }
+        }
+        await atomicWrite(paths.qmdManifest, JSON.stringify({ version: QMD_MANIFEST_VERSION, vaultId, entries: {} }, null, 2));
+        return {
+            manifest: { version: QMD_MANIFEST_VERSION, vaultId, entries: {} },
+            manifestHash: hashQmdManifest({ version: QMD_MANIFEST_VERSION, vaultId, entries: {} }),
+            counts: { indexed: 0, updated: 0, unchanged: 0, removed: removedFiles.length },
+            diagnostics: [
+                ...diagnostics,
+                {
+                    severity: "warning",
+                    code: "qmd_manifest_invalid",
+                    path: paths.qmdManifest,
+                    message: "Corrupt QMD manifest during invalidation; removed generated mirror entries fail-closed",
+                },
+            ],
+        };
+    }
+    // The set of still-valid mirror entries (present and parser-valid now).
+    const validHashes = new Map();
+    for (const doc of discovery.documents) {
+        const role = roleForDocumentType(doc.frontmatter.type);
+        const key = manifestKey(role, doc.id);
+        const serialized = serializeKnowledgeDocument(doc);
+        validHashes.set(key, hashQmdContent(serialized));
+    }
+    const removed = {};
+    const kept = {};
+    for (const [key, entry] of Object.entries(prior.entries)) {
+        if (!validHashes.has(key)) {
+            removed[key] = entry;
+        }
+        else {
+            kept[key] = entry;
+        }
+    }
+    if (Object.keys(removed).length > 0) {
+        await atomicWrite(paths.qmdManifest, JSON.stringify({ version: QMD_MANIFEST_VERSION, vaultId, entries: kept }, null, 2));
+        for (const key of Object.keys(removed)) {
+            try {
+                await rm(manifestKeyToPath(paths, key), { force: true });
+            }
+            catch {
+                // Already absent.
+            }
+        }
+    }
+    const finalManifest = { version: QMD_MANIFEST_VERSION, vaultId, entries: kept };
+    return {
+        manifest: finalManifest,
+        manifestHash: hashQmdManifest(finalManifest),
+        counts: { indexed: 0, updated: 0, unchanged: 0, removed: Object.keys(removed).length },
+        diagnostics,
+    };
+}

package/dist/extensions/llm-wiki/lib/qmd-store.js

@@ -0,0 +1,112 @@
+import { join } from "node:path";
+import { createStore } from "@tobilu/qmd";
+/**
+ * Package-private normalized adapter over the pinned @tobilu/qmd SDK.
+ *
+ * This is the ONLY production module allowed to import @tobilu/qmd. It hides
+ * SDK-specific types, collection config, model identity, and close behavior so
+ * the rest of the extension never touches QMD internals or tables directly.
+ */
+export const QMD_PACKAGE_VERSION = "2.5.3";
+export const QMD_DEFAULT_MODELS = {
+    embed: "hf:ggml-org/embeddinggemma-300M-GGUF/embeddinggemma-300M-Q8_0.gguf",
+    generate: "hf:tobil/qmd-query-expansion-1.7B-gguf/qmd-query-expansion-1.7B-q4_k_m.gguf",
+    rerank: "hf:ggml-org/Qwen3-Reranker-0.6B-Q8_0-GGUF/qwen3-reranker-0.6b-q8_0.gguf",
+};
+/**
+ * Mirror collection a hit came from: the SDK reports virtual paths
+ * "qmd://<collection>/<path>.md", and the mirror layout is
+ * ".../documents/<role>/<pageId>.md". Either form resolves the role.
+ */
+function roleFromFile(file) {
+    return /(?:^|\/)documents\/canonical\/|^qmd:\/\/canonical\//.test(file)
+        ? "canonical"
+        : "evidence";
+}
+/** Normalize raw within-store scores to 0..1 against this list's max. */
+function withNormalizedScores(hits) {
+    const max = Math.max(...hits.map((h) => h.raw), 1e-9);
+    return hits.map(({ raw, ...rest }) => ({ ...rest, score: raw / max }));
+}
+const mapLexHit = (r) => ({
+    collection: roleFromFile(r.filepath),
+    file: r.filepath,
+    title: r.title,
+    source: r.source,
+    raw: r.score,
+});
+const mapHybridHit = (r) => ({
+    collection: roleFromFile(r.file),
+    file: r.file,
+    title: r.title,
+    source: "fts",
+    body: r.bestChunk,
+    raw: r.score,
+});
+/**
+ * Open a QMD index store over the mirror documents directory, with two
+ * non-overlapping collections (canonical and evidence).
+ */
+export async function openQmdIndexStore(input) {
+    const store = await createStore({
+        dbPath: input.dbPath,
+        config: {
+            global_context: "Validated LLM Wiki knowledge",
+            collections: {
+                canonical: {
+                    path: join(input.documentsPath, "canonical"),
+                    pattern: "**/*.md",
+                    context: { "/": "Reusable conclusions, entities, requirements, and procedures" },
+                },
+                evidence: {
+                    path: join(input.documentsPath, "evidence"),
+                    pattern: "**/*.md",
+                    context: { "/": "Source evidence, observations, trajectories, and unpromoted notes" },
+                },
+            },
+        },
+    });
+    return {
+        update: (onProgress) => store.update({ onProgress }),
+        embed: ({ force, onProgress }) => store.embed({ force, chunkStrategy: "regex", onProgress }),
+        status: async () => {
+            const status = await store.getStatus();
+            const counts = Object.fromEntries(status.collections.map((collection) => [collection.name, collection.documents]));
+            return {
+                totalDocuments: status.totalDocuments,
+                needsEmbedding: status.needsEmbedding,
+                hasVectorIndex: status.hasVectorIndex,
+                canonicalDocuments: counts.canonical ?? 0,
+                evidenceDocuments: counts.evidence ?? 0,
+            };
+        },
+        close: () => store.close(),
+        searchLex: async (query, limit = 40) => withNormalizedScores((await store.searchLex(query, { limit })).map(mapLexHit)),
+        searchTyped: async (query, limit = 10) => withNormalizedScores((await store.search({
+            queries: [
+                { type: "lex", query },
+                { type: "vec", query },
+            ],
+            rerank: false,
+            candidateLimit: 40,
+            limit,
+            explain: true,
+        })).map(mapHybridHit)),
+        searchExpanded: async (query, intent, limit = 10) => withNormalizedScores((await store.search({
+            query,
+            intent,
+            rerank: true,
+            candidateLimit: 40,
+            limit,
+            explain: true,
+        })).map(mapHybridHit)),
+    };
+}
+/** Resolve model identities from env, defaulting to pinned models. No downloads. */
+export function resolveQmdModels(env = process.env) {
+    return {
+        embed: env.QMD_EMBED_MODEL?.trim() || QMD_DEFAULT_MODELS.embed,
+        generate: env.QMD_GENERATE_MODEL?.trim() || QMD_DEFAULT_MODELS.generate,
+        rerank: env.QMD_RERANK_MODEL?.trim() || QMD_DEFAULT_MODELS.rerank,
+    };
+}

package/dist/extensions/llm-wiki/lib/recall.js

@@ -78,11 +78,14 @@ function queryTerms(query) {
     if (compact && compact !== normalized)
         terms.push(compact);
     for (const part of normalized.split(/\s+/)) {
-        if (part.length >= 2)
+        if (part.length >= 2 && !STOPWORDS.has(part))
             terms.push(part);
     }
     const latinRuns = normalized.match(/[a-z0-9]{2,}/g) ?? [];
-    terms.push(...latinRuns);
+    for (const run of latinRuns) {
+        if (!STOPWORDS.has(run))
+            terms.push(run);
+    }
     const cjkRuns = normalized.match(/[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]+/gu) ?? [];
     for (const run of cjkRuns) {
         for (let size = 2; size <= 3; size++) {
@@ -95,10 +98,36 @@ function queryTerms(query) {
     }
     return unique(terms).slice(0, 30);
 }
+/** Matches any CJK (Han / Hiragana / Katakana) character. */
+const CJK_RE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u;
+/**
+ * Whether `haystack` contains `term`.
+ *
+ * Root-cause fix for issue #223. Previously this was a raw substring
+ * containment, so a 2-char query token like "to" or "so" matched thousands of
+ * unrelated words ("to" ⊂ "history"/"story"; "so" ⊂ "person"/"wilson"), and
+ * weighted field stacking pushed that junk past the auto-injection gate.
+ *
+ * Now:
+ * - CJK terms (Han/Kana) have no whitespace word boundaries, so they still
+ *   match by compact substring — a CJK bigram matches inside a longer glued
+ *   CJK run, preserving the multilingual recall the vaults depend on.
+ * - Latin/ASCII terms require a WHOLE-WORD match: a spaceless haystack is a
+ *   single word (term must equal it), and a spaced haystack must contain the
+ *   term as a whole whitespace-delimited token. "to" still matches the word
+ *   "to" and "Go" still matches "Go", but no longer "history"/"story"/"person".
+ */
 function includesTerm(haystack, term) {
     if (!haystack || !term)
         return false;
-    return haystack.includes(term) || compactText(haystack).includes(compactText(term));
+    const termCompact = compactText(term);
+    if (CJK_RE.test(termCompact)) {
+        return compactText(haystack).includes(termCompact);
+    }
+    if (!/\s/.test(haystack)) {
+        return compactText(haystack) === termCompact;
+    }
+    return haystack.split(/\s+/).some((t) => t === term || t === termCompact);
 }
 function scoreField(value, terms, weight) {
     const text = normalizeText(value);
@@ -164,6 +193,51 @@ const STOPWORDS = new Set([
     "type",
     "used",
     "using",
+    // Common English function words (issue #223). These must not become scoring
+    // terms, or a natural-language prompt full of "to"/"so"/"the"/"did" pushes
+    // unrelated pages past the auto-injection gate. 2-letter acronyms that are
+    // NOT stopwords ("go", "pi", "sso") still match, as intended.
+    "to",
+    "so",
+    "did",
+    "do",
+    "does",
+    "and",
+    "or",
+    "but",
+    "a",
+    "an",
+    "i",
+    "it",
+    "its",
+    "is",
+    "are",
+    "was",
+    "be",
+    "am",
+    "for",
+    "on",
+    "at",
+    "by",
+    "as",
+    "if",
+    "in",
+    "of",
+    "up",
+    "out",
+    "not",
+    "no",
+    "can",
+    "has",
+    "had",
+    "me",
+    "my",
+    "you",
+    "your",
+    "we",
+    "our",
+    "us",
+    "too",
 ]);
 /**
  * Split a page's body into chunks by headings.

package/dist/extensions/llm-wiki/lib/runtime.js

@@ -68,7 +68,31 @@ export class Runtime {
             const provider = model.provider ?? "unknown";
             return { ok: false, reason: `no API key for provider "${provider}"` };
         }
-        return { ok: true, model, apiKey: auth.apiKey ?? "", headers: auth.headers };
+        // Extension-registered providers (issue #222): pi-ai's default stream path
+        // may not be able to resolve their api (e.g. claude-bridge on pi 0.85+), so
+        // surface the provider's own streamSimple for the sub-agent stream. On pi
+        // < 0.85 the registry method is absent (?.) and the default path — which
+        // already knows extension streamSimples — is used instead.
+        const modelProvider = model.provider;
+        const registered = modelProvider
+            ? ctx.modelRegistry.getRegisteredProviderConfig?.(modelProvider)
+            : undefined;
+        const streamFn = registered?.streamSimple && registered.api === model.api
+            ? registered.streamSimple
+            : undefined;
+        // Auth can redirect the endpoint (e.g. GitHub Copilot business vs
+        // individual accounts) and/or carry provider-scoped env values (pi >=
+        // 0.85). Streaming against the catalogue values yields 421 Misdirected
+        // Request and the synthesis silently produces nothing (issue #222).
+        const authedModel = auth.baseUrl ? { ...model, baseUrl: auth.baseUrl } : model;
+        return {
+            ok: true,
+            model: authedModel,
+            apiKey: auth.apiKey ?? "",
+            headers: auth.headers,
+            env: auth.env,
+            streamFn,
+        };
     }
     /**
      * Fire-and-forget a background task.