forge-openclaw-plugin 0.2.25 → 0.2.27

package/dist/server/src/components/workbench-boxes/projects/projects-boxes.js

@@ -0,0 +1,62 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { buildSearchWorkbenchExecution, buildStaticWorkbenchExecution } from "../../../lib/workbench/runtime.js";
+import { createSearchEntitiesTool, createSearchInputs, createSearchOutputs, createSearchParams, createSummaryOutput } from "../../../lib/workbench/contracts.js";
+import { createGenericWorkbenchNodeView } from "../shared/generic-node-view.js";
+import { defineWorkbenchBox } from "../shared/define-workbench-box.js";
+function Slot({ children }) {
+    return _jsx(_Fragment, { children: children });
+}
+function defineProjectBox(id, title, description, tags, execute, output, tools = [], options) {
+    const inputs = options?.inputs ?? [];
+    const params = options?.params ?? [];
+    return defineWorkbenchBox(Slot, {
+        id,
+        surfaceId: "projects",
+        routePath: "/projects",
+        title,
+        icon: "projects",
+        description,
+        category: "Projects",
+        tags,
+        inputs,
+        params,
+        output,
+        tools,
+        NodeView: createGenericWorkbenchNodeView({
+            title,
+            description,
+            inputs,
+            params,
+            output,
+            tools
+        }),
+        execute
+    });
+}
+export const ProjectsHeroBox = defineProjectBox("surface:projects:hero", "Projects hero", "Projects page header.", ["projects", "hero"], (input) => buildStaticWorkbenchExecution(input, null, "Projects page header."), [createSummaryOutput({ label: "Projects summary", description: "High-level projects page framing." })]);
+export const ProjectsSearchResultsBox = defineProjectBox("surface:projects:search-results", "Search and results", "Project browser, filters, and search context.", ["projects", "search"], (input) => buildSearchWorkbenchExecution(input, {
+    query: "",
+    entityTypes: ["project"],
+    limit: 20
+}), createSearchOutputs({
+    itemKind: "project",
+    itemLabel: "Project"
+}), [createSearchEntitiesTool("Search project entities by query and entity types.")], {
+    inputs: createSearchInputs({
+        itemKind: "project",
+        itemLabel: "Project",
+        defaultEntityTypes: ["project"],
+        defaultLimit: 20
+    }),
+    params: createSearchParams({
+        itemKind: "project",
+        defaultEntityTypes: ["project"],
+        defaultLimit: 20
+    })
+});
+export const ProjectsSummaryBox = defineProjectBox("surface:projects:summary", "Collection summary", "Collection summary and project state metrics.", ["projects", "summary"], (input) => buildStaticWorkbenchExecution(input, null, "Project collection summary."), [
+    createSummaryOutput({
+        label: "Project summary",
+        description: "Summary of the project collection and current state."
+    })
+]);

package/dist/server/src/components/workbench-boxes/psyche/psyche-boxes.js

