@netnodeag/kraftwerk 0.35.0 → 0.37.0

package/dist/inspector/git.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { realpathSync } from "node:fs";
 import path from "node:path";
-import { resolveProject } from "../config.js";
+import { reposRootFor, resolveProject } from "../config.js";
 import { ENV_FILE } from "../runner/docker.js";
 import { getOutputDir, getProjectRoot } from "./context.js";
 /**
@@ -44,7 +44,7 @@ const DENY = [
 const DEFAULTS = { remote: "origin", interval: 300, autosync: "pull" };
 /** Local operations are quick; anything touching the network gets longer. */
 const LOCAL_TIMEOUT = 15_000;
-const NET_TIMEOUT = 60_000;
+export const NET_TIMEOUT = 60_000;
 const MAX_OUTPUT = 32 * 1024 * 1024;
 /** Longest diff the screen gets; a dumped database under knowledge/ is not something to read in a browser. */
 const MAX_DIFF = 512 * 1024;
@@ -70,7 +70,7 @@ const gitEnv = (extra) => ({
     GIT_OPTIONAL_LOCKS: "0",
     ...extra,
 });
-function git(args, cwd, timeoutMs = LOCAL_TIMEOUT, env) {
+export function git(args, cwd, timeoutMs = LOCAL_TIMEOUT, env) {
     return new Promise((resolve) => {
         let child;
         try {
@@ -115,7 +115,7 @@ function git(args, cwd, timeoutMs = LOCAL_TIMEOUT, env) {
  * is left alone: whoever set it owns it.
  */
 const sshCache = new Map();
-async function sshCommandFor(repoRoot) {
+export async function sshCommandFor(repoRoot) {
     if (process.env.GIT_SSH_COMMAND)
         return process.env.GIT_SSH_COMMAND;
     const hit = sshCache.get(repoRoot);
@@ -127,7 +127,7 @@ async function sshCommandFor(repoRoot) {
     return cmd;
 }
 /** A git call that may touch the network: longer timeout, non-interactive ssh. */
-async function gitNet(args, repoRoot) {
+export async function gitNet(args, repoRoot) {
     return git(args, repoRoot, NET_TIMEOUT, { GIT_SSH_COMMAND: await sshCommandFor(repoRoot) });
 }
 /**
@@ -136,7 +136,7 @@ async function gitNet(args, repoRoot) {
  */
 const literal = (p) => `:(literal)${p}`;
 /** Repo root for a directory, or null when it is not inside a git repo. */
-async function repoRootFor(dir) {
+export async function repoRootFor(dir) {
     const r = await git(["rev-parse", "--show-toplevel"], dir);
     return r.ok ? path.resolve(r.stdout.trim()) : null;
 }
@@ -220,10 +220,12 @@ function scopeFor({ project, repoRoot }) {
         project.configPath,
     ];
     const mapped = roots.filter((r) => !!r).map(rel).filter((r) => !!r);
-    const outputRel = rel(getOutputDir());
+    // Clones under the repos root are other people's history, never this
+    // repo's: excluded like run artifacts, whatever the configured roots say.
+    const excluded = [getOutputDir(), reposRootFor(project)].filter((r) => !!r);
     return {
         include: [...new Set(mapped.filter((r) => r !== "."))],
-        exclude: outputRel ? [outputRel] : [],
+        exclude: excluded.map(rel).filter((r) => !!r && r !== "."),
         wholeRepo: mapped.includes("."),
     };
 }
@@ -242,7 +244,7 @@ function reasonFor(file, code, scope) {
     if (DENY.some((re) => re.test(file)))
         return "never synced (secret or key)";
     if (scope.exclude.some((e) => within(file, e)))
-        return "run artifacts, not synced";
+        return "run artifacts or repositories, not synced";
     if (!scope.include.some((r) => within(file, r)))
         return "outside the workspace paths";
     if (/[RC]/.test(code))

package/dist/inspector/instances.d.ts

@@ -1,3 +1,4 @@
+import type { AgentSummary } from "./agents.js";
 /** Durable per-project record. The root is the key; everything else derives from it. */
 export interface ProjectRecord {
     root: string;
@@ -6,6 +7,8 @@ export interface ProjectRecord {
     /** Set on clean shutdown; older than lastStarted means the last run died. */
     lastStopped?: string;
     startCount: number;
+    /** Active agents, as last seen by the instance serving this root. */
+    agents?: AgentSummary[];
 }
 /** A verified running instance, shaped like a switcher entry. */
 export interface DiscoveredInstance {
@@ -39,12 +42,21 @@ export interface WorkspaceEntry {
 export declare const tildify: (p: string) => string;
 /** Write this instance's registry file (call once the server listens). */
 export declare function registerInstance(port: number, root: string): Promise<void>;
+/** Where this instance answers, as the switcher links it (null before listen). */
+export declare const currentInstanceUrl: () => string | null;
 /** Remove this instance's registry file. Sync so exit handlers can call it. */
 export declare function unregisterInstance(): void;
 /** All other running instances, verified live. Cached briefly — /api/meta is polled. */
 export declare function discoverInstances(): Promise<DiscoveredInstance[]>;
 /** Upsert the project record for a root (call on every inspector start). */
 export declare function registerProject(root: string): Promise<void>;
+/**
+ * Write the roster into the project's record. Called on every roster read
+ * (the UI polls it, routines tick it), so a record only changes when the
+ * roster did. Roots with no record (a CLI run in a project that never
+ * started the inspector) are left alone.
+ */
+export declare function syncProjectAgents(root: string, agents: AgentSummary[]): Promise<void>;
 /** Stamp lastStopped on clean shutdown. Sync so exit handlers can call it. */
 export declare function markProjectStopped(): void;
 /** All known projects, most recently started first. */

package/dist/inspector/instances.js

@@ -20,6 +20,9 @@ import { selfCommand } from "./self-command.js";
  * the root's kraftwerk.yml at read time, so it is always current. A
  * project that is not running can be started again from the switcher or
  * `kraftwerk projects start` — that is what makes a killed UI findable.
+ * The record also carries the project's agent roster (written whenever the
+ * instance reads it), so the ⌘K palette can list every workspace's agents
+ * from a handful of small files without probing anything.
  */
 const HOME = path.join(os.homedir(), ".kraftwerk");
 const INSTANCES_DIR = path.join(HOME, "instances");
@@ -47,6 +50,8 @@ export async function registerInstance(port, root) {
     }
     catch { } // best-effort — without it discovery just won't see us
 }
+/** Where this instance answers, as the switcher links it (null before listen). */
+export const currentInstanceUrl = () => (selfPort ? `http://localhost:${selfPort}` : null);
 /** Remove this instance's registry file. Sync so exit handlers can call it. */
 export function unregisterInstance() {
     try {
@@ -137,6 +142,7 @@ async function readProject(file) {
             lastStarted: rec.lastStarted ?? rec.firstSeen ?? "",
             lastStopped: rec.lastStopped,
             startCount: rec.startCount ?? 1,
+            ...(Array.isArray(rec.agents) ? { agents: rec.agents } : {}),
         };
     }
     catch {
@@ -155,11 +161,33 @@ export async function registerProject(root) {
             firstSeen: prev?.firstSeen || now,
             lastStarted: now,
             startCount: (prev?.startCount ?? 0) + 1,
+            ...(prev?.agents ? { agents: prev.agents } : {}),
         };
         await fs.writeFile(projectFile(abs), JSON.stringify(rec, null, 2));
     }
     catch { } // best-effort, like the instance file
 }
+let syncedAgents = "";
+/**
+ * Write the roster into the project's record. Called on every roster read
+ * (the UI polls it, routines tick it), so a record only changes when the
+ * roster did. Roots with no record (a CLI run in a project that never
+ * started the inspector) are left alone.
+ */
+export async function syncProjectAgents(root, agents) {
+    const key = `${root}\n${JSON.stringify(agents)}`;
+    if (key === syncedAgents)
+        return;
+    try {
+        const file = projectFile(root);
+        const rec = await readProject(file);
+        if (!rec)
+            return;
+        await fs.writeFile(file, JSON.stringify({ ...rec, agents }, null, 2));
+        syncedAgents = key;
+    }
+    catch { }
+}
 /** Stamp lastStopped on clean shutdown. Sync so exit handlers can call it. */
 export function markProjectStopped() {
     if (!selfRoot)

package/dist/inspector/repos.d.ts

@@ -0,0 +1,118 @@
+import { type Project } from "../config.js";
+/**
+ * Repositories: the git clones an agent works on, kept under one root
+ * inside the project (`repos.root` in kraftwerk.yml, default repos/). The
+ * folder is the registry: whatever has a .git directory directly under the
+ * root is a repository, whoever put it there — this module, the CLI, or an
+ * agent running plain `git clone`. Everything shown about a clone is read
+ * from git on request, so nothing here can go stale.
+ *
+ * The root lives inside the project on purpose: chat sessions run in the
+ * project root, so every harness reaches the clones without extra grants.
+ * It must stay out of the workspace git: `kraftwerk init` ignores it, and
+ * the workspace sync never stages it.
+ *
+ * Like git.ts, every call passes an argument array (nothing reaches a
+ * shell), never prompts, and times out — a clone from a web UI must fail
+ * loudly, not park on a credential prompt nobody sees.
+ */
+export interface RepoInfo {
+    /** Folder name under the root; the id everywhere. */
+    slug: string;
+    /** Absolute path of the clone. */
+    path: string;
+    /** origin url, absent when the clone has no origin. */
+    url?: string;
+    /** Checked-out branch, or "HEAD" when detached. */
+    branch?: string;
+    /** Short hash of HEAD. */
+    head?: string;
+    /** Subject of the HEAD commit. */
+    subject?: string;
+    /** ISO timestamp of the HEAD commit. */
+    committedAt?: string;
+    /** Modified, added, deleted or untracked paths (porcelain count). */
+    dirty: number;
+    /** Commits not on the upstream, or not on any remote when the branch tracks nothing. Absent when git could not tell. */
+    ahead?: number;
+    /** Commits on the upstream not here. Absent when the branch tracks nothing. */
+    behind?: number;
+    /** Set when git could not be read for this folder. */
+    error?: string;
+}
+export interface ReposView {
+    enabled: boolean;
+    root?: string;
+    repos: RepoInfo[];
+    /** Set when the feature is on but unusable, or off. */
+    error?: string;
+}
+export interface AddRepoInput {
+    url: string;
+    name?: string;
+    branch?: string;
+    /** Shallow clone with this many commits of history (`git clone --depth`). */
+    depth?: number;
+}
+/**
+ * A clone is the one call here that can legitimately take long: a large
+ * repository on a slow link is minutes, not seconds. Prompts are already
+ * disabled (git.ts), so a long timeout only ever cuts a transfer that is
+ * still running, and the partial clone is deleted when it does.
+ */
+export declare const CLONE_TIMEOUT: number;
+export declare function safeRepoSlug(slug: string): string;
+/** "https://github.com/org/repo.git" → "repo"; "git@host:org/repo" → "repo". */
+export declare function slugFromUrl(url: string): string;
+/**
+ * The url git gets. `github:org/repo` is the same shorthand `--from`
+ * accepts. Anything starting with a dash would be read as an option, and
+ * empty is empty.
+ */
+export declare function cloneUrl(input: string): string;
+/** Resolve the project and its repos block. `off` when the feature is not on. */
+export declare function openRepos(): Promise<{
+    project?: Project;
+    root?: string;
+    off?: boolean;
+    error?: string;
+}>;
+/** Every clone under the root, alphabetically. Folders without .git are skipped. */
+export declare function listRepos(): Promise<ReposView>;
+/**
+ * Clone into <root>/<slug>. The folder is claimed with a plain mkdir first:
+ * it fails when anything is there already, whatever it is, and two adds of
+ * the same name racing each other cannot both win. Only what this call
+ * created is deleted when the clone fails.
+ */
+export declare function addRepo(input: AddRepoInput): Promise<RepoInfo>;
+/**
+ * Fetch, then fast-forward when the clone is behind and clean. Never merges:
+ * a diverged or dirty clone is reported, and the agent (or a terminal)
+ * sorts it out inside the repo.
+ */
+export declare function updateRepo(slug: string): Promise<{
+    ok: boolean;
+    error?: string;
+    off?: boolean;
+    repo?: RepoInfo;
+}>;
+/**
+ * Delete the clone. Refuses while it holds unpushed or uncommitted work, or
+ * while git cannot tell, unless forced: the clone may be the only copy.
+ */
+export declare function removeRepo(slug: string, force?: boolean): Promise<{
+    ok: boolean;
+    error?: string;
+    off?: boolean;
+    conflict?: boolean;
+}>;
+/**
+ * Make sure the root exists and is ignored by the workspace git: a clone
+ * inside a tracked tree shows up as an untracked gitlink for everyone.
+ * Best effort — a missing .gitignore is created, one that already covers
+ * the root is left alone. Runs before every clone as well as when the
+ * feature is switched on, so a root enabled by editing kraftwerk.yml is
+ * ignored by the time the first clone lands.
+ */
+export declare function ensureReposRoot(): Promise<void>;

package/dist/inspector/repos.js

@@ -0,0 +1,249 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { gitignoreHas, ignoreEntryFor, reposRootFor, resolveProject } from "../config.js";
+import { getProjectRoot } from "./context.js";
+import { git, gitNet, sshCommandFor } from "./git.js";
+/**
+ * A clone is the one call here that can legitimately take long: a large
+ * repository on a slow link is minutes, not seconds. Prompts are already
+ * disabled (git.ts), so a long timeout only ever cuts a transfer that is
+ * still running, and the partial clone is deleted when it does.
+ */
+export const CLONE_TIMEOUT = 30 * 60_000;
+const SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+export function safeRepoSlug(slug) {
+    if (!SLUG_RE.test(slug) || slug === "." || slug === "..")
+        throw new Error(`invalid repository name "${slug}"`);
+    return slug;
+}
+/** "https://github.com/org/repo.git" → "repo"; "git@host:org/repo" → "repo". */
+export function slugFromUrl(url) {
+    const last = url.replace(/[/:]+$/, "").split(/[/:]/).pop() ?? "";
+    const slug = last.replace(/\.git$/, "");
+    return safeRepoSlug(slug);
+}
+/**
+ * The url git gets. `github:org/repo` is the same shorthand `--from`
+ * accepts. Anything starting with a dash would be read as an option, and
+ * empty is empty.
+ */
+export function cloneUrl(input) {
+    const url = input.trim();
+    if (!url)
+        throw new Error("url is required");
+    if (url.startsWith("-"))
+        throw new Error(`invalid url "${url}"`);
+    const gh = /^github:([\w.-]+\/[\w.-]+?)(?:\.git)?\/?$/.exec(url);
+    if (gh)
+        return `https://github.com/${gh[1]}.git`;
+    return url;
+}
+/** Resolve the project and its repos block. `off` when the feature is not on. */
+export async function openRepos() {
+    let project;
+    try {
+        project = await resolveProject(getProjectRoot());
+    }
+    catch (err) {
+        return { error: err.message };
+    }
+    const root = reposRootFor(project);
+    if (!root)
+        return { off: true, error: "repositories are off (enable them in settings or add `repos:` to kraftwerk.yml)" };
+    return { project, root };
+}
+/**
+ * Everything about a clone in three git calls. `status --porcelain=v2
+ * --branch` carries the branch, its upstream, ahead/behind and the change
+ * list in one spawn; `log` the head; `remote` the origin. Only a branch
+ * without upstream costs one more call.
+ */
+async function inspect(root, slug) {
+    const dir = path.join(root, slug);
+    const info = { slug, path: dir, dirty: 0 };
+    const [status, log, origin] = await Promise.all([
+        git(["status", "--porcelain=v2", "--branch", "--untracked-files=normal"], dir),
+        git(["log", "-1", "--format=%h%x00%s%x00%cI"], dir),
+        git(["remote", "get-url", "origin"], dir),
+    ]);
+    if (!status.ok)
+        return { ...info, error: status.stderr || "not a git repository" };
+    if (origin.ok)
+        info.url = origin.stdout.trim();
+    if (log.ok) {
+        const [head, subject, committedAt] = log.stdout.trim().split("\0");
+        info.head = head;
+        info.subject = subject;
+        info.committedAt = committedAt;
+    }
+    let hasUpstream = false;
+    for (const line of status.stdout.split("\n")) {
+        if (!line.trim())
+            continue;
+        if (!line.startsWith("# ")) {
+            info.dirty++;
+            continue;
+        }
+        const [key, ...rest] = line.slice(2).split(" ");
+        const value = rest.join(" ");
+        if (key === "branch.head")
+            info.branch = value === "(detached)" ? "HEAD" : value;
+        else if (key === "branch.upstream")
+            hasUpstream = true;
+        else if (key === "branch.ab") {
+            const m = /^\+(\d+) -(\d+)$/.exec(value);
+            if (m) {
+                info.ahead = Number(m[1]);
+                info.behind = Number(m[2]);
+            }
+        }
+    }
+    if (!hasUpstream || info.ahead === undefined) {
+        // No upstream (a branch made locally, a detached HEAD): count what no
+        // remote has, so the remove guard still knows about unpushed work.
+        const local = await git(["rev-list", "--count", "HEAD", "--not", "--remotes"], dir);
+        if (local.ok && /^\d+$/.test(local.stdout.trim()))
+            info.ahead = Number(local.stdout.trim());
+    }
+    return info;
+}
+/** Every clone under the root, alphabetically. Folders without .git are skipped. */
+export async function listRepos() {
+    const opened = await openRepos();
+    if (!opened.root)
+        return { enabled: false, repos: [], error: opened.error };
+    const root = opened.root;
+    const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+    const slugs = [];
+    for (const e of entries) {
+        if (!e.isDirectory() || !SLUG_RE.test(e.name))
+            continue;
+        if (await fs.stat(path.join(root, e.name, ".git")).catch(() => null))
+            slugs.push(e.name);
+    }
+    slugs.sort((a, b) => a.localeCompare(b));
+    const repos = await Promise.all(slugs.map((s) => inspect(root, s)));
+    return { enabled: true, root, repos };
+}
+const cloneError = (r) => (r.stderr || r.stdout || "git clone failed").split("\n").filter((l) => l.trim()).slice(-3).join(" ");
+/**
+ * Clone into <root>/<slug>. The folder is claimed with a plain mkdir first:
+ * it fails when anything is there already, whatever it is, and two adds of
+ * the same name racing each other cannot both win. Only what this call
+ * created is deleted when the clone fails.
+ */
+export async function addRepo(input) {
+    const opened = await openRepos();
+    if (!opened.root || !opened.project)
+        throw new Error(opened.error ?? "repositories are off");
+    const url = cloneUrl(input.url);
+    const slug = input.name?.trim() ? safeRepoSlug(input.name.trim()) : slugFromUrl(url);
+    const branch = input.branch?.trim();
+    if (branch && (branch.startsWith("-") || /\s/.test(branch)))
+        throw new Error(`invalid branch "${branch}"`);
+    if (input.depth !== undefined && (!Number.isInteger(input.depth) || input.depth < 1))
+        throw new Error(`invalid depth "${input.depth}"`);
+    const dest = path.join(opened.root, slug);
+    await prepareRoot(opened.project, opened.root);
+    try {
+        await fs.mkdir(dest);
+    }
+    catch (err) {
+        if (err.code === "EEXIST")
+            throw new Error(`"${slug}" already exists under ${opened.root}`);
+        throw err;
+    }
+    const args = [
+        "-c", "protocol.ext.allow=never", "clone",
+        ...(branch ? ["--branch", branch] : []),
+        ...(input.depth ? ["--depth", String(input.depth)] : []),
+        "--", url, dest,
+    ];
+    const r = await git(args, opened.root, CLONE_TIMEOUT, { GIT_SSH_COMMAND: await sshCommandFor(opened.project.root) });
+    if (!r.ok) {
+        await fs.rm(dest, { recursive: true, force: true }).catch(() => { });
+        throw new Error(cloneError(r));
+    }
+    return inspect(opened.root, slug);
+}
+/**
+ * Fetch, then fast-forward when the clone is behind and clean. Never merges:
+ * a diverged or dirty clone is reported, and the agent (or a terminal)
+ * sorts it out inside the repo.
+ */
+export async function updateRepo(slug) {
+    safeRepoSlug(slug);
+    const opened = await openRepos();
+    if (!opened.root)
+        return { ok: false, off: true, error: opened.error };
+    const dir = path.join(opened.root, slug);
+    if (!(await fs.stat(path.join(dir, ".git")).catch(() => null)))
+        return { ok: false, error: `no repository "${slug}"` };
+    const fetched = await gitNet(["fetch", "--prune"], dir);
+    if (!fetched.ok)
+        return { ok: false, error: fetched.stderr || "git fetch failed", repo: await inspect(opened.root, slug) };
+    let repo = await inspect(opened.root, slug);
+    if (repo.behind && !repo.ahead && repo.dirty === 0) {
+        const pulled = await git(["merge", "--ff-only", "@{upstream}"], dir);
+        if (!pulled.ok)
+            return { ok: false, error: pulled.stderr || "fast-forward failed", repo };
+        repo = await inspect(opened.root, slug);
+    }
+    else if (repo.behind && (repo.ahead || repo.dirty)) {
+        return { ok: true, error: repo.ahead ? "diverged from upstream, not fast-forwarded" : "local changes, not fast-forwarded", repo };
+    }
+    return { ok: true, repo };
+}
+/**
+ * Delete the clone. Refuses while it holds unpushed or uncommitted work, or
+ * while git cannot tell, unless forced: the clone may be the only copy.
+ */
+export async function removeRepo(slug, force = false) {
+    safeRepoSlug(slug);
+    const opened = await openRepos();
+    if (!opened.root)
+        return { ok: false, off: true, error: opened.error };
+    const dir = path.join(opened.root, slug);
+    if (!(await fs.stat(path.join(dir, ".git")).catch(() => null)))
+        return { ok: false, error: `no repository "${slug}"` };
+    if (!force) {
+        const repo = await inspect(opened.root, slug);
+        if (repo.error)
+            return { ok: false, conflict: true, error: `"${slug}" cannot be read (${repo.error}); remove it with --force` };
+        if (repo.dirty)
+            return { ok: false, conflict: true, error: `"${slug}" has ${repo.dirty} uncommitted change(s)` };
+        if (repo.ahead === undefined)
+            return { ok: false, conflict: true, error: `"${slug}": cannot tell whether it has unpushed commits; remove it with --force` };
+        if (repo.ahead)
+            return { ok: false, conflict: true, error: `"${slug}" has ${repo.ahead} unpushed commit(s)` };
+    }
+    await fs.rm(dir, { recursive: true, force: true });
+    return { ok: true };
+}
+/**
+ * Make sure the root exists and is ignored by the workspace git: a clone
+ * inside a tracked tree shows up as an untracked gitlink for everyone.
+ * Best effort — a missing .gitignore is created, one that already covers
+ * the root is left alone. Runs before every clone as well as when the
+ * feature is switched on, so a root enabled by editing kraftwerk.yml is
+ * ignored by the time the first clone lands.
+ */
+export async function ensureReposRoot() {
+    const project = await resolveProject(getProjectRoot());
+    const root = reposRootFor(project);
+    if (!root)
+        return;
+    await prepareRoot(project, root);
+}
+async function prepareRoot(project, root) {
+    await fs.mkdir(root, { recursive: true });
+    const entry = ignoreEntryFor(project.root, root);
+    if (!entry)
+        return;
+    const ignorePath = path.join(project.root, ".gitignore");
+    const existing = await fs.readFile(ignorePath, "utf8").catch(() => null);
+    if (existing !== null && gitignoreHas(existing, entry))
+        return;
+    const line = `${entry}/\n`;
+    await fs.writeFile(ignorePath, existing === null ? line : `${existing}${existing.endsWith("\n") ? "" : "\n"}${line}`).catch(() => { });
+}

package/dist/inspector/routines.d.ts

@@ -1,14 +1,14 @@
 /**
- * Routines: per-team-member scheduled prompts — "message your agent every
- * weekday at 9". Definitions live next to the member (git-tracked):
+ * Routines: per-agent scheduled prompts — "message your agent every
+ * weekday at 9". Definitions live next to the agent (git-tracked):
  *
  *   agents/<slug>/routines.yml    # list of { id, name, schedule, prompt, enabled }
  *
  * Runtime state (last run / last session / errors) is run-state, not
  * config, so it lives in <output>/routines-state.json. The scheduler is a
  * plain interval inside the inspector server: each due routine opens a new
- * session (chat) for the member and posts the prompt — the run shows up in
- * the member's sessions sidebar like any conversation. Schedules use
+ * session (chat) for the agent and posts the prompt — the run shows up in
+ * the agent's sessions sidebar like any conversation. Schedules use
  * standard 5-field cron in the server's local time.
  */
 export interface Routine {

package/dist/inspector/routines.js

@@ -2,7 +2,7 @@ import { promises as fs } from "node:fs";
 import path from "node:path";
 import { parse, stringify } from "yaml";
 import { getOutputDir } from "./context.js";
-import { getMember, listMembers, safeMemberSlug, teamRoot } from "./team.js";
+import { getAgent, listAgents, safeAgentSlug, agentsRoot } from "./agents.js";
 import { createChat, postMessage } from "./chat/sessions.js";
 /* ---------- cron ---------- */
 const ALIASES = {
@@ -86,7 +86,7 @@ export function nextRun(schedule, from = new Date()) {
 }
 /* ---------- definition CRUD (agents/<slug>/routines.yml) ---------- */
 async function routinesFile(slug) {
-    return path.join(await teamRoot(), safeMemberSlug(slug), "routines.yml");
+    return path.join(await agentsRoot(), safeAgentSlug(slug), "routines.yml");
 }
 function normalizeRoutine(raw) {
     const id = String(raw.id ?? "").trim();
@@ -179,14 +179,14 @@ export async function routineStatuses(slug) {
     });
 }
 /* ---------- firing ---------- */
-/** Open a fresh session for the member and post the routine's prompt. */
+/** Open a fresh session for the agent and post the routine's prompt. */
 async function fireRoutine(slug, routine) {
-    const member = await getMember(slug);
-    if (!member)
-        throw new Error(`team agent "${slug}" not found`);
+    const def = await getAgent(slug);
+    if (!def)
+        throw new Error(`agent "${slug}" not found`);
     const meta = await createChat({
-        agent: member.harness,
-        scope: { kind: "team", member: slug, routine: routine.id },
+        agent: def.harness,
+        scope: { kind: "agent", slug: slug, routine: routine.id },
         title: `⏰ ${routine.name}`,
     });
     const { error } = await postMessage(meta.id, routine.prompt);
@@ -219,16 +219,16 @@ async function tick() {
     const now = new Date();
     const p = (n) => String(n).padStart(2, "0");
     const minuteKey = `${now.getFullYear()}-${p(now.getMonth() + 1)}-${p(now.getDate())}T${p(now.getHours())}:${p(now.getMinutes())}`;
-    let members;
+    let agents;
     try {
-        members = await listMembers();
+        agents = await listAgents();
     }
     catch {
         return;
     }
     const state = await readState();
     let dirty = false;
-    for (const m of members) {
+    for (const m of agents) {
         for (const r of await listRoutines(m.slug).catch(() => [])) {
             if (!r.enabled)
                 continue;

package/dist/inspector/search.d.ts

@@ -0,0 +1,25 @@
+import { type AgentSummary } from "./agents.js";
+/**
+ * The ⌘K palette: every active agent in every workspace this machine
+ * knows, so a user can jump to one without switching workspaces first.
+ * This instance reads its own roster from disk; the others come from the
+ * project registry, where each instance records its roster whenever it
+ * reads it (see instances.ts). Stopped workspaces are listed too — the
+ * palette starts them on the way to the agent.
+ */
+export interface WorkspaceAgents {
+    name: string;
+    icon?: string;
+    /** Where the workspace's UI lives — hits link to `${url}/#/agents/<slug>`. */
+    url: string;
+    /** Project root (what /api/projects/start takes for a stopped workspace). */
+    root?: string;
+    /** The instance answering this request: hits navigate in place. */
+    current: boolean;
+    live: boolean;
+    agents: AgentSummary[];
+}
+export interface AgentSearch {
+    workspaces: WorkspaceAgents[];
+}
+export declare function searchAgents(): Promise<AgentSearch>;

package/dist/inspector/search.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import { resolveProject } from "../config.js";
+import { getProjectRoot } from "./context.js";
+import { listAgents, toSummary } from "./agents.js";
+import { currentInstanceUrl, discoverWorkspaces, listProjects } from "./instances.js";
+export async function searchAgents() {
+    const project = await resolveProject(getProjectRoot()).catch(() => null);
+    const self = {
+        name: project?.config.name ?? path.basename(project?.root ?? getProjectRoot()),
+        icon: project?.config.icon || undefined,
+        url: currentInstanceUrl() ?? "",
+        root: project?.root ?? getProjectRoot(),
+        current: true,
+        live: true,
+        agents: (await listAgents().catch(() => [])).filter((a) => !a.archived).map(toSummary),
+    };
+    const [workspaces, projects] = await Promise.all([discoverWorkspaces(), listProjects()]);
+    const rosters = new Map(projects.map((p) => [p.root, p.agents ?? []]));
+    const others = workspaces
+        .filter((w) => w.root && w.exists !== false)
+        .map((w) => ({
+        name: w.name,
+        icon: w.icon,
+        url: w.url,
+        root: w.root,
+        current: false,
+        live: w.live,
+        agents: rosters.get(w.root) ?? [],
+    }));
+    return { workspaces: [self, ...others] };
+}