@netnodeag/kraftwerk 0.75.0 → 0.76.0

package/dist/core/routines.js

@@ -1,11 +1,13 @@
-import { promises as fs } from "node:fs";
+import { promises as fs, realpathSync } from "node:fs";
 import path from "node:path";
 import { parse, stringify } from "yaml";
-import { getOutputDir } from "./context.js";
+import { getOutputDir, workspaceRoot } from "./context.js";
 import { perWorkspace } from "./workspace.js";
 import { getAgent, listAgents, safeAgentSlug, agentsRoot } from "./agents.js";
 import { chatAwaitingApproval, createChat, postMessage } from "./chat/sessions.js";
 import { pushNotification } from "./notifications.js";
+import { isIdentityString, localIdentity, readIdentity, identityString } from "./identity.js";
+import { gitCommit, repoRootFor } from "./git.js";
 /* ---------- cron ---------- */
 const ALIASES = {
     "@hourly": "0 * * * *",
@@ -100,8 +102,26 @@ function normalizeRoutine(raw) {
         schedule: String(raw.schedule ?? ""),
         prompt: String(raw.prompt ?? ""),
         enabled: raw.enabled !== false,
+        ...(typeof raw.runs_on === "string" && raw.runs_on.trim() ? { runsOn: raw.runs_on.trim() } : {}),
+        ...(typeof raw.private === "boolean" ? { private: raw.private } : {}),
     };
 }
+/** The file's own spelling: snake_case `runs_on`, optional keys only when set. */
+function serializeRoutine(r) {
+    return {
+        id: r.id,
+        name: r.name,
+        schedule: r.schedule,
+        prompt: r.prompt,
+        enabled: r.enabled,
+        ...(r.runsOn ? { runs_on: r.runsOn } : {}),
+        ...(r.private !== undefined ? { private: r.private } : {}),
+    };
+}
+/** Why a runs_on value is refused, or undefined. */
+function runsOnError(value) {
+    return isIdentityString(value) ? undefined : `runs_on must be <handle>@<machine> (lowercase letters, digits, ".", "_", "-"), got "${value}"`;
+}
 export async function listRoutines(slug) {
     let raw;
     try {
@@ -117,7 +137,7 @@ export async function listRoutines(slug) {
         .filter(Boolean);
 }
 async function writeRoutines(slug, routines) {
-    await fs.writeFile(await routinesFile(slug), stringify(routines));
+    await fs.writeFile(await routinesFile(slug), stringify(routines.map(serializeRoutine)));
 }
 export async function saveRoutine(slug, input) {
     const name = input.name?.trim();
@@ -134,15 +154,26 @@ export async function saveRoutine(slug, input) {
             .slice(0, 48);
     if (!id)
         throw new Error("name must contain at least one letter or digit");
+    const given = typeof input.runsOn === "string" ? input.runsOn.trim() : input.runsOn;
+    if (given) {
+        const err = runsOnError(given);
+        if (err)
+            throw new Error(err);
+    }
+    const routines = await listRoutines(slug);
+    const i = routines.findIndex((r) => r.id === id);
+    const existing = i >= 0 ? routines[i] : undefined;
+    const runsOn = given === undefined ? (existing ? existing.runsOn : await localIdentity()) : given || undefined;
+    const priv = input.private ?? existing?.private;
     const routine = {
         id,
         name,
         schedule: input.schedule.trim(),
         prompt: input.prompt,
         enabled: input.enabled !== false,
+        ...(runsOn ? { runsOn } : {}),
+        ...(priv !== undefined ? { private: priv } : {}),
     };
-    const routines = await listRoutines(slug);
-    const i = routines.findIndex((r) => r.id === id);
     if (i >= 0)
         routines[i] = routine;
     else
@@ -191,13 +222,19 @@ export async function allRoutines(workflows) {
     }))));
     return per.flat();
 }
