@netnodeag/kraftwerk 0.35.0 → 0.37.0

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
@@ -28,6 +28,8 @@ import { parse } from "yaml";
  *     remote: origin
  *     interval: 300            # seconds between background fetches
  *     autosync: pull           # off | pull
+ *   repos:                     # git repositories the agents work on (absent = off, bare key = on)
+ *     root: kraftwerk-data/repos   # where clones land, relative to the file. Default: repos
  */
 /** 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";
@@ -35,6 +37,30 @@ export const SCHEMA_URL = "https://raw.githubusercontent.com/NETNODEAG/kraftwerk
 export const CONFIG_SCHEMA_URL = "https://raw.githubusercontent.com/NETNODEAG/kraftwerk/main/kraftwerk/schema/kraftwerk.schema.json";
 export const CONFIG_FILENAMES = ["kraftwerk.yml", "kraftwerk.yaml"];
 const WORKFLOW_ROOT_CANDIDATES = ["src/workflows", "workflows"];
+/** Where clones land when `repos.root` is not set. */
+export const REPOS_DEFAULT_ROOT = "repos";
+/**
+ * Absolute repos root when the feature is on, undefined otherwise. The one
+ * place that reads the block, so the sync exclude, the doctor check, the
+ * settings save and the module itself cannot disagree.
+ */
+export function reposRootFor(project) {
+    const r = project.config.repos;
+    if (!r || r.enabled === false)
+        return undefined;
+    return path.resolve(project.root, r.root ?? REPOS_DEFAULT_ROOT);
+}
+/** A directory as a .gitignore entry: relative, forward slashes, no trailing slash; undefined outside the root. */
+export function ignoreEntryFor(projectRoot, dir) {
+    const rel = path.relative(projectRoot, path.resolve(projectRoot, dir)).split(path.sep).join("/");
+    if (!rel || rel === "." || rel.startsWith(".."))
+        return undefined;
+    return rel;
+}
+/** True when .gitignore text already covers the entry (with or without a leading or trailing slash). */
+export function gitignoreHas(text, entry) {
+    return text.split("\n").some((l) => l.trim().replace(/^\//, "").replace(/\/$/, "") === entry);
+}
 const exists = async (p) => !!(await stat(p).catch(() => null));
 /** True when the path exists and is a directory. */
 export const isDir = async (p) => (await stat(p).catch(() => null))?.isDirectory() ?? false;
@@ -87,7 +113,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"];
+const KNOWN_KEYS = ["name", "icon", "port", "workflows", "output", "knowledge", "agents", "skills", "switcher", "git", "repos"];
 async function loadConfig(configPath) {
     let raw;
     try {
@@ -123,6 +149,11 @@ async function loadConfig(configPath) {
                 config[key] = {};
             validateGit(configPath, config[key]);
         }
+        else if (key === "repos") {
+            if (config[key] === null)
+                config[key] = {};
+            validateRepos(configPath, config[key]);
+        }
         else if (typeof config[key] !== "string") {
             throw new Error(`${path.basename(configPath)}: ${key} must be a string`);
         }
@@ -182,3 +213,26 @@ function validateGit(configPath, value) {
         throw new Error(`${file}: git.autosync must be "off" or "pull"`);
     }
 }
+function validateRepos(configPath, value) {
+    const file = path.basename(configPath);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`${file}: repos must be a mapping (enabled, root)`);
+    }
+    const r = value;
+    for (const key of Object.keys(r)) {
+        if (!["enabled", "root"].includes(key)) {
+            throw new Error(`${file}: repos.${key} is unknown (allowed: enabled, root)`);
+        }
+    }
+    if (r.enabled !== undefined && typeof r.enabled !== "boolean") {
+        throw new Error(`${file}: repos.enabled must be true or false`);
+    }
+    if (r.root !== undefined && (typeof r.root !== "string" || !r.root.trim())) {
+        throw new Error(`${file}: repos.root must be a non-empty string`);
+    }
+    // The root is what `repos remove --force` deletes under, so it must never
+    // be the project itself or anything outside it.
+    if (typeof r.root === "string" && !ignoreEntryFor(path.dirname(configPath), r.root.trim())) {
+        throw new Error(`${file}: repos.root must be a directory inside the project (not ".", ".." or an absolute path outside it)`);
+    }
+}

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,8 @@ 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 { listRepos } from "../repos.js";
 import { startAcpBackend } from "./acp.js";
 import { startPiBackend } from "./pi.js";
 import { appendEvent, listChatMetas, newChatId, readEvents, readMeta, safeChatDir, writeMeta, } from "./store.js";
@@ -74,19 +75,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 +123,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 +140,53 @@ 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`);
 }
+/**
+ * "## Repositories" block: the clones under the repos root, when the
+ * feature is on. Empty when it is off, so agents in a workspace without
+ * it never hear about it.
+ */
+async function reposContext() {
+    const view = await listRepos().catch(() => null);
+    if (!view?.enabled || !view.root)
+        return "";
+    const lines = view.repos
+        .map((r) => {
+        const state = r.error ? `unreadable: ${r.error}` : [r.dirty ? `${r.dirty} uncommitted` : "clean", r.ahead ? `${r.ahead} ahead` : "", r.behind ? `${r.behind} behind` : ""].filter(Boolean).join(", ");
+        return `- ${r.slug} — ${r.path}${r.url ? ` (${r.url})` : ""}${r.branch ? `, branch ${r.branch}` : ""}${r.head ? ` @ ${r.head}` : ""}, ${state}`;
+    })
+        .join("\n");
+    return (`## Repositories\nGit repositories this workspace works on live under ${view.root} (one clone per folder). ` +
+        `When the user names one of them, work inside its folder: read its README and structure first, keep commits on a ` +
+        `branch unless told otherwise, and never push or force-push without asking.\n${lines || "(none cloned yet)"}\n\n` +
+        `Clone a new one with \`npx kraftwerk repos add <url> [--name <folder>] [--branch <b>] [--depth <n>]\` so it lands in ` +
+        `that root (\`--depth 1\` for a large repository; a plain \`git clone\` into that folder works too); ` +
+        `\`npx kraftwerk repos\` lists them, \`update <name>\` fetches and fast-forwards a clean clone, \`remove <name>\` ` +
+        `deletes one. A repository the user mentions that is not listed is not cloned yet — offer to add it.`);
+}
 /** 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 +198,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 +236,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 +252,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 +268,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.`);
     }
@@ -278,25 +302,28 @@ const RENDERING_BLOCK = `## Chat rendering\n` +
     `Prefer these relative /api/... URLs over file paths when showing results: they render directly ` +
     `in this chat and keep working wherever the inspector is reachable.`;
 async function scopeContext(scope, agent) {
-    const [base, skills] = await Promise.all([
+    // The repositories block reads every clone from git, so it runs alongside
+    // the rest instead of adding its spawns to the first prompt's latency.
+    const [base, repos, skills] = await Promise.all([
         baseScopeContext(scope, agent),
+        scope.kind === "agent" || scope.kind === "kraftwerk" ? reposContext() : Promise.resolve(""),
         availableSkills(scope),
     ]);
-    return [base, RENDERING_BLOCK, skillsBlock(skills)].filter(Boolean).join("\n\n");
+    return [base, repos, 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 +346,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 +445,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) {

package/dist/inspector/chat/store.js

@@ -26,12 +26,24 @@ export async function writeMeta(meta) {
 }
 export async function readMeta(id) {
     try {
-        return JSON.parse(await fs.readFile(path.join(safeChatDir(id), "meta.json"), "utf8"));
+        return upgradeMeta(JSON.parse(await fs.readFile(path.join(safeChatDir(id), "meta.json"), "utf8")));
     }
     catch {
         return null;
     }
 }
+/**
+ * Chats written before 0.36 scoped agent sessions as
+ * { kind: "team", member } — read them as { kind: "agent", slug } so the
+ * folders on disk never need rewriting.
+ */
+function upgradeMeta(meta) {
+    const legacy = meta.scope;
+    if (legacy?.kind === "team" && typeof legacy.member === "string") {
+        meta.scope = { kind: "agent", slug: legacy.member, ...(legacy.routine ? { routine: legacy.routine } : {}) };
+    }
+    return meta;
+}
 export async function appendEvent(id, ev) {
     await fs.appendFile(path.join(safeChatDir(id), "events.jsonl"), JSON.stringify(ev) + "\n");
 }

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

