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

package/src/samples/review/work.ts

@@ -0,0 +1,249 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+import * as Project from '@dxos/compute/Project';
+import { Database, type Obj, Ref } from '@dxos/echo';
+import { Outline, Person, PullRequest, Repo, Task, TaskSet } from '@dxos/types';
+
+import { type ImageKey, type MediaResult, type VideoKey } from './assets.ts';
+import { daysAgo } from './util.ts';
+
+//
+// The review queue: real dxos/dxos pull requests, each filed against the task it delivered, with the
+// screenshots and recordings its author attached. Finished work carries merged PRs; the tasks in
+// review carry the PRs still open, which is what a reviewer opens the space to work through.
+//
+
+type PullRequestKey = 'rail' | 'oauth' | 'toast' | 'halo' | 'archify';
+
+const PULL_REQUEST_SEEDS: ReadonlyArray<
+  SampleSpace.Seed<PullRequestKey, Omit<Obj.MakeProps<typeof PullRequest.PullRequest>, 'owner' | 'repo'>>
+> = [
+  {
+    key: 'rail',
+    number: 12544,
+    title: 'plugin-navtree: stop the L0 rail insetting items by the scrollbar strip',
+    state: 'merged',
+    author: 'wittjosiah',
+    headBranch: 'claude/l0-box-centering-regression-lg55l7',
+    additions: 65,
+    deletions: 4,
+  },
+  {
+    key: 'oauth',
+    number: 12690,
+    title: 'onboarding, connector: run desktop OAuth in the system browser',
+    state: 'merged',
+    author: 'wittjosiah',
+    headBranch: 'claude/tauri-oauth-login-ftwie0',
+    additions: 941,
+    deletions: 206,
+  },
+  {
+    key: 'toast',
+    number: 12954,
+    title: "react-ui: count down a toast's remaining time in a bar",
+    state: 'merged',
+    author: 'wittjosiah',
+    headBranch: 'claude/toast-progress-indicator-e3a046',
+    additions: 137,
+    deletions: 30,
+  },
+  {
+    key: 'halo',
+    number: 13336,
+    title: 'halo: switch identities in place with deleteIdentity instead of a reset and reload',
+    state: 'open',
+    author: 'dmaretskyi',
+    headBranch: 'dm/admiring-gauss-nqdcuk',
+    additions: 501,
+    deletions: 159,
+  },
+  {
+    key: 'archify',
+    number: 12952,
+    title: 'plugin-archify: add Archify architecture diagrams',
+    state: 'open',
+    author: 'dmaretskyi',
+    headBranch: 'claude/archify-composer-plugin-5rfrpr',
+    additions: 3176,
+    deletions: 0,
+  },
+];
+
+type ReviewerKey = 'mira' | 'kai';
+
+const REVIEWER_SEEDS: ReadonlyArray<SampleSpace.Seed<ReviewerKey, { fullName: string; jobTitle: string }>> = [
+  { key: 'mira', fullName: 'Mira Okafor', jobTitle: 'Design engineer' },
+  { key: 'kai', fullName: 'Kai Lindqvist', jobTitle: 'Platform engineer' },
+];
+
+type TaskSeed = {
+  readonly title: string;
+  readonly status: Task.Status;
+  readonly description: string;
+  readonly priority?: Task.Priority;
+  readonly pullRequest?: PullRequestKey;
+  readonly images?: ReadonlyArray<ImageKey>;
+  readonly videos?: ReadonlyArray<VideoKey>;
+  readonly reviewers?: ReadonlyArray<ReviewerKey>;
+  /** Days before the reference date the task was opened. */
+  readonly opened: number;
+};
+
+const TASK_SEEDS: ReadonlyArray<TaskSeed> = [
+  {
+    title: 'Stop the L0 rail insetting items by the scrollbar strip',
+    status: 'done',
+    priority: 'medium',
+    description: 'The current-workspace indicator is tucked under the avatar since the overlay scrollbar landed.',
+    pullRequest: 'rail',
+    images: ['railBefore', 'railAfter'],
+    opened: 30,
+  },
+  {
+    title: 'Run desktop OAuth in the system browser',
+    status: 'done',
+    priority: 'urgent',
+    description:
+      'Every OAuth flow in the desktop app fails before the provider page appears: WKWebView opens no window.',
+    pullRequest: 'oauth',
+    images: ['oauthIdle', 'oauthPending'],
+    opened: 24,
+  },
+  {
+    title: "Count down a toast's remaining time",
+    status: 'done',
+    priority: 'low',
+    description: 'A toast disappears with no warning; show the time it has left and pause it on hover.',
+    pullRequest: 'toast',
+    videos: ['toastCountdown'],
+    opened: 18,
+  },
+  {
+    title: 'Switch identities in place instead of a reset and reload',
+    status: 'review',
+    priority: 'high',
+    description: 'Logging out, recovering or joining another identity wipes the profile and reloads the app.',
+    pullRequest: 'halo',
+    videos: ['haloLogin'],
+    reviewers: ['kai'],
+    opened: 6,
+  },
+  {
+    title: 'Add Archify architecture diagrams',
+    status: 'review',
+    priority: 'medium',
+    description: 'Render a package’s module graph as a diagram an agent can generate and a person can read.',
+    pullRequest: 'archify',
+    videos: ['archify'],
+    reviewers: ['mira', 'kai'],
+    opened: 12,
+  },
+  {
+    title: "Show a pull request's review state on its task pill",
+    status: 'started',
+    priority: 'medium',
+    description: 'The pill colours by open/merged/closed; approved and changes-requested are invisible.',
+    opened: 2,
+  },
+  {
+    title: 'Record a demo for every task in review',
+    status: 'todo',
+    priority: 'low',
+    description: 'A reviewer should be able to watch the change before reading the diff.',
+    opened: 1,
+  },
+];
+
+export type WorkResult = {
+  project: Project.Project;
+  taskSet: TaskSet.TaskSet;
+  tasks: Task.Task[];
+  pullRequests: Record<PullRequestKey, PullRequest.PullRequest>;
+};
+
+/** Pull requests, reviewers, the task set, and the project that gathers them with the media. */
+export const Work: SampleSpace.Phase<WorkResult, MediaResult> = SampleSpace.phase('work', {
+  schemas: [
+    PullRequest.PullRequest,
+    Person.Person,
+    Task.Task,
+    TaskSet.TaskSet,
+    Outline.Outline,
+    Repo.Repo,
+    Project.Project,
+  ],
+  run: ({ images, videos }: MediaResult) =>
+    Effect.gen(function* () {
+      const pullRequests = yield* SampleSpace.seed(PULL_REQUEST_SEEDS, ({ key: _key, ...seed }) =>
+        Database.add(
+          PullRequest.make({
+            ...seed,
+            owner: 'dxos',
+            repo: 'dxos',
+            url: `https://github.com/dxos/dxos/pull/${seed.number}`,
+            baseBranch: 'main',
+          }),
+        ),
+      );
+
+      const reviewers = yield* SampleSpace.seed(REVIEWER_SEEDS, ({ key: _key, ...seed }) =>
+        Database.add(Person.make(seed)),
+      );
+
+      const tasks = TASK_SEEDS.map((seed) =>
+        Task.make({
+          title: seed.title,
+          description: seed.description,
+          status: seed.status,
+          priority: seed.priority,
+          reviewers: seed.reviewers?.map((key) => ({ contact: Ref.make(reviewers[key]) })),
+          artifacts: [
+            ...(seed.pullRequest ? [Ref.make(pullRequests[seed.pullRequest])] : []),
+            ...(seed.images ?? []).map((key) => Ref.make(images[key])),
+            ...(seed.videos ?? []).map((key) => Ref.make(videos[key])),
+          ],
+          history: [{ date: daysAgo(seed.opened), event: 'created', description: 'Opened.' }],
+        }),
+      );
+
+      const taskSet = yield* Database.add(TaskSet.make({ name: 'Composer polish' }));
+      yield* SampleSpace.children(taskSet, tasks, (taskSet, refs) => {
+        taskSet.tasks = refs;
+      });
+
+      const repo = yield* Database.add(
+        Repo.make({
+          name: 'dxos',
+          owner: 'dxos',
+          url: 'https://github.com/dxos/dxos',
+          description: 'TypeScript implementation of the DXOS protocols, SDK, toolchain and Composer.',
+          defaultBranch: 'main',
+        }),
+      );
+      const outline = yield* Database.add(Outline.make({ name: 'Review notes' }));
+
+      const project = yield* Database.add(
+        Project.make({
+          name: 'Composer polish',
+          description: 'Small, visible fixes to Composer, each landed as a reviewed pull request with a demo.',
+          status: 'active',
+          repo: Ref.make(repo),
+          taskSet: Ref.make(taskSet),
+          outline: Ref.make(outline),
+          artifacts: [
+            ...Object.values(pullRequests).map((pullRequest) => Ref.make(pullRequest)),
+            ...Object.values(images).map((image) => Ref.make(image)),
+            ...Object.values(videos).map((video) => Ref.make(video)),
+          ],
+        }),
+      );
+
+      return { project, taskSet, tasks, pullRequests };
+    }),
+});