@@ -0,0 +1,88 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { buildSearchWorkbenchExecution, buildStaticWorkbenchExecution } from "../../../lib/workbench/runtime.js";
+import { createSearchEntitiesTool, createSearchInputs, createSearchOutputs, createSearchParams, createSummaryOutput } from "../../../lib/workbench/contracts.js";
+import { createGenericWorkbenchNodeView } from "../shared/generic-node-view.js";
+import { defineWorkbenchBox } from "../shared/define-workbench-box.js";
+function Slot({ children }) {
+    return _jsx(_Fragment, { children: children });
+}
+function definePsycheBox(id, title, description, tags, execute, output, tools = [], options) {
+    const inputs = options?.inputs ?? [];
+    const params = options?.params ?? [];
+    return defineWorkbenchBox(Slot, {
+        id,
+        surfaceId: "psyche",
+        routePath: "/psyche",
+        title,
+        icon: "psyche",
+        description,
+        category: "Psyche",
+        tags,
+        inputs,
+        params,
+        output,
+        tools,
+        NodeView: createGenericWorkbenchNodeView({
+            title,
+            description,
+            inputs,
+            params,
+            output,
+            tools
+        }),
+        execute
+    });
+}
+export const PsycheOverviewBox = definePsycheBox("surface:psyche:overview", "Psyche overview", "High-level overview of values, patterns, beliefs, modes, and reports.", ["psyche", "overview"], (input) => buildStaticWorkbenchExecution(input, {
+    surfaces: ["values", "patterns", "beliefs", "modes", "reports"]
+}, "Psyche overview spanning values, patterns, beliefs, modes, and reports."), [createSummaryOutput({ label: "Psyche summary", description: "Summary of values, patterns, beliefs, modes, and reports." })]);
+export const PsycheValuesBox = definePsycheBox("surface:psyche:values", "Psyche values", "Values and long-lived internal directions tracked inside Forge.", ["psyche", "values"], (input) => buildSearchWorkbenchExecution(input, {
+    query: "",
+    entityTypes: ["psyche_value"],
+    limit: 20
+}), createSearchOutputs({
+    itemKind: "psyche_value",
+    itemLabel: "Psyche value"
+}), [createSearchEntitiesTool("Search psyche entities and reflective records.")], {
+    inputs: createSearchInputs({
+        itemKind: "psyche_value",
+        itemLabel: "Psyche value",
+        defaultEntityTypes: ["psyche_value"],
+        defaultLimit: 20
+    }),
+    params: createSearchParams({
+        itemKind: "psyche_value",
+        defaultEntityTypes: ["psyche_value"],
+        defaultLimit: 20
+    })
+});
+export const PsycheReportsBox = definePsycheBox("surface:psyche:reports", "Trigger reports", "Trigger reports and behavior-pattern signals linked to reflective work.", ["psyche", "reports", "patterns"], (input) => buildSearchWorkbenchExecution(input, {
+    query: "",
+    entityTypes: ["trigger_report", "behavior_pattern", "belief_entry", "mode_profile"],
+    limit: 20
+}), createSearchOutputs({
+    itemKind: "psyche_record",
+    itemLabel: "Psyche record"
+}), [createSearchEntitiesTool("Search psyche entities and reflective records.")], {
+    inputs: createSearchInputs({
+        itemKind: "psyche_record",
+        itemLabel: "Psyche record",
+        defaultEntityTypes: [
+            "trigger_report",
+            "behavior_pattern",
+            "belief_entry",
+            "mode_profile"
+        ],
+        defaultLimit: 20
+    }),
+    params: createSearchParams({
+        itemKind: "psyche_record",
+        defaultEntityTypes: [
+            "trigger_report",
+            "behavior_pattern",
+            "belief_entry",
+            "mode_profile"
+        ],
+        defaultLimit: 20
+    })
+});

package/dist/server/src/components/workbench-boxes/questionnaires/questionnaires-boxes.js

