toolcraft 0.0.93 → 0.0.95

package/dist/testing/parity.js

@@ -0,0 +1,384 @@
+import { isDeepStrictEqual } from "node:util";
+import { McpClient, McpError, ERROR_INVALID_PARAMS, createSdkTestPair } from "tiny-mcp-client";
+import { runCLI } from "../cli.js";
+import { UserError } from "../index.js";
+import { createMCPServer } from "../mcp.js";
+import { filterSchemaForScope } from "../schema-scope.js";
+import { createSDK } from "../sdk.js";
+class SurfaceScopeError extends Error {
+    constructor(surface, path) {
+        super(`Command "${path.join(" ")}" is filtered out of the ${surface} surface.`);
+        this.name = "SurfaceScopeError";
+    }
+}
+function splitWords(value) {
+    const words = [];
+    let current = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index] ?? "";
+        const lower = char.toLowerCase();
+        const upper = char.toUpperCase();
+        const isSeparator = char === "-" || char === "_" || char === " " || char === ".";
+        if (isSeparator) {
+            if (current.length > 0) {
+                words.push(current.toLowerCase());
+                current = "";
+            }
+            continue;
+        }
+        const isUppercase = char !== lower && char === upper;
+        const previous = value[index - 1];
+        const next = value[index + 1];
+        const previousIsLowercase = previous !== undefined &&
+            previous === previous.toLowerCase() &&
+            previous !== previous.toUpperCase();
+        const nextIsLowercase = next !== undefined && next === next.toLowerCase() && next !== next.toUpperCase();
+        if (isUppercase && current.length > 0 && (previousIsLowercase || nextIsLowercase)) {
+            words.push(current.toLowerCase());
+            current = char;
+            continue;
+        }
+        current += char;
+    }
+    if (current.length > 0) {
+        words.push(current.toLowerCase());
+    }
+    return words;
+}
+function formatName(value, casing) {
+    const words = splitWords(value);
+    if (casing === "camel") {
+        return words
+            .map((word, index) => index === 0 ? word : `${word.slice(0, 1).toUpperCase()}${word.slice(1)}`)
+            .join("");
+    }
+    return words.join(casing === "kebab" ? "-" : "_");
+}
+function unwrapOptional(schema) {
+    return schema.kind === "optional" ? unwrapOptional(schema.inner) : schema;
+}
+function mapUnknownMCPObject(value) {
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [formatName(key, "snake"), child]));
+}
+function filterParams(schema, params, surface) {
+    const filtered = filterSchemaForScope(schema, surface);
+    if (filtered?.kind !== "object") {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(filtered.shape).flatMap(([key, childSchema]) => {
+        const value = params[key];
+        if (value === undefined) {
+            return [];
+        }
+        const unwrapped = unwrapOptional(childSchema);
+        if (unwrapped.kind === "object" &&
+            typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)) {
+            return [[key, filterParams(unwrapped, value, surface)]];
+        }
+        return [[key, value]];
+    }));
+}
+function mapMCPValue(schema, value) {
+    const unwrapped = unwrapOptional(schema);
+    if (value === null || value === undefined) {
+        return value;
+    }
+    switch (unwrapped.kind) {
+        case "array":
+            return Array.isArray(value) ? value.map((item) => mapMCPValue(unwrapped.item, item)) : value;
+        case "object": {
+            if (typeof value !== "object" || Array.isArray(value)) {
+                return value;
+            }
+            return Object.fromEntries(Object.entries(value).map(([key, child]) => {
+                const childSchema = unwrapped.shape[key];
+                return [
+                    formatName(key, "snake"),
+                    childSchema === undefined ? child : mapMCPValue(childSchema, child)
+                ];
+            }));
+        }
+        case "record":
+            return typeof value === "object" && !Array.isArray(value)
+                ? Object.fromEntries(Object.entries(value).map(([key, child]) => [key, mapMCPValue(unwrapped.value, child)]))
+                : value;
+        case "oneOf": {
+            if (typeof value !== "object" || Array.isArray(value)) {
+                return value;
+            }
+            const objectValue = value;
+            const discriminator = objectValue[unwrapped.discriminator];
+            const branch = typeof discriminator === "string" ? unwrapped.branches[discriminator] : undefined;
+            return branch === undefined
+                ? mapUnknownMCPObject(objectValue)
+                : mapMCPValue(branch, objectValue);
+        }
+        case "union": {
+            if (typeof value !== "object" || Array.isArray(value)) {
+                return value;
+            }
+            const objectValue = value;
+            const branch = unwrapped.branches.find((candidate) => Object.keys(candidate.shape).every((key) => candidate.shape[key]?.kind === "optional" ||
+                Object.prototype.hasOwnProperty.call(objectValue, key)));
+            return branch === undefined
+                ? mapUnknownMCPObject(objectValue)
+                : mapMCPValue(branch, objectValue);
+        }
+        case "boolean":
+        case "enum":
+        case "json":
+        case "number":
+        case "string":
+            return value;
+    }
+}
+function success(value) {
+    return { ok: true, value, error: undefined };
+}
+function failure(error) {
+    return { ok: false, value: undefined, error };
+}
+async function runSDK(root, resolved, params, options) {
+    if (!resolved.command.scope.includes("sdk")) {
+        return failure(new SurfaceScopeError("sdk", resolved.path));
+    }
+    try {
+        let member = createSDK(root, options);
+        for (const segment of resolved.path) {
+            member = member[formatName(segment, "camel")];
+        }
+        if (typeof member !== "function") {
+            throw new Error(`SDK command "${resolved.path.join(".")}" is not callable.`);
+        }
+        return success(await member(filterParams(resolved.command.params, params, "sdk")));
+    }
+    catch (error) {
+        return failure(error);
+    }
+}
+function parseMcpValue(result, reference) {
+    if (result.structuredContent !== undefined) {
+        return result.structuredContent;
+    }
+    const text = result.content
+        .filter((item) => item.type === "text" && item.text !== undefined)
+        .map((item) => item.text)
+        .join("\n");
+    if (text.length === 0) {
+        return undefined;
+    }
+    if (reference?.ok === true && isDeepStrictEqual(text, reference.value)) {
+        return text;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+async function runMCP(root, resolved, params, options, reference) {
+    if (!resolved.command.scope.includes("mcp")) {
+        return failure(new SurfaceScopeError("mcp", resolved.path));
+    }
+    const server = createMCPServer(root, {
+        ...options,
+        name: `${root.name}-parity`,
+        version: "0.0.0",
+        casing: "snake"
+    });
+    const client = new McpClient({
+        clientInfo: { name: "toolcraft-parity", version: "0.0.0" }
+    });
+    const pair = await createSdkTestPair(server, () => client);
+    try {
+        const toolName = [root.name, ...resolved.path]
+            .map((segment) => formatName(segment, "snake"))
+            .join("__");
+        const argumentsValue = mapMCPValue(resolved.command.params, filterParams(resolved.command.params, params, "mcp"));
+        const result = await client.callTool({ name: toolName, arguments: argumentsValue });
+        return success(parseMcpValue(result, reference));
+    }
+    catch (error) {
+        if (error instanceof McpError && error.code === ERROR_INVALID_PARAMS) {
+            return failure(new UserError(error.message));
+        }
+        return failure(error);
+    }
+    finally {
+        await pair.cleanup();
+    }
+}
+function valueAtPath(value, path) {
+    return path.reduce((current, segment) => typeof current === "object" && current !== null
+        ? current[segment]
+        : undefined, value);
+}
+function appendCLIValue(argv, flag, value) {
+    if (typeof value === "boolean") {
+        argv.push(value ? flag : `--no-${flag.slice(2)}`);
+        return;
+    }
+    if (Array.isArray(value)) {
+        argv.push(flag, ...value.map((item) => String(item)));
+        return;
+    }
+    argv.push(flag, typeof value === "object" ? JSON.stringify(value) : String(value));
+}
+function appendCLIFlags(argv, schema, params, positionals, sourcePath = [], flagPath = []) {
+    for (const [key, rawSchema] of Object.entries(schema.shape)) {
+        const nextSourcePath = [...sourcePath, key];
+        const nextFlagPath = [...flagPath, formatName(key, "kebab")];
+        const displayPath = nextSourcePath.join(".");
+        const value = params[key];
+        if (value === undefined || positionals.has(displayPath)) {
+            continue;
+        }
+        const childSchema = unwrapOptional(rawSchema);
+        if (childSchema.kind === "object" &&
+            typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)) {
+            appendCLIFlags(argv, childSchema, value, positionals, nextSourcePath, nextFlagPath);
+            continue;
+        }
+        if (childSchema.kind === "record" &&
+            typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)) {
+            for (const [recordKey, recordValue] of Object.entries(value)) {
+                appendCLIValue(argv, `--${[...nextFlagPath, recordKey].join(".")}`, recordValue);
+            }
+            continue;
+        }
+        appendCLIValue(argv, `--${nextFlagPath.join(".")}`, value);
+    }
+}
+function buildCLIArgv(root, resolved, params) {
+    const visibleParams = filterParams(resolved.command.params, params, "cli");
+    const argv = ["node", root.name, ...resolved.path.map((segment) => formatName(segment, "kebab"))];
+    for (const positional of resolved.command.positional) {
+        const value = valueAtPath(visibleParams, positional.split("."));
+        if (Array.isArray(value)) {
+            argv.push(...value.map((item) => String(item)));
+        }
+        else if (value !== undefined) {
+            argv.push(String(value));
+        }
+    }
+    appendCLIFlags(argv, filterSchemaForScope(resolved.command.params, "cli"), visibleParams, new Set(resolved.command.positional));
+    argv.push("--output", "json", "--debug");
+    return argv;
+}
+function parseCLIValue(entries, reference) {
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (entry === undefined) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(entry);
+            if (reference?.ok !== true || isDeepStrictEqual(parsed, reference.value)) {
+                return parsed;
+            }
+            if (typeof parsed === "object" &&
+                parsed !== null &&
+                !Array.isArray(parsed) &&
+                Object.keys(parsed).length === 1 &&
+                Object.prototype.hasOwnProperty.call(parsed, "result") &&
+                isDeepStrictEqual(parsed.result, reference.value)) {
+                return reference.value;
+            }
+            if ((reference.value === null || reference.value === undefined) &&
+                isDeepStrictEqual(parsed, { ok: true })) {
+                return reference.value;
+            }
+            return parsed;
+        }
+        catch {
+            continue;
+        }
+    }
+    return entries.at(-1);
+}
+function parseCLIError(entries) {
+    const message = entries.at(-1) ?? "CLI command failed.";
+    const lines = message.split("\n");
+    const lastLine = lines.at(-1) ?? "";
+    if (lastLine.startsWith("Run ") && lastLine.endsWith(" --help for usage.")) {
+        lines.pop();
+    }
+    return new UserError(lines.join("\n"));
+}
+async function runCLISurface(root, resolved, params, options, reference) {
+    if (!resolved.command.scope.includes("cli")) {
+        return failure(new SurfaceScopeError("cli", resolved.path));
+    }
+    const entries = [];
+    const previousExitCode = process.exitCode;
+    process.exitCode = undefined;
+    try {
+        await runCLI(root, {
+            ...options,
+            argv: buildCLIArgv(root, resolved, params),
+            controls: { debug: true, output: true },
+            outputEmitter: (entry) => entries.push(entry)
+        });
+        if (process.exitCode !== undefined && process.exitCode !== 0) {
+            return failure(parseCLIError(entries));
+        }
+        return success(parseCLIValue(entries, reference));
+    }
+    catch (error) {
+        return failure(error);
+    }
+    finally {
+        process.exitCode = previousExitCode;
+    }
+}
+function errorIdentity(error) {
+    if (error instanceof Error) {
+        return { name: error.constructor.name, message: error.message };
+    }
+    return { name: typeof error, message: String(error) };
+}
+function outcomesAgree(left, right) {
+    if (left.ok !== right.ok) {
+        return false;
+    }
+    if (left.ok) {
+        return isDeepStrictEqual(left.value, right.value);
+    }
+    return isDeepStrictEqual(errorIdentity(left.error), errorIdentity(right.error));
+}
+function describeOutcome(surface, outcome) {
+    if (outcome.ok) {
+        return `${surface}: ok ${JSON.stringify(outcome.value)}`;
+    }
+    const error = errorIdentity(outcome.error);
+    return `${surface}: error ${error.name}: ${error.message}`;
+}
+export async function runParity(root, resolved, params, options) {
+    const sdk = await runSDK(root, resolved, params, options);
+    const mcp = await runMCP(root, resolved, params, options, sdk);
+    const cli = await runCLISurface(root, resolved, params, options, sdk);
+    const agree = outcomesAgree(sdk, mcp) && outcomesAgree(sdk, cli);
+    return {
+        sdk,
+        mcp,
+        cli,
+        agree,
+        ...(agree
+            ? {}
+            : {
+                diff: [
+                    `Surface outcomes differ for "${resolved.path.join(" ")}".`,
+                    describeOutcome("sdk", sdk),
+                    describeOutcome("mcp", mcp),
+                    describeOutcome("cli", cli)
+                ].join("\n")
+            })
+    };
+}