package/src/samples/stockfish/StockfishSpace.test.ts

@@ -0,0 +1,129 @@
+//
+// 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 StockfishSpace from './StockfishSpace.ts';
+
+/**
+ * The chess-MCP template is built on demand rather than committed, so this asserts its shape in
+ * place of a fixture: if a schema it seeds changes incompatibly, the build fails here.
+ */
+describe('Chess MCP template', () => {
+  test(
+    'builds an archive with the project, its plan, its skill and the test position',
+    { timeout: 120_000 },
+    async ({ expect }) => {
+      const { json, objectCount } = await EffectEx.runPromise(buildArchive(StockfishSpace.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.document')).toBe(1);
+      // The position the finished server is pointed at: a Game wrapping a chess state.
+      expect(countOf('type.game:')).toBe(1);
+      expect(countOf('type.chess.state')).toBe(1);
+      // Falsifiable without hardcoding the archive's contents: every typename in the archive must be
+      // one the definition DECLARED. A pair of zero-counts would not be — `countOf` substring-matches,
+      // so asserting a typename is absent passes just as well when the typename is misspelled.
+      const declared = new Set(StockfishSpace.make().schemas.map((schema) => Type.getTypename(schema)));
+      for (const type of Object.keys(counts)) {
+        // 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);
+        }
+      }
+      // And the two the plan creates at run time are not among them: stage four adds the server
+      // record and stage five the repository, so seeding either would name a URL that does not exist.
+      expect([...declared].filter((type) => /mcpServer|\.repo$/.test(type))).toEqual([]);
+    },
+  );
+
+  test('the plan is one root, five stages, and their steps', { timeout: 120_000 }, async ({ expect }) => {
+    const { json } = await EffectEx.runPromise(buildArchive(StockfishSpace.make()));
+    const objects: Array<{
+      '@type'?: string;
+      'id': string;
+      'title'?: string;
+      'status'?: string;
+      'assignee'?: unknown;
+      'subtasks'?: unknown;
+      'dependsOn'?: unknown;
+    }> = JSON.parse(json).objects;
+    const tasks = objects.filter((object) => object['@type']?.includes('type.task:'));
+
+    // Refs serialize as an envelope, so a parent's `subtasks` are matched by id within it.
+    const childrenOf = (id: string) => {
+      const listed = JSON.stringify(tasks.find((task) => task.id === id)?.subtasks ?? []);
+      return tasks.filter((task) => listed.includes(task.id));
+    };
+    const roots = tasks.filter((task) => !tasks.some((parent) => childrenOf(parent.id).includes(task)));
+    expect(roots).toHaveLength(1);
+    expect(roots[0].title).toBe('Ship a chess engine as an MCP server on Cloudflare Workers');
+
+    const stages = childrenOf(roots[0].id);
+    expect(stages).toHaveLength(5);
+    // Every stage has steps of its own, which is the depth the tree exists to carry.
+    for (const stage of stages) {
+      expect(childrenOf(stage.id).length).toBeGreaterThan(0);
+    }
+    expect(tasks).toHaveLength(1 + 5 + stages.flatMap((stage) => childrenOf(stage.id)).length);
+
+    // Nothing has started: this space is a plan to run, not a project caught mid-flight.
+    expect(tasks.every((task) => task.status === 'todo')).toBe(true);
+
+    // Four of the five stages depend on their predecessor; the first depends on nothing.
+    expect(tasks.filter((task) => Array.isArray(task.dependsOn) && task.dependsOn.length > 0)).toHaveLength(4);
+  });
+
+  test(
+    "only the reader's own steps are assigned to them, and the two GitHub ones are last",
+    { timeout: 120_000 },
+    async ({ expect }) => {
+      const { json } = await EffectEx.runPromise(buildArchive(StockfishSpace.make()));
+      const objects: Array<{ '@type'?: string; 'id': string; 'title'?: string; 'assignee'?: unknown }> =
+        JSON.parse(json).objects;
+      const tasks = objects.filter((object) => object['@type']?.includes('type.task:'));
+
+      // The reader owns only what an agent cannot do: two Composer settings, and the three steps that
+      // need a browser. Nothing asks for an Anthropic key, and nothing asks for a Cloudflare login to
+      // DEPLOY — claiming the account afterwards is the one Cloudflare step that is theirs, and it is
+      // ordered after the last redeploy because a claimed account is one the agent cannot update.
+      const mine = tasks.filter((task) => (task.assignee as { role?: string } | undefined)?.role === 'user');
+      expect(mine.map((task) => task.title)).toEqual([
+        'Select DeepSeek V4 Pro as the chat model',
+        'Claim the temporary Cloudflare account',
+        'Enable the Chess plugin',
+        'Create an empty GitHub repository for the server',
+        'Connect the GitHub credential, scoped to that repository',
+      ]);
+    },
+  );
+
+  test('the project binds the skill through its instructions', { timeout: 120_000 }, async ({ expect }) => {
+    const { json } = await EffectEx.runPromise(buildArchive(StockfishSpace.make()));
+    const objects: Array<{ '@type'?: string; 'id': string; 'skills'?: unknown }> = JSON.parse(json).objects;
+
+    const skill = objects.find((object) => object['@type']?.includes('type.skill'));
+    const instructions = objects.find((object) => object['@type']?.includes('type.instructions'));
+    expect(skill?.id).toBeDefined();
+    // A Skill object in the space is not enabled by proximity: `instructions.skills` is the binding.
+    expect(JSON.stringify(instructions?.skills)).toContain(String(skill?.id));
+  });
+});

package/src/samples/stockfish/StockfishSpace.ts

@@ -0,0 +1,70 @@
+//
+// 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 { Ref } from '@dxos/echo';
+
+import { Docs } from './docs.ts';
+import { ChessGame } from './game.ts';
+import { ProjectPhase } from './project.ts';
+import { DevelopmentSkill } from './skill.ts';
+import { Tasks } from './tasks.ts';
+import { REFERENCE } from './util.ts';
+
+const phases = {
+  skill: DevelopmentSkill,
+  docs: Docs,
+  game: ChessGame,
+  tasks: Tasks,
+  project: ProjectPhase,
+};
+
+/**
+ * A starting point rather than a finished world: the brief for a chess engine exposed as an MCP
+ * server on Cloudflare Workers, the plan to build it as a task tree nothing has started on, a
+ * position to point the finished thing at, and the development-preferences skill a chat working it
+ * runs with.
+ *
+ * The other space templates depict a project mid-flight; this one is meant to be RUN. Every task is
+ * `todo`, the design artifact the first stage produces is deliberately absent, and neither the MCP
+ * server record nor a repository is seeded — stages four and five create them.
+ *
+ * It is deliberately reachable with no credentials but the reader's own DXOS identity: the chat runs
+ * DeepSeek through the edge, the first deploy uses wrangler's unauthenticated mode, and the only two
+ * consent screens are in the last stage.
+ */
+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: 'Chess MCP on Workers', icon: 'shield-star', hue: 'amber' },
+    reference: REFERENCE,
+    phases,
+    build: (phases) =>
+      Effect.gen(function* () {
+        const skill = yield* phases.skill();
+        const docs = yield* phases.docs();
+        const game = yield* phases.game();
+        const tasks = yield* phases.tasks();
+        yield* phases.project({ docs, tasks, skill, game });
+
+        // The root holds collections only. Project/TaskSet/Task/Skill/Game are not collection-item
+        // types, so they live directly in the space DB and surface through their own containers.
+        yield* SampleSpace.collection('Documents', [Ref.make(docs.brief)]);
+      }),
+  });
+
+export const makeTemplate = (): AppCapabilities.SpaceTemplate =>
+  SampleSpace.makeTemplate({
+    id: 'org.dxos.plugin-debug.template.stockfish',
+    description:
+      'A brief, a five-stage plan as a task tree, a position to test against, and the skill for building it in a sandbox.',
+    definition: make(),
+  });

