@netnodeag/kraftwerk 0.35.0 → 0.37.0

package/README.md

@@ -179,8 +179,8 @@ 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
-`agents/`).
+(default `knowledge/`), and `agents:` the agent-definition root (default
+`agents/`). `repos:` turns on the [repositories](#repositories) folder.
 
 `switcher:` links other kraftwerk workspaces from the inspector header. The
 workspace name becomes a dropdown listing them:
@@ -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,81 @@ 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.
 
+### Repositories
+
+Turn on `repos:` in `kraftwerk.yml` (or the checkbox in settings) and the
+workspace gets one folder for the git repositories its agents work on:
+
+```yaml
+repos:
+  root: kraftwerk-data/repos   # default: repos/ — git-ignored, never synced
+```
+
+The folder is the registry. Whatever has a `.git` directly under the root is
+a repository, whether the "repositories" screen cloned it, `kraftwerk repos
+add <url>` did, or an agent ran `git clone` there. Every entry is read live
+from git: origin, branch, head, uncommitted changes, ahead/behind. The
+screen clones by url, fetches and fast-forwards clean clones, and removes
+them (refusing while they hold unpushed or uncommitted work). Cloning uses
+your own git credentials and never prompts, so a private remote has to work
+from a terminal first.
+
+Every agent, and the inspector assistant, gets the list as context: where
+the root is, what is cloned, and how to add more with the CLI. So "look at
+the widgets repo" works as soon as it is cloned, and "clone
+github:org/widgets and look at it" works before.
+
+```bash
+kraftwerk repos                                  # name, branch, head, state
+kraftwerk repos add github:org/widgets           # or any https / ssh url
+kraftwerk repos add <url> --name tools --branch dev
+kraftwerk repos add <url> --depth 1              # shallow clone of a large repository
+kraftwerk repos update widgets                   # fetch, fast-forward when clean
+kraftwerk repos remove widgets [--force]
+```
+
+`GET /api/repos` returns the same list for automation. The root must be a
+folder inside the project (never the project itself): it is excluded from the
+workspace git sync, the first clone adds it to `.gitignore`, and `kraftwerk
+doctor` warns when git does not ignore it.
+
 ### 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 +358,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 +383,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/doctor.js

@@ -2,7 +2,7 @@ import { spawnSync } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import chalk from "chalk";
-import { isDir, resolveProject } from "../config.js";
+import { ignoreEntryFor, isDir, reposRootFor, resolveProject } from "../config.js";
 import { discoverWorkflows } from "../discover.js";
 import { missingEnv } from "../yaml.js";
 const ICONS = {
@@ -106,6 +106,23 @@ export async function runDoctor(cwd) {
             }
         }
     }
