@netnodeag/kraftwerk 0.79.0 → 0.81.0

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

@@ -0,0 +1,74 @@
+import * as z from "zod";
+import type { EntityKind } from "../../config.js";
+import { type EntityBase, type EntityKindDef } from "../../core/entities.js";
+/**
+ * Contacts, places and events over the API. One factory, three kinds: the
+ * routes are named per kind (`contacts.list`, `places.get`, `events.save`)
+ * with the kind's own result type, so the typed client and the UI see
+ * three ordinary route families — not one generic entities endpoint whose
+ * results would be a union. Adding a kind is one definition in
+ * core/entities.ts and one factory call below.
+ */
+export declare function entityRoutes<D extends EntityBase, K extends EntityKind>(def: EntityKindDef<D, K>): readonly [import("./router.js").Route<`${K}.list`, import("../../core/entities.js").EntitiesView<D>, `/api/${K}`, undefined>, import("./router.js").Route<`${K}.create`, import("./router.js").Reply<import("../../core/entities.js").EntityDetail<D>>, `/api/${K}`, z.ZodObject<{
+    notes: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    records: z.ZodOptional<z.ZodUnknown>;
+    title: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>>, import("./router.js").Route<`${K}.get`, import("../../core/entities.js").EntityDetail<D>, `/api/${K}/:slug`, undefined>, import("./router.js").Route<`${K}.save`, import("../../core/entities.js").EntityDetail<D>, `/api/${K}/:slug`, z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    records: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>>, import("./router.js").Route<`${K}.delete`, {
+    ok: boolean;
+}, `/api/${K}/:slug`, undefined>];
+export declare const contactRoutes: readonly [import("./router.js").Route<"contacts.list", import("../../core/entities.js").EntitiesView<import("../../core/entities.js").ContactDef>, "/api/contacts", undefined>, import("./router.js").Route<"contacts.create", import("./router.js").Reply<import("../../core/entities.js").EntityDetail<import("../../core/entities.js").ContactDef>>, "/api/contacts", z.ZodObject<{
+    notes: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    records: z.ZodOptional<z.ZodUnknown>;
+    title: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>>, import("./router.js").Route<"contacts.get", import("../../core/entities.js").EntityDetail<import("../../core/entities.js").ContactDef>, "/api/contacts/:slug", undefined>, import("./router.js").Route<"contacts.save", import("../../core/entities.js").EntityDetail<import("../../core/entities.js").ContactDef>, "/api/contacts/:slug", z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    records: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>>, import("./router.js").Route<"contacts.delete", {
+    ok: boolean;
+}, "/api/contacts/:slug", undefined>];
+export declare const placeRoutes: readonly [import("./router.js").Route<"places.list", import("../../core/entities.js").EntitiesView<import("../../core/entities.js").PlaceDef>, "/api/places", undefined>, import("./router.js").Route<"places.create", import("./router.js").Reply<import("../../core/entities.js").EntityDetail<import("../../core/entities.js").PlaceDef>>, "/api/places", z.ZodObject<{
+    notes: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    records: z.ZodOptional<z.ZodUnknown>;
+    title: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>>, import("./router.js").Route<"places.get", import("../../core/entities.js").EntityDetail<import("../../core/entities.js").PlaceDef>, "/api/places/:slug", undefined>, import("./router.js").Route<"places.save", import("../../core/entities.js").EntityDetail<import("../../core/entities.js").PlaceDef>, "/api/places/:slug", z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    records: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>>, import("./router.js").Route<"places.delete", {
+    ok: boolean;
+}, "/api/places/:slug", undefined>];
+export declare const eventRoutes: readonly [import("./router.js").Route<"events.list", import("../../core/entities.js").EntitiesView<import("../../core/entities.js").EventDef>, "/api/events", undefined>, import("./router.js").Route<"events.create", import("./router.js").Reply<import("../../core/entities.js").EntityDetail<import("../../core/entities.js").EventDef>>, "/api/events", z.ZodObject<{
+    notes: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    records: z.ZodOptional<z.ZodUnknown>;
+    title: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>>, import("./router.js").Route<"events.get", import("../../core/entities.js").EntityDetail<import("../../core/entities.js").EventDef>, "/api/events/:slug", undefined>, import("./router.js").Route<"events.save", import("../../core/entities.js").EntityDetail<import("../../core/entities.js").EventDef>, "/api/events/:slug", z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    records: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>>, import("./router.js").Route<"events.delete", {
+    ok: boolean;
+}, "/api/events/:slug", undefined>];
+/** References: resolve `kind:slug` tokens — given as a list, or found in a text — against the registry. */
+export declare const refRoutes: import("./router.js").Route<"refs.resolve", {
+    refs: import("../../core/refs.js").ResolvedRef[];
+}, "/api/refs/resolve", z.ZodObject<{
+    tokens: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    text: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>>[];

package/dist/server/api/entities.js

@@ -0,0 +1,60 @@
+import * as z from "zod";
+import { CONTACTS, createEntity, deleteEntity, EVENTS, getEntity, listEntities, openEntities, PLACES, saveEntity } from "../../core/entities.js";
+import { findRefs, parseRef, resolveTokens } from "../../core/refs.js";
+import { fail, reply, route, statusByMessage } from "./router.js";
+/**
+ * Contacts, places and events over the API. One factory, three kinds: the
+ * routes are named per kind (`contacts.list`, `places.get`, `events.save`)
+ * with the kind's own result type, so the typed client and the UI see
+ * three ordinary route families — not one generic entities endpoint whose
+ * results would be a union. Adding a kind is one definition in
+ * core/entities.ts and one factory call below.
+ */
+export function entityRoutes(def) {
+    const errors = statusByMessage(new RegExp(`^no ${def.singular}`));
+    const kind = def.kind;
+    /** The editable fields. Loose: the domain checks values and keeps what it knows (unknown keys stay in the frontmatter). */
+    const Fields = z.looseObject({
+        title: z.string().optional(),
+        notes: z.string().optional(),
+        tags: z.unknown().optional(),
+        records: z.unknown().optional(),
+        ...Object.fromEntries(def.fields.map((f) => [f.name, z.unknown().optional()])),
+    });
+    const Create = Fields.extend({ title: z.string(), slug: z.string().optional() });
+    const fieldNames = def.fields.map((f) => f.name).join(", ");
+    return [
+        route({ name: `${kind}.list`, method: "GET", path: `/api/${kind}`, summary: `every ${def.singular} file under the root${def.span ? " (?from=&to= narrow by date; an entry counts while it runs)" : ""}` }, async (c) => listEntities(def, { from: c.query.get("from") ?? undefined, to: c.query.get("to") ?? undefined })),
+        route({ name: `${kind}.create`, method: "POST", path: `/api/${kind}`, summary: `create one {title, slug?, notes?, tags?, records?, ${fieldNames}}`, errors: 400, body: Create }, async (c) => {
+            if ((await openEntities(kind)).off)
+                fail(409, `${kind} are off`);
+            return reply(201, await createEntity(def, (await c.body())));
+        }),
+        route({ name: `${kind}.get`, method: "GET", path: `/api/${kind}/:slug`, summary: "fields, notes and link states", errors }, async (c) => (await getEntity(def, c.params.slug)) ?? fail(404, `no ${def.singular} "${c.params.slug}"`)),
+        route({ name: `${kind}.save`, method: "PUT", path: `/api/${kind}/:slug`, summary: 'save fields and notes ("" clears a field)', errors, body: Fields }, async (c) => saveEntity(def, c.params.slug, (await c.body()))),
+        route({ name: `${kind}.delete`, method: "DELETE", path: `/api/${kind}/:slug`, summary: "move the file to the trash", errors }, async (c) => {
+            await deleteEntity(def, c.params.slug);
+            return { ok: true };
+        }),
+    ];
+}
+export const contactRoutes = entityRoutes(CONTACTS);
+export const placeRoutes = entityRoutes(PLACES);
+export const eventRoutes = entityRoutes(EVENTS);
+/** References: resolve `kind:slug` tokens — given as a list, or found in a text — against the registry. */
+export const refRoutes = [
+    route({
+        name: "refs.resolve",
+        method: "POST",
+        path: "/api/refs/resolve",
+        summary: "resolve references {tokens?: [kind:slug], text?} to whether each target exists and where it opens",
+        errors: 400,
+        body: z.object({ tokens: z.array(z.string()).default([]), text: z.string().default("") }),
+    }, async (c) => {
+        const { tokens, text } = await c.body();
+        const given = tokens.map((t) => parseRef(t) ?? fail(400, `not a reference: "${t}" (expected <kind>:<slug>, e.g. contact:anna-meier)`));
+        const found = findRefs(text);
+        const all = [...given, ...found].filter((r, i, arr) => arr.findIndex((x) => x.kind === r.kind && x.slug === r.slug) === i);
+        return { refs: await resolveTokens(all) };
+    }),
+];

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

@@ -20,4 +20,12 @@ export declare const fileRoutes: (import("./router.js").Route<"files.delete", {
     }[];
 }, "/api/files/recent", undefined> | import("./router.js").Route<"files.scopes", {
     scopes: import("../../core/files.js").FilesScopeInfo[];
-}, "/api/files", undefined> | import("./router.js").Route<"files.upload", import("./router.js").Reply<import("../../core/files.js").FileEntry>, "/api/files/upload", undefined>)[];
+}, "/api/files", undefined> | import("./router.js").Route<"files.upload", import("./router.js").Reply<import("../../core/files.js").FileEntry>, "/api/files/upload", undefined> | import("./router.js").Route<"temp.clean", {
+    ok: boolean;
+    removed: string[];
+    bytes: number;
+}, "/api/temp", undefined> | import("./router.js").Route<"temp.list", {
+    entries: import("../../core/temp.js").TempEntry[];
+    bytes: number;
+    root: string;
+}, "/api/temp", undefined>)[];

package/dist/server/api/files.js

@@ -1,5 +1,7 @@
 import * as z from "zod";
 import { deleteFile, filesSummary, listFiles, listScopes, makeFolder, moveFile, openFile, saveUpload } from "../../core/files.js";
+import { cleanTemp, listTemp } from "../../core/temp.js";
+import { tildify } from "../../core/instances.js";
 import { reply, route } from "./router.js";
 const errors = (message) => (/^no (file|folder|project)/.test(message) ? 404 : 400);
 /** The scope (workspace, or a project's folder) and the path inside it, from the query. */
@@ -45,4 +47,15 @@ export const fileRoutes = [
         await deleteFile(...where(c));
         return { ok: true };
     }),
+    // The temp root: one scratch folder per session (core/temp.ts). Nothing in it is a deliverable, so a clean deletes for good.
+    route({ name: "temp.list", method: "GET", path: "/api/temp", summary: "the sessions' scratch folders, newest first", errors }, async () => {
+        const view = await listTemp();
+        return { ...view, root: tildify(view.root) };
+    }),
+    route({ name: "temp.clean", method: "DELETE", path: "/api/temp", summary: "remove scratch folders idle a week ?olderThanDays, or every one ?all=1", errors }, async (c) => {
+        const raw = c.query.get("olderThanDays");
+        const days = raw === null ? NaN : Number(raw);
+        const gone = await cleanTemp({ all: c.query.get("all") === "1", ...(Number.isFinite(days) && days >= 0 ? { olderThanMs: days * 24 * 60 * 60 * 1000 } : {}) });
+        return { ok: true, removed: gone.map((e) => e.id), bytes: gone.reduce((n, e) => n + e.bytes, 0) };
+    }),
 ];

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

