@dxos/plugin-debug 0.12.0-next-73daef452f1464b62efdbca75fb0067c1066f264 → 0.13.0

package/src/samples/weather/WeatherSpace.test.ts

@@ -0,0 +1,93 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { buildArchive, histogram } from '@dxos/app-toolkit/testing';
+import { Type } from '@dxos/echo';
+import * as EffectEx from '@dxos/effect/EffectEx';
+
+import * as WeatherSpace from './WeatherSpace.ts';
+
+/** A task as the archive serializes it: refs become `{ '/': 'echo:///<id>' }`. */
+type ArchivedTask = {
+  '@type'?: string;
+  'id': string;
+  'title'?: string;
+  'status'?: string;
+  'dependsOn'?: Array<{ '/': string }>;
+  'assignee'?: unknown;
+};
+
+describe('Weather MCP template', () => {
+  test('builds the project, its skill and four steps, and nothing else', { timeout: 120_000 }, async ({ expect }) => {
+    const { json, objectCount } = await EffectEx.runPromise(buildArchive(WeatherSpace.make()));
+    const counts = histogram(json);
+    const countOf = (typename: string) =>
+      Object.entries(counts)
+        .filter(([type]) => type.includes(typename))
+        .reduce((total, [, count]) => total + count, 0);
+
+    expect(objectCount).toBeGreaterThan(0);
+    expect(countOf('type.project')).toBe(1);
+    expect(countOf('type.instructions')).toBe(1);
+    expect(countOf('type.skill')).toBe(1);
+    expect(countOf('type.taskSet')).toBe(1);
+    expect(countOf('type.task:')).toBe(4);
+    expect(countOf('type.document')).toBe(0);
+  });
+
+  test('every schema the content persists is declared', { timeout: 120_000 }, async ({ expect }) => {
+    const { json } = await EffectEx.runPromise(buildArchive(WeatherSpace.make()));
+    const declared = new Set(WeatherSpace.make().schemas.map((schema) => Type.getTypename(schema)));
+
+    for (const type of Object.keys(histogram(json))) {
+      const typename = type.match(/(?:[\w-]+\.)+type\.[\w.]+/)?.[0];
+      // `spaceProperties` is the space root the harness creates, in every archive and no definition.
+      if (typename && typename !== 'org.dxos.type.spaceProperties') {
+        expect(declared).toContain(typename);
+      }
+    }
+  });
+
+  test(
+    'four ordered steps, all the agent’s, each depending on the one before',
+    { timeout: 120_000 },
+    async ({ expect }) => {
+      const tasks = await archived<ArchivedTask>('type.task:');
+
+      expect(tasks.map((task) => task.title)).toEqual([
+        'Build the weather MCP Worker',
+        'Deploy it to a temporary Cloudflare account',
+        'Configure the server for this space',
+        'Test the tool from this chat',
+      ]);
+      expect(tasks.every((task) => task.status === 'todo')).toBe(true);
+      // The run is unattended: a step assigned to the reader would stall it.
+      expect(tasks.every((task) => task.assignee === undefined)).toBe(true);
+      expect(tasks.map((task) => task.dependsOn?.map((ref) => ref['/']))).toEqual([
+        undefined,
+        ...tasks.slice(0, -1).map((task) => [`echo:///${task.id}`]),
+      ]);
+    },
+  );
+
+  test(
+    'the seeded skill starts with no MCP server for the run to fill in',
+    { timeout: 120_000 },
+    async ({ expect }) => {
+      const [skill] = await archived<{ mcpServers?: unknown[]; agentCanEnable?: boolean }>('type.skill');
+
+      expect(skill?.mcpServers).toEqual([]);
+      expect(skill?.agentCanEnable).toBe(true);
+    },
+  );
+});
+
+/** The archive's objects of one typename fragment, in the order they were written. */
+const archived = async <T>(fragment: string): Promise<T[]> => {
+  const { json } = await EffectEx.runPromise(buildArchive(WeatherSpace.make()));
+  const objects: Array<{ '@type'?: string }> = JSON.parse(json).objects;
+  return objects.filter((object) => object['@type']?.includes(fragment)) as T[];
+};