package/src/samples/stockfish/docs.ts

@@ -0,0 +1,65 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+import { Database } from '@dxos/echo';
+import * as Markdown from '@dxos/plugin-markdown/Markdown';
+
+//
+// The one artifact this space ships with.
+//
+// The brief is INPUT — what to build and what not to. The design (the tool surface and the request
+// path) is the first task's output, so it is deliberately absent: seeding it would answer the
+// question the project exists to work through.
+//
+
+const BRIEF_MD = `# Brief — chess engine as an MCP server on Workers
+
+A chess engine any chat in this space can consult, built as one Cloudflare Worker speaking MCP and
+registered against this space. The reader runs it end to end from the assistant, with no Cloudflare
+account, no GitHub account until the last stage, and no Anthropic key at any point.
+
+## Shape
+
+One Worker. One Streamable-HTTP MCP endpoint on it. Two tools — evaluate a position, and name the
+best move from it — over a chess engine compiled to WebAssembly and bundled into the Worker.
+
+## Constraints
+
+- **No database.** Every request carries the position as FEN; the Worker holds nothing between
+  requests, so it can be evicted and restarted freely.
+- **No accounts to start.** The first deploy uses wrangler's unauthenticated mode, which mints a
+  temporary Cloudflare account and prints a URL to claim it. GitHub comes last, and only to publish.
+- **No Anthropic key.** The chat driving this runs DeepSeek V4 Pro through the DXOS edge.
+- **Written by the assistant, not delegated.** The assistant edits and runs things itself in the
+  sandbox. The coding harness pre-installed in the sandbox image is not the path — see the
+  Development skill.
+- **Bounded search.** A fixed, low depth or a fixed millisecond budget per call. An MCP tool that
+  thinks for thirty seconds is a tool a chat gives up on.
+
+## Out of scope
+
+Opening books, endgame tablebases, multi-PV analysis, game persistence, per-caller rate limiting,
+and authentication beyond the shared key the MCP server record already carries.
+
+## Done means
+
+The Worker is registered as an MCP server in this space, and a chat opened on the seeded game
+answers "what is the best move here?" from the engine's reply rather than from its own knowledge —
+visible as a tool call in the transcript.
+`;
+
+export type DocsResult = { brief: Markdown.Document };
+
+/** The project's brief: the requirement the first task designs against. */
+export const Docs: SampleSpace.Phase<DocsResult> = SampleSpace.phase('docs', {
+  schemas: [Markdown.Document],
+  run: () =>
+    Effect.gen(function* () {
+      const brief = yield* Database.add(Markdown.make({ name: 'BRIEF.md', content: BRIEF_MD }));
+      return { brief };
+    }),
+});