package/dist/testing/render-capture.d.ts

@@ -0,0 +1,6 @@
+import type { RenderPrimitives } from "../index.js";
+export interface RenderCapture {
+    primitives: RenderPrimitives;
+    output(): string;
+}
+export declare function createRenderCapture(): RenderCapture;

package/dist/testing/render-capture.js

@@ -0,0 +1,54 @@
+import { createLogger, light, renderTable, stripAnsi, withOutputFormat } from "toolcraft-design";
+const captureWidth = 80;
+function withoutColors(theme) {
+    return {
+        header: (text) => stripAnsi(theme.header(text)),
+        divider: (text) => stripAnsi(theme.divider(text)),
+        prompt: (text) => stripAnsi(theme.prompt(text)),
+        number: (text) => stripAnsi(theme.number(text)),
+        intro: (text) => stripAnsi(theme.intro(text)),
+        resolvedSymbol: stripAnsi(theme.resolvedSymbol),
+        errorSymbol: stripAnsi(theme.errorSymbol),
+        accent: (text) => stripAnsi(theme.accent(text)),
+        muted: (text) => stripAnsi(theme.muted(text)),
+        success: (text) => stripAnsi(theme.success(text)),
+        warning: (text) => stripAnsi(theme.warning(text)),
+        error: (text) => stripAnsi(theme.error(text)),
+        info: (text) => stripAnsi(theme.info(text)),
+        badge: (text) => stripAnsi(theme.badge(text)),
+        styles: {
+            accent: { ...theme.styles.accent },
+            muted: { ...theme.styles.muted },
+            success: { ...theme.styles.success },
+            warning: { ...theme.styles.warning },
+            error: { ...theme.styles.error },
+            info: { ...theme.styles.info }
+        }
+    };
+}
+function createCaptureTheme() {
+    return {
+        ...withoutColors(light),
+        intro: (text) => ` Poe - ${text} `
+    };
+}
+export function createRenderCapture() {
+    const output = [];
+    const captureTheme = createCaptureTheme();
+    const emit = (message) => {
+        output.push(stripAnsi(message));
+    };
+    return {
+        primitives: {
+            logger: createLogger(emit),
+            renderTable: (options) => withOutputFormat("terminal", () => stripAnsi(renderTable({
+                ...options,
+                theme: withoutColors(options.theme),
+                maxWidth: captureWidth
+            }))),
+            getTheme: () => captureTheme,
+            note: (message, title) => emit(title === undefined ? message : `${title}\n${message}`)
+        },
+        output: () => output.join("\n")
+    };
+}