package/src/samples/weather/WeatherSpace.ts

@@ -0,0 +1,59 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Effect from 'effect/Effect';
+
+import type * as AppCapabilities from '@dxos/app-toolkit/AppCapabilities';
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+
+import { ProjectPhase } from './project.ts';
+import { WeatherSkill } from './skill.ts';
+import { Tasks } from './tasks.ts';
+import { REFERENCE } from './util.ts';
+
+export { FORECAST_URL } from './util.ts';
+
+const phases = {
+  skill: WeatherSkill,
+  tasks: Tasks,
+  project: ProjectPhase,
+};
+
+/**
+ * The fastest loop through building an MCP server and using it: one Worker with one tool over the
+ * Open-Meteo forecast, four tasks from an empty sandbox to a tool call in this chat, all of them the
+ * agent's.
+ *
+ * It sits between `WorkerSpace` (a deploy with nothing to call) and `StockfishSpace` (an engine, a
+ * design stage and a publish step): enough to exercise the whole build → deploy → configure → call
+ * path, small enough to run unattended. The account stays temporary and unclaimed, and the server is
+ * configured on a seeded skill because a skill is where a chat reads MCP servers from.
+ */
+export const make = (): SampleSpace.Definition<typeof phases, void> =>
+  SampleSpace.make({
+    // Reaches a space only where the definition is applied directly (the generator panel, the
+    // archive test): the create-space dialog takes its icon from `space-templates.ts`.
+    space: { name: 'Weather MCP', icon: 'sun', hue: 'sky' },
+    reference: REFERENCE,
+    phases,
+    build: (phases) =>
+      Effect.gen(function* () {
+        const skill = yield* phases.skill();
+        const tasks = yield* phases.tasks();
+        yield* phases.project({ tasks, skill });
+
+        // No root collection: this space seeds no documents — the project, its tasks and the skill
+        // surface through their own containers.
+      }),
+  });
+
+export const makeTemplate = (): AppCapabilities.SpaceTemplate =>
+  SampleSpace.makeTemplate({
+    id: 'org.dxos.plugin-debug.template.weather',
+    description:
+      'Four tasks an agent runs alone: a one-tool MCP server over a weather API, deployed to a temporary Worker and called from the chat.',
+    definition: make(),
+  });

package/src/samples/weather/project.ts

