@netnodeag/kraftwerk 0.34.2 → 0.36.0

package/README.md

@@ -160,12 +160,26 @@ kraftwerk run --sandbox website-check "https://..."   # isolated container per r
 kraftwerk runner ps / stop <run-id>     # see / stop running sandbox containers
 ```
 
+The inspector binds `127.0.0.1` — it has no authentication of its own and
+its chat runs coding agents against the repo, so it stays off the LAN, and
+while bound there it only answers requests whose `Host` is a loopback name
+(so a page on another site cannot reach it by re-pointing its own DNS at
+127.0.0.1). Inside a container it binds all interfaces instead, because the
+port mapping is the boundary there (`deploy-starter/` publishes to
+localhost, and its traefik override adds basic-auth). `KRAFTWERK_UI_HOST`
+overrides the default either way. A reverse proxy in front of it must set
+`X-Forwarded-Host` to the host the browser addressed (Caddy and traefik do
+by default; nginx needs `proxy_set_header X-Forwarded-Host $host;`): the
+loopback bind answers a non-loopback `Host` only when that header is
+present, and state-changing requests are refused when `Origin` names a
+different host.
+
 ### The kraftwerk.yml project config
 
 Optional, at the project root, and also the root marker for the walk-up. All
 fields are optional. `workflows:` sets the workflows root, `output:` the
 run-artifact directory (default `output/`), `knowledge:` the OKF bundle root
-(default `knowledge/`), and `agents:` the team agent-definition root (default
+(default `knowledge/`), and `agents:` the agent-definition root (default
 `agents/`).
 
 `switcher:` links other kraftwerk workspaces from the inspector header. The
@@ -178,6 +192,13 @@ switcher:
     icon: "🛰"   # optional
 ```
 
+**⌘K** (Ctrl K) anywhere in the inspector opens the agent palette: type a
+few letters of an agent's name, description or workspace and hit enter to
+jump to it. It lists the active agents of every workspace on this machine,
+running or not (a stopped one is started on the way), read from the
+project registry under `~/.kraftwerk/projects`, which every inspector keeps
+current with its roster.
+
 ### Triggering from CI, cron, or webhooks
 
 `run --json` is the machine mode. It runs non-interactively, prints one JSON
@@ -235,15 +256,15 @@ repo. Agent logins made inside the container persist in the `agent-home`
 volume. This is a different image from the `kraftwerk-runner` sandbox
 (`runner/Dockerfile`) used by `run --sandbox`.
 
-## Persistent team agents
+## Persistent agents
 
-The inspector's "team" screen turns chat agents into persistent teammates. A
-team member is one folder under the project's `agents/` root:
+The inspector's "agents" screen turns chat agents into persistent teammates. An
+agent is one folder under the project's `agents/` root:
 
 ```
 agents/max/
   agent.yml     # name, emoji, description, harness, model, effort, workflows
-  system.md     # the member's system prompt (its role)
+  system.md     # the agent's system prompt (its role)
 ```
 
 ```yaml
@@ -255,43 +276,43 @@ harness: claude        # claude | codex | pi (which chat backend runs it)
 model: sonnet          # optional; harness default when omitted
 effort: medium         # optional: low | medium | high | xhigh | max
 workflows: [tagline, website-check]
-knowledge: [customer-support]   # OKF bundles the member consults & maintains
+knowledge: [customer-support]   # OKF bundles the agent consults & maintains
 skills: [report-html]           # optional allowlist; omit = all skills, [] = none
 ```
 
-Sessions with a member are ordinary chats scoped `{ kind: "team", member }`,
-listed per member in a second sidebar. On the first message the member gets
+Sessions with an agent are ordinary chats scoped `{ kind: "agent", slug }`,
+listed per agent in a second sidebar. On the first message the agent gets
 its role plus its connected workflows and knowledge bundles injected as
 context. That context includes how to run workflows
 (`KRAFTWERK_YES=1 npx kraftwerk run <workflow> "<request>"`) and how to read
 and write knowledge through `kraftwerk knowledge`, with writes stamped with