package/src/samples/stockfish/game.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+import { Database } from '@dxos/echo';
+import * as Chess from '@dxos/plugin-chess/Chess';
+import * as Game from '@dxos/plugin-game/Game';
+
+//
+// The thing the finished server gets pointed at.
+//
+// The last stage's definition of done is a chat answering "what is the best move here?" from the
+// engine rather than from what the model already knows, so the space ships a position to ask it
+// about. Seeded as a game rather than a bare FEN in the brief because the chess chat opens on a
+// Game — a position the reader has to paste in is a step that will be skipped.
+//
+// A Spanish opening five moves deep: quiet, materially level, and with no forced tactic, so a
+// plausible answer produced without calling the tool is not accidentally the right one.
+//
+
+const OPENING_PGN = '1. e4 e5 2. Nf3 Nc6 3. Bb5 a6 4. Ba4 Nf6 5. O-O Be7 *';
+
+export type GameResult = { game: Game.Game; state: Chess.State };
+
+/** The position the deployed engine is asked about, as a game the chess chat can open. */
+export const ChessGame: SampleSpace.Phase<GameResult> = SampleSpace.phase('game', {
+  schemas: [Game.Game, Chess.State],
+  run: () =>
+    Effect.gen(function* () {
+      const state = yield* Database.add(Chess.make({ pgn: OPENING_PGN }));
+      const game = yield* Database.add(
+        Game.make({
+          name: 'Test position — Spanish, 5 moves in',
+          players: [
+            { role: 'white', name: 'You' },
+            { role: 'black', name: 'Engine' },
+          ],
+          variant: state,
+        }),
+      );
+
+      return { game, state };
+    }),
+});

