@netnodeag/kraftwerk 0.34.2 → 0.36.0

package/dist/inspector/chat/sessions.js

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

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

@@ -0,0 +1,83 @@
+export interface GitFile {
+    /** Path relative to the repo root, which is what git speaks. */
+    path: string;
+    /** Two-letter porcelain code, e.g. " M", "??", "A ". */
+    code: string;
+    /** Human label for the code: modified, added, deleted, renamed, untracked. */
+    status: string;
+    /** Inside a synced root and not denied, so it can be selected. */
+    syncable: boolean;
+    /** Why it cannot be selected, when it cannot. */
+    reason?: string;
+}
+export interface GitStatus {
+    enabled: boolean;
+    /** Set when the feature is on but the repo cannot be used. */
+    error?: string;
+    repoRoot?: string;
+    branch?: string;
+    /** Configured or inferred upstream, absent when the branch tracks nothing. */
+    upstream?: string;
+    remote?: string;
+    ahead?: number;
+    behind?: number;
+    /** True when the branches have diverged, which needs a terminal. */
+    diverged?: boolean;
+    files?: GitFile[];
+    /** Blocked entries left out of `files` because the list was capped. */
+    blockedHidden?: number;
+    /** Repo-relative roots that may be committed. */
+    scope?: string[];
+    autosync?: "off" | "pull";
+    interval?: number;
+    lastFetch?: string;
+    lastPull?: string;
+    lastError?: string;
+}
+export interface GitDiff {
+    diff: string;
+    error?: string;
+    /** The diff was cut at MAX_DIFF; the rest is available in a terminal. */
+    truncated?: boolean;
+}
+/**
+ * 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
+ * cached for a beat.
+ */
+export declare function gitStatus(fresh?: boolean): Promise<GitStatus>;
+/**
+ * Unified diff for one changed file. Reading is as sensitive as writing
+ * here: this endpoint has no auth of its own, and a diff of an untracked
+ * .env is the file itself. So the status list is the one source of readable
+ * paths: a file not listed there, or listed as blocked, is not shown.
+ * Status never lists ignored files, which covers .gitignore too.
+ */
+export declare function gitDiff(file: string): Promise<GitDiff>;
+/** Stage the given repo-relative paths and commit just those. */
+export declare function gitCommit(paths: string[], message: string): Promise<{
+    ok: boolean;
+    error?: string;
+    committed?: number;
+}>;
+export declare function gitFetch(): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+/** Fast-forward only. A diverged branch is the user's problem, not ours. */
+export declare function gitPull(): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+export declare function gitPush(): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+/**
+ * Fetch on an interval, and fast-forward when `autosync: pull` is set. Never
+ * commits. A pull is skipped while the tree is dirty, so nobody's unsaved
+ * work is disturbed by a background merge. Ticks are chained, not scheduled
+ * on a fixed interval: a fetch against a slow remote must finish (or time
+ * out) before the next one starts, or a short interval piles up processes.
+ */
+export declare function startGitSync(): void;