@@ -0,0 +1,61 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { buildSearchWorkbenchExecution, buildStaticWorkbenchExecution } from "../../../lib/workbench/runtime.js";
+import { createSearchEntitiesTool, createSearchInputs, createSearchOutputs, createSearchParams, createSummaryOutput } from "../../../lib/workbench/contracts.js";
+import { createGenericWorkbenchNodeView } from "../shared/generic-node-view.js";
+import { defineWorkbenchBox } from "../shared/define-workbench-box.js";
+function Slot({ children }) {
+    return _jsx(_Fragment, { children: children });
+}
+function defineQuestionnaireBox(id, title, description, tags, execute, output, tools = [], options) {
+    const inputs = options?.inputs ?? [];
+    const params = options?.params ?? [];
+    return defineWorkbenchBox(Slot, {
+        id,
+        surfaceId: "questionnaires",
+        routePath: "/psyche/questionnaires",
+        title,
+        icon: "questionnaire",
+        description,
+        category: "Questionnaires",
+        tags,
+        inputs,
+        params,
+        output,
+        tools,
+        NodeView: createGenericWorkbenchNodeView({
+            title,
+            description,
+            inputs,
+            params,
+            output,
+            tools
+        }),
+        execute
+    });
+}
+export const QuestionnairesLibraryBox = defineQuestionnaireBox("surface:questionnaires:library", "Questionnaire library", "Library of questionnaire instruments available in Forge.", ["questionnaires", "library"], (input) => buildSearchWorkbenchExecution(input, {
+    query: "",
+    entityTypes: ["questionnaire_instrument"],
+    limit: 20
+}), createSearchOutputs({
+    itemKind: "questionnaire_instrument",
+    itemLabel: "Questionnaire"
+}), [createSearchEntitiesTool("Search questionnaire instruments and related records.")], {
+    inputs: createSearchInputs({
+        itemKind: "questionnaire_instrument",
+        itemLabel: "Questionnaire",
+        defaultEntityTypes: ["questionnaire_instrument"],
+        defaultLimit: 20
+    }),
+    params: createSearchParams({
+        itemKind: "questionnaire_instrument",
+        defaultEntityTypes: ["questionnaire_instrument"],
+        defaultLimit: 20
+    })
+});
+export const QuestionnairesDraftingBox = defineQuestionnaireBox("surface:questionnaires:drafting", "Questionnaire drafting", "Drafting and publishing context for questionnaire instruments.", ["questionnaires", "drafting", "authoring"], (input) => buildStaticWorkbenchExecution(input, {
+    states: ["draft", "published", "run"]
+}, "Questionnaire drafting surface with draft, publish, and run lifecycle context."), [createSummaryOutput({ label: "Drafting summary", description: "Summary of questionnaire drafting and lifecycle context." })]);
+export const QuestionnairesObservationBox = defineQuestionnaireBox("surface:questionnaires:self-observation", "Self-observation calendar", "Calendar of self-observation notes and linked psyche context.", ["questionnaires", "self-observation", "psyche"], (input) => buildStaticWorkbenchExecution(input, {
+    linkedDomains: ["patterns", "reports", "notes"]
+}, "Self-observation calendar surface with linked psyche context."), [createSummaryOutput({ label: "Observation summary", description: "Summary of the self-observation calendar and linked psyche context." })]);

package/dist/server/src/components/workbench-boxes/review/review-boxes.js

@@ -0,0 +1,53 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { buildStaticWorkbenchExecution, buildWeeklyReviewWorkbenchExecution } from "../../../lib/workbench/runtime.js";
+import { createContextOutput, createSummaryOutput } from "../../../lib/workbench/contracts.js";
+import { createGenericWorkbenchNodeView } from "../shared/generic-node-view.js";
+import { defineWorkbenchBox } from "../shared/define-workbench-box.js";
+function Slot({ children }) {
+    return _jsx(_Fragment, { children: children });
+}
+function defineReviewBox(id, title, description, tags, execute, output) {
+    return defineWorkbenchBox(Slot, {
+        id,
+        surfaceId: "review",
+        routePath: "/review/weekly",
+        title,
+        icon: "review",
+        description,
+        category: "Review",
+        tags,
+        inputs: [],
+        params: [],
+        output,
+        tools: [],
+        NodeView: createGenericWorkbenchNodeView({
+            title,
+            description,
+            inputs: [],
+            params: [],
+            output,
+            tools: []
+        }),
+        execute
+    });
+}
+export const WeeklyReviewSummaryBox = defineReviewBox("surface:review:weekly-summary", "Weekly review summary", "Weekly review payload with momentum, wins, calibration, and completion state.", ["review", "weekly"], (input) => buildWeeklyReviewWorkbenchExecution(input), [
+    createSummaryOutput({
+        label: "Weekly review summary",
+        description: "Summary of momentum, wins, calibration, and review completion state."
+    }),
+    createContextOutput({
+        key: "weeklyReview",
+        label: "Weekly review payload",
+        description: "Structured weekly review payload returned by Forge.",
+        modelName: "ForgeWeeklyReview"
+    })
+]);
+export const WeeklyReviewRewardBox = defineReviewBox("surface:review:reward", "Review reward", "Reward framing and completion incentive for closing the current review cycle.", ["review", "reward"], (input) => buildStaticWorkbenchExecution(input, {
+    reward: "weekly_review_completion"
+}, "Weekly review reward surface for locking the current cycle into evidence."), [
+    createSummaryOutput({
+        label: "Review reward summary",
+        description: "Summary of the reward framing for closing the current review cycle."
+    })
+]);