@@ -367,7 +367,20 @@ export declare const routes: (Route<"agents.addJournal", {
     claimCode?: string | null;
     claimUrl?: string | null;
     workspaces?: number;
-}, "/api/cloud/unlink", undefined> | Route<"devices.code", {
+}, "/api/cloud/unlink", undefined> | Route<"contacts.create", import("./router.js").Reply<import("../../core/entities.js").EntityDetail<import("../../core/entities.js").ContactDef>>, "/api/contacts", z.ZodObject<{
+    notes: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    records: z.ZodOptional<z.ZodUnknown>;
+    title: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>> | Route<"contacts.delete", {
+    ok: boolean;
+}, "/api/contacts/:slug", undefined> | Route<"contacts.get", import("../../core/entities.js").EntityDetail<import("../../core/entities.js").ContactDef>, "/api/contacts/:slug", undefined> | Route<"contacts.list", import("../../core/entities.js").EntitiesView<import("../../core/entities.js").ContactDef>, "/api/contacts", undefined> | Route<"contacts.save", import("../../core/entities.js").EntityDetail<import("../../core/entities.js").ContactDef>, "/api/contacts/:slug", z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    records: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>> | Route<"devices.code", {
     code: string;
     expiresAt: string;
     urls: string[];
@@ -427,7 +440,20 @@ export declare const routes: (Route<"agents.addJournal", {
 }, "/api/devices/relay", z.ZodObject<{
     enabled: z.ZodBoolean;
     url: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>> | Route<"files.delete", {
+}, z.core.$strip>> | Route<"events.create", import("./router.js").Reply<import("../../core/entities.js").EntityDetail<import("../../core/entities.js").EventDef>>, "/api/events", z.ZodObject<{
+    notes: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    records: z.ZodOptional<z.ZodUnknown>;
+    title: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>> | Route<"events.delete", {
+    ok: boolean;
+}, "/api/events/:slug", undefined> | Route<"events.get", import("../../core/entities.js").EntityDetail<import("../../core/entities.js").EventDef>, "/api/events/:slug", undefined> | Route<"events.list", import("../../core/entities.js").EntitiesView<import("../../core/entities.js").EventDef>, "/api/events", undefined> | Route<"events.save", import("../../core/entities.js").EntityDetail<import("../../core/entities.js").EventDef>, "/api/events/:slug", z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    records: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>> | Route<"files.delete", {
     ok: boolean;
 }, "/api/files", undefined> | Route<"files.list", import("../../core/files.js").FilesListing, "/api/files/list", undefined> | Route<"files.mkdir", import("./router.js").Reply<import("../../core/files.js").FileEntry>, "/api/files/folder", z.ZodObject<{
     scope: z.ZodOptional<z.ZodString>;
@@ -520,6 +546,9 @@ export declare const routes: (Route<"agents.addJournal", {
     repos: boolean;
     vibeables: boolean;
     projects: boolean;
+    contacts: boolean;
+    places: boolean;
+    events: boolean;
     publicUrl: string;
     cloud: {
         included: boolean;
@@ -545,7 +574,20 @@ export declare const routes: (Route<"agents.addJournal", {
     href: string;
 }, "/api/notifications/:id/diagnose", undefined> | Route<"notifications.list", import("../../core/notifications.js").NotificationsView, "/api/notifications", undefined> | Route<"notifications.read", import("../../core/notifications.js").NotificationsView, "/api/notifications/read", z.ZodObject<{
     ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>> | Route<"projects.create", import("./router.js").Reply<import("../../core/projects.js").ProjectDetail>, "/api/projects", z.ZodObject<{
+}, z.core.$strip>> | Route<"places.create", import("./router.js").Reply<import("../../core/entities.js").EntityDetail<import("../../core/entities.js").PlaceDef>>, "/api/places", z.ZodObject<{
+    notes: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    records: z.ZodOptional<z.ZodUnknown>;
+    title: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>> | Route<"places.delete", {
+    ok: boolean;
+}, "/api/places/:slug", undefined> | Route<"places.get", import("../../core/entities.js").EntityDetail<import("../../core/entities.js").PlaceDef>, "/api/places/:slug", undefined> | Route<"places.list", import("../../core/entities.js").EntitiesView<import("../../core/entities.js").PlaceDef>, "/api/places", undefined> | Route<"places.save", import("../../core/entities.js").EntityDetail<import("../../core/entities.js").PlaceDef>, "/api/places/:slug", z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    records: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>> | Route<"projects.create", import("./router.js").Reply<import("../../core/projects.js").ProjectDetail>, "/api/projects", z.ZodObject<{
     title: z.ZodString;
     goal: z.ZodOptional<z.ZodString>;
     slug: z.ZodOptional<z.ZodString>;
@@ -576,6 +618,9 @@ export declare const routes: (Route<"agents.addJournal", {
     repos: z.ZodOptional<z.ZodUnknown>;
     workflows: z.ZodOptional<z.ZodUnknown>;
     agents: z.ZodOptional<z.ZodUnknown>;
+    contacts: z.ZodOptional<z.ZodUnknown>;
+    places: z.ZodOptional<z.ZodUnknown>;
+    events: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$loose>> | Route<"projects.saveLayout", {
     ok: boolean;
     layout: import("../../core/projects.js").ProjectLayout;
@@ -588,7 +633,12 @@ export declare const routes: (Route<"agents.addJournal", {
 }, z.core.$strip>> | Route<"protocol.get", {
     version: number;
     routes: RouteInfo[];
-}, "/api/protocol", undefined> | Route<"repos.add", import("./router.js").Reply<import("../../core/repos.js").RepoInfo>, "/api/repos", z.ZodObject<{
+}, "/api/protocol", undefined> | Route<"refs.resolve", {
+    refs: import("../../core/refs.js").ResolvedRef[];
+}, "/api/refs/resolve", z.ZodObject<{
+    tokens: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    text: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>> | Route<"repos.add", import("./router.js").Reply<import("../../core/repos.js").RepoInfo>, "/api/repos", z.ZodObject<{
     url: z.ZodDefault<z.ZodString>;
     name: z.ZodOptional<z.ZodString>;
     branch: z.ZodOptional<z.ZodString>;
@@ -663,10 +713,30 @@ export declare const routes: (Route<"agents.addJournal", {
         enabled: z.ZodBoolean;
         root: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    contacts: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        root: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    places: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        root: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    events: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        root: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$loose>> | Route<"skills.get", import("../../core/skills.js").SkillDetail, "/api/skills/:name", undefined> | Route<"skills.list", {
     root: string;
     skills: import("../../core/skills.js").SkillInfo[];
-}, "/api/skills", undefined> | Route<"trash.empty", {
+}, "/api/skills", undefined> | Route<"temp.clean", {
+    ok: boolean;
+    removed: string[];
+    bytes: number;
+}, "/api/temp", undefined> | Route<"temp.list", {
+    entries: import("../../core/temp.js").TempEntry[];
+    bytes: number;
+    root: string;
+}, "/api/temp", undefined> | Route<"trash.empty", {
     ok: boolean;
     purged: number;
 }, "/api/trash", undefined> | Route<"trash.list", {

package/dist/server/api/index.js

@@ -5,6 +5,7 @@ import { channelRoutes } from "./channels.js";
 import { chatRoutes } from "./chats.js";
 import { cloudRoutes } from "./cloud.js";
 import { deviceRoutes } from "./devices.js";
+import { contactRoutes, eventRoutes, placeRoutes, refRoutes } from "./entities.js";
 import { hubRoutes } from "./hub.js";
 import { fileRoutes } from "./files.js";
 import { gitRoutes } from "./git.js";
@@ -30,6 +31,10 @@ const domainRoutes = [
     ...chatRoutes,
     ...channelRoutes,
     ...projectRoutes,
+    ...contactRoutes,
+    ...placeRoutes,
+    ...eventRoutes,
+    ...refRoutes,
     ...runRoutes,
     ...knowledgeRoutes,
     ...fileRoutes,

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

@@ -32,6 +32,9 @@ export declare const projectRoutes: (import("./router.js").Route<"projects.creat
     repos: z.ZodOptional<z.ZodUnknown>;
     workflows: z.ZodOptional<z.ZodUnknown>;
     agents: z.ZodOptional<z.ZodUnknown>;
+    contacts: z.ZodOptional<z.ZodUnknown>;
+    places: z.ZodOptional<z.ZodUnknown>;
+    events: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$loose>> | import("./router.js").Route<"projects.saveLayout", {
     ok: boolean;
     layout: import("../../core/projects.js").ProjectLayout;

package/dist/server/api/projects.js

@@ -23,6 +23,9 @@ const ProjectFields = z.looseObject({
     repos: z.unknown().optional(),
     workflows: z.unknown().optional(),
     agents: z.unknown().optional(),
+    contacts: z.unknown().optional(),
+    places: z.unknown().optional(),
+    events: z.unknown().optional(),
 });
 /** Projects: folders with a goal, a brief, a log and links, plus the rail's order. */
 export const projectRoutes = [

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

@@ -33,6 +33,9 @@ export declare const workspaceRoutes: (import("./router.js").Route<"identity.get
     repos: boolean;
     vibeables: boolean;
     projects: boolean;
+    contacts: boolean;
+    places: boolean;
+    events: boolean;
     /** @deprecated Always "": the Cloudflare Tunnel that set it was removed in 0.65. Removed with protocol 2. */
     publicUrl: string;
     cloud: {
@@ -86,6 +89,18 @@ export declare const workspaceRoutes: (import("./router.js").Route<"identity.get
         enabled: z.ZodBoolean;
         root: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    contacts: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        root: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    places: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        root: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    events: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        root: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$loose>> | import("./router.js").Route<"update.check", import("./router.js").Reply<{
     name: string;
     current: string;

package/dist/server/api/workspace.js

@@ -33,6 +33,9 @@ const SettingsFields = z.looseObject({
     repos: RootBlock.optional(),
     vibeables: RootBlock.optional(),
     projects: RootBlock.optional(),
+    contacts: RootBlock.optional(),
+    places: RootBlock.optional(),
+    events: RootBlock.optional(),
 });
 /**
  * Mark the workspaces the hub answering this request serves — or, a daemon,
@@ -105,6 +108,9 @@ export const workspaceRoutes = [
             repos: (ws?.config.repos && ws.config.repos.enabled !== false) === true,
             vibeables: (ws?.config.vibeables && ws.config.vibeables.enabled !== false) === true,
             projects: (ws?.config.projects && ws.config.projects.enabled !== false) === true,
+            contacts: (ws?.config.contacts && ws.config.contacts.enabled !== false) === true,
+            places: (ws?.config.places && ws.config.places.enabled !== false) === true,
+            events: (ws?.config.events && ws.config.events.enabled !== false) === true,
             /** @deprecated Always "": the Cloudflare Tunnel that set it was removed in 0.65. Removed with protocol 2. */
             publicUrl: "",
             // The machine's cloud record (only the daemon registers one); `included`: this workspace rides along (no cloud.enabled: false veto).

package/dist/server/cloud.js

@@ -1,4 +1,5 @@
 import { promises as fs } from "node:fs";
+import { log } from "../core/log.js";
 import os from "node:os";
 import { resolveWorkspace } from "../config.js";
 import { claimUrlFor, machineCloud, machineGoodbye, machineHeartbeat, machineRegister, machineUnlink, MAX_REPORTED_ROUTINES, retiredCloudDir, unknownMachine, workspaceInvite, } from "../core/cloud.js";
@@ -74,10 +75,10 @@ function warnYml(cloud, ymlUrls) {
         return;
     m.warned.add(key);
     if (cloud.source === "kraftwerk.yml") {
-        console.warn(`⚠ kraftwerk.yml cloud.url is deprecated — the cloud is the machine's now: \`kraftwerk cloud on --url ${cloud.url}\` (using ${cloud.url} for now)`);
+        log("warn", "cloud", `kraftwerk.yml cloud.url is deprecated — the cloud is the machine's now: \`kraftwerk cloud on --url ${cloud.url}\` (using ${cloud.url} for now)`);
     }
     else {
-        console.warn(`⚠ kraftwerk.yml cloud.url (${ymlUrls[0]}) is ignored: the machine's cloud is ${cloud.url} (${cloud.source}); remove it from kraftwerk.yml`);
+        log("warn", "cloud", `kraftwerk.yml cloud.url (${ymlUrls[0]}) is ignored: the machine's cloud is ${cloud.url} (${cloud.source}); remove it from kraftwerk.yml`);
     }
 }
 async function register() {

package/dist/server/relay.d.ts

@@ -93,14 +93,15 @@ export interface RelayOptions {
     connect?: (url: string) => WebSocket;
     /** Give up on a connection the relay has not accepted (`ok`) within this long, and try again (default 15 s). */
     handshakeTimeoutMs?: number;
-    log?: (line: string) => void;
+    /** One relay event, leveled — the daemon writes it as a standard log line. */
+    log?: (level: "info" | "warn", line: string) => void;
 }
 /** Hold the daemon's socket to the relay, reconnecting with backoff, and answer every client behind it. */
 export declare function startRelay(opts: RelayOptions): Promise<RelayLink>;
 /** A short fingerprint of the machine key, to compare what a phone shows with what this machine shows. */
 export declare const keyFingerprint: (key: string) => string;
 /** Start, restart or stop this daemon's relay link to match ~/.kraftwerk/relay.json. */
-export declare function applyRelay(port: number, version: string, log?: (line: string) => void): Promise<RelayStatus>;
+export declare function applyRelay(port: number, version: string, log?: (level: "info" | "warn", line: string) => void): Promise<RelayStatus>;
 /** Hand push notifications to this daemon's relay link; false without one. */
 export declare const relayPush: (pushes: PushMessage[]) => boolean;
 /** The link's state; "off" when this process holds none (not the daemon, or the relay is off). */

package/dist/server/relay.js

@@ -188,7 +188,7 @@ export async function startRelay(opts) {
                 send({ t: "msg", c, d: JSON.stringify(ready) });
             }
             catch (err) {
-                log(`relay: handshake refused — ${err.message}`);
+                log("warn", `handshake refused — ${err.message}`);
                 send({ t: "close", c, reason: "handshake failed" });
                 dropConn(c);
             }
@@ -216,7 +216,7 @@ export async function startRelay(opts) {
                 return;
             }
             if (!r.ok) {
-                log(`relay: member refused — ${r.error}`);
+                log("warn", `member refused — ${r.error}`);
                 await reply(c, conn, { t: "auth", ok: false, error: r.error });
                 send({ t: "close", c, reason: r.error.slice(0, 100) });
                 dropConn(c);
@@ -234,7 +234,7 @@ export async function startRelay(opts) {
                 if (!check.ok) {
                     await reply(c, conn, { t: "fail", id: msg.id, error: check.error });
                     if (check.ended) {
-                        log(`relay: member session dropped — ${check.error}`);
+                        log("warn", `member session dropped — ${check.error}`);
                         send({ t: "close", c, reason: check.error.slice(0, 100) });
                         dropConn(c);
                     }
@@ -282,7 +282,7 @@ export async function startRelay(opts) {
             catch { }
             status.state = "error";
             status.error = "the relay did not answer";
-            log("relay: no answer from the relay — trying again");
+            log("warn", "no answer from the relay — trying again");
             schedule();
         }, opts.handshakeTimeoutMs ?? 15_000);
         handshake.unref?.();
@@ -305,7 +305,7 @@ export async function startRelay(opts) {
                 status.state = "connected";
                 status.error = undefined;
                 status.since = new Date().toISOString();
-                log(`relay: connected to ${opts.settings.url} as ${id}`);
+                log("info", `connected to ${opts.settings.url} as ${id}`);
             }
             else if (msg.t === "open" && msg.c) {
                 dropConn(msg.c);
@@ -337,11 +337,11 @@ export async function startRelay(opts) {
             if (stopped)
                 return;
             if (status.state === "connected")
-                log("relay: connection lost — reconnecting");
+                log("warn", "connection lost — reconnecting");
             status.state = "error";
             status.error = ev.code === 4401 ? `the relay refused this machine: ${ev.reason || "wrong secret"}` : ev.reason || "the relay connection closed";
             if (ev.code === 4401)
-                log(`relay: ${status.error}`);
+                log("warn", `${status.error}`);
             schedule();
         });
         socket.addEventListener("error", () => { });

package/dist/server/server.js

@@ -1,4 +1,5 @@
 import { promises as fs } from "node:fs";
+import { log } from "../core/log.js";
 import http from "node:http";
 import net from "node:net";
 import path from "node:path";
@@ -145,7 +146,7 @@ function installExitHandlers() {
     process.on("uncaughtException", (err) => {
         if (closedOnly(err))
             return;
-        console.error(`✖ ${new Date().toISOString()} crashed:`, err);
+        log("error", "server", `crashed: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
         process.exit(1);
     });
     // Chat agent subprocesses must die with the server — signals bypass "exit" handlers, so hook the signals themselves.
@@ -377,7 +378,7 @@ export async function startHub(opts) {
             await opts.onChange?.(hub);
         }
         catch (err) {
-            console.error(`kraftwerk: could not note the open workspaces: ${err.message}`);
+            log("warn", "daemon", `could not note the open workspaces: ${err.message}`);
         }
     }
     async function openNow(root, o) {

package/dist/yaml.js

@@ -293,6 +293,7 @@ export async function loadWorkflow(givenPath) {
                 verbose,
                 workspaceContext: [
                     `Working directory (read and create all files here): ${runDir}`,
+                    `Temporary files (scratch, downloads, intermediate output, one-off scripts) go to ${runDir}/temp — TMPDIR and KRAFTWERK_TEMP point there; nothing in it counts as a result of the run.`,
                     workspace,
                 ]
                     .filter(Boolean)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netnodeag/kraftwerk",
-  "version": "0.79.0",
+  "version": "0.81.0",
   "description": "Open-source agentic workspace for teams \u2014 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

@@ -171,6 +171,60 @@
         }
       }
     },
+    "contacts": {
+      "type": [
+        "object",
+        "null"
+      ],
+      "additionalProperties": false,
+      "description": "Contacts: people and organisations the workspace works with, one Markdown file (YAML frontmatter + notes) each under the root, part of the workspace. Referenced as contact:<slug> from projects, events and text. Absent = feature off, a bare `contacts:` = on with defaults.",
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "description": "Turn the feature off while keeping the config. Default: true when this block exists"
+        },
+        "root": {
+          "type": "string",
+          "description": "Where the contact files live, relative to the project root. Default: kraftwerk-data/contacts"
+        }
+      }
+    },
+    "places": {
+      "type": [
+        "object",
+        "null"
+      ],
+      "additionalProperties": false,
+      "description": "Places: addresses and points of interest, one Markdown file (YAML frontmatter + notes) each under the root, part of the workspace. Referenced as place:<slug>; a Google Maps link is derived from coordinates or the address. Absent = feature off, a bare `places:` = on with defaults.",
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "description": "Turn the feature off while keeping the config. Default: true when this block exists"
+        },
+        "root": {
+          "type": "string",
+          "description": "Where the place files live, relative to the project root. Default: kraftwerk-data/places"
+        }
+      }
+    },
+    "events": {
+      "type": [
+        "object",
+        "null"
+      ],
+      "additionalProperties": false,
+      "description": "Events: dated, one-off entries (a meeting, a launch, a deadline) with a place, contacts and a project, one Markdown file (YAML frontmatter + notes) each under the root, part of the workspace. Referenced as event:<slug>. Absent = feature off, a bare `events:` = on with defaults.",
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "description": "Turn the feature off while keeping the config. Default: true when this block exists"
+        },
+        "root": {
+          "type": "string",
+          "description": "Where the event files live, relative to the project root. Default: kraftwerk-data/events"
+        }
+      }
+    },
     "cloud": {
       "type": [
         "object",