@@ -0,0 +1,76 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+import * as Instructions from '@dxos/compute/Instructions';
+import * as Project from '@dxos/compute/Project';
+import { Database, Ref } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+import { Outline } from '@dxos/types';
+
+import { type SkillResult } from './skill.ts';
+import { type TasksResult } from './tasks.ts';
+
+export type ProjectInput = { tasks: TasksResult; skill: SkillResult };
+
+export type ProjectResult = { project: Project.Project; instructions: Instructions.Instructions };
+
+const INSTRUCTIONS = `Build, deploy, configure and test the weather MCP server described by the task \
+list, on your own and in one go: start the first task now, work them in order, and set each one's \
+status as you finish it. Do not stop to ask — nothing in this project needs me.
+
+The task descriptions are the whole specification: one Worker, one tool (\`get_weather\`), one \
+upstream API. There is no design stage. If a step starts to look like architecture, it is the wrong step.
+
+Write the code yourself in one sandbox, driving it through the Sandbox skill \
+(\`org.dxos.skill.sandbox\`). Do not delegate to the coding agent in the sandbox image — it has none \
+of this space's context.
+
+The server is called from a browser, so it must answer CORS preflights and send CORS headers on \
+every response — without them the tool silently never connects. Deploy with \`wrangler deploy --temporary\`. Do not claim the account and never file or repeat the \
+claim URL. The container is not durable, so file the Worker URL and the tool's response on this \
+project in the turn you produce them.
+
+Configure the server by setting its URL on the Weather MCP skill's \`mcpServers\` with the Database \
+skill; that skill is already bound here, so the tool is available on your next turn.
+
+This project needs no Cloudflare login and no API keys. If a step seems to need either, that is the \
+wrong step.`;
+
+/**
+ * The work-stream. It adopts the task set the tasks phase built and binds the Weather MCP skill
+ * through `instructions.skills` — the only path a seeded skill reaches a chat by — so the run can
+ * configure the server with one update and no enable step.
+ */
+export const ProjectPhase: SampleSpace.Phase<ProjectResult, ProjectInput> = SampleSpace.phase('project', {
+  // `Project.make` builds an outline for the project and the instructions' prose is stored as a
+  // Text; a phase has to declare every type it persists or the space cannot register it.
+  schemas: [Project.Project, Instructions.Instructions, Outline.Outline, Text.Text],
+  run: ({ tasks, skill }: ProjectInput) =>
+    Effect.gen(function* () {
+      const instructions = yield* Database.add(
+        Instructions.make({
+          name: 'Weather MCP',
+          text: INSTRUCTIONS,
+          skills: [Ref.make(skill.skill)],
+          objects: [Ref.make(tasks.taskSet)],
+        }),
+      );
+
+      const project = yield* Database.add(
+        Project.make({
+          name: 'Weather MCP',
+          description:
+            'A one-tool MCP server over the Open-Meteo forecast, deployed as a temporary Cloudflare Worker and called from this chat.',
+          status: 'active',
+          instructions: Ref.make(instructions),
+          taskSet: Ref.make(tasks.taskSet),
+        }),
+      );
+
+      return { project, instructions };
+    }),
+});

package/src/samples/weather/skill.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+import * as Skill from '@dxos/compute/Skill';
+import * as Template from '@dxos/compute/Template';
+import { Database } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+import { trim } from '@dxos/util';
+
+const INSTRUCTIONS = trim`
+  Carries the weather MCP server this project deploys. Its \`mcpServers\` list starts empty: the
+  Worker URL only exists once the deploy has run, and the run sets it here. A chat with this skill
+  bound connects every listed server at the start of each turn, so the \`get_weather\` tool appears
+  on the turn after the URL is set.
+`;
+
+export type SkillResult = { skill: Skill.Skill };
+
+/**
+ * The skill the deployed server hangs off. Seeded rather than created by the run because a skill is
+ * the one place a chat reads MCP servers from, and the project's instructions can bind a seeded
+ * object — so configuring the server is one field update, not a skill to author and enable.
+ */
+export const WeatherSkill: SampleSpace.Phase<SkillResult> = SampleSpace.phase('skill', {
+  schemas: [Skill.Skill, Text.Text],
+  run: () =>
+    Effect.gen(function* () {
+      const skill = yield* Database.add(
+        Skill.make({
+          key: 'org.dxos.skill.weatherMcp',
+          name: 'Weather MCP',
+          description: 'The weather MCP server deployed by this project.',
+          instructions: Template.make({ source: INSTRUCTIONS }),
+          mcpServers: [],
+          agentCanEnable: true,
+        }),
+      );
+
+      return { skill };
+    }),
+});

package/src/samples/weather/tasks.ts