package/dist/server/src/components/workbench-boxes/shared/define-workbench-box.js

@@ -0,0 +1,6 @@
+import { defineWorkbenchComponent } from "../../../lib/workbench/nodes.js";
+export function defineWorkbenchBox(component, definition) {
+    const WorkbenchBoxComponent = (props) => component(props);
+    WorkbenchBoxComponent.displayName = definition.title.replace(/\s+/g, "");
+    return defineWorkbenchComponent(WorkbenchBoxComponent, definition);
+}

package/dist/server/src/components/workbench-boxes/shared/generic-node-view.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Handle, Position } from "@xyflow/react";
+import { useState } from "react";
+import { InfoTooltip } from "../../../components/ui/info-tooltip.js";
+import { cn } from "../../../lib/utils.js";
+function describePort(port) {
+    return [port.kind, port.modelName, port.itemKind ? `item:${port.itemKind}` : null]
+        .filter(Boolean)
+        .join(" · ");
+}
+function PortList({ title, ports, align }) {
+    return (_jsxs("div", { className: "grid gap-1.5", children: [_jsxs("div", { className: cn("flex items-center gap-1 text-[10px] uppercase tracking-[0.18em] text-white/34", align === "left" ? "text-left" : "text-right"), children: [_jsx("span", { children: title }), _jsx(InfoTooltip, { content: align === "left"
+                            ? "Inputs are values this box expects from upstream nodes."
+                            : "Outputs are values this box publishes for downstream nodes.", label: align === "left" ? "Explain box inputs" : "Explain box outputs" })] }), ports.length === 0 ? (_jsx("div", { className: "rounded-full border border-dashed border-white/10 px-3 py-1.5 text-[11px] text-white/28", children: "None" })) : null, ports.map((port) => (_jsxs("div", { className: cn("relative rounded-[16px] bg-white/[0.05] px-3 py-2 text-[11px] text-white/62", align === "left" ? "pl-5 text-left" : "pr-5 text-right"), children: [_jsx(Handle, { type: align === "left" ? "target" : "source", position: align === "left" ? Position.Left : Position.Right, id: port.key, className: "!size-2.5 !border !border-white/80 !bg-[#b8c5ff]", style: {
+                            [align]: 6
+                        } }), _jsx("div", { children: port.label }), _jsx("div", { className: "mt-1 text-[10px] text-white/38", children: describePort(port) })] }, port.key)))] }));
+}
+export function createGenericWorkbenchNodeView(definition) {
+    return function GenericWorkbenchNodeView(_props) {
+        const [schemaOpen, setSchemaOpen] = useState(false);
+        return (_jsxs("div", { className: "min-w-[280px] rounded-[24px] border border-white/10 bg-[linear-gradient(180deg,rgba(20,28,45,0.98),rgba(11,16,29,0.98))] p-3 shadow-[0_26px_80px_rgba(0,0,0,0.4)]", children: [_jsxs("div", { className: "flex items-start justify-between gap-3", children: [_jsxs("div", { className: "min-w-0", children: [_jsx("div", { className: "truncate text-sm font-semibold text-white", children: definition.title }), _jsx("div", { className: "mt-1 line-clamp-2 text-[12px] leading-5 text-white/48", children: definition.description })] }), _jsx("div", { className: "rounded-full bg-white/[0.06] px-2.5 py-1 text-[10px] uppercase tracking-[0.16em] text-white/56", children: "box" })] }), definition.params.length > 0 ? (_jsxs("div", { className: "mt-3 rounded-[18px] bg-white/[0.04] px-3 py-2 text-[11px] text-white/52", children: [definition.params.length, " param", definition.params.length === 1 ? "" : "s", " configurable in the flow editor"] })) : null, definition.tools.length > 0 ? (_jsxs("div", { className: "mt-2 rounded-[18px] bg-white/[0.04] px-3 py-2 text-[11px] text-white/52", children: [definition.tools.length, " tool", definition.tools.length === 1 ? "" : "s", " available"] })) : null, _jsx("div", { className: "mt-2", children: _jsx("button", { type: "button", className: "rounded-full bg-white/[0.05] px-3 py-1.5 text-[11px] text-white/56 transition hover:bg-white/[0.08] hover:text-white", onClick: () => setSchemaOpen((current) => !current), children: schemaOpen ? "Hide schema" : "Preview schema" }) }), _jsxs("div", { className: "mt-3 grid grid-cols-[minmax(0,1fr)_minmax(0,1fr)] gap-3", children: [_jsx(PortList, { title: "Inputs", ports: definition.inputs, align: "left" }), _jsx(PortList, { title: "Outputs", ports: definition.output, align: "right" })] }), schemaOpen ? (_jsxs("div", { className: "mt-3 rounded-[18px] border border-white/8 bg-black/20 p-3", children: [_jsxs("div", { className: "flex items-center gap-2 text-[10px] uppercase tracking-[0.18em] text-white/38", children: [_jsx("span", { children: "Box contract" }), _jsx(InfoTooltip, { content: "This preview summarizes what the box consumes, publishes, and what tools it can expose to AI nodes.", label: "Explain box contract preview" })] }), _jsx("pre", { className: "mt-2 overflow-auto whitespace-pre-wrap text-[11px] leading-5 text-white/64", children: JSON.stringify({
+                                inputs: definition.inputs.map(({ key, kind, required, description, modelName, itemKind, shape, exampleValue }) => ({
+                                    key,
+                                    kind,
+                                    required: Boolean(required),
+                                    description,
+                                    modelName,
+                                    itemKind,
+                                    shape,
+                                    exampleValue
+                                })),
+                                outputs: definition.output.map(({ key, kind, required, description, modelName, itemKind, shape, exampleValue }) => ({
+                                    key,
+                                    kind,
+                                    required: Boolean(required),
+                                    description,
+                                    modelName,
+                                    itemKind,
+                                    shape,
+                                    exampleValue
+                                })),
+                                tools: definition.tools.map(({ key, accessMode, argsSchema }) => ({
+                                    key,
+                                    accessMode,
+                                    argsSchema
+                                }))
+                            }, null, 2) })] })) : null] }));
+    };
+}