@@ -17,8 +17,8 @@ export type ChatScope = {
     kind: "knowledge";
     bundle?: string;
 } | {
-    kind: "team";
-    member: string;
+    kind: "agent";
+    slug: string;
     routine?: string;
 };
 export interface ChatMeta {

package/dist/inspector/git.d.ts

@@ -40,6 +40,20 @@ export interface GitDiff {
     /** The diff was cut at MAX_DIFF; the rest is available in a terminal. */
     truncated?: boolean;
 }
+export interface GitResult {
+    ok: boolean;
+    /** Exit status, or null when git never ran (spawn error) or was killed. */
+    code: number | null;
+    stdout: string;
+    stderr: string;
+}
+export declare const NET_TIMEOUT = 60000;
+export declare function git(args: string[], cwd: string, timeoutMs?: number, env?: NodeJS.ProcessEnv): Promise<GitResult>;
+export declare function sshCommandFor(repoRoot: string): Promise<string>;
+/** A git call that may touch the network: longer timeout, non-interactive ssh. */
+export declare function gitNet(args: string[], repoRoot: string): Promise<GitResult>;
+/** Repo root for a directory, or null when it is not inside a git repo. */
+export declare function repoRootFor(dir: string): Promise<string | null>;
 /**
  * Everything the git screen renders. Each call shells out to git a handful
  * of times, and the nav badge polls it from every open tab, so results are