-the member's own actor, `<slug>/<harness>`. So the member triggers its own
+the agent's own actor, `<slug>/<harness>`. So the agent triggers its own
 workflows when a request matches, and keeps its bundles current.
 
 Model and effort ride on backend-specific channels. The claude adapter takes
 the model via ACP session options and the thinking budget via
 `MAX_THINKING_TOKENS`. Codex gets a `CODEX_CONFIG` env override (`model`,
-`model_reasoning_effort`). Pi gets `--model` and `--thinking` flags. Members
+`model_reasoning_effort`). Pi gets `--model` and `--thinking` flags. Agents
 are created and edited in the UI, or by editing the files, since the
 definition is read fresh for each new session.
 
 ### Skills in chat
 
-Chats, both general ones and team sessions, can use skills. These are
+Chats, both general ones and agent sessions, can use skills. These are
 Claude-style instruction packages, one folder per skill with a `SKILL.md`
 holding YAML frontmatter (`name`, `description`) and then the instructions.
 Four roots are discovered, each shadowing same-named skills in the roots below
 it:
 
 ```
-<project>/agents/<slug>/skills/<name>/SKILL.md   # private to that one team agent
+<project>/agents/<slug>/skills/<name>/SKILL.md   # private to that one agent
 <project>/<skills root>/<name>/SKILL.md          # workspace, git-tracked (kraftwerk.yml `skills`, default skills/)
 <project>/.claude/skills/<name>/SKILL.md         # git-tracked, per project
 ~/.claude/skills/<name>/SKILL.md                 # personal, per user
 ```
 
 Agent skills are visible only to that agent's sessions and always apply. A
-member's `skills:` allowlist narrows the shared roots only. Manage them in the
+agent's `skills:` allowlist narrows the shared roots only. Manage them in the
 agent profile under "own skills", or by editing the files.
 
 Every chat lists its visible skills as context under "## Your skills", so the
