babavoss 0.12.6 → 0.13.1

package/src/ecs/baba.ts

@@ -9,7 +9,7 @@ import type { Context } from "../kernel/context.ts";
 import { keyFields, keyField } from "./handles.ts";
 import { State, type Component, type Ask, type Resource, type Effect, type Model, type Entity, type Args, type Result, type MirrorEvent } from "./state.ts";
 import { checkPositional } from "../shell/positional.ts";
-import { render, type InterpretationSuite, type Prompt } from "../prompt/index.ts";
+import { render, type InterpretationSuite, type Prompt } from "../instructions/index.ts";
 import { routesError } from "../desktop/routes.ts";
 
 // ---- shapes --------------------------------------------------------------
@@ -105,7 +105,7 @@ export function query<const S extends Shape = {}, R = unknown, X = any>(def: { s
 /** A skill as the manifest carries it, rendered: what an agent reads when it opens it, and the calls it uses, by name. */
 export interface SkillDef { description: string; body: string; uses?: string[]; eval?: InterpretationSuite }
 /** What the baba tells agents, as the manifest carries it: its section of the context file, its skills, its hooks; the Markdown rendered. */
-export interface Promptware { context: string | null; contextEval?: InterpretationSuite; skills: Record<string, SkillDef>; hooks: HookDef[] }
+export interface Instructions { context: string | null; contextEval?: InterpretationSuite; skills: Record<string, SkillDef>; hooks: HookDef[] }
 
 /** Which harnesses get the baba's files, and Claude Code's permissions; `table` renders the contract as a table of calls; `auto` writes the files on every change. */
 export interface Harness { claude: { enabled: boolean; permissions: string[] }; codex: { enabled: boolean }; table: boolean; auto: boolean }
@@ -197,7 +197,7 @@ export const nameOf = (v: unknown): string => dataOf(v).name;
 const NAME = /^[a-z][a-zA-Z0-9-]*$/;
 const SYSTEM_NAME = /^[a-z][a-z0-9-]*$/;
 /** Words the shell keeps for itself: an action or a query may not take them. */
-export const RESERVED = new Set(["start", "stop", "status", "state", "follow", "run", "raw", "secret", "help", "mcp", "check", "install", "add-system", "serve", "promptware", "init", "babas", "service", "gui"]);
+export const RESERVED = new Set(["start", "stop", "status", "state", "follow", "run", "raw", "secret", "help", "mcp", "check", "install", "add-system", "serve", "agents", "init", "babas", "service", "gui"]);
 
 /** What a declaration makes: its handles by name, on an object with no prototype, and the model they form. */
 export interface Declared { readonly name: string; readonly refs: Readonly<Record<string, Component | Resource | Effect>>; readonly model: Model }
@@ -313,8 +313,8 @@ export interface Baba<Ss extends readonly System[] = readonly System[], K extend
   readonly $app: K;
   /** The routes of each app, as a type: what `compose<typeof baba>` asks a table of components for. */
   readonly $routes: R;
-  /** What the baba tells agents: `context(...)`, `skill(...)` and `hook(...)` from babavoss/prompt, in order. */
-  readonly promptware: readonly Prompt[];
+  /** What the baba tells agents: `context(...)`, `skill(...)` and `hook(...)` from babavoss/instructions, in order. */
+  readonly instructions: readonly Prompt[];
   /** Which harnesses get the files, and how. */
   readonly harness: Harness;
   /** Milliseconds between rounds the runtime causes on its own, for steps that need time to pass; null for a baba moved by actions and jobs. */
@@ -324,7 +324,8 @@ export interface Baba<Ss extends readonly System[] = readonly System[], K extend
   readonly queries: Record<string, QueryDef & { owner: string }>;
 }
 
-export function baba<const Ss extends readonly System[], const Sc extends readonly AppSpec[] = readonly []>(def: { systems: Ss; apps?: Sc; tick?: number; promptware?: readonly Prompt[]; harness?: HarnessInput }): Baba<Ss, Sc[number]["key"], RoutesOf<Sc>> {
+export function baba<const Ss extends readonly System[], const Sc extends readonly AppSpec[] = readonly []>(def: { systems: Ss; apps?: Sc; tick?: number; instructions?: readonly Prompt[]; harness?: HarnessInput }): Baba<Ss, Sc[number]["key"], RoutesOf<Sc>> {
+  if ("promptware" in def) throw new Error("baba({ promptware }) is gone: the agentic instructions are the .mdx files under .baba/agents/, which voss reads on its own; see the write-agentic-instructions skill");
   const harness = harnessOf(def.harness);
   if (def.tick !== undefined && !(Number.isInteger(def.tick) && def.tick > 0)) throw new Error("baba: tick is whole milliseconds, above zero");
   const model: Model = { components: [], resources: [], effects: [] };
@@ -367,7 +368,7 @@ export function baba<const Ss extends readonly System[], const Sc extends readon
   if (new Set(apps.map((v) => v.key)).size !== apps.length || apps.some((v) => !/^[a-z][a-z0-9-]*$/.test(v.key))) throw new Error("baba: app keys must be unique lowercase names");
   for (const v of apps) for (const n of v.systems ?? []) if (!systemNames.has(n)) throw new Error(`app ${v.key} shows ${n}, which is not one of the baba's systems`);
   for (const v of apps) { const e = v.routes && routesError(v.routes); if (e) throw new Error(`app ${v.key}: ${e}`); }
-  return Object.freeze({ kind: "baba", systems: def.systems, apps: apps.map((v) => ({ ...v, ...(v.systems ? { systems: [...v.systems] } : {}), ...(v.routes ? { routes: [...v.routes] } : {}) })), $app: undefined as never, $routes: undefined as never, tick: def.tick ?? null, promptware: [...(def.promptware ?? [])], harness, model, actions, queries });
+  return Object.freeze({ kind: "baba", systems: def.systems, apps: apps.map((v) => ({ ...v, ...(v.systems ? { systems: [...v.systems] } : {}), ...(v.routes ? { routes: [...v.routes] } : {}) })), $app: undefined as never, $routes: undefined as never, tick: def.tick ?? null, instructions: [...(def.instructions ?? [])], harness, model, actions, queries });
 }
 
 export function isBaba(v: unknown): v is Baba {
@@ -387,7 +388,7 @@ export function ofSystem(c: System): Baba { return baba({ systems: closureOf([c]
 export interface Manifest {
   systems: { name: string }[];
   /** What the baba tells agents, rendered: its context, its skills, its hooks; voss's own skills after the baba's. */
-  promptware: Promptware;
+  instructions: Instructions;
   harness: Harness;
   components: Record<string, { owner: string; schema: Json; accept?: true }>;
   resources: Record<string, { owner: string; schema: Json }>;
@@ -403,29 +404,38 @@ export interface Manifest {
 export interface Call { owner: string; summary: string; args: Json; positional?: string[]; result: Json }
 
 export function manifestOf(v: Baba, program = "voss baba"): Manifest {
-  const m: Manifest = { systems: v.systems.map((c) => ({ name: nameOf(c) })), promptware: { context: null, skills: {}, hooks: [] }, harness: v.harness, components: {}, resources: {}, effects: {}, actions: {}, queries: {}, tick: v.tick, apps: v.apps.map((x) => ({ ...x })) };
+  const m: Manifest = { systems: v.systems.map((c) => ({ name: nameOf(c) })), instructions: { context: null, skills: {}, hooks: [] }, harness: v.harness, components: {}, resources: {}, effects: {}, actions: {}, queries: {}, tick: v.tick, apps: v.apps.map((x) => ({ ...x })) };
   for (const c of v.model.components) m.components[c.name] = { owner: c.owner, schema: c.schema.json, ...(c.accept ? { accept: true as const } : {}) };
   for (const r of v.model.resources) m.resources[r.name] = { owner: r.owner, schema: r.schema.json };
   for (const e of v.model.effects) m.effects[e.name] = { owner: e.owner, summary: e.summary, args: e.args.json, result: e.result.json, retry: e.retry, every: e.every, repeat: e.repeat, shape: e.shape, ...(e.mirror ? { mirror: e.mirror } : {}), ...(e.event ? { event: e.event.json } : {}) };
   const call = (d: (ActionDef | QueryDef) & { owner: string }): Call => ({ owner: d.owner, summary: d.summary, args: d.args.json, ...(d.positional ? { positional: d.positional } : {}), result: d.result.json });
   for (const [n, a] of Object.entries(v.actions)) m.actions[n] = call(a);
   for (const [n, q] of Object.entries(v.queries)) m.queries[n] = call(q);
-  // The promptware renders once the contract is in the manifest, since it may refer to it.
+  // The agentic instructions renders once the contract is in the manifest, since it may refer to it.
   const refs: string[] = [];
-  m.promptware = renderPromptware(v.promptware, { manifest: m, program, refs });
-  for (const r of refs) if (!(r in m.promptware.skills)) throw new Error(`a skill says "see ${r}", which is not a skill of the baba`);
-  for (const [n, sk] of Object.entries(m.promptware.skills)) for (const u of sk.uses ?? []) if (!(u in m.actions) && !(u in m.queries)) throw new Error(`skill ${n} uses ${u}, which is not an action or query of the baba`);
-  for (const h of m.promptware.hooks) if (!(h.action in m.actions)) throw new Error(`hook on ${h.on} calls ${h.action}, which is not an action of the baba`);
+  m.instructions = renderInstructions(v.instructions, { manifest: m, program, refs });
+  for (const r of refs) if (!(r in m.instructions.skills)) throw new Error(`a skill says "see ${r}", which is not a skill of the baba`);
+  for (const [n, sk] of Object.entries(m.instructions.skills)) for (const u of sk.uses ?? []) if (!(u in m.actions) && !(u in m.queries)) throw new Error(`skill ${n} uses ${u}, which is not an action or query of the baba`);
+  for (const h of m.instructions.hooks) if (!(h.action in m.actions)) throw new Error(`hook on ${h.on} calls ${h.action}, which is not an action of the baba`);
   return m;
 }
 
-/** The baba's promptware as Markdown: the one context, each skill by name, the hooks. */
-export function renderPromptware(ps: readonly Prompt[], context: { manifest: Manifest; program: string; refs?: string[] }): Promptware {
+/** The baba with the documents voss found under .baba/agents/, after any it declares itself: what the builder hands the runtime. */
+export function instructed(v: Baba, docs: readonly Prompt[]): Baba {
+  if (!docs.length) return v;
+  return Object.freeze({ ...v, instructions: [...v.instructions, ...docs] }) as Baba;
+}
+
+/** The baba's agentic instructions as Markdown: the one context, each skill by name, the hooks. */
+export function renderInstructions(ps: readonly Prompt[], context: { manifest: Manifest; program: string; refs?: string[] }): Instructions {
   const contexts = ps.filter((p) => p.kind === "context");
   if (contexts.length > 1) throw new Error("a baba has one context(...); put every paragraph in it");
   const text = contexts[0] ? render(contexts[0].body, context) : "";
   const skills: Record<string, SkillDef> = {};
   for (const p of ps) if (p.kind === "skill") { if (p.name in skills) throw new Error(`two skills are named ${p.name}`); skills[p.name] = { description: p.description, body: render(p.body, context), uses: p.uses, ...(p.eval ? { eval: p.eval } : {}) }; }
-  const hooks = ps.filter((p) => p.kind === "hook").map((p) => ({ on: p.on, match: p.match, action: p.action, strict: p.strict }));
+  const hooks = [
+    ...(contexts[0]?.hooks ?? []).map((h) => ({ on: h.on, match: h.match ?? null, action: h.action, strict: h.strict === true })),
+    ...ps.filter((p) => p.kind === "hook").map((p) => ({ on: p.on, match: p.match, action: p.action, strict: p.strict })),
+  ];
   return { context: text || null, skills, hooks, ...(contexts[0]?.eval ? { contextEval: contexts[0].eval } : {}) };
 }

package/src/generated/build.ts

@@ -1,4 +1,4 @@
 // The commit and the moment a package was built from, stamped by the pack
 // of a release (tools/release/pack.ts) and restored after it. From a
 // checkout both are empty: the tree is the build.
-export const build = {"sha":"fe82400","at":"2026-10-08T21:33:13.250Z"};
+export const build = {"sha":"c288c8f","at":"2026-10-08T22:12:53.708Z"};

package/src/gui/gui.tsx

@@ -1,21 +1,24 @@
-// voss's GUI: voss's shell at every level. At the root, over page state: the
-// babas and the New baba wizard. At /NAME/ over the baba,
+// voss's GUI. At the root, the picker: the babas voss knows, a folder added
+// by its path, and the setup wizard of one that lacks what voss requires. At
+// /NAME/ voss's shell over the baba,
 // its apps and voss's own, the Maker, the state, the contract, the
-// promptware and the settings, as windows. One bundle, one React, served by the
+// agentic instructions and the settings, as windows. One bundle, one React, served by the
 // kernel's server child.
 import "./theme.css";
 import { Component, StrictMode, useEffect, useMemo, useState, type ComponentType, type ReactNode } from "react";
 import { createRoot } from "react-dom/client";
-import { ScopeProvider, apiHeaders, formatFailure, Maker, Desktop, useResource, useBaba, type AppProps, type ViewFailure } from "babavoss/web";
+import { ScopeProvider, apiHeaders, formatFailure, Maker, Desktop, DesktopSkeleton, type AppProps, type ViewFailure } from "babavoss/web";
 import { isApps, type Interface } from "../web/core.tsx";
-import { desktop, themes, type DesktopSystem } from "../desktop/index.ts";
+import { desktop } from "../desktop/index.ts";
 import type { AppSpec } from "../ecs/baba.ts";
 import type { Described } from "../baba/node.ts";
 import { Inspector } from "./inspector.tsx";
 import { Runner } from "./runner.tsx";
-import { Promptware } from "./promptware.tsx";
+import { Instructions } from "./instructions.tsx";
 import { Button } from "../web/ui.tsx";
 import { Root } from "./levels.tsx";
+import { Settings, SettingsBaba } from "./settings.tsx";
+import { useVossSettings } from "./voss-settings.ts";
 import type { Voss } from "../server/messages.ts";
 import { tellApart } from "../kernel/names.ts";
 
@@ -117,7 +120,8 @@ function Host() {
   const [, moveOn] = useState(0);
   useEffect(() => { if (to) { history.replaceState(null, "", `/${encodeURIComponent(scope)}/${to}${location.search}${location.hash}`); moveOn((n) => n + 1); } }, [to]);
   if (to) return null;
-  if (!d) return <div className="gui-page"><p className="bv-muted">{failed ? `${scope} did not answer: ${failed}` : "…"}</p></div>;
+  // While the baba is described the desktop's own skeleton shows, the look it will have, never a line of text.
+  if (!d) return failed ? <div className="gui-page"><p className="bv-muted">{scope} did not answer: {failed}</p></div> : <div className="gui-view"><DesktopSkeleton /></div>;
   if (!d.manifest) return <div className="gui-page"><p className="bv-error">{d.title} is not running.{d.error ? ` ${d.error}` : ""}</p></div>;
   return <ShellPage d={d} />;
 }
@@ -180,15 +184,17 @@ const useShellSystem = (apps: readonly AppSpec[] | undefined) => {
 function ShellPage({ d }: { d: Described }) {
   const { view, failure } = useInterface(d);
   const system = useShellSystem(d.manifest?.apps);
+  const person = useVossSettings();
   const manifest = d.manifest!;
   const components = useMemo(() => {
-    const pending = () => failure ? <Failure f={failure} /> : <p className="desktop-empty bv-muted">…</p>;
+    // Until the interface has loaded, a moment, an app's window is its empty sheet: no line of text that flashes and goes.
+    const pending = () => failure ? <Failure f={failure} /> : null;
     const out: Record<string, ComponentType<AppProps>> = {
       // The Maker with no specs: the interface gives voss's maker app its own component, with the baba's specs and its apps, to replace this.
       maker: ({ path, navigate, setTitle }) => <Maker specs={[]} title={d.title} path={path} navigate={navigate} setTitle={setTitle} />,
       state: () => <section className="gui-app">{d.error && <p className="bv-error">The code did not load; the last generation serves: {d.error}</p>}<Inspector manifest={manifest} /></section>,
       contract: () => <section className="gui-app"><Runner manifest={manifest} /></section>,
-      promptware: () => <section className="gui-app"><Promptware manifest={manifest} /></section>,
+      instructions: () => <section className="gui-app"><Instructions manifest={manifest} /></section>,
       settings: Settings,
     };
     for (const sc of manifest.apps ?? []) {
@@ -201,34 +207,18 @@ function ShellPage({ d }: { d: Described }) {
     return out;
   }, [view, failure, system, manifest, d.error, d.view, d.title]);
   return (
-    <div className="gui-view" key={view ? "loaded" : "loading"}>
-      <ViewBoundary fallback={(f) => <div className="gui-page"><Failure f={f} /></div>}>
-        <Desktop system={system} apps={components} title={d.title} root={{ label: "voss", href: "/" }} />
+    <div className="gui-view">
+      {/* The interface arriving swaps the apps' components in place: the desktop stays mounted, so its windows, launcher and focus stay as they are. */}
+      <ViewBoundary reset={view} fallback={(f) => <div className="gui-page"><Failure f={f} /></div>}>
+        <SettingsBaba.Provider value={d}><Desktop system={system} apps={components} title={d.title} root={{ label: "voss", href: "/" }} settings={person} /></SettingsBaba.Provider>
       </ViewBoundary>
     </div>
   );
 }
 
-/** voss's settings for this baba: the theme its pages share, in its state. */
-function Settings() {
-  const system = useMemo(() => desktop({}), []);
-  const current = useResource(system.desktopSettings)?.theme ?? "system";
-  const { fire } = useBaba<DesktopSystem>();
-  return (
-    <section className="gui-app">
-      <h2>Theme</h2>
-      <p className="bv-muted">The theme every page of this baba shows, kept in its state.</p>
-      <div className="gui-choices" role="radiogroup" aria-label="Theme">
-        {themes.map((t) => <Button key={t} variant={t === current ? "default" : "quiet"} role="radio" aria-checked={t === current} onClick={() => void fire("desktop-settings", { theme: t })}>{t}</Button>)}
-      </div>
-      <h2>voss</h2>
-      <p><a href="/">All babas</a></p>
-    </section>
-  );
-}
-
-class ViewBoundary extends Component<{ children: ReactNode; fallback: (f: ViewFailure) => ReactNode }, { failure: ViewFailure | null }> {
+class ViewBoundary extends Component<{ children: ReactNode; fallback: (f: ViewFailure) => ReactNode; /** A failure is forgotten when this changes: a new interface gets its chance. */ reset?: unknown }, { failure: ViewFailure | null }> {
   override state = { failure: null as ViewFailure | null };
+  override componentDidUpdate(before: { reset?: unknown }) { if (before.reset !== this.props.reset && this.state.failure) this.setState({ failure: null }); }
   static getDerivedStateFromError(err: unknown) {
     return { failure: { stage: "render" as const, message: err instanceof Error ? err.message : String(err), detail: err instanceof Error ? err.stack : undefined } };
   }

package/src/gui/index.ts

@@ -3,7 +3,7 @@
 // runner over any baba.
 import { dirname, join } from "node:path";
 import { rm, rename } from "node:fs/promises";
-import { early } from "./theme.ts";
+import { early, firstPaint } from "./theme.ts";
 import { shared, names, resolver } from "../build/views.ts";
 
 const here = dirname(Bun.fileURLToPath(import.meta.url));
@@ -37,11 +37,15 @@ export async function buildGui(outdir: string): Promise<void> {
 /** The import map, as the page carries it: the shared names to the modules built with the GUI. */
 export const importMap = () => JSON.stringify({ imports: Object.fromEntries(Object.entries(shared).map(([n, f]) => [n, `/assets/${f}`])) });
 
+/** The tab's icon: the Baba Voss favicon as the brand workshop makes it (marc/logo/favicon.ts, site/public/favicon.svg), the small symbol knocked out of a tan disc; inlined, since the package carries no brand files. */
+const favicon = `data:image/svg+xml,${encodeURIComponent('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"><circle cx="50" cy="50" r="50" fill="#AE8D74"/><g fill="#151312"><circle cx="33.772" cy="50" r="18"/><circle cx="71.5" cy="50" r="12.728"/></g></svg>')}`;
+
 /** The page of a scope: the theme before the first paint, the import map, the GUI. */
 export function page(scope: string | null): string {
   const meta = scope ? `<meta name="voss-scope" content="${escape(scope)}">` : "";
   return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
-<title>${scope ? escape(scope) : "voss"}</title>${meta}<script>${early}</script><link rel="stylesheet" href="/assets/theme.css">
+<meta name="color-scheme" content="light dark"><style>${firstPaint}</style>
+<title>${scope ? escape(scope) : "voss"}</title><link rel="icon" type="image/svg+xml" href="${favicon}">${meta}<script>${early}</script><link rel="stylesheet" href="/assets/theme.css">
 <script type="importmap">${importMap()}</script></head>
 <body><div id="root"></div><script type="module" src="/assets/gui.js"></script></body></html>`;
 }

package/src/gui/{promptware.tsx → instructions.tsx}

@@ -1,6 +1,6 @@
-// The promptware drawer: the baba's know-how for agents as it declares it,
+// The agentic instructions drawer: the baba's know-how for agents as it declares it,
 // the harness as the baba declares it, the plan of each output, and a sync.
-// Read from the state by the promptware system's names.
+// Read from the state by the agents system's names.
 import { useEffect, useState } from "react";
 import type { Manifest } from "../ecs/baba.ts";
 import { useBabaState } from "../web/state.tsx";
@@ -9,12 +9,12 @@ import { ErrorText } from "./runner.tsx";
 
 interface Plan { auto: boolean; lastSync: number | null; pending: number; error: string | null; outputs: { path: string; harness: string; status: string; action: string | null; reason: string }[] }
 
-export function Promptware({ manifest }: { manifest: Manifest }) {
+export function Instructions({ manifest }: { manifest: Manifest }) {
   const { fire, read, ready, round } = useBabaState();
   const [plan, setPlan] = useState<Plan | null>(null);
   const [error, setError] = useState<unknown>(null);
-  useEffect(() => { if (ready) read("promptware-plan").then((p) => setPlan(p as Plan), setError); }, [ready, round]);
-  if (!("pwStatus" in manifest.resources)) return <p className="bv-muted">This baba has no promptware system.</p>;
+  useEffect(() => { if (ready) read("agents-plan").then((p) => setPlan(p as Plan), setError); }, [ready, round]);
+  if (!("pwStatus" in manifest.resources)) return <p className="bv-muted">This baba has no agents system.</p>;
   if (!ready) return <p className="bv-muted">Reading the state…</p>;
   const act = (name: string, args: unknown) => { setError(null); return fire(name, args as never).catch((e: unknown) => { setError(e); throw e; }); };
   return (
@@ -24,7 +24,7 @@ export function Promptware({ manifest }: { manifest: Manifest }) {
       <section className="gui-section">
         <h2>Outputs</h2>
         <div className="bv-form-actions">
-          <Button variant="primary" onClick={() => void act("promptware-sync", {}).catch(() => {})}>Sync now</Button>
+          <Button variant="primary" onClick={() => void act("agents-sync", {}).catch(() => {})}>Sync now</Button>
           {plan && <span className="bv-muted">{plan.pending ? `${plan.pending} to write` : "up to date"} · {plan.auto ? "writes on every change" : "writes on sync"}{plan.lastSync ? ` · synced ${new Date(plan.lastSync).toLocaleTimeString()}` : ""}</span>}
         </div>
         {plan?.error && <p className="bv-error">{plan.error}</p>}
@@ -35,18 +35,18 @@ export function Promptware({ manifest }: { manifest: Manifest }) {
   );
 }
 
-/** What the baba tells agents, read-only here: it is code under .baba/promptware/. */
+/** What the baba tells agents, read-only here: it is code under .baba/agents/. */
 function Declared({ manifest }: { manifest: Manifest }) {
-  const pw = manifest.promptware;
+  const pw = manifest.instructions;
   const skills = Object.entries(pw.skills);
   return (
     <section className="gui-section">
-      <h2>Promptware</h2>
-      {!pw.context && skills.length === 0 && pw.hooks.length === 0 && <p className="bv-muted">Nothing declared yet: give the baba a `context(...)`, a `skill(...)` or a `hook(...)` under `promptware`.</p>}
+      <h2>Instructions</h2>
+      {!pw.context && skills.length === 0 && pw.hooks.length === 0 && <p className="bv-muted">Nothing declared yet: give the baba a `context(...)`, a `skill(...)` or a `hook(...)` under `.baba/agents/`.</p>}
       {pw.context && <p className="bv-muted">{pw.context.length} characters of context, {pw.hooks.length} hook{pw.hooks.length === 1 ? "" : "s"}.</p>}
       {pw.hooks.length > 0 && <Rows>{pw.hooks.map((h, i) => <Row key={i} hint={`${h.on}${h.match ? ` on ${h.match}` : ""}${h.strict ? " · strict" : ""}`}><code>{h.action}</code></Row>)}</Rows>}
       {skills.length > 0 && <Rows>{skills.map(([k, sk]) => <Row key={k} hint={sk.description}><code>{k}</code></Row>)}</Rows>}
-      <p className="bv-muted">The promptware is the baba's code: edit it under .baba/promptware/; the files below follow.</p>
+      <p className="bv-muted">The agentic instructions is the baba's code: edit it under .baba/agents/; the files below follow.</p>
     </section>
   );
 }
@@ -62,7 +62,7 @@ function Harness({ manifest }: { manifest: Manifest }) {
         <Row hint={h.codex.enabled ? "on" : "off"}><code>codex</code></Row>
         <Row hint={`${h.auto ? "writes on every change" : "writes on sync"}${h.table ? " · the contract as a table" : ""}`}><code>files</code></Row>
       </Rows>
-      <p className="bv-muted">Declared in .baba/index.ts: <code>{"baba({ systems, promptware, harness })"}</code>.</p>
+      <p className="bv-muted">The .mdx files under .baba/agents/, each <code>{'export const prompt = { kind: "context" | "skill", … }'}</code>; voss reads them on its own.</p>
     </section>
   );
 }