@@ -0,0 +1,98 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+import { Database, Obj, Ref } from '@dxos/echo';
+import { EntityId } from '@dxos/echo/Key';
+import { Task, TaskSet } from '@dxos/types';
+
+import { FORECAST_URL, daysAgo } from './util.ts';
+
+//
+// Four steps, flat and in order, all the agent's: nothing here needs the reader, so a chat can run
+// the plan end to end on its own. Each depends on the one before it, so a runner working ahead is
+// visibly out of order rather than merely early.
+//
+
+type TaskSeed = {
+  readonly title: string;
+  readonly description: string;
+  readonly estimate?: Task.Estimate;
+};
+
+const STEPS: ReadonlyArray<TaskSeed> = [
+  {
+    title: 'Build the weather MCP Worker',
+    description: `One sandbox for the run. A TypeScript Worker that speaks MCP over Streamable HTTP on one endpoint — \`initialize\`, \`tools/list\` and \`tools/call\` — with exactly one tool, \`get_weather\`, taking \`latitude\` and \`longitude\` and returning the current temperature and wind speed plus the hourly series from ${FORECAST_URL} with those coordinates substituted. The MCP client runs in the browser, so every response must carry CORS headers and an \`OPTIONS\` preflight must answer 204: \`Access-Control-Allow-Origin: *\`, \`Access-Control-Allow-Methods: GET, POST, DELETE, OPTIONS\`, \`Access-Control-Allow-Headers\` covering \`content-type\`, \`accept\`, \`authorization\`, \`mcp-session-id\` and \`mcp-protocol-version\`, and \`Access-Control-Expose-Headers: mcp-session-id\`. No auth, no dependencies beyond wrangler. The client is the MCP TypeScript SDK's Streamable HTTP transport, and it needs more than the three methods: answer every request with \`Content-Type: application/json\` and a JSON-RPC response object at HTTP 200 — an unknown method too, as a JSON-RPC error, never a 4xx; in \`initialize\` echo the \`protocolVersion\` the client sent, with \`capabilities: { tools: {} }\` and a \`serverInfo\`; answer any notification (a message with no \`id\`, such as \`notifications/initialized\`) with 202 and no body, since a client whose notification gets a 4xx never finishes connecting; answer \`GET\` and \`DELETE\` on the endpoint with 405. Return the tool's result as \`{ content: [{ type: 'text', text: <the forecast as JSON> }] }\`. \`--temporary\` needs wrangler 4.102+, which needs Node 22 while the sandbox runs Node 20: install \`wrangler@latest\` and run it as \`npx --yes node@22 node_modules/wrangler/bin/wrangler.js\`.`,
+    estimate: 's',
+  },
+  {
+    title: 'Deploy it to a temporary Cloudflare account',
+    description:
+      '`wrangler deploy --temporary` — plain `wrangler deploy` demands a token non-interactively. File the Worker URL on the project. Do not claim the account and do not file or repeat the claim URL: it is a bearer credential, and this run never needs it.',
+    estimate: 'xs',
+  },
+  {
+    title: 'Configure the server for this space',
+    description:
+      "Set the Worker URL on the Weather MCP skill's `mcpServers` as `{ name: 'weather', url, protocol: 'http' }` through the Database skill's update tool. The skill is already bound to this chat and servers are connected at the start of every turn, so `get_weather` appears on your next turn — no restart.",
+    estimate: 'xs',
+  },
+  {
+    title: 'Test the tool from this chat',
+    description:
+      'Before calling, check CORS against the deployed URL — `curl -i -X OPTIONS -H "Origin: http://localhost" -H "Access-Control-Request-Method: POST" -H "Access-Control-Request-Headers: content-type,mcp-session-id" <url>` must return the allow headers; a browser client fails its preflight otherwise, and the tool never appears. Then call `get_weather` for Berlin (52.52, 13.41) and file the response on the project. The call has to appear as a tool call in the transcript; a forecast the model produced on its own is a failure, not a pass.',
+    estimate: 'xs',
+  },
+];
+
+export type TasksResult = { taskSet: TaskSet.TaskSet; tasks: Task.Task[] };
+
+/** The four steps, each depending on the one before it. */
+export const Tasks: SampleSpace.Phase<TasksResult> = SampleSpace.phase('tasks', {
+  schemas: [TaskSet.TaskSet, Task.Task],
+  run: () =>
+    Effect.gen(function* () {
+      const taskSet = yield* Database.add(
+        TaskSet.make({
+          name: 'Weather MCP',
+          description: 'From an empty sandbox to a weather tool this chat calls.',
+        }),
+      );
+
+      const tasks = STEPS.map((step) =>
+        Task.make({
+          title: step.title,
+          description: step.description,
+          estimate: step.estimate,
+          status: 'todo',
+          // Task carries no due date; its dates are activity-log lines, so that is where they go.
+          history: [
+            {
+              id: EntityId.random(),
+              date: daysAgo(0),
+              event: 'created' as const,
+              description: 'Filed from the weather MCP template.',
+            },
+          ],
+        }),
+      );
+      yield* SampleSpace.children(taskSet, tasks, (taskSet, refs) => {
+        taskSet.tasks = refs;
+      });
+
+      for (const [index, task] of tasks.entries()) {
+        if (index > 0) {
+          const previous = tasks[index - 1];
+          Obj.update(task, (task) => {
+            task.dependsOn = [Ref.make(previous)];
+          });
+        }
+      }
+
+      return { taskSet, tasks };
+    }),
+});

