outask 0.0.0-stage → 1.7.0

package/README.md

@@ -1,3 +1,39 @@
-# Temporary Holding Version
+# Outask
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Outask is a lightweight task tracker that keeps tasks in readable JSON alongside your project code. Use its CLI from your terminal, or connect local AI agents through the optional MCP adapter.
+
+## Install
+
+Requires Node.js 22.23.3 or later and npm on PATH.
+
+```sh
+npm install -g outask
+outask --version
+```
+
+## CLI quick start
+
+Run from your project directory. Replace `1` with the ID returned by `create`.
+
+```sh
+outask create --title "Write release notes"
+outask list
+outask get 1
+outask update 1 --title "Review release notes"
+outask transition 1 --status done
+```
+
+See the [operator reference](https://github.com/henryh/outask/blob/main/app/README.md) for project selection, task fields and configured statuses.
+
+## Connect MCP
+
+Configure your MCP client to run `outask mcp`. Tool calls select your repository with an absolute `project_path`. See [MCP setup](https://github.com/henryh/outask/blob/main/app/mcp/README.md) for client configuration.
+
+## Update or remove
+
+```sh
+npm update -g outask
+npm uninstall -g outask
+```
+
+Uninstall removes the npm package and its commands; project tasks, skills, configuration and cache remain. See [installation and updates](https://github.com/henryh/outask/blob/main/app/README.md#installation-and-updates) for lifecycle details.

package/bin/outask

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+process.title = 'outask';
+// Node resolves this entry's real path before loading its relative modules.
+import('../runtime.cjs').then(() => import('../cli.mjs')).then(({ main }) => main(process.argv.slice(2))).catch((error) => {
+  process.stderr.write(`STARTUP_ERROR: ${error.message}\n`);
+  process.exitCode = 1;
+});

package/bin/tasks

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+process.title = 'outask';
+// Node resolves this entry's real path before loading its relative modules.
+import('../runtime.cjs').then(() => import('../cli.mjs')).then(({ main }) => main(process.argv.slice(2))).catch((error) => {
+  process.stderr.write(`STARTUP_ERROR: ${error.message}\n`);
+  process.exitCode = 1;
+});

package/cli.mjs

@@ -0,0 +1,151 @@
+import { parseArgs } from 'node:util';
+import { readFileSync } from 'node:fs';
+import { fail } from './src/errors.mjs';
+import { selectProject } from './src/projects.mjs';
+import { parseProject, projectHelp } from './scripts/arguments.mjs';
+import { reportError } from './scripts/output.mjs';
+import * as list from './scripts/list-tasks.mjs';
+import * as search from './scripts/search-tasks.mjs';
+import * as get from './scripts/get-task.mjs';
+import * as getMany from './scripts/get-tasks.mjs';
+import * as deps from './scripts/inspect-blockers.mjs';
+import * as validate from './scripts/validate-task-stores.mjs';
+import * as create from './scripts/create-task.mjs';
+import * as update from './scripts/update-task.mjs';
+import * as hook from './scripts/hook.mjs';
+import * as schema from './scripts/schema.mjs';
+import { lifecycleCommand } from './scripts/lifecycle.mjs';
+import { distributionVersion } from './src/version.mjs';
+
+const commands = {
+  list, search, get, 'get-many': getMany, deps, validate, create, update, hook, schema,
+  transition: lifecycleCommand(false),
+};
+const version = distributionVersion(JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version);
+const commandGuide = `  list       List tasks
+  search     Search task content
+  get        Read one task
+  get-many   Read several tasks
+  deps       Inspect task blockers
+  validate   Validate task stores
+  schema     Inspect or save the task schema
+  create     Create a task
+  update     Update a task
+  transition Change a task's status
+  hook       Install or remove pre-commit validation
+  mcp        Start the MCP adapter`;
+const guide = `Usage: outask <command> [options]
+
+${commandGuide}
+
+Task commands use the current project directory by default.
+Command options: outask <command> --help. Full guide: outask --help.
+Installed version: outask --version.
+`;
+const selectionHelp = `Select one project with a positional path, --project-path <path>, or --project <name>.
+With no selector, use the current working directory. Selectors cannot be combined.
+  --config <path>      Program config; overrides TASK_TRACKER_CONFIG, then XDG_CONFIG_HOME
+                      (default: the platform Outask root/config.json). Paths bypass name mappings.
+  --schema-path <file> Project-relative task schema; distinct from registry --config.
+Names resolve immediate projects_root children and explicit projects mappings;
+conflicting locations fail. No parent search or automatic worktree selection.
+`;
+const help = `Outask manages project tasks stored as JSON alongside your code.
+
+Usage: outask <command> [options]
+
+${commandGuide}
+
+Tips:
+  Run commands from your project directory, or use --project-path <directory>.
+  Start with outask create --title "Your task", then outask list.
+  Use outask <command> --help for options and examples.
+
+Installed version: outask --version (or -v).
+Permanent equivalent command: tasks.
+Repository and documentation: https://github.com/henryh/outask
+`;
+
+export async function main(args) {
+  try {
+    const [name, ...rest] = args;
+    if (['--version', '-v'].includes(name)) {
+      if (rest.length) fail('INVALID_INPUT', 'outask --version accepts no arguments');
+      process.stdout.write(`Outask v${version}\n`);
+      return;
+    }
+    if (name === undefined) {
+      process.stdout.write(guide);
+      return;
+    }
+    if (['--help', '-h', 'help'].includes(name)) {
+      if (rest.length) fail('INVALID_INPUT', 'use outask <command> --help');
+      process.stdout.write(help);
+      return;
+    }
+    if (name === 'mcp') {
+      if (rest.length === 1 && ['--help', '-h'].includes(rest[0])) {
+        process.stdout.write('Usage: outask mcp\nStart the local stdio adapter; select the project in each tool call.\nPublished releases include the adapter and its dependencies.\nConfigure the client with command outask and argument mcp.\nSetup and tool contract: https://github.com/henryh/outask/blob/main/app/mcp/README.md\n');
+        return;
+      }
+      if (rest.length) fail('INVALID_INPUT', 'outask mcp accepts no options; select the project in each tool call');
+      const [major, minor, patch] = process.versions.node.split('.').map(Number);
+      if (major < 22 || (major === 22 && (minor < 23 || (minor === 23 && patch < 3)))) {
+        fail('INCOMPATIBLE_RUNTIME', 'MCP requires Node.js >=22.23.3');
+      }
+      let adapter;
+      try { adapter = await import('./mcp/server.mjs'); }
+      catch (error) {
+        if (error.code !== 'ERR_MODULE_NOT_FOUND') throw error;
+        fail('ADAPTER_NOT_INSTALLED', 'install the application dependencies with npm ci --prefix <checkout>/app --omit=dev; for an installed package, reinstall through its original distribution channel; see app/mcp/README.md');
+      }
+      await adapter.main();
+      return;
+    }
+    if (name === 'http') {
+      try { commands.http = await import('./http.mjs'); }
+      catch (error) {
+        if (error.code !== 'ERR_MODULE_NOT_FOUND') throw error;
+        fail('ADAPTER_NOT_INSTALLED', 'HTTP release integration is unfinished; use a source checkout');
+      }
+    }
+    if (!Object.hasOwn(commands, name)) fail('INVALID_INPUT', `unknown command ${name}; use outask --help`);
+    const command = commands[name];
+    const usage = command.usage.replace(/node app\/(?:scripts\/)?[^ ]+/, `outask ${name}`);
+    const { values, positionals, tokens } = parseArgs({ args: rest, allowPositionals: true, tokens: true, options: {
+      ...command.options, project: { type: 'string' }, 'project-path': { type: 'string' }, config: { type: 'string' },
+    } });
+    for (const option of ['project', 'project-path', 'config', 'schema-path']) {
+      if (tokens.filter((token) => token.kind === 'option' && token.name === option).length > 1) {
+        fail('INVALID_INPUT', `--${option} may be supplied only once`);
+      }
+    }
+    if (values.help) {
+      process.stdout.write(command.help.replace(command.usage, usage).replace(projectHelp, selectionHelp)
+        .replace('Use list-tasks.mjs and get-task.mjs', 'Use outask list and outask get'));
+      return;
+    }
+    const withId = !['list', 'get-many', 'validate', 'create', 'hook', 'http', 'schema'].includes(name);
+    const selected = parseProject(positionals, usage, withId);
+    const hasPath = positionals.length > (withId ? 1 : 0);
+    if (Number(hasPath) + Number(values.project !== undefined) + Number(values['project-path'] !== undefined) > 1) {
+      fail('INVALID_INPUT', 'select exactly one project: positional path, --project-path or --project');
+    }
+    if (values['project-path'] === '' || values.config === '' || values['schema-path'] === '') fail('INVALID_INPUT', 'paths must not be empty');
+    const project = selectProject({ name: values.project, path: values['project-path'] ?? selected.project, config: values.config });
+    const forwarded = [];
+    for (const token of tokens) {
+      if (token.kind !== 'option' || ['project', 'project-path', 'config'].includes(token.name)) continue;
+      forwarded.push(token.value === undefined ? token.rawName : `--${token.name}=${token.value}`);
+    }
+    try {
+      await command.main([project, ...(withId ? [selected.id] : []), ...forwarded],
+        { args: rest, tokens, invocation: ['outask', name], config: values.config });
+    } catch (error) {
+      if (error.message === command.usage) error.message = usage;
+      throw error;
+    }
+  } catch (error) {
+    reportError(error);
+  }
+}

package/mcp/package-lock.json

@@ -0,0 +1,175 @@
+{
+  "name": "outask-mcp",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "outask-mcp",
+      "version": "0.1.0",
+      "license": "AGPL-3.0-only",
+      "devDependencies": {
+        "@modelcontextprotocol/client": "2.3.0"
+      },
+      "engines": {
+        "node": ">=22.23.3"
+      }
+    },
+    "node_modules/@modelcontextprotocol/client": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/client/-/client-2.3.0.tgz",
+      "integrity": "sha512-pbHtGj6EeFCHngFE8gtNPaKrsj8Mb1IMw45BLcaPML/m2WTxI7pyYmeNQvaux88Lw8BSO5r7nyRbUyIkICmGrg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@modelcontextprotocol/core": "2.3.0",
+        "cross-spawn": "^7.0.5",
+        "eventsource": "^3.0.2",
+        "eventsource-parser": "^3.0.8",
+        "jose": "^6.1.3",
+        "pkce-challenge": "^5.0.0",
+        "zod": "^4.2.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@modelcontextprotocol/core": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/core/-/core-2.3.0.tgz",
+      "integrity": "sha512-09BHFaNVBe5pB2AhzCfLj0cqmsKLERvZQ4FblzP90UMGLaXVqdZPByFjURwsUYCmxonUW2yAwgTTvle+8O2/8w==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "zod": "^4.2.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/eventsource": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz",
+      "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eventsource-parser": "^3.0.1"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/eventsource-parser": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.1.1.tgz",
+      "integrity": "sha512-EKN1vKAMcZ8MlYMpaNuxN6R9yakzH6uajHcHVTqWJzvu5pWw9DyhbP35HH8MVBQ+dZjAfDxk+A8NiR9KWaXiyQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/jose": {
+      "version": "6.2.12",
+      "resolved": "https://registry.npmjs.org/jose/-/jose-6.2.12.tgz",
+      "integrity": "sha512-9NiFmJEex0sy2Dk58j2UGBSHgUs2ypF9eZSu4L6vjOX3Dp96Sw1F3uL+H+D1sx02jZZdzUT0HgvCy59CuvXcWw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/panva"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/pkce-challenge": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.1.tgz",
+      "integrity": "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.20.0"
+      }
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/zod": {
+      "version": "4.6.6",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.6.6.tgz",
+      "integrity": "sha512-4UmzQUF5fxvfcYHlbjBmejU+w+hbDnWFx4aS8kBx7nPBHcO2SqPbpAG8snbdg+Xse4pRefR98hgjFgIMCI/UhA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}

package/mcp/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "outask-mcp",
+  "version": "0.1.0",
+  "description": "Outask stdio MCP adapter for repository-local task tracking",
+  "private": true,
+  "author": "Henry <me@henrydev.me>",
+  "license": "AGPL-3.0-only",
+  "type": "module",
+  "engines": {
+    "node": ">=22.23.3"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/client": "2.3.0"
+  }
+}

package/mcp/server.mjs

@@ -0,0 +1,132 @@
+import { McpServer } from '@modelcontextprotocol/server';
+import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';
+import { z } from 'zod/v4';
+import { inspectBlockers, maxDepth } from '../src/blockers.mjs';
+import { readConfig } from '../src/config.mjs';
+import { createTask } from '../src/create.mjs';
+import { errorText, fail } from '../src/errors.mjs';
+import { inputBytes, maxLimit } from '../src/limits.mjs';
+import { selectProject } from '../src/projects.mjs';
+import { jsonBytes } from '../src/response.mjs';
+import { searchTasks } from '../src/search.mjs';
+import { countTasks, getTask, getTasks, listTasks } from '../src/tasks.mjs';
+import { deleteTask, transitionTask } from '../src/transition.mjs';
+import { updateTask } from '../src/update.mjs';
+import { validateProject } from '../src/validation.mjs';
+import { inspectSchema, materialiseSchema } from '../src/schema.mjs';
+
+const text = z.string().min(1);
+const id = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const limit = z.number().int().min(1).max(maxLimit).optional()
+  .describe(`Integer limit from 1 to ${maxLimit}; default 10. For more paged results, use the returned continuation.`);
+const selection = {
+  project: text.optional().describe('Configured project name; exclusive with project_path.'),
+  project_path: text.optional().describe('Project directory; defaults to server working directory.'),
+  config: text.optional().describe('Name registry path; otherwise TASK_TRACKER_CONFIG or the Outask default registry.'),
+  schema_path: text.optional().describe('Project-relative task schema; overrides automatic default/legacy selection.'),
+};
+const reading = {
+  stores: z.array(text).optional().describe('Store names; ["all"] includes retained history. Exclusive with group.'),
+  group: z.enum(['Active', 'Done', 'Archive']).optional(),
+  fields: z.array(text).optional().describe('Field projection; ["all"] includes extension fields.'),
+  no_cache: z.boolean().optional().describe('Default false; omit for normal reads, which can use a freshness-checked cache when enabled and otherwise fall back to authoritative JSON. Set true only for explicit JSON-only reads or cache diagnostics; true never opens or refreshes the cache.'),
+};
+const writing = {
+  store: text.optional().describe('Destination store, when ambiguous.'),
+  if_updated_at: text.optional().describe('Exact last-read updated_at; rejects stale writes.'),
+};
+const object = z.record(z.string(), z.unknown());
+const writes = ({ store, if_updated_at }) => ({ store, ifUpdatedAt: if_updated_at });
+const reads = ({ no_cache, ...args }) => ({ ...args, noCache: no_cache ?? false });
+
+export function createServer() {
+  const server = new McpServer({ name: 'outask', version: '0.1.0' });
+  function register(name, description, shape, operation, cacheRead = false) {
+    server.registerTool(name, {
+      description,
+      inputSchema: z.strictObject({ ...selection, ...shape }),
+    }, async (args) => {
+      try {
+        if (jsonBytes(args, 0, inputBytes) > inputBytes) fail('INPUT_TOO_LARGE', 'tool arguments exceed 8 MiB');
+        const { project, project_path, config, schema_path, ...input } = args;
+        if (project !== undefined && project_path !== undefined) {
+          fail('INVALID_INPUT', 'select exactly one project: project or project_path');
+        }
+        const path = selectProject({ name: project, path: project_path, config });
+        const advisories = [];
+        const result = operation(path, {
+          ...input, schemaPath: schema_path,
+          ...(cacheRead ? { onAdvisory: (advisory) => advisories.push(advisory) } : {}),
+        }, { config });
+        // Core operations bound their complete result before committing any write.
+        // Avoid duplicating the payload in text, which would double the wire budget.
+        return {
+          content: [
+            { type: 'text', text: 'Task operation completed; see structuredContent.' },
+            ...advisories.map((advisory) => ({ type: 'text', text: `Advisory ${advisory.code}: ${advisory.message}` })),
+          ],
+          structuredContent: result,
+        };
+      } catch (error) {
+        const result = { code: error.code ?? 'INTERNAL_ERROR', message: errorText(error.message) };
+        return { isError: true, content: [{ type: 'text', text: `${result.code}: ${result.message}` }], structuredContent: { error: result } };
+      }
+    });
+  }
+  register('list_tasks', `List tasks (Active by default), with bounded pagination (maximum limit ${maxLimit}). Defaults: id,title,status; limit 10; offset 0; sort id.`, {
+    ...reading, limit, offset: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+    filters: z.array(z.strictObject({ field: text, value: z.string() })).optional(),
+    status: text.optional().describe('Exact case-sensitive status filter.'),
+    ids: z.array(id).optional(), sort: text.optional(), desc: z.boolean().optional(),
+    count: z.boolean().optional().describe('Return only the matching count; omit pagination and projection arguments.'),
+  }, (path, { desc, count, status, filters = [], ...args }) => {
+    const query = { ...reads(args), descending: desc, filters: [...filters, ...(status === undefined ? [] : [{ field: 'status', value: status }])] };
+    return count ? { count: countTasks(path, query) } : listTasks(path, query);
+  }, true);
+  register('get_task', 'Get one task, including all fields by default. Active only unless stores or group select history.', {
+    ...reading, id,
+  }, (path, { id, ...args }) => getTask(path, id, reads(args)), true);
+  register('get_tasks', 'Get requested tasks in caller ID order, report missing IDs and continue with a bounded cursor.', {
+    ...reading, ids: z.array(id).min(1), limit, cursor: text.optional(),
+  }, (path, { ids, ...args }) => getTasks(path, ids, reads(args)), true);
+  register('search_tasks', 'Search task content with bounded results, snippets and stable continuation.', {
+    ...reading, query: text, search_fields: z.array(text).optional(), limit, cursor: text.optional(),
+  }, (path, { query, search_fields, ...args }, { config }) => searchTasks(path, query, {
+    ...reads(args), searchFields: search_fields, slowQueryMs: readConfig(config).slowQueryMs, refreshMode: 'detached',
+  }), true);
+  register('create_task', 'Create a task with a safe project-wide ID. Returns the complete persisted record.', {
+    task: object.describe('Task fields; title required, status defaults from project. Extensions preserved.'), store: writing.store,
+  }, (path, { task, store, schemaPath }) => createTask(path, task, { store, schemaPath }));
+  register('update_task', 'Patch a retained task atomically. Duplicate additions are silent no-ops. Returns the complete record.', {
+    ...writing, id, patch: z.strictObject({
+      set: object.optional(), add: z.record(z.string(), z.array(z.unknown())).optional(),
+      remove: z.record(z.string(), z.array(z.unknown())).optional(), unset: z.array(text).optional(),
+    }),
+  }, (path, args) => updateTask(path, args.id, args.patch, { ...writes(args), schemaPath: args.schemaPath }));
+  register('transition_task', 'Move a retained task to an exact configured status; Active blockers prevent starting. Returns the complete record.', {
+    ...writing, id, status: text,
+  }, (path, args) => transitionTask(path, args.id, args.status, { ...writes(args), schemaPath: args.schemaPath }));
+  register('delete_task', 'Archive a task with its ID and fields retained; optionally select an Archive status. Returns the complete record.', {
+    ...writing, id, status: text.optional(),
+  }, (path, args) => deleteTask(path, args.id, { ...writes(args), status: args.status, schemaPath: args.schemaPath }));
+  register('inspect_blockers', 'Inspect exact Active blockers and eligibility, plus a bounded graph. Cycles are diagnostics; defaults: depth 1, limit 10.', {
+    id, limit: limit.describe(`Integer limit from 1 to ${maxLimit} graph edges; default 10. Additional edges are omitted and reported by graph.truncated.limit.`),
+    depth: z.number().int().min(1).max(maxDepth).optional(),
+    no_cache: reading.no_cache,
+  }, (path, { id, ...args }) => inspectBlockers(path, id, reads(args)), true);
+  register('validate_project', 'Validate retained stores after manual edits and refresh service metadata without rewriting task records.', {}, validateProject);
+  register('inspect_schema', 'Inspect the complete effective project task schema as editable JSON; no task stores required.', {}, inspectSchema);
+  register('materialise_schema', 'Write the effective schema at the selected project schema path without changing task records. Existing schema requires replace.', {
+    replace: z.boolean().optional().describe('Explicitly allow replacement of the existing schema; custom fields are preserved.'),
+  }, materialiseSchema);
+  return server;
+}
+
+export async function main() {
+  process.title = 'outask';
+  const server = createServer();
+  const transport = new StdioServerTransport(process.stdin, process.stdout, { maxBufferSize: inputBytes });
+  server.server.onerror = (error) => process.stderr.write(`${errorText(error.message)}\n`);
+  process.stdin.once('end', () => { void server.close(); });
+  await server.connect(transport);
+}