@netnodeag/kraftwerk 0.35.0 → 0.36.0

package/README.md

@@ -179,7 +179,7 @@ different host.
 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
@@ -192,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
@@ -249,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
@@ -269,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
@@ -313,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`.
 
@@ -338,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,7 +15,7 @@
  *   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
@@ -71,7 +71,7 @@ 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;

package/dist/config.js

@@ -18,7 +18,7 @@ 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

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 {

package/dist/inspector/chat/sessions.js

@@ -5,7 +5,7 @@ import { knowledgeIndex } from "../knowledge.js";
 import { getRun, listRuns, safeRunDir } from "../runs.js";
 import { listSkills, readSkill } from "../skills.js";
 import { listWorkflows } from "../workflows.js";
-import { getMember, listMembers } from "../team.js";
+import { getAgent, listAgents } from "../agents.js";
 import { startAcpBackend } from "./acp.js";
 import { startPiBackend } from "./pi.js";
 import { appendEvent, listChatMetas, newChatId, readEvents, readMeta, safeChatDir, writeMeta, } from "./store.js";
@@ -74,19 +74,19 @@ function emit(state, ev) {
 /* ---------- skills ---------- */
 /**
  * Skills visible to a chat: every discovered skill (workspace skills root
- * + .claude/skills roots, plus the member's own agents/<slug>/skills for team
- * sessions), narrowed by the team member's allowlist when the chat is a team
+ * + .claude/skills roots, plus the agent's own agents/<slug>/skills for agent
+ * sessions), narrowed by the agent's allowlist when the chat is an agent
  * session (absent allowlist = all, empty = none). The agent's own skills
  * always apply — the allowlist narrows shared skills only.
  */
 async function availableSkills(scope) {
-    const all = await listSkills(scope.kind === "team" ? scope.member : undefined).catch(() => []);
-    if (scope.kind !== "team")
+    const all = await listSkills(scope.kind === "agent" ? scope.slug : undefined).catch(() => []);
+    if (scope.kind !== "agent")
         return all;
-    const member = await getMember(scope.member).catch(() => null);
-    if (!member || member.skills === undefined)
+    const def = await getAgent(scope.slug).catch(() => null);
+    if (!def || def.skills === undefined)
         return all;
-    const allowed = new Set(member.skills.map((n) => n.toLowerCase()));
+    const allowed = new Set(def.skills.map((n) => n.toLowerCase()));
     return all.filter((s) => s.source === "agent" || allowed.has(s.name.toLowerCase()));
 }
 /** "## Your skills" context block (empty when no skills are visible). */
@@ -122,12 +122,12 @@ async function expandSkillInvocation(scope, text) {
         `Arguments the user passed to the skill: ${args || "(none)"}`);
 }
 /* ---------- scope context ---------- */
-/** "## Your knowledge" block for a team member's connected OKF bundles. */
-async function teamKnowledgeContext(member) {
-    if (member.knowledge.length === 0)
+/** "## Your knowledge" block for a agent's connected OKF bundles. */
+async function agentKnowledgeContext(def) {
+    if (def.knowledge.length === 0)
         return "";
     const { bundles } = await knowledgeIndex().catch(() => ({ bundles: [] }));
-    const lines = member.knowledge
+    const lines = def.knowledge
         .map((name) => {
         const b = bundles.find((x) => x.name === name);
         return b
@@ -139,30 +139,30 @@ async function teamKnowledgeContext(member) {
         `part of your job. Consult them before answering questions in their domain, and keep them current ` +
         `when you learn something durable:\n${lines}\n\n` +
         `Read with \`npx kraftwerk knowledge list <bundle>\`, \`get <bundle>/<path>\`, \`search <text>\`. ` +