package/dist/server/src/components/workbench-boxes/strategies/strategies-boxes.js

@@ -0,0 +1,62 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { buildSearchWorkbenchExecution, buildStaticWorkbenchExecution } from "../../../lib/workbench/runtime.js";
+import { createSearchEntitiesTool, createSearchInputs, createSearchOutputs, createSearchParams, createSummaryOutput } from "../../../lib/workbench/contracts.js";
+import { createGenericWorkbenchNodeView } from "../shared/generic-node-view.js";
+import { defineWorkbenchBox } from "../shared/define-workbench-box.js";
+function Slot({ children }) {
+    return _jsx(_Fragment, { children: children });
+}
+function defineStrategyBox(id, title, description, tags, execute, output, tools = [], options) {
+    const inputs = options?.inputs ?? [];
+    const params = options?.params ?? [];
+    return defineWorkbenchBox(Slot, {
+        id,
+        surfaceId: "strategies",
+        routePath: "/strategies",
+        title,
+        icon: "strategy",
+        description,
+        category: "Strategies",
+        tags,
+        inputs,
+        params,
+        output,
+        tools,
+        NodeView: createGenericWorkbenchNodeView({
+            title,
+            description,
+            inputs,
+            params,
+            output,
+            tools
+        }),
+        execute
+    });
+}
+export const StrategiesHeroBox = defineStrategyBox("surface:strategies:hero", "Strategies hero", "Strategies page header and sequencing context.", ["strategies", "hero"], (input) => buildStaticWorkbenchExecution(input, null, "Strategies page header."), [createSummaryOutput({ label: "Strategies summary", description: "High-level strategies page framing." })]);
+export const StrategiesSearchResultsBox = defineStrategyBox("surface:strategies:search-results", "Strategies list and results", "Strategy browser and structured operating context.", ["strategies", "search"], (input) => buildSearchWorkbenchExecution(input, {
+    query: "",
+    entityTypes: ["strategy"],
+    limit: 20
+}), createSearchOutputs({
+    itemKind: "strategy",
+    itemLabel: "Strategy"
+}), [createSearchEntitiesTool("Search strategy entities by query and entity types.")], {
+    inputs: createSearchInputs({
+        itemKind: "strategy",
+        itemLabel: "Strategy",
+        defaultEntityTypes: ["strategy"],
+        defaultLimit: 20
+    }),
+    params: createSearchParams({
+        itemKind: "strategy",
+        defaultEntityTypes: ["strategy"],
+        defaultLimit: 20
+    })
+});
+export const StrategiesSummaryBox = defineStrategyBox("surface:strategies:summary", "Strategies summary", "Strategy collection summary and state context.", ["strategies", "summary"], (input) => buildStaticWorkbenchExecution(input, null, "Strategy collection summary."), [
+    createSummaryOutput({
+        label: "Strategy summary",
+        description: "Summary of strategy state and collection context."
+    })
+]);

