@visual-z/xeno 0.1.4 → 0.2.0

package/src/store/packages.ts

@@ -0,0 +1,98 @@
+/** Package storage is local metadata; only runtime/package-manager may install sources. */
+import { mkdir, stat } from "node:fs/promises";
+import { join, resolve, relative, isAbsolute, sep } from "node:path";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
+import { readJsonFile } from "./config.ts";
+import { atomicWrite } from "./atomic.ts";
+import { serialized } from "./serial.ts";
+import { packageConfig, packageDeclaration, parsePackageSource, type PackageDeclaration, type PackageSource } from "../core/packages.ts";
+import type { ResourceKind } from "../core/resource-selection.ts";
+
+export type PackageScope = "user" | "project" | "cli";
+export interface PackageRecord { source: string; identity: string; path: string; version?: string; revision?: string }
+export interface PackageRoot {
+  source: PackageSource; declaration: Exclude<PackageDeclaration,string>; scope: PackageScope; base: string;
+  root?: string; delta?: Exclude<PackageDeclaration,string>; trusted: boolean;
+}
+export function packageSource(source: string, base: string): PackageSource {
+  return parsePackageSource(source, path => resolve(base, path.startsWith("~/") ? join(homedir(),path.slice(2)) : path === "~" ? homedir() : path));
+}
+export function packageKey(source: PackageSource): string {
+  // Config identity omits versions, but installed references must retain them:
+  // publishing a new pin cannot invalidate the old declaration before its atomic write.
+  const version=source.kind==="npm"?source.version:source.kind==="git"?source.ref:undefined;
+  return createHash("sha256").update(source.id+"\0"+(version??"")).digest("hex");
+}
+export function packageHome(base: string): string { return join(base,"packages"); }
+export function managedPackagePath(base: string, path: string): string {
+  const home = packageHome(base), target = resolve(home,path), rel = relative(home,target);
+  if (!rel || rel === ".." || rel.startsWith(".." + sep) || isAbsolute(rel)) throw Error("Package path escapes its managed directory");
+  return target;
+}
+export async function packageRecords(base: string): Promise<Record<string, PackageRecord>> {
+  const read = await readJsonFile<Record<string,PackageRecord>>(join(packageHome(base),"installed.json"));
+  if (read.error) throw Error(read.error);
+  if (read.value && (typeof read.value !== "object" || Array.isArray(read.value))) throw Error("Invalid package installation index");
+  const records=read.value ?? {};
+  for(const record of Object.values(records)) {
+    if (!record || typeof record.source !== "string" || typeof record.identity !== "string" || typeof record.path !== "string") throw Error("Invalid package installation entry");
+    managedPackagePath(base,record.path);
+  }
+  return records;
+}
+export async function savePackageRecord(base: string, source: PackageSource, record: PackageRecord | undefined): Promise<void> {
+  const path=join(packageHome(base),"installed.json");
+  await serialized(path,async()=>{const records=await packageRecords(base); if(record) records[packageKey(source)]=record; else delete records[packageKey(source)]; await mkdir(packageHome(base),{recursive:true}); await atomicWrite(path,JSON.stringify(records,null,2)+"\n");});
+}
+export async function removePackageRecords(base:string,identity:string):Promise<string[]> {
+  const path=join(packageHome(base),"installed.json");
+  return serialized(path,async()=>{const records=await packageRecords(base),keys=Object.keys(records).filter(key=>records[key]!.identity===identity);for(const key of keys)delete records[key];await mkdir(packageHome(base),{recursive:true});await atomicWrite(path,JSON.stringify(records,null,2)+"\n");return keys;});
+}
+export async function installedPackage(source: PackageSource, base: string): Promise<string | undefined> {
+  if(source.kind==="local") return await stat(source.path).then(()=>source.path,()=>undefined);
+  const record=(await packageRecords(base))[packageKey(source)];
+  if (!record || record.identity!==source.id) return undefined;
+  const installed=packageSource(record.source,base);
+  if(source.kind==="npm"&&(installed.kind!=="npm"||installed.version!==source.version)||source.kind==="git"&&(installed.kind!=="git"||installed.ref!==source.ref))return undefined;
+  const path=managedPackagePath(base,record.path); return await stat(path).then(s=>s.isDirectory()?path:undefined,()=>undefined);
+}
+export async function configuredPackages(base: string): Promise<PackageDeclaration[]> {
+  const read=await readJsonFile<Record<string,unknown>>(join(base,"settings.json")); if(read.error)throw Error(read.error);
+  if(read.value!==null&&(typeof read.value!=="object"||Array.isArray(read.value)))throw Error("Settings must be an object");
+  const list=read.value?.["packages"] ?? []; if(!Array.isArray(list)||!list.every(packageDeclaration))throw Error("Invalid packages configuration"); return list;
+}
+export async function savePackageDeclaration(base: string, source: PackageSource, declaration: PackageDeclaration | undefined): Promise<void> {
+  const file=join(base,"settings.json");
+  await serialized(file,async()=>{
+    const read=await readJsonFile<Record<string,unknown>>(file); if(read.error)throw Error(read.error);
+    if(read.value!==null&&(typeof read.value!=="object"||Array.isArray(read.value)))throw Error("Settings must be an object");
+    const previous=read.value?.["packages"]??[]; if(!Array.isArray(previous)||!previous.every(packageDeclaration))throw Error("Invalid packages configuration");
+    const packages=previous.filter(entry=>packageSource(packageConfig(entry).source,base).id!==source.id);
+    if(declaration!==undefined)packages.push(declaration);
+    await mkdir(base,{recursive:true}); await atomicWrite(file,JSON.stringify({...read.value,packages},null,2)+"\n");
+  });
+}
+export async function packageRoots(user: readonly PackageDeclaration[], project: readonly PackageDeclaration[], opts:{userDir:string;projectDir:string;trusted:boolean}, diagnostics:string[]):Promise<PackageRoot[]> {
+  const roots=new Map<string,PackageRoot>();
+  for(const scope of ["user","project"] as const) for(const entry of scope==="user"?user:project) {
+    try {
+      const declaration=packageConfig(entry),base=scope==="user"?opts.userDir:opts.projectDir,source=packageSource(declaration.source,base),existing=roots.get(source.id);
+      if(scope==="project"&&existing&&(!opts.trusted||declaration.autoload===false)) { if(opts.trusted)existing.delta=declaration; continue; }
+      const root=await installedPackage(source,base);
+      if(!root)diagnostics.push(`Package ${source.source} is not installed; run xeno install ${source.source}${scope==="project"?" --local":""}`);
+      roots.set(source.id,{source,declaration,scope,base,...(root?{root}:{}),trusted:scope==="user"||opts.trusted});
+    } catch(error){diagnostics.push(String(error));}
+  }
+  return [...roots.values()];
+}
+export async function packageManifest(root: string): Promise<Partial<Record<ResourceKind, readonly string[]>>> {
+  if(await stat(root).then(s=>s.isFile(),()=>false)) return {extensions:[root],skills:[],prompts:[],themes:[]};
+  const read=await readJsonFile<{xeno?:unknown;pi?:unknown}>(join(root,"package.json"));if(read.error)throw Error(read.error);
+  const value=read.value?.xeno??read.value?.pi;
+  if(value===undefined)return {extensions:["extensions"],skills:["skills"],prompts:["prompts"],themes:["themes"]};
+  if(!value||typeof value!=="object"||Array.isArray(value))throw Error("Invalid package resource manifest");
+  const result:Partial<Record<ResourceKind,readonly string[]>>={};
+  for(const kind of ["extensions","skills","prompts","themes"] as const){const paths=(value as Record<string,unknown>)[kind]??[];if(!Array.isArray(paths)||paths.some(path=>typeof path!=="string"))throw Error("Invalid package manifest " + kind);result[kind]=paths;}
+  return result;
+}