package/src/samples/weather/util.ts

@@ -0,0 +1,21 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+
+/** Stable reference date so regenerations are reproducible. Override with NOW=2026-05-20 env. */
+export const REFERENCE = process.env.NOW ? new Date(process.env.NOW) : new Date('2026-05-20T15:00:00Z');
+
+/**
+ * Bound to the same reference the definition declares, so the pure content builders can date their
+ * objects without every one of them being an effect.
+ */
+export const clock = SampleSpace.makeClock(REFERENCE);
+
+/** ISO timestamp that many days before {@link REFERENCE}, at an optional UTC hour of that day. */
+export const daysAgo = clock.daysAgo;
+
+/** The upstream the Worker's one tool wraps; parameterised on coordinates by the tool. */
+export const FORECAST_URL =
+  'https://api.open-meteo.com/v1/forecast?latitude=52.52&longitude=13.41&current=temperature_2m,wind_speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m';

package/src/samples/worker/WorkerSpace.test.ts

@@ -0,0 +1,102 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { buildArchive, histogram } from '@dxos/app-toolkit/testing';
+import { Type } from '@dxos/echo';
+import * as EffectEx from '@dxos/effect/EffectEx';
+
+import * as WorkerSpace from './WorkerSpace.ts';
+
+/** A task as the archive serializes it: refs become `{ '/': 'echo:///<id>' }`. */
+type ArchivedTask = {
+  '@type'?: string;
+  'id': string;
+  'title'?: string;
+  'status'?: string;
+  'dependsOn'?: Array<{ '/': string }>;
+  'assignee'?: { role?: string; name?: string };
+};
+
+/** The archive's tasks, in the order they were written. */
+const taskArchive = async (definition: ReturnType<typeof WorkerSpace.make>): Promise<ArchivedTask[]> => {
+  const { json } = await EffectEx.runPromise(buildArchive(definition));
+  const objects: ArchivedTask[] = JSON.parse(json).objects;
+  return objects.filter((object) => object['@type']?.includes('type.task:'));
+};
+
+/**
+ * Built on demand rather than committed, so this asserts the shape in place of a fixture: if a
+ * schema it seeds changes incompatibly, the build fails here.
+ */
+describe('Worker template', () => {
+  test('builds the project and its five steps, and nothing else', { timeout: 120_000 }, async ({ expect }) => {
+    const { json, objectCount } = await EffectEx.runPromise(buildArchive(WorkerSpace.make()));
+    const counts = histogram(json);
+    const countOf = (typename: string) =>
+      Object.entries(counts)
+        .filter(([type]) => type.includes(typename))
+        .reduce((total, [, count]) => total + count, 0);
+
+    expect(objectCount).toBeGreaterThan(0);
+    expect(countOf('type.project')).toBe(1);
+    expect(countOf('type.instructions')).toBe(1);
+    expect(countOf('type.taskSet')).toBe(1);
+    expect(countOf('type.task:')).toBe(5);
+    // The URL and the response body are what the run produces, so the space ships no documents.
+    expect(countOf('type.document')).toBe(0);
+  });
+
+  // Falsifiable without hardcoding the archive's contents: every typename in the archive must be one
+  // the definition DECLARED. The zero-count above would not be — `countOf` substring-matches, so
+  // asserting a typename is absent passes just as well when the typename is misspelled.
+  test('every schema the content persists is declared', { timeout: 120_000 }, async ({ expect }) => {
+    const { json } = await EffectEx.runPromise(buildArchive(WorkerSpace.make()));
+    const declared = new Set(WorkerSpace.make().schemas.map((schema) => Type.getTypename(schema)));
+
+    for (const type of Object.keys(histogram(json))) {
+      // Not namespace-limited: `Project.make` persists `com.example.type.project`, so matching only
+      // `org.dxos.*` would let the project's own types go unchecked.
+      const typename = type.match(/(?:[\w-]+\.)+type\.[\w.]+/)?.[0];
+      // `spaceProperties` is the space root the harness creates, not a phase's content, so it is in
+      // every archive and in no definition's schema list.
+      if (typename && typename !== 'org.dxos.type.spaceProperties') {
+        expect(declared).toContain(typename);
+      }
+    }
+  });
+
+  test('every step is todo and each depends on the one before it', { timeout: 120_000 }, async ({ expect }) => {
+    const tasks = await taskArchive(WorkerSpace.make());
+
+    expect(tasks.map((task) => task.title)).toEqual([
+      'Create a sandbox and install wrangler',
+      'Write the Worker',
+      'Deploy it with no Cloudflare login',
+      'Fetch the deployed URL and check the response',
+      'Claim the temporary Cloudflare account',
+    ]);
+    expect(tasks.every((task) => task.status === 'todo')).toBe(true);
+
+    // The identity each dependency names, not merely how many there are: a chain wired to the wrong
+    // predecessor has the same shape as the right one and would otherwise pass.
+    expect(tasks.map((task) => task.dependsOn?.map((ref) => ref['/']))).toEqual([
+      undefined,
+      ...tasks.slice(0, -1).map((task) => [`echo:///${task.id}`]),
+    ]);
+  });
+
+  // The one browser step is the reader's, and it is last: an agent with no login cannot update a
+  // claimed account, so claiming before the deploy would strand the run.
+  test('only the claim is assigned to the reader, and it is last', { timeout: 120_000 }, async ({ expect }) => {
+    const tasks = await taskArchive(WorkerSpace.make());
+    const assigned = tasks.filter((task) => task.assignee !== undefined);
+
+    expect(assigned.map((task) => task.title)).toEqual(['Claim the temporary Cloudflare account']);
+    // The role is what the row reads as "not the agent's"; a name alone would not say that.
+    expect(assigned.map((task) => task.assignee?.role)).toEqual(['user']);
+    expect(tasks.at(-1)?.title).toEqual('Claim the temporary Cloudflare account');
+  });
+});