package/dist/server/src/components/workbench-boxes/tasks/tasks-boxes.js

@@ -0,0 +1,76 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { buildSearchWorkbenchExecution, buildStaticWorkbenchExecution } from "../../../lib/workbench/runtime.js";
+import { createSearchEntitiesTool, createSearchInputs, createSearchOutputs, createSearchParams, createSummaryOutput, createTaskStatusTool } from "../../../lib/workbench/contracts.js";
+import { createGenericWorkbenchNodeView } from "../shared/generic-node-view.js";
+import { defineWorkbenchBox } from "../shared/define-workbench-box.js";
+function Slot({ children }) {
+    return _jsx(_Fragment, { children: children });
+}
+function defineTasksBox(id, title, description, tags, execute, output, tools = [], options) {
+    const inputs = options?.inputs ?? [];
+    const params = options?.params ?? [];
+    return defineWorkbenchBox(Slot, {
+        id,
+        surfaceId: "tasks",
+        routePath: "/today",
+        title,
+        icon: "task",
+        description,
+        category: "Tasks",
+        tags,
+        inputs,
+        params,
+        output,
+        tools,
+        NodeView: createGenericWorkbenchNodeView({
+            title,
+            description,
+            inputs,
+            params,
+            output,
+            tools
+        }),
+        execute
+    });
+}
+export const TasksInboxBox = defineTasksBox("surface:tasks:inbox", "Task queue", "Searchable task queue spanning backlog, focus, and in-progress work.", ["tasks", "queue", "search"], (input) => buildSearchWorkbenchExecution(input, {
+    query: "",
+    entityTypes: ["task"],
+    limit: 20
+}), createSearchOutputs({
+    itemKind: "task",
+    itemLabel: "Task"
+}), [
+    createSearchEntitiesTool("Search task entities by title, status, or linked context."),
+    createTaskStatusTool("Move a task between backlog, focus, in progress, blocked, and done.")
+], {
+    inputs: createSearchInputs({
+        itemKind: "task",
+        itemLabel: "Task",
+        defaultEntityTypes: ["task"],
+        defaultLimit: 20
+    }),
+    params: createSearchParams({
+        itemKind: "task",
+        defaultEntityTypes: ["task"],
+        defaultLimit: 20
+    })
+});
+export const TasksFocusBox = defineTasksBox("surface:tasks:focus-lane", "Focus lane", "Focused task lane for what should happen next right now.", ["tasks", "focus", "execution"], (input) => buildStaticWorkbenchExecution(input, {
+    hint: "Use this surface to represent active or next-up work."
+}, "Focus lane context for the current execution board."), [
+    createSummaryOutput({
+        label: "Focus summary",
+        description: "Human-readable explanation of what the focus lane represents."
+    })
+], [
+    createTaskStatusTool("Change task state as the flow decides what should happen next.")
+]);
+export const TasksSummaryBox = defineTasksBox("surface:tasks:summary", "Task summary", "High-level summary of the current task system and work state.", ["tasks", "summary"], (input) => buildStaticWorkbenchExecution(input, {
+    states: ["backlog", "focus", "in_progress", "blocked", "done"]
+}, "Task system summary with the key task states Forge tracks."), [
+    createSummaryOutput({
+        label: "Task summary",
+        description: "High-level summary of the current task system and work state."
+    })
+]);