@@ -299,16 +320,16 @@ agent reaches for one when the request matches. Typing `/` in the composer
 opens an autocomplete over them. Sending `/<name> <args>` expands the skill's
 SKILL.md into the prompt, which is what makes this work identically on claude,
 codex, and pi. On top of that, claude discovers `.claude/skills` natively (a
-team member's `skills:` allowlist narrows that via ACP session options) and pi
-loads each visible skill folder via `--skill`. Team members take an optional
+agent's `skills:` allowlist narrows that via ACP session options) and pi
+loads each visible skill folder via `--skill`. Agents take an optional
 `skills:` list in `agent.yml`. Omitted means all discovered skills, an empty
 list means none, otherwise it is the allowlist. `GET /api/skills` returns
 what's discovered.
 
 ### Routines, or scheduled prompts
 
-A member can have routines, cron-scheduled prompts that work like standing
-orders for an employee. Definitions live next to the member in
+An agent can have routines, cron-scheduled prompts that work like standing
+orders for an employee. Definitions live next to the agent in
 `agents/<slug>/routines.yml` and are git-tracked. Run state (last run, last
 session, errors) lives in `<output>/routines-state.json`.
 
@@ -324,12 +345,12 @@ session, errors) lives in `<output>/routines-state.json`.
 ```
 
 The inspector server runs the scheduler in-process, so there is no external
-cron to set up. Every due routine opens a fresh session for the member, posts
+cron to set up. Every due routine opens a fresh session for the agent, posts
 the prompt, and shows up in the sessions sidebar titled "⏰ <name>". Routine
 sessions run unattended, so tool-permission requests are auto-approved, with
 the request and approval pair left in the thread as an audit trail. Give
 routine prompts the same trust you would give a `KRAFTWERK_YES=1` workflow
-run. Manage routines on the member page, where you can create, edit and
+run. Manage routines on the agent page, where you can create, edit and
 delete them, toggle enabled, hit "run now", and jump to the last run's
 session. Schedules missed while the server is down are skipped, not replayed.
 

package/dist/cli/init.js

@@ -6,7 +6,7 @@ import { initBundle, writeConcept } from "../okf.js";
 /**
  * `kraftwerk init` — make any repository a kraftwerk consumer in one
  * command: kraftwerk.yml (root marker + config), a kraftwerk-data/ tree with
- * a runnable example workflow, a starter team agent ("max"), a demo
+ * a runnable example workflow, a starter agent ("max"), a demo
  * knowledge bundle, and an output ignore entry. Everything is idempotent:
  * existing files are left untouched and reported.
  */
@@ -20,7 +20,7 @@ port: 1981   # port \`kraftwerk ui\` listens on
 workflows: ${DATA_DIR}/workflows   # where workflows live
 output: ${DATA_DIR}/output         # where run artifacts land (git-ignored)
 knowledge: ${DATA_DIR}/knowledge   # OKF knowledge bundles
-agents: ${DATA_DIR}/agents         # team agent definitions
+agents: ${DATA_DIR}/agents         # agent definitions
 skills: ${DATA_DIR}/skills         # workspace skills (shared instruction packages)
 `;
 const WORKFLOW_TEMPLATE = `# yaml-language-server: $schema=${SCHEMA_URL}
@@ -107,7 +107,7 @@ export async function runInit(cwd) {
     await put(`${DATA_DIR}/workflows/hello/workflow.yml`, WORKFLOW_TEMPLATE);
     await put(`${DATA_DIR}/workflows/hello/prompts/assistant.md`, PERSONA_TEMPLATE);
     await put(`${DATA_DIR}/workflows/hello/prompts/answer.md`, PROMPT_TEMPLATE);
-    // Team agent "max".
+    // Agent "max".
     await put(`${DATA_DIR}/agents/max/agent.yml`, AGENT_YML_TEMPLATE);
     await put(`${DATA_DIR}/agents/max/system.md`, AGENT_SYSTEM_TEMPLATE);
     // Example workspace skill.

package/dist/cli/routines.js

@@ -4,22 +4,22 @@ import chalk from "chalk";
 import { resolveProject } from "../config.js";
 import { setOutputDir, setProjectRoot } from "../inspector/context.js";
 import { deleteRoutine, listRoutines, routineStatuses, saveRoutine, } from "../inspector/routines.js";
-import { getMember, listMembers } from "../inspector/team.js";
+import { getAgent, listAgents } from "../inspector/agents.js";
 /**
  * `kraftwerk routines` — CLI surface over per-agent scheduled prompts
  * (agents/<slug>/routines.yml). Definition CRUD works directly on the
  * files; `run` fires through the running inspector server, because the
  * session (chat) and the scheduler live there.
  */
-/** Point the inspector context at this project so team/routine paths resolve. */
+/** Point the inspector context at this project so agent/routine paths resolve. */
 async function initContext() {
     const project = await resolveProject(process.cwd());
     setProjectRoot(project.root);
     setOutputDir(project.outputDir);
     return { port: project.config.port ?? 1981 };
 }
-async function requireMember(slug) {
-    if (!(await getMember(slug))) {
+async function requireAgent(slug) {
+    if (!(await getAgent(slug))) {
         console.error(chalk.red(`Agent "${slug}" not found (expected agents/${slug}/agent.yml).`));
         process.exit(2);
     }
@@ -56,9 +56,9 @@ export function registerRoutineCommands(program) {
         .option("--json", "Machine-readable output")
         .action(async (agent, opts) => {
         await initContext();
-        const slugs = agent ? [agent] : (await listMembers()).map((m) => m.slug);
+        const slugs = agent ? [agent] : (await listAgents()).map((m) => m.slug);
         if (agent)
-            await requireMember(agent);
+            await requireAgent(agent);
         const all = {};
         for (const slug of slugs)
             all[slug] = await routineStatuses(slug);
@@ -89,7 +89,7 @@ export function registerRoutineCommands(program) {
         .option("--disabled", "Create it switched off")
         .action(async (agent, opts) => {
         await initContext();
-        await requireMember(agent);
+        await requireAgent(agent);
         const prompt = opts.prompt ??
             (opts.file ? await readFile(path.resolve(opts.file), "utf8") : process.stdin.isTTY ? "" : await readStdin());
         if (!prompt.trim()) {
@@ -124,7 +124,7 @@ export function registerRoutineCommands(program) {
         .argument("<id>", "Routine id (see `kraftwerk routines <agent>`)")
         .action(async (agent, id) => {
         await initContext();
-        await requireMember(agent);
+        await requireAgent(agent);
         if (!(await listRoutines(agent)).some((r) => r.id === id)) {
             console.error(chalk.red(`Routine "${agent}/${id}" not found.`));
             process.exit(2);
@@ -158,7 +158,7 @@ export function registerRoutineCommands(program) {
         .action(async (agent, id, opts) => {
         const { port } = await initContext();
         const p = opts.port ? Number(opts.port) : port;
-        const url = `http://localhost:${p}/api/team/${encodeURIComponent(agent)}/routines/${encodeURIComponent(id)}/run`;
+        const url = `http://localhost:${p}/api/agents/${encodeURIComponent(agent)}/routines/${encodeURIComponent(id)}/run`;
         let body;
         try {
             body = (await (await fetch(url, { method: "POST" })).json());

package/dist/config.d.ts

@@ -15,18 +15,40 @@
  *   workflows: src/workflows   # workflows root, relative to the file
  *   output: output             # run-artifact directory, relative to the file
  *   knowledge: knowledge       # OKF knowledge-bundle root, relative to the file
- *   agents: agents             # team agent-definition root, relative to the file
+ *   agents: agents             # agent-definition root, relative to the file
  *   skills: skills             # workspace skill root, relative to the file
  *   switcher:                  # other kraftwerk workspaces, linked from the header dropdown
  *     - name: other space
  *       url: https://localhost:1985
  *       icon: "🛰"              # optional emoji shown next to the entry
+ *   git:                       # workspace git sync (absent = off, bare key = on with defaults)
+ *     remote: origin
+ *     interval: 300            # seconds between background fetches
+ *     autosync: pull           # off | pull
  */
 /** Stable, versionless URL of the workflow JSON schema (editor validation). */
 export declare const SCHEMA_URL = "https://raw.githubusercontent.com/NETNODEAG/kraftwerk/main/kraftwerk/schema/workflow.schema.json";
 /** Stable, versionless URL of the kraftwerk.yml JSON schema (editor validation). */
 export declare const CONFIG_SCHEMA_URL = "https://raw.githubusercontent.com/NETNODEAG/kraftwerk/main/kraftwerk/schema/kraftwerk.schema.json";
 export declare const CONFIG_FILENAMES: string[];
+/**
+ * Git sync for the workspace. The synced paths are not configurable: they
+ * are the roots this file already declares (workflows, knowledge, agents,
+ * skills) plus kraftwerk.yml itself. Commit and push stay manual; the
+ * interval only fetches, and pulls when `autosync` allows it.
+ */
+export interface GitConfig {
+    /** false keeps the block but turns the feature off. Default: true. */
+    enabled?: boolean;
+    /** Remote to fetch, pull and push. Default: origin. */
+    remote?: string;
+    /** Branch to sync. Default: whatever is checked out. */
+    branch?: string;
+    /** Seconds between background fetches. 0 disables the timer. Default: 300. */
+    interval?: number;
+    /** off = fetch only. pull = also fast-forward when behind and clean. Default: pull. */
+    autosync?: "off" | "pull";
+}
 /** One entry of the workspace switcher: another kraftwerk instance to link to. */
 export interface SwitcherEntry {
     /** Display name of the other workspace. */
@@ -49,12 +71,14 @@ export interface ProjectConfig {
     output?: string;
     /** OKF knowledge-bundle root relative to the project root. Default: knowledge */
     knowledge?: string;
-    /** Team agent-definition root relative to the project root. Default: agents */
+    /** Agent-definition root relative to the project root. Default: agents */
     agents?: string;
     /** Workspace skill root relative to the project root. Default: skills */
     skills?: string;
     /** Other kraftwerk workspaces, shown as a switcher dropdown in the inspector header. */
     switcher?: SwitcherEntry[];
+    /** Workspace git sync. Absent = off. */
+    git?: GitConfig;
 }
 export interface Project {
     /** Absolute project root the CLI operates on. */

package/dist/config.js

@@ -18,12 +18,16 @@ import { parse } from "yaml";
  *   workflows: src/workflows   # workflows root, relative to the file
  *   output: output             # run-artifact directory, relative to the file
  *   knowledge: knowledge       # OKF knowledge-bundle root, relative to the file
- *   agents: agents             # team agent-definition root, relative to the file
+ *   agents: agents             # agent-definition root, relative to the file
  *   skills: skills             # workspace skill root, relative to the file
  *   switcher:                  # other kraftwerk workspaces, linked from the header dropdown
  *     - name: other space
  *       url: https://localhost:1985
  *       icon: "🛰"              # optional emoji shown next to the entry
+ *   git:                       # workspace git sync (absent = off, bare key = on with defaults)
+ *     remote: origin
+ *     interval: 300            # seconds between background fetches
+ *     autosync: pull           # off | pull
  */
 /** Stable, versionless URL of the workflow JSON schema (editor validation). */
 export const SCHEMA_URL = "https://raw.githubusercontent.com/NETNODEAG/kraftwerk/main/kraftwerk/schema/workflow.schema.json";
@@ -83,6 +87,7 @@ export async function resolveProject(cwd) {
     const root = gitFallback ?? start;
     return { root, config: {}, outputDir: path.join(root, "output") };
 }
+const KNOWN_KEYS = ["name", "icon", "port", "workflows", "output", "knowledge", "agents", "skills", "switcher", "git"];
 async function loadConfig(configPath) {
     let raw;
     try {
@@ -94,10 +99,10 @@ async function loadConfig(configPath) {
     if (raw === null || raw === undefined)
         return {};
     if (typeof raw !== "object" || Array.isArray(raw)) {
-        throw new Error(`${path.basename(configPath)}: expected a mapping (name, icon, port, workflows, output, knowledge, agents, skills, switcher)`);
+        throw new Error(`${path.basename(configPath)}: expected a mapping (${KNOWN_KEYS.join(", ")})`);
     }
     const config = raw;
-    const known = ["name", "icon", "port", "workflows", "output", "knowledge", "agents", "skills", "switcher"];
+    const known = KNOWN_KEYS;
     for (const key of Object.keys(config)) {
         if (!known.includes(key)) {
             throw new Error(`${path.basename(configPath)}: unknown key "${key}" (allowed: ${known.join(", ")})`);
@@ -110,6 +115,14 @@ async function loadConfig(configPath) {
         else if (key === "switcher") {
             validateSwitcher(configPath, config[key]);
         }
+        else if (key === "git") {
+            // A bare `git:` line parses as null. Every field has a default, so read
+            // it as "on, with defaults" instead of failing the whole config load
+            // and taking the rest of the inspector down with it.
+            if (config[key] === null)
+                config[key] = {};
+            validateGit(configPath, config[key]);
+        }
         else if (typeof config[key] !== "string") {
             throw new Error(`${path.basename(configPath)}: ${key} must be a string`);
         }
@@ -142,3 +155,30 @@ function validateSwitcher(configPath, value) {
         }
     });
 }
+function validateGit(configPath, value) {
+    const file = path.basename(configPath);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`${file}: git must be a mapping (enabled, remote, branch, interval, autosync)`);
+    }
+    const g = value;
+    const known = ["enabled", "remote", "branch", "interval", "autosync"];
+    for (const key of Object.keys(g)) {
+        if (!known.includes(key)) {
+            throw new Error(`${file}: git.${key} is unknown (allowed: ${known.join(", ")})`);
+        }
+    }
+    if (g.enabled !== undefined && typeof g.enabled !== "boolean") {
+        throw new Error(`${file}: git.enabled must be true or false`);
+    }
+    for (const key of ["remote", "branch"]) {
+        if (g[key] !== undefined && (typeof g[key] !== "string" || !g[key].trim())) {
+            throw new Error(`${file}: git.${key} must be a non-empty string`);
+        }
+    }
+    if (g.interval !== undefined && (typeof g.interval !== "number" || !Number.isInteger(g.interval) || g.interval < 0)) {
+        throw new Error(`${file}: git.interval must be a whole number of seconds (0 disables the timer)`);
+    }
+    if (g.autosync !== undefined && g.autosync !== "off" && g.autosync !== "pull") {
+        throw new Error(`${file}: git.autosync must be "off" or "pull"`);
+    }
+}

package/dist/inspector/{team.d.ts → agents.d.ts}

@@ -1,17 +1,17 @@
 import type { ChatAgentId } from "./chat/types.js";
 /**
- * Team: persistent agent teammates, defined on the filesystem. Each member
+ * Agents: persistent agents, defined on the filesystem. Each one
  * is one folder under the project's agents/ root:
  *
  *   agents/<slug>/agent.yml    # name, emoji, harness, model, effort, workflows
- *   agents/<slug>/system.md    # the member's system prompt / role description
+ *   agents/<slug>/system.md    # the agent's system prompt / role description
  *
  * Definitions are git-tracked project config (like workflows/), not run
  * state — sessions with a member are ordinary chats scoped to it.
  */
 export declare const HARNESSES: ChatAgentId[];
 export declare const EFFORTS: readonly ["low", "medium", "high", "xhigh", "max"];
-export interface TeamMember {
+export interface Agent {
     slug: string;
     name: string;
     emoji: string;
@@ -33,17 +33,26 @@ export interface TeamMember {
     /** Archived: hidden from the active roster, restorable any time. */
     archived?: boolean;
 }
-export interface TeamMemberDetail extends TeamMember {
+/** What the ⌘K palette needs to find and show an agent — kept in the project registry. */
+export interface AgentSummary {
+    slug: string;
+    name: string;
+    emoji: string;
+    description?: string;
+    group?: string;
+}
+export declare const toSummary: (a: Agent) => AgentSummary;
+export interface AgentDetail extends Agent {
     /** Contents of system.md — the member's system prompt. */
     system: string;
 }
-export declare function teamRoot(): Promise<string>;
-export declare function safeMemberSlug(slug: string): string;
+export declare function agentsRoot(): Promise<string>;
+export declare function safeAgentSlug(slug: string): string;
 /** Derive a slug from a display name: "Max Müller" -> "max-mueller"-ish. */
 export declare function slugFromName(name: string): string;
-export declare function listMembers(): Promise<TeamMember[]>;
-export declare function getMember(slug: string): Promise<TeamMemberDetail | null>;
-export interface SaveMemberInput {
+export declare function listAgents(): Promise<Agent[]>;
+export declare function getAgent(slug: string): Promise<AgentDetail | null>;
+export interface SaveAgentInput {
     slug?: string;
     name: string;
     emoji?: string;
@@ -59,7 +68,7 @@ export interface SaveMemberInput {
     skills?: string[];
     system?: string;
 }
-export declare function saveMember(input: SaveMemberInput): Promise<TeamMemberDetail>;
+export declare function saveAgent(input: SaveAgentInput): Promise<AgentDetail>;
 /** Archive/unarchive a member: toggles `archived:` in agent.yml, nothing else. */
-export declare function setMemberArchived(slug: string, archived: boolean): Promise<TeamMemberDetail>;
-export declare function deleteMember(slug: string): Promise<void>;
+export declare function setAgentArchived(slug: string, archived: boolean): Promise<AgentDetail>;
+export declare function deleteAgent(slug: string): Promise<void>;

package/dist/inspector/{team.js → agents.js}

@@ -3,24 +3,32 @@ import path from "node:path";
 import { parse, stringify } from "yaml";
 import { resolveProject } from "../config.js";
 import { getProjectRoot } from "./context.js";
+import { syncProjectAgents } from "./instances.js";
 /**
- * Team: persistent agent teammates, defined on the filesystem. Each member
+ * Agents: persistent agents, defined on the filesystem. Each one
  * is one folder under the project's agents/ root:
  *
  *   agents/<slug>/agent.yml    # name, emoji, harness, model, effort, workflows
- *   agents/<slug>/system.md    # the member's system prompt / role description
+ *   agents/<slug>/system.md    # the agent's system prompt / role description
  *
  * Definitions are git-tracked project config (like workflows/), not run
  * state — sessions with a member are ordinary chats scoped to it.
  */
 export const HARNESSES = ["claude", "codex", "pi"];
 export const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
-export async function teamRoot() {
+export const toSummary = (a) => ({
+    slug: a.slug,
+    name: a.name,
+    emoji: a.emoji,
+    ...(a.description ? { description: a.description } : {}),
+    ...(a.group ? { group: a.group } : {}),
+});
+export async function agentsRoot() {
     const project = await resolveProject(getProjectRoot());
     return path.resolve(project.root, project.config.agents ?? "agents");
 }
 const SLUG_RE = /^[a-z0-9][a-z0-9-]{0,48}$/;
-export function safeMemberSlug(slug) {
+export function safeAgentSlug(slug) {
     if (!SLUG_RE.test(slug))
         throw new Error(`invalid agent slug "${slug}"`);
     return slug;
@@ -55,8 +63,8 @@ function normalize(slug, raw) {
         ...(raw.archived === true ? { archived: true } : {}),
     };
 }
-export async function listMembers() {
-    const root = await teamRoot();
+export async function listAgents() {
+    const root = await agentsRoot();
     let entries;
     try {
         entries = (await fs.readdir(root, { withFileTypes: true }))
@@ -66,7 +74,7 @@ export async function listMembers() {
     catch {
         return [];
     }
-    const members = await Promise.all(entries.map(async (slug) => {
+    const agents = await Promise.all(entries.map(async (slug) => {
         try {
             const raw = parse(await fs.readFile(path.join(root, slug, "agent.yml"), "utf8"));
             return normalize(slug, (raw ?? {}));
@@ -75,10 +83,17 @@ export async function listMembers() {
             return null;
         }
     }));
-    return members.filter(Boolean).sort((a, b) => a.name.localeCompare(b.name));
+    const list = agents.filter(Boolean).sort((a, b) => a.name.localeCompare(b.name));
+    // Keep the registry's copy of the roster current for the other instances'
+    // palettes. Awaited so a read that follows a save sees the record updated;
+    // it only writes when the roster changed.
+    await resolveProject(getProjectRoot())
+        .then((p) => syncProjectAgents(p.root, list.filter((a) => !a.archived).map(toSummary)))
+        .catch(() => { });
+    return list;
 }
-export async function getMember(slug) {
-    const dir = path.join(await teamRoot(), safeMemberSlug(slug));
+export async function getAgent(slug) {
+    const dir = path.join(await agentsRoot(), safeAgentSlug(slug));
     let raw;
     try {
         raw = parse(await fs.readFile(path.join(dir, "agent.yml"), "utf8"));
@@ -89,7 +104,7 @@ export async function getMember(slug) {
     const system = await fs.readFile(path.join(dir, "system.md"), "utf8").catch(() => "");
     return { ...normalize(slug, (raw ?? {})), system: system.trim() };
 }
-export async function saveMember(input) {
+export async function saveAgent(input) {
     const name = input.name?.trim();
     if (!name)
         throw new Error("name is required");
@@ -99,8 +114,8 @@ export async function saveMember(input) {
     if (input.effort && !EFFORTS.includes(input.effort)) {
         throw new Error(`effort must be one of: ${EFFORTS.join(", ")}`);
     }
-    const slug = input.slug ? safeMemberSlug(input.slug) : slugFromName(name);
-    const dir = path.join(await teamRoot(), slug);
+    const slug = input.slug ? safeAgentSlug(input.slug) : slugFromName(name);
+    const dir = path.join(await agentsRoot(), slug);
     await fs.mkdir(dir, { recursive: true });
     // Profile edits must not silently unarchive: carry the flag over.
     const existing = await fs
@@ -122,11 +137,11 @@ export async function saveMember(input) {
     };
     await fs.writeFile(path.join(dir, "agent.yml"), stringify(yml));
     await fs.writeFile(path.join(dir, "system.md"), (input.system ?? "").trim() + "\n");
-    return (await getMember(slug));
+    return (await getAgent(slug));
 }
 /** Archive/unarchive a member: toggles `archived:` in agent.yml, nothing else. */
-export async function setMemberArchived(slug, archived) {
-    const dir = path.join(await teamRoot(), safeMemberSlug(slug));
+export async function setAgentArchived(slug, archived) {
+    const dir = path.join(await agentsRoot(), safeAgentSlug(slug));
     let raw;
     try {
         raw = (parse(await fs.readFile(path.join(dir, "agent.yml"), "utf8")) ?? {});
@@ -140,9 +155,9 @@ export async function setMemberArchived(slug, archived) {
     else
         delete yml.archived;
     await fs.writeFile(path.join(dir, "agent.yml"), stringify(yml));
-    return (await getMember(slug));
+    return (await getAgent(slug));
 }
-export async function deleteMember(slug) {
-    const dir = path.join(await teamRoot(), safeMemberSlug(slug));
+export async function deleteAgent(slug) {
+    const dir = path.join(await agentsRoot(), safeAgentSlug(slug));
     await fs.rm(dir, { recursive: true, force: true });
 }

package/dist/inspector/chat/backend.d.ts

@@ -19,7 +19,7 @@ export interface BackendHooks {
     }>): Promise<string | null>;
 }
 /**
- * Optional per-chat model/effort overrides (from a team member definition).
+ * Optional per-chat model/effort overrides (from an agent definition).
  * Each backend maps them onto whatever its agent actually supports.
  */
 export interface BackendTuning {