@netnodeag/kraftwerk 0.64.0 → 0.66.0

package/dist/core/git.js

@@ -4,7 +4,8 @@ import path from "node:path";
 import { projectsRootFor, reposRootFor, resolveWorkspace, vibeablesRootFor, isSafeGitName } from "../config.js";
 import { ENV_FILE } from "../runner/docker.js";
 import { getOutputDir, workspaceRoot } from "./context.js";
-import { perWorkspace } from "./workspace.js";
+import { perWorkspace, workspaceOpen } from "./workspace.js";
+import { workspaceEnv } from "./env.js";
 /**
  * Workspace git sync. Several people run kraftwerk against one git repo, so
  * knowledge, agents, skills, channels and workflows travel between them like
@@ -65,7 +66,7 @@ const MAX_BLOCKED = 200;
  * terminal read that never returns, and the inspector hangs with it.
  */
 const gitEnv = (extra) => ({
-    ...process.env,
+    ...workspaceEnv(),
     GIT_TERMINAL_PROMPT: "0",
     GIT_ASKPASS: "",
     SSH_ASKPASS: "",
@@ -341,6 +342,8 @@ const gitState = perWorkspace(() => ({
     timer: null,
     ticking: false,
     lastRun: 0,
+    /** Set when the workspace closes: a tick in flight does not schedule the next one. */
+    stopped: false,
 }));
 /** Invalidate the status cache after anything that changes the repo. */
 const touched = () => {
@@ -643,10 +646,19 @@ const RECHECK_MS = 60_000;
  * out) before the next one starts, or a short interval piles up processes.
  */
 export function startGitSync() {
+    gitState().stopped = false;
     if (gitState().timer || gitState().ticking)
         return;
     schedule(0);
 }
+/** Stop the current workspace's background sync (the workspace closes). A tick in flight finishes, then stops. */
+export function stopGitSync() {
+    const s = gitState();
+    s.stopped = true;
+    if (s.timer)
+        clearTimeout(s.timer);
+    s.timer = null;
+}
 function schedule(ms) {
     const timer = setTimeout(() => void tick(), ms);
     timer.unref?.();
@@ -671,8 +683,12 @@ async function tick() {
         // A failed tick is retried at the next one; the status carries lastError.
     }
     finally {
-        gitState().ticking = false;
-        schedule(next);
+        // The workspace may have closed while git ran: then its state is gone and nothing is scheduled.
+        if (workspaceOpen()) {
+            gitState().ticking = false;
+            if (!gitState().stopped)
+                schedule(next);
+        }
     }
 }
 async function sync(repo) {

package/dist/core/instances.d.ts

@@ -6,6 +6,8 @@ export declare const legacyWorkspacesDir: () => string;
 /** Durable per-project record. The root is the key; everything else derives from it. */
 export interface WorkspaceRecord {
     root: string;
+    /** The workspace's address on this machine (kraftwerk.yml `slug`, else its folder name), as of its last start. */
+    slug?: string;
     firstSeen: string;
     lastStarted: string;
     /** Set on clean shutdown; older than lastStarted means the last run died. */
@@ -29,10 +31,14 @@ export interface DiscoveredInstance {
     named?: boolean;
     live: true;
     root?: string;
-    /** Server process id (what to signal to stop it). */
+    /** Server process id (what to signal to stop it — unless `hub`). */
     pid: number;
     /** The kraftwerk version the instance runs. */
     version?: string;
+    /** Its slug, when a daemon serves it. */
+    slug?: string;
+    /** Served by a daemon next to other workspaces: stopped by closing it there. */
+    hub?: boolean;
 }
 /**
  * One workspace as the switcher shows it: a known project (running or
@@ -60,12 +66,20 @@ export interface WorkspaceEntry {
 export declare const workspaceRecordName: (root: string) => string;
 /** ~/… for display. */
 export declare const tildify: (p: string) => string;
-/** Write this instance's registry file (call once the server listens). */
-export declare function registerInstance(port: number, root: string): Promise<void>;
-/** Where this instance answers, as the switcher links it (null before listen). */
+/**
+ * Write a served workspace's registry file (call once the server listens).
+ * A daemon's workspaces carry their slug and address and get a file each;
+ * a standalone server keeps the one `<pid>.json` it always had.
+ */
+export declare function registerInstance(port: number, root: string, opts?: {
+    url?: string;
+    slug?: string;
+    hub?: boolean;
+}): Promise<void>;
+/** Where the current workspace answers, as the switcher links it (null before listen). */
 export declare const currentInstanceUrl: () => string | null;
-/** Remove this instance's registry file. Sync so exit handlers can call it. */
-export declare function unregisterInstance(): void;
+/** Remove a served workspace's registry file — every one this process wrote when no root is given. Sync so exit handlers can call it. */
+export declare function unregisterInstance(root?: string): void;
 /**
  * All other running instances, verified live. Cached briefly — /api/meta is
  * polled. `fresh` probes now; `readOnly` leaves the records of instances that
@@ -80,10 +94,14 @@ export declare function registerWorkspace(root: string): Promise<void>;
 export declare const syncWorkspaceAgents: (root: string, agents: AgentSummary[]) => Promise<void>;
 export declare const syncWorkspaceChannels: (root: string, channels: ChannelSummary[]) => Promise<void>;
 export declare const syncWorkspaceProjects: (root: string, projects: ProjectHit[]) => Promise<void>;
-/** Stamp lastStopped on clean shutdown. Sync so exit handlers can call it. */
-export declare function markWorkspaceStopped(): void;
+/** Stamp lastStopped on a clean stop — every workspace this process serves when no root is given. Sync so exit handlers can call it. */
+export declare function markWorkspaceStopped(root?: string): void;
 /** All known workspaces, most recently started first. */
 export declare function listWorkspaceRecords(): Promise<WorkspaceRecord[]>;
+/** A record's slug: as registered, or (records from before 0.66) its folder name made into one. */
+export declare const recordSlug: (r: WorkspaceRecord) => string;
+/** Other registered workspaces with this slug — two workspaces cannot share an address. */
+export declare function slugClashes(slug: string, root: string): Promise<WorkspaceRecord[]>;
 /** Drop a workspace record (the root itself is untouched) — from the legacy directory too, see migrateRegistry. */
 export declare function forgetWorkspace(root: string): Promise<boolean>;
 /**
@@ -137,10 +155,12 @@ export interface StartResult {
  */
 export declare function startWorkspace(root: string): Promise<StartResult>;
 /**
- * Stop a running workspace: SIGTERM to its server process, which
- * unregisters, stamps lastStopped and exits; the `kraftwerk ui` supervisor
- * follows. Matched by root, or by url for instances from older versions
- * that registered no root. Waits up to ~5s for the port to go quiet.
+ * Stop a running workspace. A daemon's workspace is closed there — the
+ * daemon and every other workspace in it keep running. A standalone one
+ * gets SIGTERM to its server process, which unregisters, stamps
+ * lastStopped and exits; the `kraftwerk ui` supervisor follows. Matched by
+ * root, or by url for instances from older versions that registered no
+ * root. Waits up to ~5s for it to go quiet.
  */
 export declare function stopWorkspace(target: {
     root?: string;

package/dist/core/instances.js

@@ -3,8 +3,10 @@ import { createHash } from "node:crypto";
 import fsSync, { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { absolutePath, isDir, resolveWorkspace } from "../config.js";
+import { absolutePath, isDir, resolveWorkspace, slugFromFolder, workspaceSlug } from "../config.js";
 import { selfCommand } from "./self-command.js";
+import { DAEMON_PORT, daemonCall, findDaemon } from "./daemon.js";
+import { currentWorkspace } from "./workspace.js";
 /**
  * Two registries under ~/.kraftwerk, two lifecycles:
  *
@@ -31,9 +33,16 @@ const workspacesDir = () => path.join(kwHome(), "workspaces");
 /** Where the records lived before 0.49 (`kraftwerk projects`); moved over once, see migrateRegistry. */
 export const legacyWorkspacesDir = () => path.join(kwHome(), "projects");
 const logsDir = () => path.join(kwHome(), "logs");
-const selfFile = () => path.join(instancesDir(), `${process.pid}.json`);
-let selfPort = null;
-let selfRoot = null;
+const own = new Map();
+/** The workspace the caller runs in (a request, a timer), or null outside any. */
+function currentRoot() {
+    try {
+        return currentWorkspace().root;
+    }
+    catch {
+        return null;
+    }
+}
 /** File name of a root's record: a hash of the absolute root, the same under the old and the new directory. */
 export const workspaceRecordName = (root) => `${createHash("sha1").update(absolutePath(root)).digest("hex").slice(0, 16)}.json`;
 const recordFile = (root) => path.join(workspacesDir(), workspaceRecordName(root));
@@ -43,42 +52,61 @@ export const tildify = (p) => {
     return p === home || p.startsWith(home + path.sep) ? "~" + p.slice(home.length) : p;
 };
 /* ---------- instances (ephemeral) ---------- */
-/** Write this instance's registry file (call once the server listens). */
-export async function registerInstance(port, root) {
-    selfPort = port;
-    selfRoot = absolutePath(root);
+/**
+ * Write a served workspace's registry file (call once the server listens).
+ * A daemon's workspaces carry their slug and address and get a file each;
+ * a standalone server keeps the one `<pid>.json` it always had.
+ */
+export async function registerInstance(port, root, opts = {}) {
+    const abs = absolutePath(root);
+    const file = path.join(instancesDir(), opts.hub ? `${process.pid}-${workspaceRecordName(abs)}` : `${process.pid}.json`);
+    const url = opts.url ?? `http://localhost:${port}`;
+    const mine = { port, url, file };
+    own.set(abs, mine);
     try {
         await fs.mkdir(instancesDir(), { recursive: true });
-        const rec = { pid: process.pid, port, startedAt: new Date().toISOString(), root: selfRoot };
-        await fs.writeFile(selfFile(), JSON.stringify(rec));
+        const rec = { pid: process.pid, port, startedAt: new Date().toISOString(), root: abs, ...(opts.hub ? { url, slug: opts.slug, hub: true } : {}) };
+        await fs.writeFile(file, JSON.stringify(rec));
+        // Closed while this wrote (an open and a close in quick succession): the file must not outlive it.
+        if (own.get(abs) !== mine)
+            await fs.unlink(file).catch(() => { });
     }
     catch { } // best-effort — without it discovery just won't see us
+    cache = null;
+    wsCache.clear();
 }
-/** Where this instance answers, as the switcher links it (null before listen). */
-export const currentInstanceUrl = () => (selfPort ? `http://localhost:${selfPort}` : null);
-/** Remove this instance's registry file. Sync so exit handlers can call it. */
-export function unregisterInstance() {
-    try {
-        fsSync.unlinkSync(selfFile());
+/** Where the current workspace answers, as the switcher links it (null before listen). */
+export const currentInstanceUrl = () => own.get(currentRoot() ?? "")?.url ?? null;
+/** Remove a served workspace's registry file — every one this process wrote when no root is given. Sync so exit handlers can call it. */
+export function unregisterInstance(root) {
+    const roots = root ? [absolutePath(root)] : [...own.keys()];
+    for (const r of roots) {
+        try {
+            fsSync.unlinkSync(own.get(r)?.file ?? "");
+        }
+        catch { }
+        own.delete(r);
     }
-    catch { }
+    cache = null;
+    wsCache.clear();
 }
 /**
  * Probe one registered port: is a kraftwerk inspector answering? `probe=1`
  * tells the other side to skip its own discovery — two instances probing
  * each other's /api/meta must not recurse.
  */
-async function probe(port) {
+async function probe(port, slug) {
     // `listen(port, "localhost")` binds one address family, whichever the
     // resolver returns first (::1 on this platform), so an instance started
     // with KRAFTWERK_UI_HOST=localhost or ::1 is not on 127.0.0.1. A refused
     // connection returns at once, so the second try costs nothing when the
     // first one answers.
-    return (await probeAt("127.0.0.1", port)) ?? (await probeAt("[::1]", port));
+    return (await probeAt("127.0.0.1", port, slug)) ?? (await probeAt("[::1]", port, slug));
 }
-async function probeAt(host, port) {
+async function probeAt(host, port, slug) {
     try {
-        const r = await fetch(`http://${host}:${port}/api/meta?probe=1`, {
+        // A daemon's workspace answers under its slug; the path form needs no name resolution.
+        const r = await fetch(`http://${host}:${port}${slug ? `/w/${slug}` : ""}/api/meta?probe=1`, {
             signal: AbortSignal.timeout(400),
         });
         if (!r.ok)
@@ -110,7 +138,7 @@ let cache = null;
  */
 export async function discoverInstances(opts = {}) {
     if (!opts.fresh && cache && Date.now() - cache.at < 5_000)
-        return cache.entries;
+        return notSelf(cache.entries);
     let files;
     try {
         files = await fs.readdir(instancesDir());
@@ -128,21 +156,25 @@ export async function discoverInstances(opts = {}) {
         catch {
             return null;
         }
-        if (rec.pid === process.pid || rec.port === selfPort)
-            return null;
-        const found = await probe(rec.port);
+        const found = await probe(rec.port, rec.hub ? rec.slug : undefined);
         if (!found) {
             if (!opts.readOnly)
                 await fs.unlink(path.join(instancesDir(), f)).catch(() => { }); // stale — prune
             return null;
         }
-        return { ...found, root: rec.root, pid: rec.pid };
+        return { ...found, root: rec.root, pid: rec.pid, ...(rec.hub ? { url: rec.url ?? found.url, slug: rec.slug, hub: true } : {}) };
     }));
     const entries = probed
         .filter((e) => e != null)
         .sort((a, b) => a.name.localeCompare(b.name));
     cache = { at: Date.now(), entries };
-    return entries;
+    return notSelf(entries);
+}
+/** Leave out the asking workspace itself (an older instance file without a root: by this process and port). */
+function notSelf(entries) {
+    const me = currentRoot();
+    const port = me ? own.get(me)?.port : undefined;
+    return entries.filter((e) => (e.root ? e.root !== me : !(e.pid === process.pid && e.url === `http://localhost:${port}`)));
 }
 /* ---------- workspaces (durable) ---------- */
 let migrated = null;
@@ -182,6 +214,7 @@ async function readRecord(file) {
             return null;
         return {
             root: rec.root,
+            ...(typeof rec.slug === "string" ? { slug: rec.slug } : {}),
             firstSeen: rec.firstSeen ?? rec.lastStarted ?? "",
             lastStarted: rec.lastStarted ?? rec.firstSeen ?? "",
             lastStopped: rec.lastStopped,
@@ -197,14 +230,19 @@ async function readRecord(file) {
 }
 /** Upsert the project record for a root (call on every inspector start). */
 export async function registerWorkspace(root) {
-    await migrateRegistry();
     const abs = absolutePath(root);
+    // Where it goes is decided now: the registry of the home this was called in, whatever HOME is by the time it writes.
+    const dir = workspacesDir();
+    const file = path.join(dir, workspaceRecordName(abs));
+    await migrateRegistry();
     const now = new Date().toISOString();
     try {
-        await fs.mkdir(workspacesDir(), { recursive: true });
-        const prev = await readRecord(recordFile(abs));
+        await fs.mkdir(dir, { recursive: true });
+        const prev = await readRecord(file);
+        const slug = await resolveWorkspace(abs).then(workspaceSlug, () => slugFromFolder(path.basename(abs)));
         const rec = {
             root: abs,
+            slug,
             firstSeen: prev?.firstSeen || now,
             lastStarted: now,
             startCount: (prev?.startCount ?? 0) + 1,
@@ -212,7 +250,7 @@ export async function registerWorkspace(root) {
             ...(prev?.channels ? { channels: prev.channels } : {}),
             ...(prev?.projects ? { projects: prev.projects } : {}),
         };
-        await fs.writeFile(recordFile(abs), JSON.stringify(rec, null, 2));
+        await fs.writeFile(file, JSON.stringify(rec, null, 2));
     }
     catch { } // best-effort, like the instance file
 }
@@ -241,17 +279,17 @@ async function syncWorkspaceList(root, key, list) {
 export const syncWorkspaceAgents = (root, agents) => syncWorkspaceList(root, "agents", agents);
 export const syncWorkspaceChannels = (root, channels) => syncWorkspaceList(root, "channels", channels);
 export const syncWorkspaceProjects = (root, projects) => syncWorkspaceList(root, "projects", projects);
-/** Stamp lastStopped on clean shutdown. Sync so exit handlers can call it. */
-export function markWorkspaceStopped() {
-    if (!selfRoot)
-        return;
-    try {
-        const file = recordFile(selfRoot);
-        const rec = JSON.parse(fsSync.readFileSync(file, "utf8"));
-        rec.lastStopped = new Date().toISOString();
-        fsSync.writeFileSync(file, JSON.stringify(rec, null, 2));
+/** Stamp lastStopped on a clean stop — every workspace this process serves when no root is given. Sync so exit handlers can call it. */
+export function markWorkspaceStopped(root) {
+    for (const r of root ? [absolutePath(root)] : [...own.keys()]) {
+        try {
+            const file = recordFile(r);
+            const rec = JSON.parse(fsSync.readFileSync(file, "utf8"));
+            rec.lastStopped = new Date().toISOString();
+            fsSync.writeFileSync(file, JSON.stringify(rec, null, 2));
+        }
+        catch { }
     }
-    catch { }
 }
 /** All known workspaces, most recently started first. */
 export async function listWorkspaceRecords() {
@@ -268,6 +306,13 @@ export async function listWorkspaceRecords() {
         .filter((r) => r != null)
         .sort((a, b) => b.lastStarted.localeCompare(a.lastStarted));
 }
+/** A record's slug: as registered, or (records from before 0.66) its folder name made into one. */
+export const recordSlug = (r) => r.slug ?? slugFromFolder(path.basename(r.root));
+/** Other registered workspaces with this slug — two workspaces cannot share an address. */
+export async function slugClashes(slug, root) {
+    const abs = absolutePath(root);
+    return (await listWorkspaceRecords()).filter((r) => r.root !== abs && recordSlug(r) === slug);
+}
 /** Drop a workspace record (the root itself is untouched) — from the legacy directory too, see migrateRegistry. */
 export async function forgetWorkspace(root) {
     await migrateRegistry();
@@ -310,7 +355,8 @@ async function describeRoot(root) {
         return fallback;
     }
 }
-let wsCache = null;
+/** Per asking workspace: each leaves itself out of its list. */
+const wsCache = new Map();
 /**
  * The switcher's view: every known project joined with the live instances,
  * plus running instances with no project record yet. The calling instance
@@ -318,13 +364,15 @@ let wsCache = null;
  * discoverInstances — /api/meta is polled and this stats every root.
  */
 export async function discoverWorkspaces() {
-    if (wsCache && Date.now() - wsCache.at < 5_000)
-        return wsCache.entries;
+    const me = currentRoot() ?? "";
+    const hit = wsCache.get(me);
+    if (hit && Date.now() - hit.at < 5_000)
+        return hit.entries;
     const [projects, live] = await Promise.all([listWorkspaceRecords(), discoverInstances()]);
     const liveByRoot = new Map(live.filter((i) => i.root).map((i) => [i.root, i]));
     const consumed = new Set();
     const entries = (await Promise.all(projects
-        .filter((p) => p.root !== selfRoot)
+        .filter((p) => p.root !== me)
         .map(async (p) => {
         const base = { root: p.root, rootLabel: tildify(p.root), lastStarted: p.lastStarted, lastStopped: p.lastStopped };
         let running = liveByRoot.get(p.root);
@@ -371,7 +419,7 @@ export async function discoverWorkspaces() {
             return a.live ? -1 : 1;
         return (b.lastStarted ?? "").localeCompare(a.lastStarted ?? "") || a.name.localeCompare(b.name);
     });
-    wsCache = { at: Date.now(), entries };
+    wsCache.set(me, { at: Date.now(), entries });
     return entries;
 }
 const countDirs = async (dir, marker) => {
@@ -403,25 +451,27 @@ const countEntries = async (dir) => {
 export async function listWorkspacesDetailed() {
     const others = await discoverWorkspaces();
     const all = [...others];
-    if (selfRoot && selfPort) {
-        const d = await describeRoot(selfRoot);
-        const rec = await readRecord(recordFile(selfRoot));
+    const me = currentRoot();
+    const mine = me ? own.get(me) : undefined;
+    if (me && mine) {
+        const d = await describeRoot(me);
+        const rec = await readRecord(recordFile(me));
         all.unshift({
             name: d.name,
             icon: d.icon,
             color: d.color,
             named: d.named,
-            url: `http://localhost:${selfPort}`,
+            url: mine.url,
             live: true,
-            root: selfRoot,
-            rootLabel: tildify(selfRoot),
+            root: me,
+            rootLabel: tildify(me),
             exists: true,
             lastStarted: rec?.lastStarted,
             lastStopped: rec?.lastStopped,
         });
     }
     return Promise.all(all.map(async (e) => {
-        const current = !!selfRoot && e.root === selfRoot;
+        const current = !!me && e.root === me;
         const base = { ...e, current, state: e.live ? "running" : "stopped" };
         if (!e.root)
             return base;
@@ -476,15 +526,25 @@ export async function startWorkspace(root) {
     if (!exists)
         return { ok: false, error: `not a project directory (missing or moved): ${abs}` };
     const url = `http://localhost:${port}`;
-    if (abs === selfRoot)
+    if (abs === currentRoot())
         return { ok: false, url, live: true, error: "that is this workspace" };
     // Already running, or the port is taken by another kraftwerk?
-    cache = wsCache = null;
+    cache = null;
+    wsCache.clear();
     const live = await discoverInstances();
     const byRoot = live.find((i) => i.root === abs);
     if (byRoot)
         return { ok: true, url: byRoot.url, live: true };
-    if (port === selfPort)
+    // The machine runs a daemon: it serves this workspace next to the others.
+    const daemon = await findDaemon();
+    if (daemon) {
+        const r = await daemonCall(daemon.port, "open", abs).catch((err) => ({ ok: false, status: 0, data: { error: err.message } }));
+        cache = null;
+        wsCache.clear();
+        return r.ok ? { ok: true, url: r.data.url, live: true, pid: daemon.pid } : { ok: false, error: r.data.error ?? `the daemon refused (${r.status})` };
+    }
+    const mine = own.get(currentRoot() ?? "");
+    if (mine && port === mine.port)
         return { ok: false, url, error: `port ${port} is used by this workspace` };
     const byPort = live.find((i) => i.url === url);
     if (byPort)
@@ -526,7 +586,8 @@ export async function startWorkspace(root) {
         if (exited)
             return { ok: false, url, pid: child.pid, log, error: `kraftwerk ui ${exited}` };
         if (await probe(port)) {
-            cache = wsCache = null;
+            cache = null;
+            wsCache.clear();
             return { ok: true, url, live: true, pid: child.pid, log };
         }
     }
@@ -534,20 +595,30 @@ export async function startWorkspace(root) {
 }
 /* ---------- stop a project ---------- */
 /**
- * Stop a running workspace: SIGTERM to its server process, which
- * unregisters, stamps lastStopped and exits; the `kraftwerk ui` supervisor
- * follows. Matched by root, or by url for instances from older versions
- * that registered no root. Waits up to ~5s for the port to go quiet.
+ * Stop a running workspace. A daemon's workspace is closed there — the
+ * daemon and every other workspace in it keep running. A standalone one
+ * gets SIGTERM to its server process, which unregisters, stamps
+ * lastStopped and exits; the `kraftwerk ui` supervisor follows. Matched by
+ * root, or by url for instances from older versions that registered no
+ * root. Waits up to ~5s for it to go quiet.
  */
 export async function stopWorkspace(target) {
-    if (target.root && absolutePath(target.root) === selfRoot) {
+    if (target.root && absolutePath(target.root) === currentRoot()) {
         return { ok: false, error: "that is this workspace — stop it from its own terminal or pid" };
     }
-    cache = wsCache = null;
+    cache = null;
+    wsCache.clear();
     const live = await discoverInstances();
     const inst = live.find((i) => (target.root && i.root === absolutePath(target.root)) || (target.url && i.url === target.url));
     if (!inst)
         return { ok: false, error: "not running" };
+    if (inst.hub && inst.root) {
+        const port = Number(new URL(inst.url).port) || DAEMON_PORT;
+        const r = await daemonCall(port, "close", inst.root).catch((err) => ({ ok: false, status: 0, data: { error: err.message } }));
+        cache = null;
+        wsCache.clear();
+        return r.ok ? { ok: true } : { ok: false, error: r.data.error ?? `the daemon refused (${r.status})` };
+    }
     try {
         process.kill(inst.pid, "SIGTERM");
     }
@@ -559,7 +630,8 @@ export async function stopWorkspace(target) {
     while (Date.now() < deadline) {
         await new Promise((r) => setTimeout(r, 250));
         if (!(await probe(port))) {
-            cache = wsCache = null;
+            cache = null;
+            wsCache.clear();
             return { ok: true };
         }
     }

package/dist/core/routines.d.ts

@@ -76,4 +76,10 @@ export declare function runRoutineNow(slug: string, id: string): Promise<{
 }>;
 /** 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. */
+export declare function stopRoutineScheduler(): void;
+/** Whether the current workspace's scheduler runs (tests, the hub's view). */
+export declare const routineSchedulerRunning: () => boolean;
+/** The current workspace's scheduler timer, or null — for tests that check it really stops (a cleared slot would read null either way). */
+export declare const routineSchedulerTimer: () => ReturnType<typeof setInterval> | null;
 export {};

package/dist/core/routines.js

@@ -305,3 +305,14 @@ export function startRoutineScheduler() {
     s.timer = setInterval(() => void tick().catch(() => { }), 20_000);
     s.timer.unref?.();
 }
+/** Stop the current workspace's scheduler (the workspace closes): no routine of it fires any more. */
+export function stopRoutineScheduler() {
+    const s = scheduler();
+    if (s.timer)
+        clearInterval(s.timer);
+    s.timer = null;
+}
+/** Whether the current workspace's scheduler runs (tests, the hub's view). */
+export const routineSchedulerRunning = () => scheduler().timer !== null;
+/** The current workspace's scheduler timer, or null — for tests that check it really stops (a cleared slot would read null either way). */
+export const routineSchedulerTimer = () => scheduler().timer;

package/dist/core/runner.js

@@ -2,10 +2,11 @@ import { spawn, spawnSync } from "node:child_process";
 import { mkdirSync, openSync, closeSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { workspaceRoot } from "./context.js";
-import { perWorkspace } from "./workspace.js";
+import { perWorkspace, workspaceOpen } from "./workspace.js";
 import { RUN_ID_RE, getRun, safeRunDir } from "./runs.js";
 import { pushNotification } from "./notifications.js";
 import { newRunId } from "../workflow.js";
+import { workspaceEnv } from "./env.js";
 /**
  * Workflow trigger for the web UI. The inspector stays decoupled from the
  * framework runtime: it shells out to `npx kraftwerk run` in the consumer
@@ -54,7 +55,7 @@ export function triggerRun(opts) {
         cwd: workspaceRoot(),
         detached: true,
         stdio: ["ignore", log, log],
-        env: { ...process.env, FORCE_COLOR: "0" },
+        env: { ...workspaceEnv(), FORCE_COLOR: "0" },
     });
     child.unref();
     closeSync(log);
@@ -66,13 +67,16 @@ export function triggerRun(opts) {
     // framework wrote a trace (missing env var, npx failure) shows as failed
     // instead of running until the stale timeout.
     child.on("exit", (code, signal) => {
-        launchers().delete(runId);
         try {
             writeFileSync(path.join(runDir, "trigger.json"), JSON.stringify({ exitCode: code ?? 1, signal, finishedAt: new Date().toISOString() }, null, 2) + "\n");
         }
         catch {
             /* run dir removed meanwhile */
         }
+        // A run outlives its workspace closing (it is detached): the file above is all it leaves then.
+        if (!workspaceOpen())
+            return;
+        launchers().delete(runId);
         void getRun(runId)
             .then((run) => {
             const ok = run?.status === "ok";

package/dist/core/vibeables.d.ts

@@ -140,3 +140,5 @@ export declare function startDev(slug: string): Promise<VibeableStatus>;
 export declare function stopDev(slug: string): Promise<VibeableStatus>;
 /** Server shutdown: no dev server may outlive the inspector. */
 export declare function disposeAllDevs(): void;
+/** The current workspace's dev servers and file watchers end (the workspace closes). */
+export declare function disposeWorkspaceDevs(): void;