package/src/samples/worker/WorkerSpace.ts

@@ -0,0 +1,56 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Effect from 'effect/Effect';
+
+import type * as AppCapabilities from '@dxos/app-toolkit/AppCapabilities';
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+
+import { ProjectPhase } from './project.ts';
+import { Tasks } from './tasks.ts';
+import { REFERENCE } from './util.ts';
+
+const phases = {
+  tasks: Tasks,
+  project: ProjectPhase,
+};
+
+/**
+ * The smallest thing that still builds and deploys: one Cloudflare Worker returning a greeting and
+ * the time, as five tasks from an empty sandbox to a URL that answers.
+ *
+ * It is the short path through the same ground `StockfishSpace` covers at length. There the work is
+ * the engine and the deploy is one stage of five; here the deploy IS the project, so there is no
+ * brief to design against, no skill to bind and nothing seeded for the run to point at — a chat
+ * that reads the task list has the whole specification.
+ *
+ * Reachable with no credentials but the reader's own DXOS identity: the first deploy uses wrangler's
+ * unauthenticated mode, and the single consent screen is the last task.
+ */
+export const make = (): SampleSpace.Definition<typeof phases, void> =>
+  SampleSpace.make({
+    // Reaches a space only where the definition is applied directly (the generator panel, the
+    // archive test): the create-space dialog takes its icon from `space-templates.ts`, which
+    // overrides every template's by list index. See DESIGN.md §7.
+    space: { name: 'Hello Worker', icon: 'rocket-launch', hue: 'cyan' },
+    reference: REFERENCE,
+    phases,
+    build: (phases) =>
+      Effect.gen(function* () {
+        const tasks = yield* phases.tasks();
+        yield* phases.project({ tasks });
+
+        // No root collection: the root holds collections only, and this space seeds no documents —
+        // the project and its tasks surface through their own containers.
+      }),
+  });
+
+export const makeTemplate = (): AppCapabilities.SpaceTemplate =>
+  SampleSpace.makeTemplate({
+    id: 'org.dxos.plugin-debug.template.worker',
+    description: 'Five tasks from an empty sandbox to a Cloudflare Worker that answers, with no account to start.',
+    definition: make(),
+  });

