@netnodeag/kraftwerk 0.75.1 → 0.76.0

package/dist/core/identity.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Who and where this kraftwerk is: ~/.kraftwerk/identity.json, one per
+ * machine (every workspace here shares it).
+ *
+ *   { "handle": "lukas", "machine": "mbp", "previous": ["lukas@old-name"] }
+ *
+ * The identity string is `handle@machine`. A workspace is git-shared, its
+ * run state is not, so a routine names the one identity that fires it
+ * (`runs_on:` in routines.yml) — without that every clone would fire it.
+ *
+ * Defaults come from the OS (user name, host name without its domain) and
+ * are written the first time they are read: macOS changes the host name
+ * with the network, and an identity that drifts with it would silently stop
+ * every routine assigned to this machine. Renaming appends the retired pair
+ * to `previous`, so routines that still name it can be found and healed.
+ */
+export interface Identity {
+    handle: string;
+    machine: string;
+    /** Retired `handle@machine` pairs, oldest first. */
+    previous: string[];
+}
+/** One half of an identity: lowercase, no "@". */
+export declare const IDENTITY_PART_RE: RegExp;
+/** The OS user name. */
+export declare function defaultHandle(): string;
+/** The host name, lowercased, without `.local` or a domain; anything outside [a-z0-9-] becomes "-". */
+export declare function defaultMachine(hostname?: string): string;
+/** Why a handle or machine name is refused, or undefined when it is fine. */
+export declare function identityPartError(label: "handle" | "machine", value: string): string | undefined;
+/** `handle@machine` with both halves well-formed: what `runs_on:` must look like. */
+export declare function isIdentityString(value: string): boolean;
+export declare const identityString: (id: Pick<Identity, "handle" | "machine">) => string;
+/**
+ * This machine's identity. A missing file gets the OS defaults, written so
+ * they stay put; a damaged field falls back to its default without being
+ * written over (a person may be halfway through editing the file).
+ */
+export declare function readIdentity(): Promise<Identity>;
+/** This machine's `handle@machine`. */
+export declare function localIdentity(): Promise<string>;
+/** Change the handle and/or machine name; the pair it replaces goes to `previous`. */
+export declare function setIdentity(change: {
+    handle?: string;
+    machine?: string;
+}): Promise<Identity>;

package/dist/core/identity.js