+    // Repositories: the clones root must stay out of the workspace git. git
+    // itself decides — that covers worktrees (.git is a file), a workspace
+    // nested in a larger repo, a .gitignore at the toplevel, global excludes.
+    const reposRoot = reposRootFor(project);
+    if (reposRoot) {
+        const entry = ignoreEntryFor(project.root, reposRoot) ?? path.relative(project.root, reposRoot);
+        const label = `repos: ${path.relative(cwd, reposRoot) || "."}`;
+        const check = spawnSync("git", ["check-ignore", "-q", "--", reposRoot], { cwd: project.root, encoding: "utf8" });
+        if (check.error)
+            report("info", label, "git not found — cannot check .gitignore");
+        else if (check.status === 0)
+            report("ok", label, "git-ignored");
+        else if (check.status === 1)
+            report("warn", label, `${entry}/ is not git-ignored — clones would show up as untracked gitlinks; add it to .gitignore`);
+        else
+            report("ok", label, "not inside a git repository");
+    }
     const found = project.workflowsRoot ? await discoverWorkflows(cwd) : [];
     if (!project.workflowsRoot) {
         report("warn", "no workflows root", "expected src/workflows/ or workflows/ — `kraftwerk init` scaffolds one");

package/dist/cli/init.js

@@ -1,12 +1,12 @@
 import { appendFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import chalk from "chalk";
-import { CONFIG_SCHEMA_URL, SCHEMA_URL } from "../config.js";
+import { CONFIG_SCHEMA_URL, gitignoreHas, SCHEMA_URL } from "../config.js";
 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,8 +20,10 @@ 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)
+# repos:                          # git repositories the agents work on (uncomment both lines to enable)
+#   root: ${DATA_DIR}/repos       # clones land here (git-ignored); a bare \`repos:\` uses repos/ instead
 `;
 const WORKFLOW_TEMPLATE = `# yaml-language-server: $schema=${SCHEMA_URL}
 name: hello
@@ -107,7 +109,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.
@@ -124,20 +126,25 @@ export async function runInit(cwd) {
         await writeConcept(knowledgeRoot, DEMO_BUNDLE, "playbooks/refunds", DEMO_CONCEPT, "kraftwerk-init");
         created.push(bundleRel);
     }
-    // .gitignore: append the output dir if it's not covered yet.
-    const outputEntry = `${DATA_DIR}/output`;
+    // .gitignore: the output dir and the repos root (clones must never become
+    // gitlinks of the workspace repo). A missing file gets both in one write;
+    // an existing one only the entries it lacks.
     const gitignorePath = path.join(cwd, ".gitignore");
     const gitignore = (await readFile(gitignorePath, "utf8").catch(() => null)) ?? null;
+    const entries = [`${DATA_DIR}/output`, `${DATA_DIR}/repos`];
     if (gitignore === null) {
-        await writeFile(gitignorePath, `${outputEntry}/\n`);
+        await writeFile(gitignorePath, entries.map((e) => `${e}/\n`).join(""));
         created.push(".gitignore");
     }
-    else if (!gitignore.split("\n").some((l) => l.trim().replace(/\/$/, "") === outputEntry)) {
-        await appendFile(gitignorePath, `${gitignore.endsWith("\n") ? "" : "\n"}${outputEntry}/\n`);
-        created.push(`.gitignore (${outputEntry}/ added)`);
-    }
     else {
-        skipped.push(".gitignore");
+        const missing = entries.filter((e) => !gitignoreHas(gitignore, e));
+        if (missing.length === 0) {
+            skipped.push(".gitignore");
+        }
+        else {
+            await appendFile(gitignorePath, `${gitignore.endsWith("\n") ? "" : "\n"}${missing.map((e) => `${e}/\n`).join("")}`);
+            created.push(`.gitignore (${missing.map((e) => `${e}/`).join(", ")} added)`);
+        }
     }
     for (const f of created)
         console.log(`${chalk.green("✔")} ${f}`);

package/dist/cli/kraftwerk.js

@@ -13,6 +13,7 @@ import { runDoctor } from "./doctor.js";
 import { runInit } from "./init.js";
 import { registerKnowledgeCommands } from "./knowledge.js";
 import { registerProjectCommands } from "./projects.js";
+import { registerRepoCommands } from "./repos.js";
 import { registerRoutineCommands } from "./routines.js";
 import { listRuns, showRun } from "./runs.js";
 import { runUi } from "./ui.js";
@@ -27,6 +28,7 @@ import { runUi } from "./ui.js";
  *   kraftwerk routines ...            per-agent scheduled prompts (list/add/remove/enable/run)
  *   kraftwerk ui                      start the inspector web UI (localhost:1981)
  *   kraftwerk projects ...            known projects on this machine (list/start/forget)
+ *   kraftwerk repos ...               repositories the agents work on (list/add/update/remove)
  *   kraftwerk doctor                  preflight: harness CLIs, docker, workflows, env
  *   kraftwerk validate [paths...]     validate without executing
  *
@@ -259,6 +261,7 @@ runs
 registerKnowledgeCommands(program);
 registerRoutineCommands(program);
 registerProjectCommands(program);
+registerRepoCommands(program);
 program
     .command("ui")
     .description("Start the inspector web UI for this project's runs and workflows")

package/dist/cli/projects.d.ts

@@ -1,2 +1,16 @@
 import type { Command } from "commander";
+/**
+ * `kraftwerk projects` — every project that ever ran the inspector on this
+ * machine (~/.kraftwerk/projects), joined with what is running right now.
+ * The answer to "where did I start that UI, and how do I get it back":
+ *
+ *   kraftwerk projects                 list: name, root, running/stopped
+ *   kraftwerk projects start <ref>     relaunch `kraftwerk ui` in that root, detached
+ *   kraftwerk projects stop <ref>      SIGTERM a running UI (also ones started in a terminal)
+ *   kraftwerk projects forget <ref>    drop the record (the folder stays)
+ *
+ * <ref> is a project name, the root's folder name, the root path, or a
+ * port / localhost:port for running instances that recorded no root.
+ */
+export declare const fmtAgo: (iso?: string) => string;
 export declare function registerProjectCommands(program: Command): void;

package/dist/cli/projects.js

@@ -15,7 +15,7 @@ import { discoverWorkspaces, forgetProject, startProject, stopProject, tildify,
  * <ref> is a project name, the root's folder name, the root path, or a
  * port / localhost:port for running instances that recorded no root.
  */
-const fmtAgo = (iso) => {
+export const fmtAgo = (iso) => {
     if (!iso)
         return "—";
     const s = Math.max(0, (Date.now() - Date.parse(iso)) / 1000);

package/dist/cli/repos.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerRepoCommands(program: Command): void;

package/dist/cli/repos.js

@@ -0,0 +1,115 @@
+import chalk from "chalk";
+import Table from "cli-table3";
+import { addRepo, listRepos, removeRepo, updateRepo } from "../inspector/repos.js";
+import { fmtAgo } from "./projects.js";
+import { initContext as prepare } from "./routines.js";
+/**
+ * `kraftwerk repos` — the git repositories the agents work on, kept under
+ * the project's repos root (`repos.root` in kraftwerk.yml). The same module
+ * the inspector uses, so a clone made here shows up on the repositories
+ * screen and in every agent's context at once:
+ *
+ *   kraftwerk repos                        list: name, branch, head, state
+ *   kraftwerk repos add <url> [--name x] [--branch b] [--depth n]
+ *   kraftwerk repos update <name>          fetch, fast-forward when clean
+ *   kraftwerk repos remove <name> [--force]
+ */
+const die = (msg) => {
+    console.error(chalk.red(msg));
+    process.exit(1);
+};
+export function registerRepoCommands(program) {
+    const repos = program
+        .command("repos")
+        .description("Repositories the agents work on: list, clone one into the repos root, update, remove");
+    repos
+        .command("list", { isDefault: true })
+        .description("List the clones under the repos root with branch, head and state")
+        .option("--json", "Machine-readable output")
+        .action(async (opts) => {
+        await prepare();
+        const view = await listRepos();
+        if (opts.json) {
+            console.log(JSON.stringify(view, null, 2));
+            return;
+        }
+        if (!view.enabled)
+            die(view.error ?? "repositories are off");
+        if (view.repos.length === 0) {
+            console.log(chalk.dim(`No repositories under ${view.root} yet — \`kraftwerk repos add <url>\` clones one.`));
+            return;
+        }
+        const table = new Table({
+            head: ["name", "branch", "head", "state", "url"].map((h) => chalk.bold(h)),
+            wordWrap: true,
+            colWidths: [22, 16, 30, 18, 40],
+        });
+        for (const r of view.repos) {
+            const state = r.error
+                ? chalk.red(r.error)
+                : [
+                    r.dirty ? chalk.yellow(`${r.dirty} changed`) : "",
+                    r.ahead ? chalk.green(`${r.ahead}↑`) : "",
+                    r.behind ? chalk.cyan(`${r.behind}↓`) : "",
+                ]
+                    .filter(Boolean)
+                    .join(" ") || chalk.dim("clean");
+            table.push([
+                chalk.cyan(r.slug),
+                r.branch ?? "—",
+                r.head ? `${r.head} ${chalk.dim(r.subject ?? "")}\n${chalk.dim(fmtAgo(r.committedAt))}` : "—",
+                state,
+                r.url ?? chalk.dim("(no origin)"),
+            ]);
+        }
+        console.log(table.toString());
+        console.log(chalk.dim(view.root ?? ""));
+    });
+    repos
+        .command("add")
+        .description("Clone a repository into the repos root")
+        .argument("<url>", "git url, or github:org/repo")
+        .option("--name <name>", "Folder name under the root (default: last url segment)")
+        .option("--branch <branch>", "Branch to check out")
+        .option("--depth <n>", "Shallow clone with n commits of history (large repositories)")
+        .option("--json", "Print the new entry as JSON")
+        .action(async (url, opts) => {
+        await prepare();
+        try {
+            const depth = opts.depth === undefined ? undefined : Number(opts.depth);
+            const repo = await addRepo({ url, name: opts.name, branch: opts.branch, depth });
+            if (opts.json)
+                console.log(JSON.stringify(repo, null, 2));
+            else
+                console.log(`${chalk.green("✔")} ${chalk.cyan(repo.slug)} → ${repo.path}${repo.branch ? chalk.dim(` (${repo.branch})`) : ""}`);
+        }
+        catch (err) {
+            die(err.message);
+        }
+    });
+    repos
+        .command("update")
+        .description("Fetch a repository and fast-forward it when it is clean")
+        .argument("<name>", "Folder name under the root")
+        .action(async (name) => {
+        await prepare();
+        const r = await updateRepo(name).catch((err) => ({ ok: false, error: err.message, repo: undefined }));
+        if (!r.ok)
+            die(r.error ?? "update failed");
+        const repo = r.repo;
+        const tail = r.error ? chalk.yellow(` — ${r.error}`) : "";
+        console.log(`${chalk.green("✔")} ${chalk.cyan(name)} at ${repo.head} ${chalk.dim(repo.subject ?? "")}${tail}`);
+    });
+    repos
+        .command("remove")
+        .description("Delete a clone from the repos root (refused while it holds unpushed or uncommitted work)")
+        .argument("<name>", "Folder name under the root")
+        .option("--force", "Delete even with local changes")
+        .action(async (name, opts) => {
+        await prepare();
+        const r = await removeRepo(name, !!opts.force).catch((err) => ({ ok: false, error: err.message }));
+        if (!r.ok)
+            die(r.error ?? "remove failed");
+        console.log(`${chalk.green("✔")} removed ${chalk.cyan(name)}`);
+    });
+}

package/dist/cli/routines.d.ts

@@ -1,2 +1,12 @@
 import type { Command } from "commander";
+/**
+ * `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 agent/routine paths resolve. */
+export declare function initContext(): Promise<{
+    port: number;
+}>;
 export declare function registerRoutineCommands(program: Command): void;

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. */
-async function initContext() {
+/** Point the inspector context at this project so agent/routine paths resolve. */
+export 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
@@ -25,6 +25,8 @@
  *     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 declare const SCHEMA_URL = "https://raw.githubusercontent.com/NETNODEAG/kraftwerk/main/kraftwerk/schema/workflow.schema.json";
@@ -49,6 +51,29 @@ export interface GitConfig {
     /** off = fetch only. pull = also fast-forward when behind and clean. Default: pull. */
     autosync?: "off" | "pull";
 }
+/**
+ * Repositories: git clones the agents work on, kept under one root inside
+ * the project so every agent finds them at a known path. The root is never
+ * synced by the workspace git and should be git-ignored.
+ */
+export interface ReposConfig {
+    /** false keeps the block but turns the feature off. Default: true. */
+    enabled?: boolean;
+    /** Where clones land, relative to the project root. Default: repos */
+    root?: string;
+}
+/** Where clones land when `repos.root` is not set. */
+export declare 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 declare function reposRootFor(project: Project): string | undefined;
+/** A directory as a .gitignore entry: relative, forward slashes, no trailing slash; undefined outside the root. */
+export declare function ignoreEntryFor(projectRoot: string, dir: string): string | undefined;
+/** True when .gitignore text already covers the entry (with or without a leading or trailing slash). */
+export declare function gitignoreHas(text: string, entry: string): boolean;
 /** One entry of the workspace switcher: another kraftwerk instance to link to. */
 export interface SwitcherEntry {
     /** Display name of the other workspace. */
@@ -71,7 +96,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;
@@ -79,6 +104,8 @@ export interface ProjectConfig {
     switcher?: SwitcherEntry[];
     /** Workspace git sync. Absent = off. */
     git?: GitConfig;
+    /** Repositories the agents work on. Absent = off. */
+    repos?: ReposConfig;
 }
 export interface Project {
     /** Absolute project root the CLI operates on. */