+/** Whether a routine fires on the machine whose identity is `me`: enabled and runs_on exactly that. */
+export const firesHere = (r, me) => r.enabled && r.runsOn === me;
 export async function routineStatuses(slug) {
-    const [routines, state] = await Promise.all([listRoutines(slug), readState()]);
+    const [routines, state, id] = await Promise.all([listRoutines(slug), readState(), readIdentity()]);
+    const me = identityString(id);
     return routines.map((r) => {
         const s = state[`${slug}/${r.id}`] ?? {};
+        const runner = !r.runsOn ? "unassigned" : r.runsOn === me ? "here" : "elsewhere";
         return {
             ...r,
-            ...(r.enabled ? { nextRunAt: nextRun(r.schedule) } : {}),
+            runner,
+            ...(r.runsOn && id.previous.includes(r.runsOn) ? { retired: true } : {}),
+            ...(firesHere(r, me) ? { nextRunAt: nextRun(r.schedule) } : {}),
             ...(s.lastRunAt ? { lastRunAt: s.lastRunAt } : {}),
             ...(s.lastChatId ? { lastChatId: s.lastChatId } : {}),
             ...(s.lastChatId && chatAwaitingApproval(s.lastChatId) ? { awaitingApproval: true } : {}),
@@ -254,48 +291,152 @@ export async function runRoutineNow(slug, id) {
 /* ---------- scheduler ---------- */
 /** The scheduler's timer, one per workspace. */
 const scheduler = perWorkspace(() => ({ timer: null }));
+/**
+ * The routines due at `now` that fire on this machine: enabled, runs_on
+ * exactly this identity, cron matching. Everything else — unassigned,
+ * another machine's, a retired identity's — is never due here.
+ */
+export async function dueRoutines(now, me) {
+    const identity = me ?? (await localIdentity());
+    const out = [];
+    for (const m of await listAgents()) {
+        for (const r of await listRoutines(m.slug).catch(() => [])) {
+            if (!firesHere(r, identity))
+                continue;
+            try {
+                if (cronMatches(parseCron(r.schedule), now))
+                    out.push({ slug: m.slug, routine: r });
+            }
+            catch {
+                // invalid schedule — surfaced by validation on save, skip here
+            }
+        }
+    }
+    return out;
+}
 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 agents;
+    let due;
     try {
-        agents = await listAgents();
+        due = await dueRoutines(now);
     }
     catch {
         return;
     }
+    if (!due.length)
+        return;
     const state = await readState();
     let dirty = false;
-    for (const m of agents) {
-        for (const r of await listRoutines(m.slug).catch(() => [])) {
-            if (!r.enabled)
-                continue;
-            let due = false;
-            try {
-                due = cronMatches(parseCron(r.schedule), now);
+    for (const { slug, routine: r } of due) {
+        const key = `${slug}/${r.id}`;
+        if (state[key]?.lastMinute === minuteKey)
+            continue;
+        state[key] = { ...state[key], lastMinute: minuteKey };
+        dirty = true;
+        try {
+            const chatId = await fireRoutine(slug, r);
+            state[key] = { ...state[key], lastRunAt: now.toISOString(), lastChatId: chatId };
+            delete state[key].lastError;
+        }
+        catch (err) {
+            state[key] = { ...state[key], lastError: err.message };
+            void notifyRoutineFailed(slug, r, err.message);
+        }
+    }
+    if (dirty)
+        await writeState(state);
+}
+/** Every routine in the workspace that has no runner, or names a retired identity of this machine. */
+export async function runnerFindings() {
+    const id = await readIdentity();
+    const out = { unassigned: [], retired: [] };
+    let since = 0;
+    // Archived agents included: the scheduler fires their routines too.
+    for (const a of await listAgents()) {
+        const routines = await listRoutines(a.slug).catch(() => []);
+        let hit = false;
+        for (const r of routines) {
+            if (!r.runsOn && r.enabled) {
+                out.unassigned.push({ agent: a.slug, id: r.id, name: r.name });
+                hit = true;
             }
-            catch {
-                continue; // invalid schedule — surfaced by validation on save, skip here
+            else if (r.runsOn && id.previous.includes(r.runsOn)) {
+                out.retired.push({ agent: a.slug, id: r.id, name: r.name, from: r.runsOn });
+                hit = true;
             }
-            const key = `${m.slug}/${r.id}`;
-            if (!due || state[key]?.lastMinute === minuteKey)
+        }
+        if (hit) {
+            const st = await fs.stat(await routinesFile(a.slug)).catch(() => null);
+            if (st && st.mtimeMs > since)
+                since = st.mtimeMs;
+        }
+    }
+    if (since)
+        out.since = new Date(since).toISOString();
+    return out;
+}
+/**
+ * "Run these here": make this machine the runner of the routines `pick`
+ * selects, write routines.yml and commit just the files it touched — the
+ * commit is what tells the other clones who runs them. A workspace without
+ * git sync, or a commit that fails, keeps the written files and says why.
+ */
+export async function adoptRoutines(pick, message) {
+    const id = await readIdentity();
+    const me = identityString(id);
+    const adopted = [];
+    const written = [];
+    for (const a of await listAgents()) {
+        const routines = await listRoutines(a.slug).catch(() => []);
+        let changed = false;
+        for (const r of routines) {
+            if (r.runsOn === me || !pick(a.slug, r, id.previous))
                 continue;
-            state[key] = { ...state[key], lastMinute: minuteKey };
-            dirty = true;
-            try {
-                const chatId = await fireRoutine(m.slug, r);
-                state[key] = { ...state[key], lastRunAt: now.toISOString(), lastChatId: chatId };
-                delete state[key].lastError;
-            }
-            catch (err) {
-                state[key] = { ...state[key], lastError: err.message };
-                void notifyRoutineFailed(m.slug, r, err.message);
-            }
+            adopted.push({ agent: a.slug, id: r.id, name: r.name, ...(r.runsOn ? { from: r.runsOn } : {}) });
+            r.runsOn = me;
+            changed = true;
+        }
+        if (changed) {
+            await writeRoutines(a.slug, routines);
+            written.push(await routinesFile(a.slug));
         }
     }
-    if (dirty)
-        await writeState(state);
+    const root = workspaceRoot();
+    const files = written.map((f) => path.relative(root, f).split(path.sep).join("/"));
+    if (!written.length)
+        return { runsOn: me, adopted, files, commit: null };
+    return { runsOn: me, adopted, files, commit: await commitFiles(written, message ?? `Routines run on ${me}: ${adopted.map((x) => `${x.agent}/${x.id}`).join(", ")}`) };
+}
+async function commitFiles(abs, message) {
+    const repoRoot = await repoRootFor(path.dirname(abs[0]));
+    if (!repoRoot)
+        return { ok: false, error: "the workspace is not a git repository" };
+    // rev-parse answers with symlinks resolved (/var → /private/var on macOS); the files must be spelled the same way.
+    const real = (p) => {
+        try {
+            return realpathSync.native(p);
+        }
+        catch {
+            return path.resolve(p);
+        }
+    };
+    const rel = abs.map((f) => path.relative(repoRoot, real(f)).split(path.sep).join("/"));
+    return gitCommit(rel, message);
+}
+/** Adopt one routine (whatever its runs_on said). */
+export async function adoptRoutine(slug, id) {
+    const safe = safeAgentSlug(slug);
+    if (!(await listRoutines(safe)).some((r) => r.id === id))
+        throw new Error("routine not found");
+    const result = await adoptRoutines((agent, r) => agent === safe && r.id === id);
+    const routine = (await routineStatuses(safe)).find((r) => r.id === id);
+    return { ...result, routine };
+}
+/** Adopt every enabled routine without runs_on — and, with `retired`, every one naming a retired identity of this machine. */
+export function adoptUnassigned(opts = {}) {
+    return adoptRoutines((_agent, r, previous) => (!r.runsOn && r.enabled) || (!!opts.retired && !!r.runsOn && previous.includes(r.runsOn)));
 }
 /** Start the current workspace's scheduler; safe to call more than once. Ticks run in that workspace. */
 export function startRoutineScheduler() {

package/dist/server/api/agents.d.ts

@@ -5,7 +5,9 @@ export declare const agentRoutes: (import("./router.js").Route<"agents.addJourna
 }, "/api/agents/:slug/journal", z.ZodObject<{
     entry: z.ZodDefault<z.ZodString>;
     kind: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>> | import("./router.js").Route<"agents.archive", import("../../core/agents.js").AgentDetail, "/api/agents/:slug/archive", z.ZodObject<{
+}, z.core.$strip>> | import("./router.js").Route<"agents.adoptRoutine", import("../../core/routines.js").AdoptResult & {
+    routine: import("../../core/routines.js").RoutineStatus;
+}, "/api/agents/:slug/routines/:id/adopt", undefined> | import("./router.js").Route<"agents.archive", import("../../core/agents.js").AgentDetail, "/api/agents/:slug/archive", z.ZodObject<{
     archived: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>> | import("./router.js").Route<"agents.create", import("../../core/agents.js").AgentDetail, "/api/agents", z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
@@ -56,6 +58,8 @@ export declare const agentRoutes: (import("./router.js").Route<"agents.addJourna
     schedule: z.ZodOptional<z.ZodString>;
     prompt: z.ZodOptional<z.ZodString>;
     enabled: z.ZodOptional<z.ZodBoolean>;
+    runsOn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    private: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>> | import("./router.js").Route<"agents.saveSkill", import("../../core/skills.js").SkillInfo & {
     content: string;
 }, "/api/agents/:slug/skills", z.ZodObject<{

package/dist/server/api/agents.js

@@ -2,7 +2,7 @@ import * as z from "zod";
 import { agentsRoot, deleteAgent, getAgent, listAgents, saveAgent, setAgentArchived } from "../../core/agents.js";
 import { appendJournal, readJournal } from "../../core/journal.js";
 import { UI_ACTOR } from "../../core/knowledge.js";
-import { deleteRoutine, routineStatuses, runRoutineNow, saveRoutine } from "../../core/routines.js";
+import { adoptRoutine, deleteRoutine, listRoutines, routineStatuses, runRoutineNow, saveRoutine } from "../../core/routines.js";
 import { deleteAgentSkill, listAgentSkills, readSkill, saveAgentSkill } from "../../core/skills.js";
 import { fail, route } from "./router.js";
 /** A member's editable fields. Loose: saveAgent checks values (name, harness, effort) and keeps what it knows. */
@@ -21,13 +21,19 @@ const AgentFields = z.looseObject({
     skills: z.array(z.string()).optional(),
     system: z.string().optional(),
 });
-/** A routine: every field saveRoutine stores (it builds the routine from these alone), so a strict object loses nothing. saveRoutine checks name, prompt and the cron schedule. */
+/**
+ * A routine: every field saveRoutine stores (it builds the routine from these alone), so a strict object loses nothing.
+ * saveRoutine checks name, prompt, the cron schedule and runsOn. runsOn absent keeps the stored runner (a new routine:
+ * this machine); null or "" unassigns it.
+ */
 const RoutineFields = z.object({
     id: z.string().optional(),
     name: z.string().optional(),
     schedule: z.string().optional(),
     prompt: z.string().optional(),
     enabled: z.boolean().optional(),
+    runsOn: z.string().nullable().optional(),
+    private: z.boolean().optional(),
 });
 /** Agents (team members): definition, own skills, journal, routines. */
 export const agentRoutes = [
@@ -92,5 +98,16 @@ export const agentRoutes = [
         await deleteRoutine(c.params.slug, c.params.id);
         return { ok: true };
     }),
+    route({
+        name: "agents.adoptRoutine",
+        method: "POST",
+        path: "/api/agents/:slug/routines/:id/adopt",
+        summary: "run this routine here: runs_on = this machine's identity, routines.yml committed",
+        errors: 400,
+    }, async (c) => {
+        if (!(await listRoutines(c.params.slug)).some((r) => r.id === c.params.id))
+            fail(404, "routine not found");
+        return adoptRoutine(c.params.slug, c.params.id);
+    }),
     route({ name: "agents.runRoutine", method: "POST", path: "/api/agents/:slug/routines/:id/run", summary: "run a routine now", errors: 400 }, async (c) => runRoutineNow(c.params.slug, c.params.id)),
 ];

package/dist/server/api/index.d.ts

@@ -27,7 +27,9 @@ export declare const routes: (Route<"agents.addJournal", {
 }, "/api/agents/:slug/journal", z.ZodObject<{
     entry: z.ZodDefault<z.ZodString>;
     kind: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>> | Route<"agents.archive", import("../../core/agents.js").AgentDetail, "/api/agents/:slug/archive", z.ZodObject<{
+}, z.core.$strip>> | Route<"agents.adoptRoutine", import("../../core/routines.js").AdoptResult & {
+    routine: import("../../core/routines.js").RoutineStatus;
+}, "/api/agents/:slug/routines/:id/adopt", undefined> | Route<"agents.archive", import("../../core/agents.js").AgentDetail, "/api/agents/:slug/archive", z.ZodObject<{
     archived: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>> | Route<"agents.create", import("../../core/agents.js").AgentDetail, "/api/agents", z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
@@ -78,6 +80,8 @@ export declare const routes: (Route<"agents.addJournal", {
     schedule: z.ZodOptional<z.ZodString>;
     prompt: z.ZodOptional<z.ZodString>;
     enabled: z.ZodOptional<z.ZodBoolean>;
+    runsOn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    private: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>> | Route<"agents.saveSkill", import("../../core/skills.js").SkillInfo & {
     content: string;
 }, "/api/agents/:slug/skills", z.ZodObject<{
@@ -399,7 +403,12 @@ export declare const routes: (Route<"agents.addJournal", {
     aliasPort?: number | undefined;
 }, "/api/hub/open", z.ZodObject<{
     root: z.ZodString;
-}, z.core.$strip>> | Route<"knowledge.concept", import("../../okf.js").ConceptDetail, "/api/knowledge/:bundle/concept", undefined> | Route<"knowledge.create", import("../../okf.js").BundleInfo, "/api/knowledge", z.ZodObject<{
+}, z.core.$strip>> | Route<"identity.get", {
+    handle: string;
+    machine: string;
+    identity: string;
+    previous: string[];
+}, "/api/identity", undefined> | Route<"knowledge.concept", import("../../okf.js").ConceptDetail, "/api/knowledge/:bundle/concept", undefined> | Route<"knowledge.create", import("../../okf.js").BundleInfo, "/api/knowledge", z.ZodObject<{
     name: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>> | Route<"knowledge.delete", {
     ok: boolean;
@@ -497,7 +506,9 @@ export declare const routes: (Route<"agents.addJournal", {
     error?: string;
     off?: boolean;
     repo?: import("../../core/repos.js").RepoInfo;
-}>, "/api/repos/:slug/update", undefined> | Route<"routines.list", {
+}>, "/api/repos/:slug/update", undefined> | Route<"routines.adopt", import("../../core/routines.js").AdoptResult, "/api/routines/adopt", z.ZodObject<{
+    retired: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>> | Route<"routines.list", {
     routines: (import("../../core/routines.js").RoutineStatus & {
         agent: {
             slug: string;

package/dist/server/api/runs.d.ts

@@ -1,6 +1,8 @@
 import * as z from "zod";
 /** Workflows, their runs, and the routines that start them. */
-export declare const runRoutes: (import("./router.js").Route<"routines.list", {
+export declare const runRoutes: (import("./router.js").Route<"routines.adopt", import("../../core/routines.js").AdoptResult, "/api/routines/adopt", z.ZodObject<{
+    retired: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>> | import("./router.js").Route<"routines.list", {
     routines: (import("../../core/routines.js").RoutineStatus & {
         agent: {
             slug: string;

package/dist/server/api/runs.js

@@ -2,7 +2,7 @@ import { promises as fs } from "node:fs";
 import * as z from "zod";
 import { getOutputDir } from "../../core/context.js";
 import { decide } from "../../core/decisions.js";
-import { allRoutines } from "../../core/routines.js";
+import { adoptUnassigned, allRoutines } from "../../core/routines.js";
 import { dockerStatus, stopRun, triggerRun } from "../../core/runner.js";
 import { deleteRun, getRun, listRuns, readRunFile, safeRunDir } from "../../core/runs.js";
 import { deleteWorkflow, getWorkflow, listWorkflows } from "../../core/workflows.js";
@@ -59,6 +59,14 @@ export const runRoutes = [
     route({ name: "routines.list", method: "GET", path: "/api/routines", summary: "every agent's routines with run state and the workflows each one names" }, async () => ({
         routines: await allRoutines((await listWorkflows()).workflows),
     })),
+    route({
+        name: "routines.adopt",
+        method: "POST",
+        path: "/api/routines/adopt",
+        summary: "run these here: every enabled routine without runs_on (and, with {retired: true}, those naming a retired identity) gets this machine; routines.yml committed",
+        errors: 400,
+        body: z.object({ retired: z.boolean().default(false) }),
+    }, async (c) => adoptUnassigned({ retired: (await c.body()).retired })),
     route({ name: "runs.list", method: "GET", path: "/api/runs", summary: "every run in the output dir" }, async () => ({ outputDir: getOutputDir(), runs: await listRuns() })),
     route({ name: "runs.get", method: "GET", path: "/api/runs/:id", summary: "one run: phases, gates, files" }, async (c) => (await validRun(getRun(c.params.id))) ?? fail(404, "not found")),
     route({ name: "runs.fileText", method: "GET", path: "/api/runs/:id/text", summary: "one run file's text ?name=, tail-capped" }, async (c) => {

package/dist/server/api/workspace.d.ts

@@ -6,7 +6,12 @@ type StartReply = StartResult & {
     here?: true;
 };
 /** The workspace itself: identity and features, settings, the other workspaces, updates. */
-export declare const workspaceRoutes: (import("./router.js").Route<"meta.get", {
+export declare const workspaceRoutes: (import("./router.js").Route<"identity.get", {
+    handle: string;
+    machine: string;
+    identity: string;
+    previous: string[];
+}, "/api/identity", undefined> | import("./router.js").Route<"meta.get", {
     workspaceName: string;
     workspaceSlug: string;
     workspaceIcon: string;

package/dist/server/api/workspace.js

@@ -11,6 +11,7 @@ import { getSettings, saveSettings } from "../../core/settings.js";
 import { canSelfUpdate, startUpdate, updateStatus } from "../../core/update.js";
 import { getDiskVersion, getPkgName, getPkgVersion, RESTART_EXIT_CODE, supervised } from "../version.js";
 import { disposeAllDevs } from "../../core/vibeables.js";
+import { identityString, readIdentity } from "../../core/identity.js";
 import { fail, reply, route } from "./router.js";
 /** A feature block with a folder (repos, vibeables, projects); saveSettings checks the root. Nested blocks are plain objects: saveSettings reads only these fields. */
 const RootBlock = z.object({ enabled: z.boolean(), root: z.string().optional() });
@@ -108,6 +109,10 @@ export const workspaceRoutes = [
             switcher,
         };
     }),
+    route({ name: "identity.get", method: "GET", path: "/api/identity", summary: "this machine's identity (handle@machine) — what routines name in runs_on" }, async () => {
+        const id = await readIdentity();
+        return { handle: id.handle, machine: id.machine, identity: identityString(id), previous: id.previous };
+    }),
     route({ name: "settings.get", method: "GET", path: "/api/settings", summary: "kraftwerk.yml, parsed, with resolved paths" }, async () => getSettings()),
     route({ name: "settings.save", method: "PUT", path: "/api/settings", summary: "write the UI-editable subset of kraftwerk.yml", errors: 400, body: SettingsFields }, async (c) => saveSettings((await c.body()))),
     route({ name: "workspaces.list", method: "GET", path: "/api/workspaces", summary: "every known workspace incl. this one, with state and counts" }, async () => placeInHub(await listWorkspacesDetailed())),

package/dist/server/push.js

@@ -11,7 +11,7 @@ export function sealPush(keyBase64, content) {
     const ct = Buffer.concat([cipher.update(JSON.stringify(content), "utf8"), cipher.final()]);
     return Buffer.concat([nonce, ct, cipher.getAuthTag()]).toString("base64");
 }
-const LABEL = { approval: "Approval", question: "Question", failed: "Failed" };
+const LABEL = { approval: "Approval", question: "Question", failed: "Failed", runner: "Routines" };
 export function contentOf(item, workspace) {
     return {
         title: `${LABEL[item.kind] ?? "Needs you"} · ${workspace.name}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netnodeag/kraftwerk",
-  "version": "0.75.0",
+  "version": "0.76.0",
   "description": "Open-source agentic workspace for teams — where people and AI agents get work done together: agents (Claude Code, Codex, Pi), skills, shared knowledge, repeatable workflows, and deterministic verification",
   "keywords": [
     "agents",

package/schema/kraftwerk.schema.json

@@ -6,6 +6,11 @@
   "type": "object",
   "additionalProperties": false,
   "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^ws_[a-z0-9]{10}$",
+      "description": "The workspace's identity on every machine and clone: ws_ followed by 10 lowercase base36 characters. Committed with kraftwerk.yml; `kraftwerk init` writes it, `kraftwerk doctor --fix` adds a missing one."
+    },
     "name": {
       "type": "string",
       "description": "Display name of the project (\"environment\"), shown in the inspector header and browser tab"