@@ -0,0 +1,106 @@
+import { randomBytes } from "node:crypto";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/** One half of an identity: lowercase, no "@". */
+export const IDENTITY_PART_RE = /^[a-z0-9._-]+$/;
+/** How many retired pairs are kept. */
+const MAX_PREVIOUS = 10;
+// Resolved on every use, not at import: a test swaps HOME after some module already imported this one.
+const identityFile = () => path.join(os.homedir(), ".kraftwerk", "identity.json");
+/** A free-form name as an identity half: lowercase, anything outside [a-z0-9._-] becomes "-". */
+function sanitize(raw, fallback) {
+    const s = raw
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/-{2,}/g, "-")
+        .replace(/^[-.]+|[-.]+$/g, "");
+    return s || fallback;
+}
+/** The OS user name. */
+export function defaultHandle() {
+    let name = "";
+    try {
+        name = os.userInfo().username;
+    }
+    catch {
+        name = process.env.USER ?? process.env.USERNAME ?? "";
+    }
+    return sanitize(name, "user");
+}
+/** The host name, lowercased, without `.local` or a domain; anything outside [a-z0-9-] becomes "-". */
+export function defaultMachine(hostname = os.hostname()) {
+    const host = hostname.toLowerCase().split(".")[0] ?? "";
+    const s = host.replace(/[^a-z0-9-]+/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+    return s || "machine";
+}
+/** Why a handle or machine name is refused, or undefined when it is fine. */
+export function identityPartError(label, value) {
+    if (!value)
+        return `${label} must not be empty`;
+    if (value.includes("@"))
+        return `${label} must not contain "@" (the identity is handle@machine)`;
+    if (!IDENTITY_PART_RE.test(value))
+        return `${label} must be lowercase letters, digits, ".", "_" or "-"`;
+    return undefined;
+}
+/** `handle@machine` with both halves well-formed: what `runs_on:` must look like. */
+export function isIdentityString(value) {
+    const parts = value.split("@");
+    return parts.length === 2 && IDENTITY_PART_RE.test(parts[0]) && IDENTITY_PART_RE.test(parts[1]);
+}
+export const identityString = (id) => `${id.handle}@${id.machine}`;
+async function write(id) {
+    const file = identityFile();
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    // A temp name per write: two writers in flight must not rename each other's file.
+    const tmp = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+    await fs.writeFile(tmp, JSON.stringify(id, null, 2) + "\n");
+    await fs.rename(tmp, file);
+}
+/**
+ * This machine's identity. A missing file gets the OS defaults, written so
+ * they stay put; a damaged field falls back to its default without being
+ * written over (a person may be halfway through editing the file).
+ */
+export async function readIdentity() {
+    let raw = null;
+    try {
+        raw = JSON.parse(await fs.readFile(identityFile(), "utf8"));
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            raw = {};
+    }
+    const handle = typeof raw?.handle === "string" && !identityPartError("handle", raw.handle) ? raw.handle : defaultHandle();
+    const machine = typeof raw?.machine === "string" && !identityPartError("machine", raw.machine) ? raw.machine : defaultMachine();
+    const previous = Array.isArray(raw?.previous) ? raw.previous.filter((p) => typeof p === "string" && isIdentityString(p)) : [];
+    const id = { handle, machine, previous };
+    if (raw === null)
+        await write(id).catch(() => { });
+    return id;
+}
+/** This machine's `handle@machine`. */
+export async function localIdentity() {
+    return identityString(await readIdentity());
+}
+/** Change the handle and/or machine name; the pair it replaces goes to `previous`. */
+export async function setIdentity(change) {
+    for (const label of ["handle", "machine"]) {
+        const v = change[label];
+        if (v === undefined)
+            continue;
+        const err = identityPartError(label, v);
+        if (err)
+            throw new Error(err);
+    }
+    const cur = await readIdentity();
+    const next = { handle: change.handle ?? cur.handle, machine: change.machine ?? cur.machine, previous: cur.previous };
+    const before = identityString(cur);
+    const after = identityString(next);
+    if (before !== after) {
+        next.previous = [...cur.previous.filter((p) => p !== before && p !== after), before].slice(-MAX_PREVIOUS);
+    }
+    await write(next);
+    return next;
+}

package/dist/core/routines.d.ts

@@ -10,6 +10,15 @@
  * 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.
+ *
+ * The definitions travel with the workspace's git, the state does not, so a
+ * workspace cloned on three machines would fire every routine three times.
+ * Each routine therefore names its runner, `runs_on: <handle>@<machine>`
+ * (see identity.ts), and the scheduler is strict: a routine fires only where
+ * runs_on is exactly this machine's identity. No runs_on, no runner — an
+ * unassigned routine fires nowhere until someone adopts it ("run these
+ * here"), which writes runs_on and commits routines.yml so the other clones
+ * learn who runs it. `private:` is stored and round-tripped; nothing reads it yet.
  */
 export interface Routine {
     id: string;
@@ -18,8 +27,21 @@ export interface Routine {
     schedule: string;
     prompt: string;
     enabled: boolean;
+    /** The one identity (`handle@machine`) that fires it. Absent: unassigned, fires nowhere. */
+    runsOn?: string;
+    /** Stored as given; no behaviour yet. */
+    private?: boolean;
 }
+/**
+ * Who fires a routine, seen from this machine: here, on another identity,
+ * or nobody (no runs_on).
+ */
+export type RoutineRunner = "here" | "elsewhere" | "unassigned";
 export interface RoutineStatus extends Routine {
+    runner: RoutineRunner;
+    /** runs_on names an identity this machine had before (identity.json `previous`): a rename left it behind. */
+    retired?: boolean;
+    /** Only for an enabled routine that fires here. */
     nextRunAt?: string;
     lastRunAt?: string;
     lastChatId?: string;
@@ -46,6 +68,9 @@ export interface SaveRoutineInput {
     schedule: string;
     prompt: string;
     enabled?: boolean;
+    /** Absent: kept as it is (a new routine gets this machine's identity). null or "": unassigned. */
+    runsOn?: string | null;
+    private?: boolean;
 }
 export declare function saveRoutine(slug: string, input: SaveRoutineInput): Promise<Routine>;
 export declare function deleteRoutine(slug: string, id: string): Promise<void>;
@@ -70,10 +95,66 @@ export declare function allRoutines(workflows: {
     };
     workflows: string[];
 })[]>;
+/** Whether a routine fires on the machine whose identity is `me`: enabled and runs_on exactly that. */
+export declare const firesHere: (r: Routine, me: string) => boolean;
 export declare function routineStatuses(slug: string): Promise<RoutineStatus[]>;
 export declare function runRoutineNow(slug: string, id: string): Promise<{
     chatId: string;
 }>;
+/**
+ * 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 declare function dueRoutines(now: Date, me?: string): Promise<{
+    slug: string;
+    routine: Routine;
+}[]>;
+export interface RunnerRef {
+    agent: string;
+    id: string;
+    name: string;
+    /** What runs_on said before (absent: unassigned). */
+    from?: string;
+}
+export interface RunnerFindings {
+    /** Enabled routines without runs_on: they fire nowhere. */
+    unassigned: RunnerRef[];
+    /** Routines whose runs_on is one of this machine's retired identities. */
+    retired: RunnerRef[];
+    /** Newest change to a routines.yml involved, ISO (the attention item's "since"). */
+    since?: string;
+}
+/** Every routine in the workspace that has no runner, or names a retired identity of this machine. */
+export declare function runnerFindings(): Promise<RunnerFindings>;
+export interface AdoptResult {
+    /** This machine's identity, now the runner of every routine listed. */
+    runsOn: string;
+    adopted: RunnerRef[];
+    /** routines.yml files written, relative to the workspace root. */
+    files: string[];
+    /** The git commit of those files; null when nothing changed. Not ok: written, but not committed (why in `error`). */
+    commit: {
+        ok: boolean;
+        error?: string;
+        committed?: number;
+    } | null;
+}
+/**
+ * "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 declare function adoptRoutines(pick: (agent: string, r: Routine, previous: string[]) => boolean, message?: string): Promise<AdoptResult>;
+/** Adopt one routine (whatever its runs_on said). */
+export declare function adoptRoutine(slug: string, id: string): Promise<AdoptResult & {
+    routine: RoutineStatus;
+}>;
+/** Adopt every enabled routine without runs_on — and, with `retired`, every one naming a retired identity of this machine. */
+export declare function adoptUnassigned(opts?: {
+    retired?: boolean;
+}): Promise<AdoptResult>;
 /** Start the current workspace's scheduler; safe to call more than once. Ticks run in that workspace. */
 export declare function startRoutineScheduler(): void;
 /** Stop the current workspace's scheduler (the workspace closes): no routine of it fires any more. */

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;