package/src/samples/stockfish/project.ts

@@ -0,0 +1,87 @@
+//
+// 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 { Outline } from '@dxos/types';
+
+import { type DocsResult } from './docs.ts';
+import { type GameResult } from './game.ts';
+import { type SkillResult } from './skill.ts';
+import { type TasksResult } from './tasks.ts';
+
+//
+// The project that ties the plan, the brief, the test position and the skill together.
+//
+
+export type ProjectInput = { docs: DocsResult; tasks: TasksResult; skill: SkillResult; game: GameResult };
+
+export type ProjectResult = { project: Project.Project; instructions: Instructions.Instructions };
+
+const INSTRUCTIONS = `Keep the Development skill enabled for the whole session — it carries how work \
+is tracked, where the code is written and what counts as evidence, and it applies to every turn \
+rather than to one task. Do not disable it to save context.
+
+Build the MCP server described in BRIEF.md by working the task tree in order, and set each task's \
+status as you finish it: the task list is how the reader follows this run.
+
+Write the code yourself in one sandbox, driving it through the Sandbox skill. The sandbox image \
+ships a coding agent of its own; do not delegate this project to it — it has none of this space's \
+context, and its output would land on a container filesystem rather than in this project.
+
+Verify every stage before starting the next, and redeploy in the two that change Worker code — a \
+design or registration stage has nothing to deploy. File what you produce — the design, the Worker \
+URL, the tool responses — as artifacts on this project rather than leaving it in the chat. The \
+claim URL that the first deploy prints is a bearer credential for the account: give it to me \
+directly and file it nowhere.
+
+This project needs no Anthropic key and no Cloudflare login. 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 carries the brief as an artifact.
+ *
+ * The skill reaches a chat through `instructions.skills`, which is the only binding path: a Skill
+ * object sitting in the space is not enabled by proximity. Binding makes it available; the text
+ * above is what keeps it on. The Sandbox skill cannot be bound the same way — it is contributed by
+ * a plugin under a key rather than stored here — so the text names it instead.
+ *
+ * No `repo` and no `McpServer`: the repository is created in stage five and the server record in
+ * stage four, and seeding either would name a URL that does not exist.
+ */
+export const ProjectPhase: SampleSpace.Phase<ProjectResult, ProjectInput> = SampleSpace.phase('project', {
+  // `Outline.Outline` is not created here directly: `Project.make` builds one for the project's own
+  // outline, and a phase has to declare every type it persists or the space cannot register it.
+  schemas: [Project.Project, Instructions.Instructions, Outline.Outline],
+  run: ({ docs, tasks, skill, game }: ProjectInput) =>
+    Effect.gen(function* () {
+      const instructions = yield* Database.add(
+        Instructions.make({
+          name: 'Chess MCP on Workers',
+          text: INSTRUCTIONS,
+          skills: [Ref.make(skill.skill)],
+          objects: [Ref.make(docs.brief), Ref.make(tasks.taskSet), Ref.make(game.game)],
+        }),
+      );
+
+      const project = yield* Database.add(
+        Project.make({
+          name: 'Chess MCP on Workers',
+          description:
+            'A chess engine served from one Cloudflare Worker as an MCP server, registered against this space so any chat can ask it for a move.',
+          status: 'active',
+          instructions: Ref.make(instructions),
+          taskSet: Ref.make(tasks.taskSet),
+          artifacts: [Ref.make(docs.brief)],
+        }),
+      );
+
+      return { project, instructions };
+    }),
+});