package/dist/tiny-mcp-client.d.ts

@@ -0,0 +1 @@
+export * from "tiny-mcp-client";

package/dist/tiny-mcp-client.js

@@ -0,0 +1 @@
+export * from "tiny-mcp-client";

package/node_modules/@poe-code/agent-defs/package.json

@@ -1,4 +1,6 @@
 {
+  "name": "@poe-code/agent-defs",
+  "version": "0.0.1",
   "private": true,
   "license": "MIT",
   "type": "module",

package/node_modules/@poe-code/agent-human-in-loop/README.md

@@ -1,4 +1,4 @@
-## Overview
+# @poe-code/agent-human-in-loop
 
 `@poe-code/agent-human-in-loop` is a UI-only package for asking a human "approve this?" before an agent proceeds. The UI is providerized, sync vs async is the caller's choice because the API returns a Promise you can await immediately or hold and resolve later, and the package is approval-only: decline returns a declined outcome and can optionally capture a reason.
 
@@ -21,7 +21,13 @@ declare function mockProvider(
 - `osascriptProvider({ title?, binary? })` — macOS native dialog via `display dialog`. Mac only.
 - `mockProvider(answer | thunk)` — fixed or scripted answers for tests.
 
-## Env vars
+## Configuration Options
+
+- `osascriptProvider({ title?, binary? })`: optional dialog title and `osascript` binary path.
+- `mockProvider(answer)`: fixed approval result or callback for tests.
+- `requestApproval({ message, approveLabel?, declineLabel?, declineInputPrompt?, provider })`: approval prompt payload and provider.
+
+## Environment Variables
 
 None in v1.
 
@@ -29,6 +35,10 @@ None in v1.
 
 Messages and prompts are passed verbatim through the dialog; the provider escapes `"` and `\` for AppleScript string literals. Do not pass user-supplied AppleScript fragments expecting them to execute.
 
+## Manual QA
+
+Use [QA.md](QA.md) for package-level approval-flow checks after behavior changes.
+
 ## Example
 
 ```ts

package/node_modules/@poe-code/agent-human-in-loop/package.json

@@ -1,4 +1,6 @@
 {
+  "name": "@poe-code/agent-human-in-loop",
+  "version": "0.0.1",
   "private": true,
   "license": "MIT",
   "type": "module",

package/node_modules/@poe-code/agent-mcp-config/README.md

@@ -36,13 +36,13 @@ console.log(supportedAgents);
 
 `ApplyOptions` controls how mutations are applied:
 
-| Option | Type | Description |
-| ------ | ---- | ----------- |
-| `fs` | `FileSystem` | Filesystem adapter from `@poe-code/config-mutations`. |
-| `homeDir` | `string` | Home directory used to resolve `~` in agent config paths. |
-| `platform` | `"darwin" \| "linux" \| "win32"` | Selects platform-specific config paths. |
-| `dryRun` | `boolean` | Computes mutations without writing files. |
-| `observers` | `MutationObservers` | Receives mutation lifecycle events. |
+| Option      | Type                             | Description                                               |
+| ----------- | -------------------------------- | --------------------------------------------------------- |
+| `fs`        | `FileSystem`                     | Filesystem adapter from `@poe-code/config-mutations`.     |
+| `homeDir`   | `string`                         | Home directory used to resolve `~` in agent config paths. |
+| `platform`  | `"darwin" \| "linux" \| "win32"` | Selects platform-specific config paths.                   |
+| `dryRun`    | `boolean`                        | Computes mutations without writing files.                 |
+| `observers` | `MutationObservers`              | Receives mutation lifecycle events.                       |
 
 The package's built-in agent config table declares `configFile`, `configKey`,
 `format`, `shape`, and optional `mcpOutputFormat` per supported agent.

package/node_modules/@poe-code/agent-mcp-config/package.json

@@ -1,4 +1,6 @@
 {
+  "name": "@poe-code/agent-mcp-config",
+  "version": "0.0.1",
   "private": true,
   "license": "MIT",
   "type": "module",

package/node_modules/@poe-code/config-mutations/README.md

@@ -38,14 +38,14 @@ await runMutations(
 
 `MutationContext` controls execution:
 
-| Option | Type | Description |
-| ------ | ---- | ----------- |
-| `fs` | `FileSystem` | Required filesystem adapter. |
-| `homeDir` | `string` | Required home directory for `~` expansion. |
-| `dryRun` | `boolean` | Reports changes without writing them. |
-| `observers` | `MutationObservers` | Receives mutation lifecycle events. |
-| `templates` | `TemplateLoader` | Loads templates referenced by template mutations. |
-| `pathMapper` | `PathMapper` | Redirects target directories for isolated config flows. |
+| Option       | Type                | Description                                             |
+| ------------ | ------------------- | ------------------------------------------------------- |
+| `fs`         | `FileSystem`        | Required filesystem adapter.                            |
+| `homeDir`    | `string`            | Required home directory for `~` expansion.              |
+| `dryRun`     | `boolean`           | Reports changes without writing them.                   |
+| `observers`  | `MutationObservers` | Receives mutation lifecycle events.                     |
+| `templates`  | `TemplateLoader`    | Loads templates referenced by template mutations.       |
+| `pathMapper` | `PathMapper`        | Redirects target directories for isolated config flows. |
 
 Mutation builders also expose per-mutation options such as target path, format,
 label, force removal, backup behavior, template id, and transform callbacks.

package/node_modules/@poe-code/config-mutations/package.json

@@ -1,4 +1,6 @@
 {
+  "name": "@poe-code/config-mutations",
+  "version": "0.0.1",
   "private": true,
   "license": "MIT",
   "type": "module",

package/node_modules/@poe-code/frontmatter/README.md

@@ -26,10 +26,10 @@ Duplicate mapping keys use YAML's last-wins behavior by default, matching the
 legacy frontmatter readers. Callers that need strict YAML mappings can pass
 `{ uniqueKeys: true }` to `parseFrontmatter` or `parseFrontmatterDocument`.
 
-## Environment
+## Environment Variables
 
 This package reads no environment variables.
 
-## Config
+## Configuration Options
 
 This package has no configuration options.

package/node_modules/@poe-code/frontmatter/package.json

@@ -1,4 +1,6 @@
 {
+  "name": "@poe-code/frontmatter",
+  "version": "0.0.1",
   "private": true,
   "license": "MIT",
   "type": "module",

package/node_modules/@poe-code/process-runner/README.md

@@ -32,7 +32,7 @@ Low-level process execution abstraction. Single interface for launching processe
 - `extraArgs`: additional runtime arguments.
 - `containerName`: optional container name prefix.
 
-## Environment variables
+## Environment Variables
 
 This package exposes no environment variables.
 

package/node_modules/@poe-code/process-runner/package.json

@@ -1,4 +1,6 @@
 {
+  "name": "@poe-code/process-runner",
+  "version": "0.0.1",
   "private": true,
   "license": "MIT",
   "type": "module",

package/node_modules/@poe-code/task-list/README.md

@@ -46,7 +46,7 @@ interface EventDef<TState extends string = string> {
 
 Pass a custom machine with `openTaskList({ stateMachine })`. If omitted, the package uses `defaultStateMachine`, whose event names are `plan`, `start`, `complete`, and `archive`.
 
-## Options
+## Configuration Options
 
 | Option            | Type                                           | Default                    | Behavior                                                                                                          |
 | ----------------- | ---------------------------------------------- | -------------------------- | ----------------------------------------------------------------------------------------------------------------- |
@@ -59,7 +59,7 @@ Pass a custom machine with `openTaskList({ stateMachine })`. If omitted, the pac
 | `fs`              | `TaskListFs`                                   | `node:fs/promises` adapter | Injectable filesystem, primarily for tests.                                                                       |
 | `stateMachine`    | `StateMachineDef`                              | `defaultStateMachine`      | Overrides the task lifecycle used by `create`, `fire`, `canFire`, and `events`.                                   |
 
-## Env vars
+## Environment Variables
 
 | Env var   | Behavior                                                        |
 | --------- | --------------------------------------------------------------- |
@@ -231,7 +231,7 @@ interface SyncGhProjectReport extends VerifyGhProjectReport {
 }
 ```
 
-The CLI exposes the same verification and provisioning flow:
+The root CLI exposes verification, provisioning, and task mutation commands:
 
 ```sh
 poe-code tasks verify <list> --workflow ./WORKFLOW.md --repo octo-org/octo-repo --project octo-org/7 --states queued,agent-running,human-review,done,failed,archived --json
@@ -249,6 +249,18 @@ poe-code tasks sync <list> --workflow ./WORKFLOW.md --repo octo-org/octo-repo --
 | `--json`                   | `verify`, `sync` | Prints the report as JSON.                          |
 | `--yes`                    | `sync`           | Confirms non-interactive provisioning.              |
 
+Additional task backend commands:
+
+| Command                                 | Purpose                                               |
+| --------------------------------------- | ----------------------------------------------------- |
+| `poe-code tasks move`                   | Move tasks between workflow-configured backends.      |
+| `poe-code tasks import`                 | Import Markdown task files into a configured backend. |
+| `poe-code tasks get <id>`               | Read one task.                                        |
+| `poe-code tasks set <id>`               | Update one task.                                      |
+| `poe-code tasks set-state <id> <state>` | Set one task's state.                                 |
+| `poe-code tasks next <id>`              | Advance one task to the next workflow state.          |
+| `poe-code tasks comment <id>`           | Add a task comment when the backend supports it.      |
+
 The `Status` field name and option names are matched case-sensitively. The field must be named `Status`, and required option names must match exactly. For example, `status` is treated as a missing field, and `Done` is treated as missing when the required state is `done`.
 
 In v1, if sync creates a new GitHub Project v2 board, the CLI prints the new project number and does not rewrite `WORKFLOW.md`. The operator must update `WORKFLOW.md` by hand with the printed `<owner>/<number>`.

package/node_modules/@poe-code/task-list/package.json

@@ -1,4 +1,6 @@
 {
+  "name": "@poe-code/task-list",
+  "version": "0.0.1",
   "private": true,
   "license": "MIT",
   "type": "module",