pi-para 0.6.4 → 0.6.6

package/src/doctor.ts

@@ -5,7 +5,7 @@ import { readSecretStore, resolveCredentialRef } from "./credentials.js";
 import { getParaPaths } from "./paths.js";
 import { openStore, closeStore } from "./store.js";
 import type { ProviderCredentialRef } from "./config.js";
-import { createPiModelRegistry, getCaptureSelection, resolveSelectedModel } from "./model-resolver.js";
+import { createModelApiKeyResolver, createPiModelServices, getCaptureSelection, resolveSelectedModel } from "./model-resolver.js";
 import { SchedulerStateDB } from "./scheduler/state.js";
 import { ensureGeneratedStateGitignore, fixSecretPermissions, missingGeneratedStateGitignorePatterns } from "./repair.js";
 
@@ -51,7 +51,7 @@ export async function runDoctor(options: DoctorOptions = {}): Promise<DoctorResu
 
   checks.push(await checkSecrets(paths.secretsPath));
   checks.push(await checkGeneratedStateGitignore(paths.wikiDir));
-  checks.push(...await checkProviderDiagnostics(loaded.config, paths.secretsPath, options));
+  checks.push(...await checkProviderDiagnostics(loaded.config, paths.secretsPath, `${paths.agentDir}/auth.json`, options));
 
   if (options.validateQmd !== false) {
     checks.push(await checkQmd(paths.wikiDir, loaded.config, paths.secretsPath));
@@ -131,6 +131,7 @@ async function checkGeneratedStateGitignore(wikiDir: string): Promise<DoctorChec
 async function checkProviderDiagnostics(
   config: ParaUserConfig,
   secretsPath: string,
+  authPath: string,
   options: DoctorOptions,
 ): Promise<DoctorCheck[]> {
   const checks: DoctorCheck[] = [];
@@ -144,49 +145,50 @@ async function checkProviderDiagnostics(
   if (!config.qmd.embedEnabled) {
     checks.push({ name: "qmd-embedding", status: "ok", message: "embedding disabled" });
   } else if (config.qmd.embedding) {
-    checks.push(await checkCredentialProfile("qmd-embedding", config.qmd.embedding, secretsPath));
+    checks.push(await checkCredentialProfile("qmd-embedding", config.qmd.embedding, secretsPath, authPath));
   } else {
     checks.push({ name: "qmd-embedding", status: "warn", message: "embedding enabled but no pi-para embedding profile is configured" });
   }
 
   if (config.qmd.rerank) {
-    checks.push(await checkCredentialProfile("qmd-rerank", config.qmd.rerank, secretsPath));
+    checks.push(await checkCredentialProfile("qmd-rerank", config.qmd.rerank, secretsPath, authPath));
   } else {
     checks.push({ name: "qmd-rerank", status: "ok", message: "rerank disabled" });
   }
 
-  checks.push(await checkCaptureModel(config, secretsPath, options.testCaptureModel === true));
+  checks.push(await checkCaptureModel(config, secretsPath, authPath, options.testCaptureModel === true));
   return checks;
 }
 
-async function checkCredentialProfile(name: string, profile: ProviderCredentialRef, secretsPath: string): Promise<DoctorCheck> {
+async function checkCredentialProfile(name: string, profile: ProviderCredentialRef, secretsPath: string, authPath: string): Promise<DoctorCheck> {
   const label = `${profile.provider}/${profile.model ?? "model not set"}`;
   if (profile.credentialRef === "none") {
     return { name, status: "ok", message: `${label} uses no credential` };
   }
-  const resolved = await resolveCredentialRef(profile.credentialRef, { secretsPath });
+  const services = profile.credentialRef.startsWith("pi-auth:") ? await createPiModelServices({ authPath }) : null;
+  const resolved = await resolveCredentialRef(profile.credentialRef, { secretsPath, credentials: services?.credentials });
   if (!resolved.ok) {
     return { name, status: "warn", message: `${label} credential missing: ${resolved.error}` };
   }
   return { name, status: "ok", message: `${label} credential available via ${resolved.source}` };
 }
 
-async function checkCaptureModel(config: ParaUserConfig, secretsPath: string, testModel: boolean): Promise<DoctorCheck> {
+async function checkCaptureModel(config: ParaUserConfig, secretsPath: string, authPath: string, testModel: boolean): Promise<DoctorCheck> {
   const selection = getCaptureSelection(config);
   if (!testModel) {
     if (selection === "auto") return { name: "capture-model", status: "ok", message: "auto selection; run doctor --test-capture-model to resolve" };
-    return checkCredentialProfile("capture-model", selection, secretsPath);
+    return checkCredentialProfile("capture-model", selection, secretsPath, authPath);
   }
 
   try {
-    const registry = await createPiModelRegistry();
-    if (!registry) return { name: "capture-model", status: "warn", message: "Pi model registry unavailable" };
-    const model = resolveSelectedModel(selection, registry.modelRegistry, { preferredModelSpec: "anthropic/claude-sonnet-4-20250514" });
+    const services = await createPiModelServices({ authPath });
+    if (!services) return { name: "capture-model", status: "warn", message: "Pi credential runtime is unavailable" };
+    const model = resolveSelectedModel(selection, services.modelRegistry, { preferredModelSpec: "anthropic/claude-sonnet-4-20250514" });
     if (!model) return { name: "capture-model", status: "warn", message: "no capture model resolved" };
-    const getKey = selection === "auto"
-      ? () => registry.modelRegistry.getApiKeyForProvider(model.provider)
-      : () => resolveCredentialRef(selection.credentialRef, { secretsPath, authStorage: registry.authStorage }).then((r) => r.value);
-    const key = await getKey();
+    const key = await createModelApiKeyResolver(selection, services.modelRegistry, {
+      credentials: services.credentials,
+      secretsPath,
+    })(model.provider);
     return key
       ? { name: "capture-model", status: "ok", message: `${model.provider}/${model.id} credential available` }
       : { name: "capture-model", status: "warn", message: `${model.provider}/${model.id} resolved but credential is missing` };

package/src/index.ts

@@ -30,7 +30,7 @@ import {
   enqueueCompletedSessionsFromRegistry,
 } from "./scheduler/session-capture.js";
 import { loadParaConfig, toLegacyRuntimeConfig, type ParaUserConfig } from "./config.js";
-import { createModelApiKeyResolver, createPiModelRegistry, getCaptureSelection, resolveSelectedModel } from "./model-resolver.js";
+import { createModelApiKeyResolver, createPiModelServices, getCaptureSelection, resolveSelectedModel } from "./model-resolver.js";
 import { StateDB } from "./state.js";
 
 // Re-export public types for consumers
@@ -169,6 +169,7 @@ export default async function piPara(pi: ExtensionAPI): Promise<void> {
   const loadedConfig = await loadConfig();
   const config = loadedConfig.runtime;
   const wikiDir = config.wikiDir;
+  const printMode = isPrintModeProcess();
 
   let store: QMDStore | null = null;
   let currentScope: ProjectScope | null = null;
@@ -246,7 +247,15 @@ export default async function piPara(pi: ExtensionAPI): Promise<void> {
   });
 
   // Register tools, context injection, commands
-  registerTools(pi, wikiDir, storeProxy, getScope, markContextDirty, () => config.searchGraphBoost);
+  registerTools(
+    pi,
+    wikiDir,
+    storeProxy,
+    getScope,
+    markContextDirty,
+    () => config.searchGraphBoost,
+    () => loadedConfig.userConfig?.lint ?? { autoFix: true, staleDays: 90 },
+  );
   setupContextInjection(pi, wikiDir, storeProxy, () => currentScope, getConfig);
   registerCommands(pi, wikiDir, storeProxy, getScope, setScope);
 
@@ -300,10 +309,10 @@ export default async function piPara(pi: ExtensionAPI): Promise<void> {
     const startupCatchupEnabled = autoCaptureEnabled && wikiConfig?.captureOnStartup !== false && schedulerConfig?.startupCatchup !== false;
     try {
       const loadedParaConfig = await loadParaConfig({ migrate: true });
-      const registry = autoCaptureEnabled ? await createPiModelRegistry() : null;
-      if (registry) {
+      const services = autoCaptureEnabled ? await createPiModelServices() : null;
+      if (services) {
         const captureSelection = getCaptureSelection(loadedParaConfig.config);
-        const captureModel = resolveSelectedModel(captureSelection, registry.modelRegistry, {
+        const captureModel = resolveSelectedModel(captureSelection, services.modelRegistry, {
           legacyModelSpec: config.daemonModel,
           preferredModelSpec: "anthropic/claude-sonnet-4-20250514",
         });
@@ -312,8 +321,8 @@ export default async function piPara(pi: ExtensionAPI): Promise<void> {
             wikiDir,
             storeProvider: () => store,
             model: captureModel,
-            getApiKey: createModelApiKeyResolver(captureSelection, registry.modelRegistry, {
-              authStorage: registry.authStorage,
+            getApiKey: createModelApiKeyResolver(captureSelection, services.modelRegistry, {
+              credentials: services.credentials,
               secretsPath: loadedParaConfig.paths.secretsPath,
             }),
           });
@@ -324,7 +333,7 @@ export default async function piPara(pi: ExtensionAPI): Promise<void> {
     }
 
     const embedEnabled = loadedConfig.userConfig?.qmd.embedEnabled !== false;
-    const schedulerEnabled = !isPrintModeProcess() && schedulerConfig?.enabled !== false;
+    const schedulerEnabled = !printMode && schedulerConfig?.enabled !== false;
     const scheduler = schedulerEnabled
       ? startWikiScheduler({
         wikiDir,
@@ -372,15 +381,15 @@ export default async function piPara(pi: ExtensionAPI): Promise<void> {
           ctx.ui.setStatus("pi-para", `wiki: ${url}`);
         } else {
           ctx.ui.setStatus("pi-para", "wiki: ready (web UI disabled)");
-          setTimeout(() => ctx.ui.setStatus("pi-para", undefined), 5000);
+          if (!printMode) setTimeout(() => ctx.ui.setStatus("pi-para", undefined), 5000);
         }
       } catch {
         ctx.ui.setStatus("pi-para", "wiki: ready");
-        setTimeout(() => ctx.ui.setStatus("pi-para", undefined), 3000);
+        if (!printMode) setTimeout(() => ctx.ui.setStatus("pi-para", undefined), 3000);
       }
     } else {
       ctx.ui.setStatus("pi-para", "wiki: ready");
-      setTimeout(() => ctx.ui.setStatus("pi-para", undefined), 3000);
+      if (!printMode) setTimeout(() => ctx.ui.setStatus("pi-para", undefined), 3000);
     }
   });
 

package/src/link-utils.ts

@@ -50,10 +50,14 @@ function findProtectedRanges(body: string): Array<[number, number]> {
     ranges.push([m.index, m.index + m[0].length]);
   }
 
-  // Inline code
-  const inlineCodeRe = /`[^`]+`/g;
+  // Inline code. Keep spans on one line and skip fenced regions already
+  // recorded above. The old /`[^`]+`/ pattern could start at a closing fence
+  // backtick and protect hundreds of characters of ordinary Markdown.
+  const inlineCodeRe = /`+[^`\n]+`+/g;
   while ((m = inlineCodeRe.exec(body)) !== null) {
-    ranges.push([m.index, m.index + m[0].length]);
+    const start = m.index;
+    const end = m.index + m[0].length;
+    if (!isProtected(start, end, ranges)) ranges.push([start, end]);
   }
 
   // Existing [[wikilinks]]
@@ -89,19 +93,40 @@ function isProtected(pos: number, end: number, ranges: Array<[number, number]>):
   return false;
 }
 
+/** Find plain-text slug mentions that autoLinkSlugs can actually fix. */
+export function findUnlinkedSlugs(
+  body: string,
+  allSlugs: Set<string>,
+  ownSlug?: string,
+): string[] {
+  if (allSlugs.size === 0) return [];
+  const bodyLinks = new Set(extractWikilinks(body));
+  const protectedRanges = findProtectedRanges(body);
+  const unlinked: string[] = [];
+
+  const sortedSlugs = [...allSlugs]
+    .filter((slug) => slug !== ownSlug && !bodyLinks.has(slug))
+    .sort((a, b) => b.length - a.length);
+
+  for (const slug of sortedSlugs) {
+    const escaped = slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(`(?<![a-z0-9-])${escaped}(?![a-z0-9-])`, "g");
+    let match: RegExpExecArray | null;
+    while ((match = re.exec(body)) !== null) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (!isProtected(start, end, protectedRanges)) {
+        unlinked.push(slug);
+        break;
+      }
+    }
+  }
+  return unlinked;
+}
+
 /**
- * Auto-link page slug mentions in body text with [[wikilinks]].
- *
- * - Wraps unlinked slug mentions in [[slug]]
- * - Skips code blocks, URLs, existing [[wikilinks]], headings
- * - Matches longest slugs first to avoid partial matches
- * - Uses word-boundary matching (won't match "pi-para" inside "pi-para-daemon")
- * - Only links each slug once per page (first occurrence) to avoid noise
- *
- * @param body - Page body markdown
- * @param allSlugs - Set of all existing page slugs
- * @param ownSlug - This page's own slug (excluded from auto-linking)
- * @returns Updated body with [[wikilinks]] inserted
+ * Auto-link page slug mentions while skipping code, URLs, headings, and
+ * existing wikilinks. Only the first fixable occurrence of each slug is linked.
  */
 export function autoLinkSlugs(
   body: string,
@@ -115,7 +140,6 @@ export function autoLinkSlugs(
     .filter(s => s !== ownSlug)
     .sort((a, b) => b.length - a.length);
 
-  const protectedRanges = findProtectedRanges(body);
   const linkedSlugs = new Set(extractWikilinks(body));
 
   let result = body;

package/src/lint.ts

@@ -24,6 +24,7 @@ import {
   extractWikilinks,
   removeWikilink,
   autoLinkSlugs,
+  findUnlinkedSlugs,
   syncFrontmatterLinks,
 } from "./link-utils.js";
 import { normalizeTags, normalizeScopes } from "./tag-registry.js";
@@ -415,22 +416,9 @@ function checkLinkSync(
 ): LintIssue[] {
   const issues: LintIssue[] = [];
   for (const p of pages) {
-    // Find slugs mentioned in body but not wrapped in [[...]]
-    const bodyLinks = new Set(extractWikilinks(p.body));
-    const sortedSlugs = [...allSlugs]
-      .filter(s => s !== p.slug)
-      .sort((a, b) => b.length - a.length);
-
-    const unlinked: string[] = [];
-    for (const slug of sortedSlugs) {
-      if (bodyLinks.has(slug)) continue;
-      // Check if slug appears as plain text in body (word-boundary match)
-      const escaped = slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const re = new RegExp(`(?<![a-z0-9-])${escaped}(?![a-z0-9-])`);
-      if (re.test(p.body)) {
-        unlinked.push(slug);
-      }
-    }
+    // Use the exact same protected-range semantics as the fixer so every
+    // auto-fixable issue is actionable (no code-block/heading false positives).
+    const unlinked = findUnlinkedSlugs(p.body, allSlugs, p.slug);
 
     if (unlinked.length > 0) {
       issues.push({
@@ -603,7 +591,9 @@ async function fixSecrets(
           updated: new Date().toISOString(),
         },
       };
-      await writePage(wikiDir, fixedPage);
+      p.body = fixedPage.body;
+      p.frontmatter = fixedPage.frontmatter;
+      await writePage(wikiDir, p);
 
       fixed.push({
         severity: "error",
@@ -650,7 +640,9 @@ async function fixLinkSync(
           updated: new Date().toISOString(),
         },
       };
-      await writePage(wikiDir, fixedPage);
+      p.body = fixedPage.body;
+      p.frontmatter = fixedPage.frontmatter;
+      await writePage(wikiDir, p);
 
       if (addedLinks.length > 0) {
         fixed.push({
@@ -729,7 +721,9 @@ async function fixBrokenLinks(
       body: newBody,
       frontmatter: { ...p.frontmatter, links: newFmLinks },
     };
-    await writePage(wikiDir, fixedPage);
+    p.body = fixedPage.body;
+    p.frontmatter = fixedPage.frontmatter;
+    await writePage(wikiDir, p);
 
     for (const link of broken) {
       fixed.push({
@@ -931,11 +925,10 @@ export async function lintWiki(
 
   // Load all pages
   const refs = await listPages(wikiDir);
-  const pages: WikiPage[] = [];
-  for (const ref of refs) {
-    const page = await readPage(wikiDir, ref.category, ref.slug);
-    if (page) pages.push(page);
-  }
+  const loadedPages = await Promise.all(
+    refs.map((ref) => readPage(wikiDir, ref.category, ref.slug)),
+  );
+  const pages = loadedPages.filter((page): page is WikiPage => page !== null);
 
   // Build slug set
   const allSlugs = new Set(pages.map((p) => p.slug));
@@ -978,15 +971,38 @@ export async function lintWiki(
   // Auto-fix if enabled
   const fixed: LintIssue[] = [];
   if (autoFix) {
-    // Fix secrets first — highest priority
-    fixed.push(...(await fixSecrets(wikiDir, pages)));
-    fixed.push(...(await fixBrokenLinks(wikiDir, pages, allSlugs)));
-    fixed.push(...(await fixLinkSync(wikiDir, pages, allSlugs)));
-    fixed.push(...(await fixTagHealth(wikiDir, pages)));
-    fixed.push(...(await fixIndexDrift(wikiDir, pages, indexContent)));
-    fixed.push(...(await fixFrontmatter(wikiDir, pages)));
-    fixed.push(...(await fixScopeDrift(wikiDir, pages)));
-    fixed.push(...(await fixSchemaVersion(wikiDir, pages)));
+    // Only run a fixer against pages its check identified. Previously every
+    // fixer rescanned all P pages (and link sync scanned all S slugs per page)
+    // even when that category had zero issues.
+    const affectedPages = (category: LintIssue["category"]): WikiPage[] => {
+      const paths = new Set(
+        issues
+          .filter((issue) => issue.category === category && issue.autoFixable && issue.page)
+          .map((issue) => issue.page!),
+      );
+      return paths.size === 0
+        ? []
+        : pages.filter((page) => paths.has(`${page.category}/${page.slug}`));
+    };
+    const hasIssue = (category: LintIssue["category"]): boolean =>
+      issues.some((issue) => issue.category === category && issue.autoFixable);
+
+    // Fix secrets first — highest priority.
+    const secretPages = affectedPages("secrets");
+    if (secretPages.length > 0) fixed.push(...(await fixSecrets(wikiDir, secretPages)));
+    const brokenPages = affectedPages("broken-link");
+    if (brokenPages.length > 0) fixed.push(...(await fixBrokenLinks(wikiDir, brokenPages, allSlugs)));
+    const linkPages = affectedPages("link-sync");
+    if (linkPages.length > 0) fixed.push(...(await fixLinkSync(wikiDir, linkPages, allSlugs)));
+    const tagPages = affectedPages("tag-health");
+    if (tagPages.length > 0) fixed.push(...(await fixTagHealth(wikiDir, tagPages)));
+    if (hasIssue("index-drift")) fixed.push(...(await fixIndexDrift(wikiDir, pages, indexContent)));
+    const frontmatterPages = affectedPages("frontmatter");
+    if (frontmatterPages.length > 0) fixed.push(...(await fixFrontmatter(wikiDir, frontmatterPages)));
+    const scopePages = affectedPages("scope-drift");
+    if (scopePages.length > 0) fixed.push(...(await fixScopeDrift(wikiDir, scopePages)));
+    const schemaPages = affectedPages("schema-version");
+    if (schemaPages.length > 0) fixed.push(...(await fixSchemaVersion(wikiDir, schemaPages)));
   }
 
   // Recount broken links for stats

package/src/model-resolver.ts

@@ -3,15 +3,22 @@ import type { ProviderCredentialRef, ParaUserConfig } from "./config.js";
 import { resolveCredentialRef } from "./credentials.js";
 
 export interface ModelRegistryLike {
+  getAll(): Model<any>[];
   getAvailable(): Model<any>[];
   find(provider: string, modelId: string): Model<any> | undefined;
   getApiKeyForProvider(provider: string): Promise<string | undefined>;
 }
 
-export interface AuthStorageLike {
+export interface PiCredentialReader {
+  hasStoredCredential(provider: string): boolean;
   getApiKey(provider: string): Promise<string | undefined>;
 }
 
+export interface PiModelServices {
+  modelRegistry: ModelRegistryLike;
+  credentials: PiCredentialReader;
+}
+
 export type ModelSelection = ProviderCredentialRef | "auto";
 
 export function parseProviderModelSpec(spec: string): { provider: string; modelId: string } | null {
@@ -20,6 +27,10 @@ export function parseProviderModelSpec(spec: string): { provider: string; modelI
   return { provider: spec.slice(0, idx), modelId: spec.slice(idx + 1) };
 }
 
+function isRemoteModel(model: Model<any>): boolean {
+  return model.provider !== "node-llama-cpp" && model.provider !== "local" && !model.provider.includes("llama");
+}
+
 export function resolveSelectedModel(
   selection: ModelSelection,
   registry: ModelRegistryLike,
@@ -27,47 +38,50 @@ export function resolveSelectedModel(
 ): Model<any> | null {
   if (selection !== "auto") {
     if (selection.model) return registry.find(selection.provider, selection.model) ?? null;
-    return registry.getAvailable().find((model) => model.provider === selection.provider) ?? null;
+    return registry.getAvailable().find((model) => model.provider === selection.provider && isRemoteModel(model)) ?? null;
   }
 
   const legacy = opts.legacyModelSpec ? parseProviderModelSpec(opts.legacyModelSpec) : null;
   if (legacy) {
     const model = registry.find(legacy.provider, legacy.modelId);
-    if (model) return model;
+    if (model && isRemoteModel(model)) return model;
   }
 
   const preferred = opts.preferredModelSpec ? parseProviderModelSpec(opts.preferredModelSpec) : null;
   if (preferred) {
     const model = registry.find(preferred.provider, preferred.modelId);
-    if (model) return model;
+    if (model && isRemoteModel(model)) return model;
   }
 
-  return pickBestAvailableModel(registry.getAvailable());
+  return pickBestAvailableModel(registry.getAvailable().filter(isRemoteModel));
 }
 
 export function pickBestAvailableModel(models: Model<any>[]): Model<any> | null {
-  if (models.length === 0) return null;
-  const sonnet = models.find((model) => model.provider === "anthropic" && /sonnet/i.test(model.id));
+  const remote = models.filter(isRemoteModel);
+  if (remote.length === 0) return null;
+  const sonnet = remote.find((model) => model.provider === "anthropic" && /sonnet/i.test(model.id));
   if (sonnet) return sonnet;
-  return [...models].sort((a, b) => (b.contextWindow ?? 0) - (a.contextWindow ?? 0))[0] ?? null;
+  return [...remote].sort((a, b) => (b.contextWindow ?? 0) - (a.contextWindow ?? 0))[0] ?? null;
 }
 
 export function createModelApiKeyResolver(
   selection: ModelSelection,
   registry: ModelRegistryLike,
-  opts: { authStorage?: AuthStorageLike; secretsPath?: string } = {},
+  opts: { credentials?: PiCredentialReader; secretsPath?: string } = {},
 ): (provider: string) => Promise<string | undefined> {
   return async (provider: string) => {
-    if (selection === "auto") return registry.getApiKeyForProvider(provider);
+    if (selection === "auto") {
+      return opts.credentials ? opts.credentials.getApiKey(provider) : registry.getApiKeyForProvider(provider);
+    }
+    if (selection.provider !== provider) return undefined;
 
     if (selection.credentialRef.startsWith("pi-auth:")) {
       const configuredProvider = selection.credentialRef.slice("pi-auth:".length);
-      if (configuredProvider !== provider && selection.provider !== provider) return undefined;
-      return (await opts.authStorage?.getApiKey(provider)) ?? await registry.getApiKeyForProvider(provider);
+      if (configuredProvider !== provider) return undefined;
+      return opts.credentials ? opts.credentials.getApiKey(provider) : registry.getApiKeyForProvider(provider);
     }
 
     if (selection.credentialRef.startsWith("secret:")) {
-      if (selection.provider !== provider) return undefined;
       const resolved = await resolveCredentialRef(selection.credentialRef, { secretsPath: opts.secretsPath });
       return resolved.ok ? resolved.value : undefined;
     }
@@ -80,17 +94,28 @@ export function getCaptureSelection(config: ParaUserConfig): ModelSelection {
   return config.models.capture;
 }
 
-export async function createPiModelRegistry(): Promise<{ authStorage: AuthStorageLike; modelRegistry: ModelRegistryLike } | null> {
+export async function createPiModelServices(
+  options: { authPath?: string } = {},
+): Promise<PiModelServices | null> {
   try {
     const mod = await import("@earendil-works/pi-coding-agent");
-    const typed = mod as unknown as {
-      AuthStorage?: { create(): AuthStorageLike };
-      ModelRegistry?: { create(authStorage: AuthStorageLike): ModelRegistryLike };
+    const runtime = await mod.ModelRuntime.create({ authPath: options.authPath, allowModelNetwork: false });
+    const modelRegistry = new mod.ModelRegistry(runtime);
+    await modelRegistry.refresh();
+    return {
+      modelRegistry,
+      credentials: {
+        hasStoredCredential: (provider) => Boolean(mod.readStoredCredential(provider, options.authPath)),
+        getApiKey: async (provider) => {
+          if (!mod.readStoredCredential(provider, options.authPath)) return undefined;
+          return (await runtime.getAuth(provider))?.auth.apiKey;
+        },
+      },
     };
-    if (!typed.AuthStorage || !typed.ModelRegistry) return null;
-    const authStorage = typed.AuthStorage.create();
-    return { authStorage, modelRegistry: typed.ModelRegistry.create(authStorage) };
   } catch {
     return null;
   }
 }
+
+/** @deprecated Use createPiModelServices. */
+export const createPiModelRegistry = createPiModelServices;

package/src/tools.ts

@@ -860,13 +860,23 @@ function createMoveExecute(
 
 // -- Factory: wiki_lint execute ----------------------------------------------
 
-function createLintExecute(wikiDir: string) {
+function createLintExecute(
+  wikiDir: string,
+  store: QMDStore,
+  markDirty: () => void,
+  getLintConfig?: () => { autoFix: boolean; staleDays: number },
+) {
   return async (
     params: { autoFix?: boolean },
   ): Promise<AgentToolResult<WikiLintDetails>> => {
+    const configured = getLintConfig?.();
     const report = await lintWiki(wikiDir, {
-      autoFix: params.autoFix ?? true,
+      autoFix: params.autoFix ?? configured?.autoFix ?? true,
+      staleDays: configured?.staleDays ?? 90,
     });
+    if (report.fixed.length > 0) {
+      scheduleWikiMaintenance(wikiDir, store, markDirty);
+    }
 
     const { issues, fixed, stats } = report;
 
@@ -1057,6 +1067,7 @@ export function registerTools(
   getScope: () => ProjectScope,
   markDirty: () => void,
   getGraphBoost?: () => boolean,
+  getLintConfig?: () => { autoFix: boolean; staleDays: number },
 ): void {
   const ingestExec = createIngestExecute(wikiDir, store, getScope);
   const queryExec = createQueryExecute(wikiDir, store, getScope, getGraphBoost);
@@ -1064,7 +1075,7 @@ export function registerTools(
   const editExec = createEditExecute(wikiDir, store, markDirty);
   const readExec = createReadExecute(wikiDir);
   const moveExec = createMoveExecute(wikiDir, store, markDirty);
-  const lintExec = createLintExecute(wikiDir);
+  const lintExec = createLintExecute(wikiDir, store, markDirty, getLintConfig);
   const migrateExec = createMigrateExecute(wikiDir);
   const summarizeExec = createSummarizeExecute(wikiDir, getScope);
 
@@ -1306,7 +1317,8 @@ export function registerTools(
       try { return await lintExec(params); } finally { ctx.ui.setStatus("pi-para", undefined); }
     },
     renderCall(args, theme) {
-      const mode = args.autoFix === false ? "report-only" : "auto-fix";
+      const configuredAutoFix = getLintConfig?.().autoFix ?? true;
+      const mode = (args.autoFix ?? configuredAutoFix) ? "auto-fix" : "report-only";
       return new Text(
         theme.fg("toolTitle", theme.bold("wiki_lint ")) +
           theme.fg("muted", `[${mode}]`),