@netnodeag/kraftwerk 0.75.0 → 0.76.0

package/dist/config.js

@@ -1,4 +1,5 @@
-import { readFile, stat } from "node:fs/promises";
+import { randomInt } from "node:crypto";
+import { readFile, stat, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { parse } from "yaml";
@@ -13,6 +14,7 @@ import { parse } from "yaml";
  *
  * All fields are optional — a valid kraftwerk.yml may be empty:
  *
+ *   id: ws_k3f9x2m7q1          # the workspace's identity across machines and clones (committed; `kraftwerk init` writes it)
  *   name: my-project           # display name (inspector header, "environment")
  *   icon: "⚡"                  # emoji shown as inspector favicon
  *   color: "#c2410c"           # accent for this workspace in the switcher (default: derived from the root)
@@ -174,7 +176,7 @@ export async function resolveWorkspace(cwd) {
             const { config, legacyKeys } = loaded;
             const workflowsRoot = await findWorkflowsDir(dir, config.workflows);
             if (!bare || (workflowsRoot && path.resolve(workflowsRoot) === bare.workflowsRoot)) {
-                return { root: dir, config, configPath, workflowsRoot, outputDir: path.resolve(dir, config.output ?? "output"), ...(legacyKeys.length ? { legacyKeys } : {}) };
+                return { root: dir, config, configPath, ...(config.id ? { id: config.id } : {}), workflowsRoot, outputDir: path.resolve(dir, config.output ?? "output"), ...(legacyKeys.length ? { legacyKeys } : {}) };
             }
             return bare;
         }
@@ -213,7 +215,37 @@ export function slugFromFolder(folder) {
 export function workspaceSlug(ws) {
     return ws.config.slug ?? slugFromFolder(path.basename(ws.root));
 }
-const KNOWN_KEYS = ["name", "slug", "icon", "color", "port", "workflows", "output", "knowledge", "agents", "skills", "switcher", "git", "repos", "vibeables", "projects", "cloud"];
+/** A workspace id: `ws_` and 10 lowercase base36 characters. */
+export const WORKSPACE_ID_RE = /^ws_[a-z0-9]{10}$/;
+/** A fresh workspace id for kraftwerk.yml. */
+export function newWorkspaceId() {
+    const alphabet = "0123456789abcdefghijklmnopqrstuvwxyz";
+    let id = "ws_";
+    for (let i = 0; i < 10; i++)
+        id += alphabet[randomInt(alphabet.length)];
+    return id;
+}
+/**
+ * Give an existing kraftwerk.yml an id, textually: one line inserted after
+ * the leading comments, the rest of the file byte for byte as it was (a
+ * re-serialised YAML document would lose the comments people keep there).
+ * Returns the id, or the one already there.
+ */
+export async function addWorkspaceId(configPath) {
+    const text = await readFile(configPath, "utf8");
+    const existing = /^id:\s*["']?(ws_[a-z0-9]{10})["']?\s*(#.*)?$/m.exec(text);
+    if (existing)
+        return existing[1];
+    const id = newWorkspaceId();
+    const line = `id: ${id}   # this workspace's identity on every machine and clone — commit it, keep it`;
+    const lines = text.split("\n");
+    const first = lines.findIndex((l) => !/^\s*(#|$)/.test(l));
+    // Nothing but comments (or nothing at all): the id goes at the end.
+    const out = first === -1 ? `${text.replace(/\n*$/, text.trim() ? "\n" : "")}${line}\n` : [...lines.slice(0, first), line, ...lines.slice(first)].join("\n");
+    await writeFile(configPath, out);
+    return id;
+}
+const KNOWN_KEYS = ["id", "name", "slug", "icon", "color", "port", "workflows", "output", "knowledge", "agents", "skills", "switcher", "git", "repos", "vibeables", "projects", "cloud"];
 /**
  * Keys an older kraftwerk understood and this one ignores, so the files
  * that still carry them keep loading: `public:` and `tunnel:` (the
@@ -243,6 +275,9 @@ async function loadConfig(configPath) {
         if (!known.includes(key)) {
             throw new Error(`${path.basename(configPath)}: unknown key "${key}" (allowed: ${known.join(", ")})`);
         }
+        if (key === "id" && (typeof config[key] !== "string" || !WORKSPACE_ID_RE.test(config[key]))) {
+            throw new Error(`${path.basename(configPath)}: id must be "ws_" followed by 10 lowercase letters or digits (like ws_k3f9x2m7q1), got ${JSON.stringify(config[key])} — delete the line and run \`kraftwerk doctor --fix\` for a fresh one`);
+        }
         if (key === "slug" && (typeof config[key] !== "string" || !SLUG_RE.test(config[key]))) {
             throw new Error(`${path.basename(configPath)}: slug must be lowercase letters, digits and dashes, starting with a letter or digit (at most 63)`);
         }

package/dist/core/attention.d.ts

@@ -1,9 +1,13 @@
+import { type RunnerRef } from "./routines.js";
 /**
  * What needs you: every place where work is stuck on a human, with whose it
  * is. Two sources: requests waiting in a live chat (an approval, a question
  * — the agent cannot go on until someone answers) and failures nobody has
  * looked at yet (a routine or a workflow run that ended badly; unread
  * failure notifications). Oldest first: what waits longest comes first.
+ * A third, about setup rather than one piece of work: routines nobody runs
+ * (enabled, no runs_on) and routines naming an identity this machine has
+ * retired — both fire nowhere until someone assigns them a runner.
  *
  * The inspector builds everything urgent from this one list: the counts on
  * the rail, the "needs you" part of the bell, the tab title and "next",
@@ -29,7 +33,8 @@ export interface AttentionOwner {
 export interface AttentionItem {
     /** The request id (live requests) or the notification id (failures). */
     id: string;
-    kind: "approval" | "question" | "failed";
+    /** runner: routines without a runner, or naming a retired identity of this machine (see routines.ts). */
+    kind: "approval" | "question" | "failed" | "runner";
     /** What is asked, or what went wrong. */
     title: string;
     /** The session it sits in. */
@@ -41,6 +46,8 @@ export interface AttentionItem {
     owner: AttentionOwner;
     /** Failures: the notification to mark read once the item was opened. */
     notificationId?: string;
+    /** runner items: the routines concerned; `from` is the retired identity they name. */
+    routines?: RunnerRef[];
 }
 export interface AttentionView {
     items: AttentionItem[];

package/dist/core/attention.js

@@ -2,11 +2,13 @@ import { listAgents } from "./agents.js";
 import { waitingRequests } from "./chat/sessions.js";
 import { chatHref, listNotifications } from "./notifications.js";
 import { listProjects } from "./projects.js";
+import { runnerFindings } from "./routines.js";
 export async function listAttention() {
-    const [agents, projects, notes] = await Promise.all([
+    const [agents, projects, notes, runners] = await Promise.all([
         listAgents().catch(() => []),
         listProjects().catch(() => ({ projects: [] })),
         listNotifications().catch(() => ({ items: [] })),
+        runnerFindings().catch(() => ({ unassigned: [], retired: [] })),
     ]);
     const agentOf = (slug) => {
         const a = agents.find((x) => x.slug === slug);
@@ -65,6 +67,40 @@ export async function listAttention() {
             notificationId: n.id,
         };
     });
-    const items = [...waiting, ...failed].sort((a, b) => a.since.localeCompare(b.since));
+    // One item per problem, not per routine: the fix ("run these here") is one action for all of them.
+    const since = runners.since ?? new Date(0).toISOString();
+    // The fix lives on an agent profile's routines panel (/agents/<slug>/info — /agents/<slug> redirects
+    // to a chat). Routines of one agent: that profile and its rail entry; of several: the first agent's
+    // profile, whose banner adopts across the whole workspace.
+    const placed = (these) => {
+        const slugs = [...new Set(these.map((r) => r.agent))];
+        return slugs.length === 1
+            ? { href: `/agents/${slugs[0]}/info`, owner: { agent: agentOf(slugs[0]) } }
+            : { href: `/agents/${slugs[0]}/info`, owner: {} };
+    };
+    const runner = [];
+    const n = runners.unassigned.length;
+    if (n) {
+        runner.push({
+            id: "runner:unassigned",
+            kind: "runner",
+            title: `${n} routine${n === 1 ? " has" : "s have"} no runner — ${n === 1 ? "it fires" : "they fire"} nowhere until a machine runs ${n === 1 ? "it" : "them"}`,
+            since,
+            ...placed(runners.unassigned),
+            routines: runners.unassigned,
+        });
+    }
+    for (const old of [...new Set(runners.retired.map((r) => r.from))]) {
+        const these = runners.retired.filter((r) => r.from === old);
+        runner.push({
+            id: `runner:retired:${old}`,
+            kind: "runner",
+            title: `${these.length} routine${these.length === 1 ? " names" : "s name"} a retired identity ${old} — reassign`,
+            since,
+            ...placed(these),
+            routines: these,
+        });
+    }
+    const items = [...waiting, ...failed, ...runner].sort((a, b) => a.since.localeCompare(b.since));
     return { items };
 }

package/dist/core/daemon.d.ts

@@ -29,10 +29,24 @@ export declare function lastOpenRoots(): Promise<string[]>;
 /** The daemon file as the last daemon left it; null without one. */
 export declare function readDaemonFile(): Promise<DaemonFile | null>;
 /** The running daemon (its file, and a hub that answers on its port), or null. */
-export declare function findDaemon(): Promise<{
+export declare function findDaemon(timeoutMs?: number): Promise<{
     pid: number;
     port: number;
 } | null>;
+export type DaemonState = {
+    state: "running" | "busy";
+    pid: number;
+    port: number;
+} | {
+    state: "stopped";
+};
+/**
+ * Whether a daemon runs, telling a slow one from a stopped one: "busy" is a
+ * daemon whose process lives and whose port is taken but that did not answer
+ * in time. A busy daemon is never "stopped" — starting another would only
+ * crash on the taken port, and restarting it would interrupt its agents.
+ */
+export declare function daemonState(timeoutMs?: number): Promise<DaemonState>;
 /** Ask the daemon to open or close a workspace (this machine's request: local trust). */
 export declare function daemonCall<T>(port: number, verb: "open" | "close", root: string): Promise<{
     ok: boolean;

package/dist/core/daemon.js

@@ -1,4 +1,5 @@
 import { promises as fs } from "node:fs";
+import net from "node:net";
 import os from "node:os";
 import path from "node:path";
 /**
@@ -47,18 +48,20 @@ export async function readDaemonFile() {
         return null;
     }
 }
+/**
+ * How long a daemon may take to answer before it counts as not there. A
+ * daemon under load (agents at work, a busy machine) can take a second or
+ * two; 0.8 s once read such a one as stopped.
+ */
+const ANSWER_MS = 3000;
 /** The running daemon (its file, and a hub that answers on its port), or null. */
-export async function findDaemon() {
-    let rec;
-    try {
-        rec = JSON.parse(await fs.readFile(daemonFile(), "utf8"));
-    }
-    catch {
+export async function findDaemon(timeoutMs = ANSWER_MS) {
+    const rec = await readDaemonFile();
+    if (!rec)
         return null;
-    }
     try {
         // Every kraftwerk server answers /api/hub; only the daemon says it is one (a standalone `kraftwerk ui` may sit on that port now).
-        const r = await fetch(`http://127.0.0.1:${rec.port}/api/hub`, { signal: AbortSignal.timeout(800) });
+        const r = await fetch(`http://127.0.0.1:${rec.port}/api/hub`, { signal: AbortSignal.timeout(timeoutMs) });
         const body = r.ok ? (await r.json()) : null;
         return body?.daemon === true ? { pid: rec.pid, port: rec.port } : null;
     }
@@ -66,6 +69,41 @@ export async function findDaemon() {
         return null;
     }
 }
+const pidAlive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM: it exists, it is just not ours to signal.
+        return err.code === "EPERM";
+    }
+};
+const portTaken = (port) => new Promise((resolve) => {
+    const sock = net.connect({ host: "127.0.0.1", port });
+    const done = (taken) => {
+        sock.destroy();
+        resolve(taken);
+    };
+    sock.setTimeout(1000, () => done(true)); // accepted nothing yet, refused nothing either: something holds it
+    sock.once("connect", () => done(true));
+    sock.once("error", () => done(false));
+});
+/**
+ * Whether a daemon runs, telling a slow one from a stopped one: "busy" is a
+ * daemon whose process lives and whose port is taken but that did not answer
+ * in time. A busy daemon is never "stopped" — starting another would only
+ * crash on the taken port, and restarting it would interrupt its agents.
+ */
+export async function daemonState(timeoutMs = ANSWER_MS) {
+    const found = await findDaemon(timeoutMs);
+    if (found)
+        return { state: "running", ...found };
+    const rec = await readDaemonFile();
+    if (rec && pidAlive(rec.pid) && (await portTaken(rec.port)))
+        return { state: "busy", pid: rec.pid, port: rec.port };
+    return { state: "stopped" };
+}
 /** Ask the daemon to open or close a workspace (this machine's request: local trust). */
 export async function daemonCall(port, verb, root) {
     const r = await fetch(`http://127.0.0.1:${port}/api/hub/${verb}`, {

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. */