-        `Write ONLY through \`npx kraftwerk knowledge put <bundle>/<path> --file <tmp.md> --actor ${member.slug}/${member.harness}\` ` +
+        `Write ONLY through \`npx kraftwerk knowledge put <bundle>/<path> --file <tmp.md> --actor ${def.slug}/${def.harness}\` ` +
         `(write the markdown to a temp file first; the CLI stamps provenance and maintains index.md/log.md). ` +
         `Never hand-edit index.md or log.md, and never add \`verified\` yourself — verification is the human's ` +
         `click in the UI.\n\n`);
 }
 /** Base context per scope; scopeContext() appends the shared skills block. */
 async function baseScopeContext(scope, agent) {
-    if (scope.kind === "team") {
-        const member = await getMember(scope.member).catch(() => null);
-        if (!member) {
-            return `You were opened as team agent "${scope.member}", but its definition under agents/ is missing. Tell the user and ask them to recreate it.`;
+    if (scope.kind === "agent") {
+        const def = await getAgent(scope.slug).catch(() => null);
+        if (!def) {
+            return `You were opened as agent "${scope.slug}", but its definition under agents/ is missing. Tell the user and ask them to recreate it.`;
         }
         const { workflows } = await listWorkflows().catch(() => ({ workflows: [] }));
-        const connected = workflows.filter((w) => member.workflows.includes(w.slug));
-        const missing = member.workflows.filter((slug) => !connected.some((w) => w.slug === slug));
+        const connected = workflows.filter((w) => def.workflows.includes(w.slug));
+        const missing = def.workflows.filter((slug) => !connected.some((w) => w.slug === slug));
         const wfLines = connected
             .map((w) => `- ${w.slug}: ${w.description ?? w.name ?? ""} (${w.steps} steps)`)
             .join("\n");
-        return (`You are ${member.emoji} ${member.name}, a persistent agent teammate on this project's team ` +
-            `(defined in agents/${member.slug}/). The user works with you like with a colleague: every session ` +
-            `is a conversation with the same ${member.name}, so keep this role consistently. You are an AI agent, ` +
+        return (`You are ${def.emoji} ${def.name}, a persistent agent of this project ` +
+            `(defined in agents/${def.slug}/). The user works with you like with a colleague: every session ` +
+            `is a conversation with the same ${def.name}, so keep this role consistently. You are an AI agent, ` +
             `not a human — never pretend otherwise, but do own your role.\n\n` +
-            `## Your role\n${member.system || "(no system prompt written yet — ask the user what your job should be)"}\n\n` +
-            (member.workflows.length > 0
+            `## Your role\n${def.system || "(no system prompt written yet — ask the user what your job should be)"}\n\n` +
+            (def.workflows.length > 0
                 ? `## Your workflows\nThese kraftwerk workflows are part of your job. When the user's request matches one, ` +
                     `run it yourself instead of doing the work by hand:\n${wfLines || "(none found)"}\n` +
                     (missing.length > 0
@@ -174,9 +174,9 @@ async function baseScopeContext(scope, agent) {
                     `run id and summarize the result. Confirm with the user before starting a long or expensive run ` +
                     `unless they clearly asked for it.\n\n`
                 : "") +
-            (await teamKnowledgeContext(member)) +
+            (await agentKnowledgeContext(def)) +
             `The working directory is the project root. Stay within your role; if a request is clearly outside it, ` +
-            `say so and suggest which teammate or tool fits better.` +
+            `say so and suggest which agent or tool fits better.` +
             (scope.routine
                 ? `\n\nThis session was started automatically by your scheduled routine "${scope.routine}" — ` +
                     `nobody may be watching live. Complete the task autonomously (tool permissions are ` +
@@ -212,11 +212,11 @@ async function baseScopeContext(scope, agent) {
             `verification is the human's click in the UI. Ask the user what knowledge to capture, then author concise, well-typed concepts.`);
     }
     if (scope.kind === "kraftwerk") {
-        const [{ workflows }, runs, knowledge, members] = await Promise.all([
+        const [{ workflows }, runs, knowledge, agents] = await Promise.all([
             listWorkflows(),
             listRuns(),
             knowledgeIndex().catch(() => ({ bundles: [] })),
-            listMembers().catch(() => []),
+            listAgents().catch(() => []),
         ]);
         const wfLines = workflows
             .map((w) => `- ${w.slug}: ${w.description ?? w.name ?? ""} (${w.steps} steps, ${w.agents} agents)`)
@@ -228,7 +228,7 @@ async function baseScopeContext(scope, agent) {
         const bundleLines = knowledge.bundles
             .map((b) => `- ${b.name} (${b.concepts} concepts${b.updatedAt ? `, updated ${b.updatedAt.slice(0, 10)}` : ""})`)
             .join("\n");
-        const memberLines = members
+        const agentLines = agents
             .map((m) => `- ${m.emoji} ${m.name} (${m.slug})${m.description ? `: ${m.description}` : ""}`)
             .join("\n");
         return (`You are the assistant inside the kraftwerk inspector, a UI for a workflow-as-code agent framework. ` +
@@ -244,8 +244,8 @@ async function baseScopeContext(scope, agent) {
             `Read with \`npx kraftwerk knowledge list [bundle]\`, \`get <bundle>/<path>\`, \`search <text>\`. ` +
             `Write ONLY through \`npx kraftwerk knowledge put <bundle>/<path> --file <tmp.md> --actor kraftwerk-chat/${agent}\` ` +
             `(stamps provenance, maintains index.md/log.md — never hand-edit those).\n\n` +
-            `## Team agents\n${memberLines || "(none)"}\n` +
-            `These are persistent agent teammates (defined under agents/); the user talks to them on the ` +
+            `## Agents\n${agentLines || "(none)"}\n` +
+            `These are persistent agents (defined under agents/); the user talks to them on the ` +
             `Agents screen. Point the user there when a request clearly belongs to one of them.\n\n` +
             `Answer questions about workflows and runs by reading the files above. Do not modify run outputs unless asked.`);
     }
@@ -285,18 +285,18 @@ async function scopeContext(scope, agent) {
     return [base, RENDERING_BLOCK, skillsBlock(skills)].filter(Boolean).join("\n\n");
 }
 /* ---------- backend lifecycle ---------- */
-/** Team chats carry the member's model/effort; resolved live so edits apply to new backends. */
+/** Agent sessions carry the agent's model/effort; resolved live so edits apply to new backends. */
 async function backendTuning(scope, agent) {
     const tuning = {};
-    if (scope.kind === "team") {
-        const member = await getMember(scope.member).catch(() => null);
-        if (member?.model)
-            tuning.model = member.model;
-        if (member?.effort)
-            tuning.effort = member.effort;
-        // Claude discovers skills natively; a defined allowlist narrows that.
-        if (agent === "claude" && member?.skills)
-            tuning.skills = member.skills;
+    if (scope.kind === "agent") {
+        const def = await getAgent(scope.slug).catch(() => null);
+        if (def?.model)
+            tuning.model = def.model;
+        if (def?.effort)
+            tuning.effort = def.effort;
+        // Claude discovers skills natively; an agentined allowlist narrows that.
+        if (agent === "claude" && def?.skills)
+            tuning.skills = def.skills;
     }
     // Run chats live in the run folder — grant claude the project root so
     // project-level skills and files stay reachable.
@@ -319,7 +319,7 @@ async function ensureBackend(state) {
             // Routine-triggered sessions run unattended: auto-approve, but keep
             // the request/resolution pair in the thread as an audit trail.
             const scope = state.meta.scope;
-            if (scope.kind === "team" && scope.routine) {
+            if (scope.kind === "agent" && scope.routine) {
                 const allow = options.find((o) => o.kind?.startsWith("allow")) ?? options[0];
                 const requestId = randomUUID();
                 emit(state, { type: "permission_request", requestId, title, options });
@@ -418,7 +418,7 @@ export async function postMessage(id, text) {
             // Routine sessions are one-shot and unattended: release the agent
             // process as soon as the turn ends instead of waiting for the reaper.
             const scope = state.meta.scope;
-            if (scope.kind === "team" && scope.routine)
+            if (scope.kind === "agent" && scope.routine)
                 dropBackend(state);
         }
         catch (err) {