package/dist/server/src/components/workbench-boxes/today/today-boxes.js

@@ -0,0 +1,78 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { buildSearchWorkbenchExecution, buildStaticWorkbenchExecution } from "../../../lib/workbench/runtime.js";
+import { createSearchEntitiesTool, createSearchInputs, createSearchOutputs, createSearchParams, createSummaryOutput } from "../../../lib/workbench/contracts.js";
+import { createGenericWorkbenchNodeView } from "../shared/generic-node-view.js";
+import { defineWorkbenchBox } from "../shared/define-workbench-box.js";
+function Slot({ children }) {
+    return _jsx(_Fragment, { children: children });
+}
+function defineTodayBox(id, title, description, tags, execute, output, tools = [], options) {
+    const inputs = options?.inputs ?? [];
+    const params = options?.params ?? [];
+    return defineWorkbenchBox(Slot, {
+        id,
+        surfaceId: "today",
+        routePath: "/today",
+        title,
+        icon: "today",
+        description,
+        category: "Today",
+        tags,
+        inputs,
+        params,
+        output,
+        tools,
+        NodeView: createGenericWorkbenchNodeView({
+            title,
+            description,
+            inputs,
+            params,
+            output,
+            tools
+        }),
+        execute
+    });
+}
+export const TodayHeroBox = defineTodayBox("surface:today:hero", "Today hero", "Daily execution header and directive.", ["today", "hero"], (input) => buildStaticWorkbenchExecution(input, null, "Daily execution header."), [createSummaryOutput({ label: "Today summary", description: "High-level framing for today's execution." })]);
+export const TodayMetricsBox = defineTodayBox("surface:today:metrics", "Live metrics", "Daily XP, level, and momentum metrics.", ["today", "metrics"], (input) => buildStaticWorkbenchExecution(input, null, "Daily metrics."), [createSummaryOutput({ label: "Metrics summary", description: "Summary of today's XP, level, and momentum metrics." })]);
+export const TodayRunwayBox = defineTodayBox("surface:today:runway", "Runway", "Execution lane and current work.", ["today", "execution"], (input) => buildSearchWorkbenchExecution(input, {
+    query: "",
+    entityTypes: ["task", "habit"],
+    limit: 16
+}), createSearchOutputs({
+    itemKind: "execution_item",
+    itemLabel: "Execution item"
+}), [createSearchEntitiesTool("Search today's active tasks and habits by query and entity types.")], {
+    inputs: createSearchInputs({
+        itemKind: "execution_item",
+        itemLabel: "Execution item",
+        defaultEntityTypes: ["task", "habit"],
+        defaultLimit: 16
+    }),
+    params: createSearchParams({
+        itemKind: "execution_item",
+        defaultEntityTypes: ["task", "habit"],
+        defaultLimit: 16
+    })
+});
+export const TodayCalendarBox = defineTodayBox("surface:today:calendar", "Calendar", "Calendar context for today.", ["today", "calendar"], (input) => buildStaticWorkbenchExecution(input, null, "Today's calendar context."), [createSummaryOutput({ label: "Calendar summary", description: "Summary of today's calendar context." })]);
+export const TodayFocusBox = defineTodayBox("surface:today:focus", "Current focus", "Today priorities and focus context.", ["today", "focus"], (input) => buildSearchWorkbenchExecution(input, {
+    query: "",
+    entityTypes: ["task", "habit"],
+    limit: 16
+}), createSearchOutputs({
+    itemKind: "focus_item",
+    itemLabel: "Focus item"
+}), [createSearchEntitiesTool("Search today's priority tasks and habits by query and entity types.")], {
+    inputs: createSearchInputs({
+        itemKind: "focus_item",
+        itemLabel: "Focus item",
+        defaultEntityTypes: ["task", "habit"],
+        defaultLimit: 16
+    }),
+    params: createSearchParams({
+        itemKind: "focus_item",
+        defaultEntityTypes: ["task", "habit"],
+        defaultLimit: 16
+    })
+});