package/src/samples/worker/project.ts

@@ -0,0 +1,72 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+import * as Instructions from '@dxos/compute/Instructions';
+import * as Project from '@dxos/compute/Project';
+import { Database, Ref } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+import { Outline } from '@dxos/types';
+
+import { type TasksResult } from './tasks.ts';
+
+export type ProjectInput = { tasks: TasksResult };
+
+export type ProjectResult = { project: Project.Project; instructions: Instructions.Instructions };
+
+const INSTRUCTIONS = `Deploy the Worker described by the task list, working the tasks in order and \
+setting each one's status as you finish it: the task list is how I follow this run.
+
+What the Worker does is the whole specification — one fetch handler, JSON out, a greeting and the \
+current UTC time. There is no design stage and nothing to choose. If a step starts to look like \
+architecture, it is the wrong step.
+
+Write the code yourself in one sandbox, driving it through the Sandbox skill \
+(\`org.dxos.skill.sandbox\`). The sandbox image ships a coding agent of its own; do not delegate to \
+it — it has none of this space's context, and its output would land on a container filesystem \
+rather than in this project.
+
+The container is not durable, so file what has to outlive it — the Worker URL, the response body — \
+as artifacts on this project in the turn you produce it, not at the end. The claim URL that the \
+deploy prints is a bearer credential for the account: give it to me directly and file it nowhere.
+
+This project needs no Cloudflare login and no API keys. If a step seems to need either, that is the \
+wrong step.`;
+
+/**
+ * The work-stream. It adopts the task set the tasks phase built (`Project.make` would otherwise
+ * create its own empty one), and starts with no artifacts: the URL and the response are what the
+ * run produces, and seeding either would name something that does not exist.
+ */
+export const ProjectPhase: SampleSpace.Phase<ProjectResult, ProjectInput> = SampleSpace.phase('project', {
+  // Neither `Outline.Outline` nor `Text.Text` is created here directly: `Project.make` builds an
+  // outline for the project, and the instructions' prose is stored as a Text. A phase has to declare
+  // every type it persists or the space cannot register it.
+  schemas: [Project.Project, Instructions.Instructions, Outline.Outline, Text.Text],
+  run: ({ tasks }: ProjectInput) =>
+    Effect.gen(function* () {
+      const instructions = yield* Database.add(
+        Instructions.make({
+          name: 'Hello Worker',
+          text: INSTRUCTIONS,
+          objects: [Ref.make(tasks.taskSet)],
+        }),
+      );
+
+      const project = yield* Database.add(
+        Project.make({
+          name: 'Hello Worker',
+          description:
+            'One Cloudflare Worker that answers with a greeting and the time, deployed from a sandbox with no Cloudflare account.',
+          status: 'active',
+          instructions: Ref.make(instructions),
+          taskSet: Ref.make(tasks.taskSet),
+        }),
+      );
+
+      return { project, instructions };
+    }),
+});