package/src/store/recovery.ts

@@ -34,6 +34,14 @@ export async function recoverCut(dir: string, cursor: Cursor): Promise<Cursor> {
     next_node: Math.max(cursor.next_node, cut.next_node + 1, ...nodes.map((n) => n + 1)),
     model: cut.next_model ?? cursor.model, updated_at: cut.at,
   };
+  // Old cut records did not identify providers. Do not carry the source's
+  // provider onto a different legacy model and manufacture an identity.
+  if (cut.next_provider !== undefined) next.provider = cut.next_provider;
+  else if (next.model !== cursor.model) delete next.provider;
+  if (cut.next_thinking !== undefined) next.thinking = cut.next_thinking;
+  if (cut.next_context_ref !== undefined) next.context_ref = cut.next_context_ref;
+  delete next.at_event;
+  delete next.needs_model_checkpoint;
   await writeCursor(dir, next);
   return next;
 }

package/src/store/resource-index.ts

@@ -0,0 +1,170 @@
+/** One resource inventory for loading and configuration; paths carry their declaring scope. */
+import { readdir, realpath, stat, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve, sep } from "node:path";
+import { configDir, readJsonFile } from "./config.ts";
+import { atomicWrite } from "./atomic.ts";
+import { serialized } from "./serial.ts";
+import { parseSettings, type Settings } from "../core/settings.ts";
+import { parseResourcePattern, resourceOverride, updateResourcePatterns, type ResourceEntry, type ResourceKind, type ResourceOverride } from "../core/resource-selection.ts";
+import { packageResourceEnabled, packageConfig } from "../core/packages.ts";
+import { packageRoots, packageManifest, packageSource, configuredPackages, savePackageDeclaration, type PackageRoot } from "./packages.ts";
+
+export interface ResourceOptions {
+  workspace: string; trusted: boolean; configDir?: string;
+  noSkills?: boolean; noPromptTemplates?: boolean;
+  noThemes?: boolean; themePaths?: readonly string[];
+  skillPaths?: readonly string[]; promptTemplatePaths?: readonly string[];
+  noExtensions?: boolean; extensionPaths?: readonly string[];
+  packagePaths?: readonly { source: string; path: string }[];
+  local?: boolean;
+}
+export interface ResourceIndex {
+  entries: ResourceEntry[]; diagnostics: string[]; user: Settings; project: Settings;
+  userDir: string; projectDir: string; trusted: boolean;
+}
+export function resourcePath(path: string, base: string): string {
+  const expanded = path === "~" ? homedir() : path.startsWith("~/") ? join(homedir(), path.slice(2)) : path;
+  return resolve(base, expanded);
+}
+function matches(path: string, pattern: string, base: string): boolean {
+  const absolute = resourcePath(pattern, base);
+  return path === absolute || path.startsWith(absolute + sep) || new Bun.Glob(absolute.replace(/\\/g, "/")).match(path.replace(/\\/g, "/"));
+}
+export async function discoverResources(opts: ResourceOptions): Promise<ResourceIndex> {
+  const userDir = opts.configDir ?? configDir(), projectDir = join(opts.workspace, ".xeno");
+  const index: ResourceIndex = { entries: [], diagnostics: [], user: {}, project: {}, userDir, projectDir, trusted: opts.trusted };
+  for (const scope of ["user", "project"] as const) {
+    const file = join(scope === "user" ? userDir : projectDir, "settings.json");
+    const read = await readJsonFile<unknown>(file);
+    if (read.error) index.diagnostics.push(read.error);
+    const parsed = parseSettings(read.value);
+    index.diagnostics.push(...parsed.diagnostics.map(message => `${file}: ${message}`));
+    // Global-only policy cannot be granted by the project it would trust.
+    const { defaultProjectTrust: _ignored, ...project } = parsed.settings;
+    index[scope] = scope === "project" ? project : parsed.settings;
+  }
+  const found = new Map<string, ResourceEntry>();
+  const packages=await packageRoots(index.user.packages??[],index.project.packages??[],index,index.diagnostics);
+  const explicitPackageRoots=new Set<string>();
+  for(const source of opts.extensionPaths??[]) {
+    const path=resourcePath(source,opts.workspace);
+    const manifest=await readJsonFile<{pi?:unknown;xeno?:unknown}>(join(path,"package.json"));
+    const conventional=(await Promise.all(["extensions","skills","prompts","themes"].map(kind=>stat(join(path,kind)).then(s=>s.isDirectory(),()=>false)))).some(Boolean);
+    if(manifest.value?.pi||manifest.value?.xeno||conventional) {
+      explicitPackageRoots.add(path); packages.push({source:packageSource(source,opts.workspace),declaration:{source},scope:"cli",base:opts.workspace,root:path,trusted:true});
+    }
+  }
+  for(const entry of opts.packagePaths??[])packages.push({source:packageSource(entry.source,opts.workspace),declaration:{source:entry.source},scope:"cli",base:opts.workspace,root:entry.path,trusted:true});
+  for (const kind of ["skills", "prompts", "themes", "extensions"] as const) {
+    const disabled = kind === "skills" ? opts.noSkills : kind === "prompts" ? opts.noPromptTemplates : kind === "extensions" ? opts.noExtensions : opts.noThemes;
+    for (const scope of ["user", "project"] as const) {
+      const base = scope === "user" ? userDir : projectDir;
+      const sources = [join(base, kind), ...(index[scope][kind] ?? []).map(parseResourcePattern).filter(p => p.enabled).map(p => resourcePath(p.pattern, base))];
+      for (const source of [...new Set(sources)]) for (const path of await resourceFiles(source, kind, index.diagnostics, source !== join(base, kind))) {
+        // A project override of an inherited path does not transfer resource ownership.
+        if (found.has(kind + ":" + path)) continue;
+        const global = resourceOverride(index.user[kind] ?? [], pattern => matches(path, pattern, userDir));
+        const local = resourceOverride(index.project[kind] ?? [], pattern => matches(path, pattern, projectDir));
+        const inherited = !disabled && global !== "skip";
+        const trusted = scope === "user" || opts.trusted;
+        const enabled = trusted && !disabled && (opts.trusted && local !== "inherit" ? local === "load" : inherited);
+        found.set(kind + ":" + path, { kind, path, name: kind === "skills" ? basename(dirname(path)) : basename(path).replace(/\.[^.]+$/, ""),
+          scope, source, enabled, inherited, override: local, trusted });
+      }
+    }
+    const cli = kind === "skills" ? opts.skillPaths : kind === "prompts" ? opts.promptTemplatePaths : kind === "extensions" ? opts.extensionPaths : opts.themePaths;
+    for (const source of cli ?? []) for (const path of explicitPackageRoots.has(resourcePath(source,opts.workspace)) ? [] : await resourceFiles(resourcePath(source, opts.workspace), kind, index.diagnostics, true)) {
+      found.set(kind + ":" + path, { kind, path, name: kind === "skills" ? basename(dirname(path)) : basename(path).replace(/\.[^.]+$/, ""),
+        scope: "cli", source, enabled: true, inherited: true, override: "inherit", trusted: true });
+    }
+    for(const pkg of packages) await addPackageResources(found,index,pkg,kind,!!disabled);
+  }
+  index.entries = [...found.values()];
+  return index;
+}
+
+async function addPackageResources(found:Map<string,ResourceEntry>,index:ResourceIndex,pkg:PackageRoot,kind:ResourceKind,disabled:boolean):Promise<void> {
+  if(!pkg.root)return;
+  try {
+    const manifest=await packageManifest(pkg.root),patterns=manifest[kind]??[],candidates=new Set<string>();
+    for(const pattern of patterns.map(parseResourcePattern).filter(p=>p.enabled)) {
+      for(const path of await resourceFiles(resourcePath(pattern.pattern,pkg.root),kind,index.diagnostics))candidates.add(path);
+    }
+    for(const path of candidates) {
+      const match=(pattern:string,exact=false)=>exact?path===resourcePath(pattern,pkg.root!):matches(path,pattern,pkg.root!);
+      // The package manifest is the outer boundary; settings cannot expose undeclared files.
+      if(!packageResourceEnabled(patterns,match))continue;
+      const inherited=packageResourceEnabled(pkg.declaration[kind],match)&&pkg.declaration.autoload!==false;
+      const delta=packageResourceEnabled(pkg.delta?.[kind],match,inherited);
+      const global=resourceOverride(index.user[kind]??[],pattern=>matches(path,pattern,index.userDir));
+      const flat=resourceOverride(index.project[kind]??[],pattern=>matches(path,pattern,index.projectDir));
+      const local=flat!=="inherit"?flat:resourceOverride(pkg.delta?.[kind]??[],match);
+      const base=inherited&&global!=="skip",enabled=pkg.scope==="cli"||pkg.trusted&&!disabled&&(index.trusted&&local!=="inherit"?local==="load":delta&&global!=="skip");
+      if(found.get(kind+":"+path)?.scope==="cli")continue;
+      found.set(kind+":"+path,{kind,path,name:kind==="skills"?basename(dirname(path)):basename(path).replace(/\.[^.]+$/,""),scope:pkg.scope,source:pkg.source.source,
+        enabled,inherited:base,override:local,trusted:pkg.trusted,package:{source:pkg.source.source,identity:pkg.source.id,root:pkg.root}});
+    }
+  }catch(error){index.diagnostics.push(`${pkg.source.source}: ${String(error)}`);}
+}
+
+/** Iterative realpath tracking allows linked resource folders without following cycles. */
+async function resourceFiles(source: string, kind: ResourceKind, diagnostics: string[], required = false): Promise<string[]> {
+  const files: string[] = [], seen = new Set<string>(), stack = [source];
+  if (/[*?{[]/.test(source)) {
+    try { return [...new Bun.Glob(source).scanSync({ absolute: true, onlyFiles: true })].sort(); }
+    catch (error) { diagnostics.push(`${source}: ${String(error)}`); return []; }
+  }
+  while (stack.length) {
+    const path = stack.pop()!;
+    try {
+      const canonical = await realpath(path); if (seen.has(canonical)) continue; seen.add(canonical);
+      const info = await stat(path);
+      if (info.isDirectory()) {
+        if (kind === "extensions" && path !== source) {
+          const manifest = await readJsonFile<{ xeno?: { extensions?: string[] }; pi?: { extensions?: string[] } }>(join(path, "package.json"));
+          const declared = manifest.value?.xeno?.extensions ?? manifest.value?.pi?.extensions;
+          if (declared) { for (const entry of declared) stack.push(resolve(path, entry)); continue; }
+          for (const ext of ["ts", "js", "mts", "mjs"]) {
+            const entry = join(path, `index.${ext}`);
+            if (await stat(entry).then(s => s.isFile(), () => false)) { stack.push(entry); break; }
+          }
+          continue;
+        }
+        const entries = (await readdir(path, { withFileTypes: true })).sort((a, b) => b.name.localeCompare(a.name));
+        for (const entry of entries) if (!entry.name.startsWith(".") && entry.name !== "node_modules" && (kind === "skills" || kind === "extensions" || !entry.isDirectory())) stack.push(join(path, entry.name));
+      } else if (info.isFile() && (kind === "skills" ? basename(path) === "SKILL.md" || path === source : kind === "extensions" ? /\.[cm]?[jt]s$/.test(path) : path.endsWith(kind === "themes" ? ".json" : ".md"))) files.push(resolve(path));
+    } catch (error) { if ((error as { code?: string }).code !== "ENOENT" || required && path === source) diagnostics.push(`${path}: ${String(error)}`); }
+  }
+  return files;
+}
+export async function setResourceOverride(index: ResourceIndex, entry: ResourceEntry, scope: "user" | "project", state: ResourceOverride): Promise<void> {
+  if (entry.scope === "cli") throw new Error("Explicit command-line resources are controlled by their flags");
+  if (scope === "user" && entry.scope !== "user") throw new Error("Project resources are configured in project scope");
+  const base = scope === "user" ? index.userDir : index.projectDir;
+  if(entry.package) {
+    const metadata=entry.package,previous=(await configuredPackages(base)).find(value=>packageSource(packageConfig(value).source,base).id===metadata.identity);
+    const source=metadata.identity.startsWith("local:")?metadata.root:metadata.source;
+    const config=previous?{...packageConfig(previous)}:{source,...(scope==="project"&&entry.scope==="user"?{autoload:false}:{})};
+    const old=config[entry.kind],patterns=old?.length===0&&state!=="inherit"?["!**/*",...(old??[])]:old??[];
+    const selected=updateResourcePatterns(patterns,entry.path,state,pattern=>resourcePath(pattern,metadata.root)===entry.path);
+    if(selected.length)config[entry.kind]=selected;else delete config[entry.kind];
+    await savePackageDeclaration(base,packageSource(source,base),config);return;
+  }
+  const file = join(base, "settings.json");
+  await serialized(file, async () => {
+    const { value, error } = await readJsonFile<Record<string, unknown>>(file);
+    if (error) throw new Error(error);
+    if (value !== null && (typeof value !== "object" || Array.isArray(value))) throw new Error("Settings must be an object");
+    const previous = value?.[entry.kind];
+    if (previous !== undefined && (!Array.isArray(previous) || previous.some(p => typeof p !== "string"))) throw new Error("Resource paths must be strings");
+    const patterns = updateResourcePatterns((previous ?? []) as string[], entry.path, state, pattern => resourcePath(pattern, base) === entry.path);
+    await mkdir(base, { recursive: true });
+    await atomicWrite(file, JSON.stringify({ ...value, [entry.kind]: patterns }, null, 2) + "\n");
+  });
+}
+
+export function themeResourcePath(index: ResourceIndex, name: string): string | undefined {
+  const candidates = index.entries.filter(entry => entry.kind === "themes" && (entry.name === name || entry.path === name));
+  return candidates.findLast(entry => entry.enabled)?.path ?? (candidates.length ? "dark" : undefined);
+}

package/src/store/resources.ts

@@ -9,11 +9,11 @@
  * Theme and keymap are UI state and are not logged.
  */
 
-import { readdir, readFile, stat } from "node:fs/promises";
-import type { Dirent } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { watch } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { configDir, readJsonFile, writeJsonFile, settingsPath } from "./config.ts";
-import { projectSettingsPath } from "./trust.ts";
+import { discoverResources, themeResourcePath, type ResourceIndex } from "./resource-index.ts";
 import { parseSkill, type Skill } from "../core/skills.ts";
 import { parsePromptTemplate, type PromptTemplate } from "../core/prompts.ts";
 import {
@@ -28,9 +28,7 @@ import {
 } from "../core/keymap.ts";
 import {
   defaultSettings,
-  explicitSettings,
   mergeSettings,
-  parseSettings,
   settingsToWrite,
   type Settings,
 } from "../core/settings.ts";
@@ -40,6 +38,9 @@ export interface LoadUiOptions {
   readonly trusted: boolean;
   /** `--theme <name|path>`, wins over settings. */
   readonly theme?: string;
+  readonly noThemes?: boolean;
+  readonly themePaths?: readonly string[];
+  readonly tuiMode?: "regular" | "fullscreen";
 }
 
 export interface UiResources {
@@ -62,52 +63,60 @@ export function userThemePath(name: string): string {
   return join(configDir(), "themes", `${name}.json`);
 }
 
-export async function loadUiResources(opts: LoadUiOptions): Promise<UiResources> {
-  const diagnostics: string[] = [];
-
-  const userRead = await readJsonFile<unknown>(settingsPath());
-  if (userRead.error) diagnostics.push(userRead.error);
-  const userParsed = parseSettings(userRead.value);
-  diagnostics.push(...userParsed.diagnostics);
-  const userOverrides = explicitSettings(userRead.value, userParsed.settings);
+export async function loadUiResources(opts: LoadUiOptions, resources?: ResourceIndex): Promise<UiResources> {
+  const index = resources ?? await discoverResources(opts);
+  const diagnostics = [...index.diagnostics];
+  const userOverrides = index.user;
 
-  let projectSettings: Settings = {};
-  if (opts.trusted) {
-    const projectRead = await readJsonFile<unknown>(projectSettingsPath(opts.workspace));
-    if (projectRead.error) diagnostics.push(projectRead.error);
-    if (projectRead.value !== null) {
-      const parsed = parseSettings(projectRead.value);
-      diagnostics.push(...parsed.diagnostics);
-      projectSettings = parsed.settings;
-    }
-  }
-
-  const cli: Settings = opts.theme !== undefined && opts.theme.length > 0 ? { theme: opts.theme } : {};
+  const cli: Settings = { ...(opts.theme ? { theme: opts.theme } : {}), ...(opts.tuiMode ? { tuiMode: opts.tuiMode } : {}) };
   const settings = mergeSettings({
     builtin: defaultSettings(),
-    user: userParsed.settings,
-    project: projectSettings,
+    user: index.user,
+    project: opts.trusted ? index.project : {},
     cli,
   });
 
-  const theme = await resolveTheme(settings.theme ?? "dark", diagnostics);
+  const theme = await resolveTheme(selectedThemePath(index, settings.theme ?? "dark", opts.noThemes), diagnostics);
   const keymap = await resolveKeymap(opts.workspace, opts.trusted, diagnostics);
 
   return { settings, theme, keymap, diagnostics, userOverrides };
 }
 
+/** Loading and watching share enablement; a disabled resource must not reactivate on file changes. */
+export function selectedThemePath(index: ResourceIndex, name: string, noThemes = false): string {
+  const source = themeResourcePath(index, name);
+  const disabled = !source && (noThemes || index.entries.some(entry => entry.kind === "themes" && (entry.name === name || entry.path === name) && !entry.enabled));
+  return disabled && !["dark", "light", "system", "auto"].includes(name) ? "dark" : source ?? name;
+}
+
 export async function writeUserSettings(overrides: Partial<Settings>): Promise<void> {
   const { value, error } = await readJsonFile<unknown>(settingsPath());
   const prev =
     error === null && typeof value === "object" && value !== null && !Array.isArray(value)
       ? (value as { readonly [k: string]: unknown })
       : {};
-  const next = { ...prev, ...settingsToWrite(overrides) };
+  const next = { ...prev, ...settingsToWrite(overrides),
+    ...(overrides.terminal ? { terminal: { ...(typeof prev["terminal"] === "object" ? prev["terminal"] : {}), ...overrides.terminal } } : {}),
+    ...(overrides.modelThinkingLevels ? { modelThinkingLevels: { ...(typeof prev["modelThinkingLevels"] === "object" ? prev["modelThinkingLevels"] : {}), ...overrides.modelThinkingLevels } } : {}),
+    ...Object.fromEntries((["images", "markdown"] as const).filter(key => overrides[key]).map(key => [key, { ...(typeof prev[key] === "object" ? prev[key] : {}), ...overrides[key] }])),
+  };
   await writeJsonFile(settingsPath(), next, false);
 }
 
-async function resolveTheme(spec: string, diagnostics: string[]): Promise<Theme> {
+/** Remove only the user's override; project defaults and unrelated keys retain their ownership. */
+export async function removeModelThinkingOverride(identity: string): Promise<void> {
+  const { value, error } = await readJsonFile<Record<string, unknown>>(settingsPath());
+  if (error) throw new Error(error);
+  if (!value || typeof value !== "object" || Array.isArray(value)) return;
+  const levels = value["modelThinkingLevels"];
+  if (!levels || typeof levels !== "object" || Array.isArray(levels)) return;
+  const next = Object.fromEntries(Object.entries(levels).filter(([key]) => key !== identity));
+  await writeJsonFile(settingsPath(), { ...value, modelThinkingLevels: next }, false);
+}
+
+export async function resolveTheme(spec: string, diagnostics: string[]): Promise<Theme> {
   if (spec === "dark" || spec === "light") return builtinTheme(spec);
+  if (spec === "system" || spec === "auto") return { ...builtinTheme("dark"), name: spec };
 
   const path = looksLikePath(spec) ? spec : userThemePath(spec);
   const { value, error } = await readJsonFile<unknown>(path);
@@ -124,8 +133,37 @@ async function resolveTheme(spec: string, diagnostics: string[]): Promise<Theme>
   return parsed.theme;
 }
 
+/** Directory watching survives atomic editor saves; malformed edits keep the last valid palette. */
+export function watchTheme(spec: string, apply: (theme: Theme) => void, report: (message: string) => void): () => void {
+  if (["dark", "light", "system", "auto"].includes(spec)) return () => {};
+  const file = looksLikePath(spec) ? spec : userThemePath(spec);
+  let timer: ReturnType<typeof setTimeout> | undefined, closed = false;
+  const changed = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => { void (async () => {
+      const diagnostics: string[] = [];
+      const theme = await resolveTheme(spec, diagnostics);
+      if (closed) return;
+      if (diagnostics.length) report(diagnostics.join("\n")); else apply(theme);
+    })(); }, 80);
+  };
+  try {
+    const watcher = watch(dirname(file), { persistent: false }, (_event, name) => { if (!name || String(name) === basename(file)) changed(); });
+    watcher.on("error", error => { if (!closed) report(String(error)); });
+    return () => { closed = true; if (timer) clearTimeout(timer); watcher.close(); };
+  } catch (error) { report(String(error)); return () => { closed = true; }; }
+}
+
+export async function discoverThemes(index?: ResourceIndex): Promise<string[]> {
+  if (index) return [...new Set(["dark", "light", "system", "auto", ...index.entries.filter(entry => entry.kind === "themes" && entry.enabled).map(entry => entry.name)])];
+  let names: string[] = [];
+  try { names = (await readdir(join(configDir(), "themes"))).filter(name => name.endsWith(".json")).map(name => name.slice(0, -5)).sort(); }
+  catch (error) { if (!isNotFound(error)) throw error; }
+  return [...new Set(["dark", "light", "system", "auto", ...names])];
+}
+
 async function resolveKeymap(workspace: string, trusted: boolean, diagnostics: string[]): Promise<Keymap> {
-  let map = defaultKeymap();
+  let map = defaultKeymap(process.platform === "win32" ? "win32" : process.env["WSL_DISTRO_NAME"] || process.env["WSL_INTEROP"] ? "wsl" : "posix");
 
   const userRead = await readJsonFile<unknown>(keybindingsPath());
   if (userRead.error) diagnostics.push(userRead.error);
@@ -171,7 +209,7 @@ export interface LoadedTextResources {
  * Discover skills and prompt templates. Project directories load only when
  * trusted, matching `.xeno/settings.json`. A bad file is named and skipped.
  */
-export async function loadTextResources(opts: LoadTextOptions): Promise<LoadedTextResources> {
+export async function loadTextResources(opts: LoadTextOptions, resources?: ResourceIndex): Promise<LoadedTextResources> {
   const diagnostics: string[] = [];
   const skills = new Map<string, Skill>();
   const prompts = new Map<string, PromptTemplate>();
@@ -195,24 +233,11 @@ export async function loadTextResources(opts: LoadTextOptions): Promise<LoadedTe
     prompts.set(prompt.name, prompt);
   };
 
-  if (opts.noSkills !== true) {
-    await loadSkillsFromDir(join(opts.configDir, "skills"), addSkill, diagnostics);
-    if (opts.trusted) {
-      await loadSkillsFromDir(join(opts.workspace, ".xeno", "skills"), addSkill, diagnostics);
-    }
-  }
-  for (const path of opts.skillPaths ?? []) {
-    await loadSkillsFromPath(path, addSkill, diagnostics);
-  }
-
-  if (opts.noPromptTemplates !== true) {
-    await loadPromptsFromDir(join(opts.configDir, "prompts"), addPrompt, diagnostics);
-    if (opts.trusted) {
-      await loadPromptsFromDir(join(opts.workspace, ".xeno", "prompts"), addPrompt, diagnostics);
-    }
-  }
-  for (const path of opts.promptTemplatePaths ?? []) {
-    await loadPromptsFromPath(path, addPrompt, diagnostics);
+  const index = resources ?? await discoverResources(opts);
+  diagnostics.push(...index.diagnostics);
+  for (const entry of index.entries) if (entry.enabled) {
+    if (entry.kind === "skills") await absorbSkill(entry.path, addSkill, diagnostics);
+    if (entry.kind === "prompts") await absorbPrompt(entry.path, addPrompt, diagnostics);
   }
 
   return {
@@ -222,85 +247,6 @@ export async function loadTextResources(opts: LoadTextOptions): Promise<LoadedTe
   };
 }
 
-async function loadSkillsFromDir(
-  dir: string,
-  add: (skill: Skill) => void,
-  diagnostics: string[],
-): Promise<void> {
-  const files: string[] = [];
-  await collectSkillFiles(dir, files, diagnostics);
-  for (const file of files) await absorbSkill(file, add, diagnostics);
-}
-
-async function loadSkillsFromPath(
-  path: string,
-  add: (skill: Skill) => void,
-  diagnostics: string[],
-): Promise<void> {
-  const info = await statKind(path);
-  if (info === "missing") {
-    diagnostics.push(`skill path not found: ${path}`);
-    return;
-  }
-  if (info === "file") {
-    await absorbSkill(path, add, diagnostics);
-    return;
-  }
-  await loadSkillsFromDir(path, add, diagnostics);
-}
-
-async function loadPromptsFromDir(
-  dir: string,
-  add: (prompt: PromptTemplate) => void,
-  diagnostics: string[],
-): Promise<void> {
-  let entries: Dirent[];
-  try {
-    entries = await readdir(dir, { withFileTypes: true });
-  } catch (err) {
-    if (isNotFound(err)) return;
-    diagnostics.push(`${dir}: ${errMessage(err)}`);
-    return;
-  }
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.toLowerCase().endsWith(".md")) continue;
-    await absorbPrompt(join(dir, entry.name), add, diagnostics);
-  }
-}
-
-async function loadPromptsFromPath(
-  path: string,
-  add: (prompt: PromptTemplate) => void,
-  diagnostics: string[],
-): Promise<void> {
-  const info = await statKind(path);
-  if (info === "missing") {
-    diagnostics.push(`prompt template not found: ${path}`);
-    return;
-  }
-  if (info === "dir") {
-    await loadPromptsFromDir(path, add, diagnostics);
-    return;
-  }
-  await absorbPrompt(path, add, diagnostics);
-}
-
-async function collectSkillFiles(dir: string, out: string[], diagnostics: string[]): Promise<void> {
-  let entries: Dirent[];
-  try {
-    entries = await readdir(dir, { withFileTypes: true });
-  } catch (err) {
-    if (isNotFound(err)) return;
-    diagnostics.push(`${dir}: ${errMessage(err)}`);
-    return;
-  }
-  for (const entry of entries) {
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) await collectSkillFiles(full, out, diagnostics);
-    else if (entry.isFile() && entry.name === "SKILL.md") out.push(full);
-  }
-}
-
 async function absorbSkill(
   filePath: string,
   add: (skill: Skill) => void,
@@ -343,19 +289,6 @@ async function readUtf8(path: string): Promise<string | null> {
   }
 }
 
-async function statKind(path: string): Promise<"file" | "dir" | "missing"> {
-  try {
-    const info = await stat(path);
-    return info.isDirectory() ? "dir" : "file";
-  } catch {
-    return "missing";
-  }
-}
-
 function isNotFound(err: unknown): boolean {
   return (err as { code?: string }).code === "ENOENT";
 }
-
-function errMessage(err: unknown): string {
-  return err instanceof Error ? err.message : String(err);
-}