package/dist/server/src/components/workbench-boxes/wiki/wiki-boxes.js

@@ -0,0 +1,60 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { buildStaticWorkbenchExecution, buildWikiHealthWorkbenchExecution, buildWikiPagesWorkbenchExecution } from "../../../lib/workbench/runtime.js";
+import { createContextOutput, createRecordListOutput, createSummaryOutput } from "../../../lib/workbench/contracts.js";
+import { createGenericWorkbenchNodeView } from "../shared/generic-node-view.js";
+import { defineWorkbenchBox } from "../shared/define-workbench-box.js";
+function Slot({ children }) {
+    return _jsx(_Fragment, { children: children });
+}
+function defineWikiBox(id, title, description, tags, execute, output) {
+    return defineWorkbenchBox(Slot, {
+        id,
+        surfaceId: "wiki",
+        routePath: "/wiki",
+        title,
+        icon: "wiki",
+        description,
+        category: "Wiki",
+        tags,
+        inputs: [],
+        params: [],
+        output,
+        tools: [],
+        NodeView: createGenericWorkbenchNodeView({
+            title,
+            description,
+            inputs: [],
+            params: [],
+            output,
+            tools: []
+        }),
+        execute
+    });
+}
+export const WikiPagesBox = defineWikiBox("surface:wiki:pages", "Wiki pages", "Live list of wiki pages that can be used as memory or authored knowledge.", ["wiki", "pages"], (input) => buildWikiPagesWorkbenchExecution(input), [
+    createSummaryOutput({ label: "Wiki page summary", description: "Summary of the currently available wiki pages." }),
+    createRecordListOutput({
+        key: "pages",
+        label: "Wiki pages",
+        description: "Structured wiki page records available in Forge memory.",
+        modelName: "ForgeWikiPages",
+        itemKind: "wiki_page"
+    })
+]);
+export const WikiHealthBox = defineWikiBox("surface:wiki:health", "Wiki health", "Index health, unresolved links, and orphaned-page signals for the wiki.", ["wiki", "health"], (input) => buildWikiHealthWorkbenchExecution(input), [
+    createSummaryOutput({ label: "Wiki health summary", description: "Summary of unresolved links and orphaned-page signals." }),
+    createContextOutput({
+        key: "health",
+        label: "Wiki health",
+        description: "Structured wiki health payload returned by Forge.",
+        modelName: "ForgeWikiHealth"
+    })
+]);
+export const WikiAuthoringBox = defineWikiBox("surface:wiki:authoring", "Wiki authoring", "Authoring and ingest surface for creating or refining Forge memory.", ["wiki", "authoring", "ingest"], (input) => buildStaticWorkbenchExecution(input, {
+    actions: ["upsert", "ingest", "reindex"]
+}, "Wiki authoring surface for ingesting sources and maintaining memory pages."), [
+    createSummaryOutput({
+        label: "Wiki authoring summary",
+        description: "Summary of wiki authoring and ingest actions available on this surface."
+    })
+]);

package/dist/server/src/lib/api-error.js

@@ -0,0 +1,37 @@
+export class ForgeApiError extends Error {
+    status;
+    code;
+    details;
+    requestPath;
+    constructor(input) {
+        super(input.message);
+        this.name = "ForgeApiError";
+        this.status = input.status;
+        this.code = input.code;
+        this.details = input.details ?? [];
+        this.requestPath = input.requestPath;
+    }
+}
+export function describeApiError(error) {
+    if (error instanceof ForgeApiError) {
+        return {
+            title: `Request failed (${error.status})`,
+            description: error.details.length > 0
+                ? `${error.message} ${error.details.map((detail) => `${detail.path}: ${detail.message}`).join(" · ")}`
+                : error.message,
+            code: error.code
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            title: "Something went wrong",
+            description: error.message,
+            code: "unknown_error"
+        };
+    }
+    return {
+        title: "Something went wrong",
+        description: "Unexpected API failure.",
+        code: "unknown_error"
+    };
+}