toolcraft 0.0.121 → 0.0.123

package/README.md

@@ -425,22 +425,24 @@ Modes:
 - `sync` — handler waits for approval before running.
 - `async` — toolcraft enqueues the command, returns a pending marker, and runs it in a fresh process when an operator approves via the reserved `approvals` group.
 
-Wire the same `humanInLoop` options into every entrypoint:
+The runtime never ships with the core entrypoints — it loads only through the `toolcraft/human-in-loop` export, and providers are surfaced from the same export. Wire the same runtime into every entrypoint:
 
 ```ts
-const humanInLoop = {
-  provider: slackApprovalProvider({ channel: "#deploys", client }),
+import { createHumanInLoop, osascriptProvider } from "toolcraft/human-in-loop";
+
+const humanInLoop = createHumanInLoop({
+  provider: osascriptProvider({ title: "Approval needed" }), // required
   taskList: { dir: ".toolcraft/approvals.yaml", format: "yaml-file" as const }
-};
+});
 
-await runCLI(root, { humanInLoop });
-createMCPServer(root, { name: "mytool", version: "0.1.0", humanInLoop });
-const sdk = createSDK(root, { humanInLoop });
+await runCLI(root, { humanInLoop, approvals: true });
+createMCPServer(root, { name: "mytool", version: "0.1.0", humanInLoop, approvals: true });
+const sdk = createSDK(root, { humanInLoop, approvals: true });
 ```
 
-If `provider` is omitted, toolcraft picks a default lazily on first use: `osascriptProvider` on macOS; otherwise a stub that throws `UserError("no human-in-loop provider configured for this platform")`.
+`provider` is required — there is no implicit platform default. `defaultProviderForPlatform()` (osascript on macOS, a throwing stub elsewhere) is exported for callers that want that behavior explicitly. A command that declares `humanInLoop` config while no runtime is wired fails at startup, as does `approvals: true` without a runtime.
 
-A built-in `approvals` group is auto-merged into every root:
+With `approvals: true`, the built-in `approvals` group is merged into the root:
 
 - `approvals list` — list pending tasks (CLI, MCP, SDK).
 - `approvals show --approval-id <id>` — show one task.
@@ -448,7 +450,7 @@ A built-in `approvals` group is auto-merged into every root:
 
 The name `approvals` is reserved. Defining your own `approvals` group fails at startup.
 
-The async runner re-execs your binary (`process.execPath` + `process.argv[1]` by default; override via `humanInLoop.binPath`). Re-exec calls the same toolcraft entrypoint with the same `humanInLoop` options — do not branch on `argv` before calling `runCLI`/`runMCP`/`createSDK`.
+The async runner re-execs your binary (`process.execPath` + `process.argv[1]` by default; override via the `binPath` option of `createHumanInLoop`). Re-exec calls the same toolcraft entrypoint with the same wired runtime — do not branch on `argv` before calling `runCLI`/`runMCP`/`createSDK`.
 
 Async results must be JSON-serializable; non-serializable returns mark the approval as failed instead of being persisted.
 
@@ -459,7 +461,7 @@ import type {
   ApprovalRequest,
   ApprovalResult,
   HumanInLoopProvider
-} from "@poe-code/agent-human-in-loop";
+} from "toolcraft/human-in-loop";
 
 export function slackApprovalProvider(opts: {
   channel: string;
@@ -545,7 +547,7 @@ esbuild records dependency paths relative to the build layout. A standalone inst
 
 ## Configuration Options
 
-Toolcraft configuration is code-first. Use `defineCommand(config)` and `defineGroup(config)` for the command tree, then pass runtime options to `runCLI`, `createSDK`, `createMCPServer`, or `runMCP`. MCP proxy schemas are cached under `.toolcraft/mcp`, and optional human-in-loop state is configured with `HumanInLoopRuntimeOptions`.
+Toolcraft configuration is code-first. Use `defineCommand(config)` and `defineGroup(config)` for the command tree, then pass runtime options to `runCLI`, `createSDK`, `createMCPServer`, or `runMCP`. MCP proxy schemas are cached under `.toolcraft/mcp`, and human-in-loop approvals are wired explicitly with `createHumanInLoop` from `toolcraft/human-in-loop`.
 
 ## API reference
 
@@ -589,7 +591,8 @@ additional long CLI flags. For example, `rawResponse` normally maps to `--raw-re
 - `presets?: boolean` — enables `--preset <path>` for loading parameter defaults from JSON files.
 - `controls?: { debug?, logLevel?, output?, verbose?, yes? }` — enables generated global CLI controls. Set `output: true` to expose `--output <rich|md|markdown|json>`.
 - `apiVersion?: string` — for `requires.apiVersion`.
-- `humanInLoop?: HumanInLoopRuntimeOptions`
+- `humanInLoop?: HumanInLoopRuntime` — from `createHumanInLoop` (`toolcraft/human-in-loop`); required for commands with `humanInLoop` config.
+- `approvals?: boolean` — merge the built-in `approvals` group; requires `humanInLoop`.
 - `errorReports?: boolean | { dir?: string }`
 - `projectRoot?: string` — root used for MCP proxy cache files (`.toolcraft/mcp/*.json`).
 
@@ -609,17 +612,21 @@ additional long CLI flags. For example, `rawResponse` normally maps to `--raw-re
 - `omitRootToolNamePrefix?: boolean` — defaults to `false`. Set to `true` to omit the root group name from single-root MCP tool names (`bot__create`).
 - `casing?: "snake" | "camel"` — affects MCP input-schema property names, output-schema property names, and structured result keys. Tool names always stay `__`-joined snake_case.
 
-### `HumanInLoopRuntimeOptions`
+### `createHumanInLoop(options)` (from `toolcraft/human-in-loop`)
 
 ```ts
+import { createHumanInLoop, defaultProviderForPlatform, osascriptProvider } from "toolcraft/human-in-loop";
+
 type HumanInLoopRuntimeOptions = {
-  provider?: HumanInLoopProvider;
+  provider: HumanInLoopProvider; // required
   taskList?: TaskList | { dir: string; format: "markdown-dir" | "yaml-file" };
   listName?: string; // defaults to "approvals"
   binPath?: { execPath: string; entryArgs: readonly string[] };
 };
 ```
 
+Returns the `HumanInLoopRuntime` accepted by `runCLI` / `createMCPServer` / `createSDK`.
+
 ### Handler context
 
 - `params` — inferred from the command `params` schema.
@@ -635,7 +642,7 @@ type HumanInLoopRuntimeOptions = {
 - `defineCommand`, `defineGroup`
 - `S`, `toJsonSchema`, type helpers — re-exported from `toolcraft-schema`
 - `UserError`, `ApprovalDeclinedError`, `HttpError` and the HTTP error subclasses.
-- Type exports: `Command`, `Group`, `Scope`, `HandlerContext`, `HumanInLoopConfig`, `HumanInLoopPending`, `HumanInLoopRuntimeOptions`, schema types from `toolcraft-schema`.
+- Type exports: `Command`, `Group`, `Scope`, `HandlerContext`, `HumanInLoopConfig`, `HumanInLoopPending`, `HumanInLoopRuntime`, schema types from `toolcraft-schema`.
 
 Subpath imports:
 

package/composition.json

@@ -103,7 +103,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.121",
+      "version": "0.0.123",
       "license": "MIT"
     },
     {
@@ -113,7 +113,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.121",
+      "version": "0.0.123",
       "license": "MIT"
     },
     {

package/dist/cli.compile-check.js

@@ -27,7 +27,10 @@ const ignoredOptions = {
     logger: (event) => {
         event.level;
     },
-    humanInLoop: {},
+    humanInLoop: {
+        invoke: async (node, ctx) => node.handler(ctx),
+        mergeApprovalsGroup: (root) => root,
+    },
     version: "1.0.0",
 };
 const ignoredServiceOptions = {

package/dist/cli.d.ts

@@ -2,7 +2,7 @@ import "./node-require-shim.js";
 import { configureTheme } from "toolcraft-design";
 import type { Command, Group, HandlerFs, LogLevel, RenderPrimitives, RuntimeLoggerInput } from "./index.js";
 import { type ErrorReportsOption } from "./error-report.js";
-import type { HumanInLoopRuntimeOptions } from "./human-in-loop/types.js";
+import type { HumanInLoopRuntime } from "./human-in-loop/types.js";
 export { renderErrorReport } from "./error-report.js";
 export type { ErrorReportRenderContext, ErrorReportRenderResult } from "./error-report.js";
 export { configureTheme };
@@ -34,7 +34,7 @@ export interface RunCLIOptions<TServices extends object = Record<string, unknown
     env?: Record<string, string>;
     fetch?: typeof globalThis.fetch;
     fs?: HandlerFs;
-    humanInLoop?: HumanInLoopRuntimeOptions;
+    humanInLoop?: HumanInLoopRuntime;
     logLevel?: LogLevel;
     logger?: RuntimeLoggerInput;
     outputEmitter?: (entry: string) => void;
@@ -92,6 +92,7 @@ export interface CLICommandTreeSnapshotOptions {
     argv?: readonly string[];
     casing?: Casing;
     controls?: CLIControls;
+    humanInLoop?: HumanInLoopRuntime;
     presets?: boolean;
     version?: string;
 }

package/dist/cli.js

@@ -7,6 +7,7 @@ import { cancel, configureTheme, confirm, createLogger, formatCommandList, forma
 import { ApprovalDeclinedError, ToolcraftBugError, UserError, assertCommandRequirements, getCommandSourcePath, hasMcpProxyConfig, resolveCommandSecrets } from "./index.js";
 import { hasOwnErrorCode } from "./error-codes.js";
 import { writeErrorReport } from "./error-report.js";
+import { assertHumanInLoopWired, mergeApprovalsRoot } from "./human-in-loop/wiring.js";
 import { getExpectedNumberDescription, isValidNumberSchemaValue } from "./number-schema.js";
 import { findEntrypointPackageMetadata } from "./package-metadata.js";
 import { redactHttpBody, redactHttpHeaderValue } from "./redaction.js";
@@ -24,8 +25,6 @@ configureTheme({ brand: "blue", label: "Toolcraft" });
 export { configureTheme };
 const NULL_OPTION_VALUE = Symbol("toolcraft.cli.null");
 const optionalModulePaths = {
-    approvals: "./human-in-loop/approvals-commands.js",
-    humanInLoop: "./human-in-loop/gate.js",
     mcpProxy: "./mcp-proxy.js"
 };
 function importOptionalModule(specifier) {
@@ -42,9 +41,7 @@ function importOptionalModule(specifier) {
 export async function createCLICommandTreeSnapshot(roots, options = {}) {
     const argv = [...(options.argv ?? ["node", "toolcraft"])];
     const normalizedRoot = normalizeRoots(roots, argv);
-    const root = options.approvals === true
-        ? (await importOptionalModule(optionalModulePaths.approvals)).mergeApprovalsGroup(normalizedRoot)
-        : normalizedRoot;
+    const root = mergeApprovalsRoot(normalizedRoot, options);
     const controls = resolveCLIControls(options.controls);
     const presetsEnabled = options.presets === true;
     const globalLongOptionFlags = getGlobalLongOptionFlags(presetsEnabled, options.version !== undefined, controls);
@@ -3028,7 +3025,7 @@ function getResolvedFlags(command) {
     const flags = command.optsWithGlobals();
     return flags;
 }
-async function executeCommand(state, services, requirementOptions, runtimeFetch, runtimeOptions, runtimeEnv, runtimeFs, outputEmitter, outputFormats, promptStreams, diagnosticsOptions, onErrorReportContext) {
+async function executeCommand(state, services, requirementOptions, runtimeFetch, humanInLoop, runtimeEnv, runtimeFs, outputEmitter, outputFormats, promptStreams, diagnosticsOptions, onErrorReportContext) {
     const logger = createLogger(outputEmitter);
     const optionValues = state.actionCommand.optsWithGlobals();
     const resolvedFlags = optionValues;
@@ -3162,8 +3159,8 @@ async function executeCommand(state, services, requirementOptions, runtimeFetch,
                     throw new UserError("Operation cancelled.");
                 }
             }
-            const result = state.command.humanInLoop
-                ? await (await importOptionalModule(optionalModulePaths.humanInLoop)).invokeWithHumanInLoop(state.command, context, runtimeOptions, state.commandPath)
+            const result = state.command.humanInLoop && humanInLoop !== undefined
+                ? await humanInLoop.invoke(state.command, context, state.commandPath)
                 : await state.command.handler(context);
             if (output === "rich" && runtime.isFixture) {
                 writeRichHeader(`${state.command.name} (fixture)`);
@@ -3729,20 +3726,19 @@ export async function runCLI(roots, options = {}) {
     let errorReportContext;
     try {
         const normalizedRoot = normalizeRoots(roots, argv);
-        const root = options.approvals === true
-            ? (await importOptionalModule(optionalModulePaths.approvals)).mergeApprovalsGroup(normalizedRoot)
-            : normalizedRoot;
+        const root = mergeApprovalsRoot(normalizedRoot, options);
+        assertHumanInLoopWired(root, options.humanInLoop);
         if (hasMcpProxyConfig(root)) {
             await (await importOptionalModule(optionalModulePaths.mcpProxy)).resolveMcpProxies(root, { projectRoot: options.projectRoot });
         }
         const casing = options.casing ?? "kebab";
         const services = (options.services ?? {});
-        const runtimeOptions = options.humanInLoop ?? {};
+        const humanInLoop = options.humanInLoop;
         const runtimeFetch = options.fetch ?? globalThis.fetch;
         version = options.version ?? findEntrypointPackageMetadata(argv[1])?.version;
         const servicesWithBuiltIns = {
             ...services,
-            runtimeOptions,
+            humanInLoop,
             root
         };
         const requirementOptions = {
@@ -3777,7 +3773,7 @@ export async function runCLI(roots, options = {}) {
         const execute = async (state) => {
             lastActionCommand = state.actionCommand;
             resolvedCommandPath = formatCliCommandPath(state.commandPath);
-            await executeCommand(state, servicesWithBuiltIns, requirementOptions, runtimeFetch, runtimeOptions, options.env, options.fs, options.outputEmitter, controls.outputFormats, {
+            await executeCommand(state, servicesWithBuiltIns, requirementOptions, runtimeFetch, humanInLoop, options.env, options.fs, options.outputEmitter, controls.outputFormats, {
                 input: options.promptInput,
                 output: options.promptOutput
             }, {

package/dist/composition.json

@@ -103,7 +103,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.121",
+      "version": "0.0.123",
       "license": "MIT"
     },
     {
@@ -113,7 +113,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.121",
+      "version": "0.0.123",
       "license": "MIT"
     },
     {

package/dist/human-in-loop/approval-tasks.d.ts

@@ -1,5 +1,7 @@
 import type { OpenTaskListOptions, TaskList, Tasks } from "@poe-code/task-list";
-import type { HumanInLoopPending, HumanInLoopRuntimeOptions } from "./types.js";
+import type { HumanInLoopPending } from "./types.js";
+import type { HumanInLoopRuntimeOptions } from "./runtime-options.js";
+type ApprovalListOptions = Pick<HumanInLoopRuntimeOptions, "taskList" | "listName">;
 import { type ApprovalPlanValue } from "./plan-hash.js";
 export interface ApprovalPayload {
     approvalId?: string;
@@ -14,7 +16,7 @@ export interface ApprovalPayload {
     result?: unknown;
     error?: unknown;
 }
-export declare function ensureApprovalList(runtimeOptions: HumanInLoopRuntimeOptions | undefined, deps?: {
+export declare function ensureApprovalList(runtimeOptions: ApprovalListOptions | undefined, deps?: {
     create?: boolean;
     openTaskList?: (options: OpenTaskListOptions) => Promise<TaskList>;
 }): Promise<{
@@ -33,3 +35,4 @@ export declare function loadApproval(ctx: {
     tasks: Tasks;
     approvalId: string;
 }): Promise<ApprovalPayload | undefined>;
+export {};

package/dist/human-in-loop/approvals-commands.d.ts

@@ -1,7 +1,7 @@
 import type { CommandNode, Group } from "../index.js";
-import type { HumanInLoopRuntimeOptions } from "./types.js";
+import type { HumanInLoopRuntimeInstance } from "./runtime-options.js";
 interface ApprovalBuiltInServices {
-    runtimeOptions: HumanInLoopRuntimeOptions;
+    humanInLoop: HumanInLoopRuntimeInstance;
     root: CommandNode<any>;
 }
 export declare const approvalsGroup: Group<ApprovalBuiltInServices> & {

package/dist/human-in-loop/approvals-commands.js

@@ -25,9 +25,11 @@ export const approvalsGroup = markApprovalsBuiltIn(defineGroup({
             description: "List queued approvals.",
             scope: listScope,
             params: listParams,
-            handler: async ({ params, runtimeOptions }) => {
+            handler: async ({ params, humanInLoop }) => {
                 try {
-                    const { tasks } = await ensureApprovalList(runtimeOptions, { create: false });
+                    const { tasks } = await ensureApprovalList(humanInLoop.runtimeOptions, {
+                        create: false
+                    });
                     return loadApprovals(tasks, params.state);
                 }
                 catch (error) {
@@ -48,9 +50,11 @@ export const approvalsGroup = markApprovalsBuiltIn(defineGroup({
             description: "Show one approval.",
             scope: listScope,
             params: showParams,
-            handler: async ({ params, runtimeOptions }) => {
+            handler: async ({ params, humanInLoop }) => {
                 try {
-                    const { tasks } = await ensureApprovalList(runtimeOptions, { create: false });
+                    const { tasks } = await ensureApprovalList(humanInLoop.runtimeOptions, {
+                        create: false
+                    });
                     return tasks.get(params.approvalId);
                 }
                 catch (error) {
@@ -71,8 +75,8 @@ export const approvalsGroup = markApprovalsBuiltIn(defineGroup({
             description: "Run one queued approval.",
             scope: runScope,
             params: runParams,
-            handler: async ({ params, runtimeOptions, root }) => {
-                return runApproval(params.approvalId, runtimeOptions, root);
+            handler: async ({ params, humanInLoop, root }) => {
+                return runApproval(params.approvalId, humanInLoop.runtimeOptions, root);
             },
             render: {
                 rich: (result, primitives) => {

package/dist/human-in-loop/gate.d.ts

@@ -1,8 +1,8 @@
 import type { Command, HandlerContext } from "../index.js";
 import { enqueueApproval } from "./approval-tasks.js";
-import type { HumanInLoopPending, HumanInLoopProvider, HumanInLoopRuntimeOptions } from "./types.js";
-export declare function resolveProvider(runtimeOptions: HumanInLoopRuntimeOptions | undefined): HumanInLoopProvider;
-export declare function invokeWithHumanInLoop<T>(node: Command<any, any, any, T>, ctx: HandlerContext<any, any, any>, runtimeOptions: HumanInLoopRuntimeOptions | undefined, commandPath: string, options?: {
+import type { HumanInLoopPending } from "./types.js";
+import type { HumanInLoopRuntimeOptions } from "./runtime-options.js";
+export declare function invokeWithHumanInLoop<T>(node: Command<any, any, any, T>, ctx: HandlerContext<any, any, any>, runtimeOptions: HumanInLoopRuntimeOptions, commandPath: string, options?: {
     enqueueApproval?: typeof enqueueApproval;
     spawnRunner?: boolean;
 }): Promise<T | HumanInLoopPending>;

package/dist/human-in-loop/gate.js

@@ -1,26 +1,7 @@
 import { enqueueApproval, ensureApprovalList } from "./approval-tasks.js";
-import { defaultProviderForPlatform } from "./default-provider.js";
 import { spawnApprovalRunner } from "./spawn.js";
 import { ApprovalDeclinedError } from "./types.js";
 import { assertApprovalPlanHash, createApprovalPlan, formatApprovalMessage } from "./plan-hash.js";
-const providersByRuntime = new WeakMap();
-let providerWithoutRuntime;
-export function resolveProvider(runtimeOptions) {
-    if (runtimeOptions?.provider !== undefined) {
-        return runtimeOptions.provider;
-    }
-    if (runtimeOptions === undefined) {
-        providerWithoutRuntime ??= defaultProviderForPlatform();
-        return providerWithoutRuntime;
-    }
-    const cachedProvider = providersByRuntime.get(runtimeOptions);
-    if (cachedProvider !== undefined) {
-        return cachedProvider;
-    }
-    const provider = defaultProviderForPlatform();
-    providersByRuntime.set(runtimeOptions, provider);
-    return provider;
-}
 export async function invokeWithHumanInLoop(node, ctx, runtimeOptions, commandPath, options = {}) {
     if (!node.humanInLoop) {
         return node.handler(ctx);
@@ -54,8 +35,7 @@ export async function invokeWithHumanInLoop(node, ctx, runtimeOptions, commandPa
         }
         return pending;
     }
-    const provider = resolveProvider(runtimeOptions);
-    const result = await provider.requestApproval({
+    const result = await runtimeOptions.provider.requestApproval({
         message,
         declineInputPrompt: node.humanInLoop.declineInputPrompt
     });

package/dist/human-in-loop/index.d.ts

@@ -1,7 +1,10 @@
+export { createHumanInLoop } from "./runtime.js";
 export { defaultProviderForPlatform } from "./default-provider.js";
+export { osascriptProvider } from "@poe-code/agent-human-in-loop";
 export { invokeWithHumanInLoop } from "./gate.js";
 export { approvalStateMachine } from "./state-machine.js";
 export { ApprovalDeclinedError } from "./types.js";
 export type { ApprovalEvent, ApprovalState } from "./state-machine.js";
-export type { HumanInLoopConfig, HumanInLoopPending, HumanInLoopRuntimeOptions } from "./types.js";
+export type { HumanInLoopConfig, HumanInLoopPending, HumanInLoopRuntime } from "./types.js";
+export type { HumanInLoopRuntimeInstance, HumanInLoopRuntimeOptions } from "./runtime-options.js";
 export type { HumanInLoopProvider } from "@poe-code/agent-human-in-loop";

package/dist/human-in-loop/index.js

@@ -1,4 +1,6 @@
+export { createHumanInLoop } from "./runtime.js";
 export { defaultProviderForPlatform } from "./default-provider.js";
+export { osascriptProvider } from "@poe-code/agent-human-in-loop";
 export { invokeWithHumanInLoop } from "./gate.js";
 export { approvalStateMachine } from "./state-machine.js";
 export { ApprovalDeclinedError } from "./types.js";

package/dist/human-in-loop/runner.d.ts

@@ -1,3 +1,3 @@
 import type { CommandNode } from "../index.js";
-import type { HumanInLoopRuntimeOptions } from "./types.js";
+import type { HumanInLoopRuntimeOptions } from "./runtime-options.js";
 export declare function runApproval(approvalId: string, runtimeOptions: HumanInLoopRuntimeOptions, root: CommandNode<any>): Promise<void>;

package/dist/human-in-loop/runner.js

@@ -2,7 +2,6 @@ import { InvalidTransitionError } from "@poe-code/task-list";
 import { UserError, resolveCommandSecrets } from "../index.js";
 import { createEnv, createFs } from "../runtime/io.js";
 import { ensureApprovalList } from "./approval-tasks.js";
-import { resolveProvider } from "./gate.js";
 import { createRuntimeLogger } from "../runtime-logging.js";
 import { assertApprovalPlanHash, createApprovalPlan, formatApprovalMessage, isApprovalPlanValue } from "./plan-hash.js";
 const MAX_AVAILABLE_COMMAND_PATHS = 20;
@@ -13,7 +12,7 @@ export async function runApproval(approvalId, runtimeOptions, root) {
         return;
     }
     const approval = readApprovalPayload(task);
-    const provider = resolveProvider(runtimeOptions);
+    const provider = runtimeOptions.provider;
     try {
         await tasks.fire(approvalId, "claim", {
             metadataPatch: {

package/dist/human-in-loop/runtime-options.d.ts

@@ -0,0 +1,19 @@
+import type { HumanInLoopProvider } from "@poe-code/agent-human-in-loop";
+import type { TaskList } from "@poe-code/task-list";
+import type { HumanInLoopRuntime } from "./types.js";
+/** The concrete runtime built by `createHumanInLoop` — carries its options for the approvals built-ins. */
+export interface HumanInLoopRuntimeInstance extends HumanInLoopRuntime {
+    readonly runtimeOptions: HumanInLoopRuntimeOptions;
+}
+export interface HumanInLoopRuntimeOptions {
+    provider: HumanInLoopProvider;
+    taskList?: TaskList | {
+        dir: string;
+        format: "markdown-dir" | "yaml-file";
+    };
+    listName?: string;
+    binPath?: {
+        execPath: string;
+        entryArgs: readonly string[];
+    };
+}

package/dist/human-in-loop/runtime-options.js

@@ -0,0 +1 @@
+export {};

package/dist/human-in-loop/runtime.d.ts

@@ -0,0 +1,2 @@
+import type { HumanInLoopRuntimeInstance, HumanInLoopRuntimeOptions } from "./runtime-options.js";
+export declare function createHumanInLoop(options: HumanInLoopRuntimeOptions): HumanInLoopRuntimeInstance;

package/dist/human-in-loop/runtime.js

@@ -0,0 +1,14 @@
+import { UserError } from "../user-error.js";
+import { mergeApprovalsGroup } from "./approvals-commands.js";
+import { invokeWithHumanInLoop } from "./gate.js";
+export function createHumanInLoop(options) {
+    if (options?.provider === undefined) {
+        throw new UserError('createHumanInLoop requires a provider — import one from "toolcraft/human-in-loop" (e.g. osascriptProvider) or pass your own');
+    }
+    const runtimeOptions = { ...options };
+    return {
+        runtimeOptions,
+        invoke: (node, ctx, commandPath) => invokeWithHumanInLoop(node, ctx, runtimeOptions, commandPath),
+        mergeApprovalsGroup
+    };
+}

package/dist/human-in-loop/spawn.d.ts

@@ -1,3 +1,3 @@
-import type { HumanInLoopRuntimeOptions } from "./types.js";
-export declare function spawnApprovalRunner(approvalId: string, runtimeOptions: HumanInLoopRuntimeOptions, spawnFn?: typeof import("node:child_process").spawn): void;
+import type { HumanInLoopRuntimeOptions } from "./runtime-options.js";
+export declare function spawnApprovalRunner(approvalId: string, runtimeOptions: Pick<HumanInLoopRuntimeOptions, "binPath">, spawnFn?: typeof import("node:child_process").spawn): void;
 export default spawnApprovalRunner;

package/dist/human-in-loop/types.d.ts

@@ -1,6 +1,5 @@
-import type { HumanInLoopProvider } from "@poe-code/agent-human-in-loop";
-import type { TaskList } from "@poe-code/task-list";
 import type { ObjectSchema, Static } from "toolcraft-schema";
+import type { Command, Group, HandlerContext } from "../index.js";
 import { UserError } from "../user-error.js";
 export interface HumanInLoopConfig<TParamsSchema extends ObjectSchema<any>> {
     mode: "sync" | "async";
@@ -14,17 +13,14 @@ export interface HumanInLoopConfig<TParamsSchema extends ObjectSchema<any>> {
     }) => unknown | Promise<unknown>;
     declineInputPrompt?: string;
 }
-export interface HumanInLoopRuntimeOptions {
-    provider?: HumanInLoopProvider;
-    taskList?: TaskList | {
-        dir: string;
-        format: "markdown-dir" | "yaml-file";
-    };
-    listName?: string;
-    binPath?: {
-        execPath: string;
-        entryArgs: readonly string[];
-    };
+/**
+ * The wired human-in-loop runtime. Core entrypoints only know this interface;
+ * the implementation ships behind the `toolcraft/human-in-loop` export and is
+ * created with `createHumanInLoop({ provider, ... })`.
+ */
+export interface HumanInLoopRuntime {
+    invoke<T>(node: Command<any, any, any, T>, ctx: HandlerContext<any, any, any>, commandPath: string): Promise<T | HumanInLoopPending>;
+    mergeApprovalsGroup<TServices extends object>(root: Group<TServices>): Group<TServices>;
 }
 export interface HumanInLoopPending {
     status: "pending-approval";
@@ -43,4 +39,3 @@ export declare class ApprovalDeclinedError extends UserError {
         approvalId?: string;
     });
 }
-export type { HumanInLoopProvider } from "@poe-code/agent-human-in-loop";

package/dist/human-in-loop/wiring.d.ts

@@ -0,0 +1,11 @@
+import type { CommandNode, Group } from "../index.js";
+import type { HumanInLoopRuntime } from "./types.js";
+/**
+ * Human-in-loop config on a command is only allowed when a runtime is wired.
+ * Called by every entrypoint (CLI, MCP, SDK) after the root is normalized.
+ */
+export declare function assertHumanInLoopWired(root: CommandNode<any>, humanInLoop: HumanInLoopRuntime | undefined): void;
+export declare function mergeApprovalsRoot<TServices extends object>(root: Group<TServices>, options: {
+    approvals?: boolean;
+    humanInLoop?: HumanInLoopRuntime;
+}): Group<TServices>;

package/dist/human-in-loop/wiring.js

@@ -0,0 +1,36 @@
+import { UserError } from "../user-error.js";
+const WIRING_HINT = 'pass { humanInLoop: createHumanInLoop({ provider, ... }) } from "toolcraft/human-in-loop"';
+/**
+ * Human-in-loop config on a command is only allowed when a runtime is wired.
+ * Called by every entrypoint (CLI, MCP, SDK) after the root is normalized.
+ */
+export function assertHumanInLoopWired(root, humanInLoop) {
+    if (humanInLoop !== undefined) {
+        return;
+    }
+    const commandPath = findHumanInLoopCommandPath(root, []);
+    if (commandPath !== undefined) {
+        throw new UserError(`command '${commandPath}' declares humanInLoop but no runtime is wired — ${WIRING_HINT}`);
+    }
+}
+export function mergeApprovalsRoot(root, options) {
+    if (options.approvals !== true) {
+        return root;
+    }
+    if (options.humanInLoop === undefined) {
+        throw new UserError(`approvals: true requires a wired humanInLoop runtime — ${WIRING_HINT}`);
+    }
+    return options.humanInLoop.mergeApprovalsGroup(root);
+}
+function findHumanInLoopCommandPath(node, path) {
+    if (node.kind === "command") {
+        return node.humanInLoop ? path.join(".") || node.name : undefined;
+    }
+    for (const child of node.children) {
+        const found = findHumanInLoopCommandPath(child, [...path, child.name]);
+        if (found !== undefined) {
+            return found;
+        }
+    }
+    return undefined;
+}

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import type { McpServerConfig } from "@poe-code/agent-mcp-config";
 import type { AnySchema, ObjectSchema, Static } from "toolcraft-schema";
 import type { LoggerOutput, RenderTableOptions, ThemePalette } from "toolcraft-design";
 import { ApprovalDeclinedError } from "./human-in-loop/types.js";
-import type { HumanInLoopConfig, HumanInLoopPending, HumanInLoopRuntimeOptions } from "./human-in-loop/types.js";
+import type { HumanInLoopConfig, HumanInLoopPending, HumanInLoopRuntime } from "./human-in-loop/types.js";
 import { ToolcraftBugError, UserError } from "./user-error.js";
 import type { RuntimeLogger } from "./runtime-logging.js";
 import type { StreamStatusEvent, ToolcraftStream } from "./stream.js";
@@ -235,4 +235,4 @@ export type { FileChangeRendererOptions, FileChangeResult } from "./file-change-
 export type { FileChange, FileChangeDisplayMode, FileChangeKind } from "toolcraft-design";
 export type { DiagnosticLogEvent, LogLevel, RuntimeLogger, RuntimeLoggerInput } from "./runtime-logging.js";
 export type { AnySchema, ArraySchema, BooleanSchema, CliMissingParameterChoice, CliMissingParameterContext, CliMissingParameterResolution, CliOutputMode, CliSchemaOptions, EnumSchema, JsonSchema, JsonSchemaDocument, JsonSchemaDocumentOptions, JsonValue, JsonValueSchema, NumberSchema, ObjectSchema, OneOfSchema, OptionalSchema, RecordSchema, SchemaBase, Static, StringSchema, UnionSchema, ValidationIssue, ValidationResult } from "./schema.js";
-export type { HumanInLoopConfig, HumanInLoopPending, HumanInLoopRuntimeOptions };
+export type { HumanInLoopConfig, HumanInLoopPending, HumanInLoopRuntime };

package/dist/mcp.compile-check.js

@@ -21,7 +21,10 @@ const ignoredOptions = {
     fetch: globalThis.fetch,
     tools: ["usage"],
     casing: "snake",
-    humanInLoop: {},
+    humanInLoop: {
+        invoke: async (node, ctx) => node.handler(ctx),
+        mergeApprovalsGroup: (root) => root,
+    },
 };
 const ignoredServer = createMCPServer(ignoredRoot, ignoredOptions);
 const ignoredServerArray = createMCPServer([ignoredRoot], ignoredOptions);

package/dist/mcp.d.ts

@@ -2,7 +2,7 @@ import "./node-require-shim.js";
 import { type SDKTransport, type Server as TinyServer } from "tiny-stdio-mcp-server";
 import type { Group, HandlerFs, LogLevel, RuntimeLoggerInput } from "./index.js";
 import { type ErrorReportsOption } from "./error-report.js";
-import { type HumanInLoopRuntimeOptions } from "./human-in-loop/index.js";
+import { type HumanInLoopRuntime } from "./human-in-loop/types.js";
 type Casing = "snake" | "camel";
 type CmdkitServer = Omit<TinyServer, "connect"> & {
     connect(transport: SDKTransport): Promise<void>;
@@ -21,7 +21,7 @@ export interface RunMCPOptions<TServices extends object = Record<string, unknown
     fs?: HandlerFs;
     name: string;
     version?: string;
-    humanInLoop?: HumanInLoopRuntimeOptions;
+    humanInLoop?: HumanInLoopRuntime;
     projectRoot?: string;
     logLevel?: LogLevel;
     logger?: RuntimeLoggerInput;

package/dist/mcp.js

@@ -4,8 +4,8 @@ import { toJsonSchema } from "toolcraft-schema";
 import { createHttpErrorEnvelope, isHttpErrorLike } from "./api-error-summary.js";
 import { ToolcraftBugError, UserError, assertCommandRequirements, resolveCommandSecrets } from "./index.js";
 import { writeErrorReport } from "./error-report.js";
-import { mergeApprovalsGroup } from "./human-in-loop/approvals-commands.js";
-import { ApprovalDeclinedError, invokeWithHumanInLoop } from "./human-in-loop/index.js";
+import { ApprovalDeclinedError } from "./human-in-loop/types.js";
+import { assertHumanInLoopWired, mergeApprovalsRoot } from "./human-in-loop/wiring.js";
 import { hasMcpProxyGroups, resolveMcpProxies } from "./mcp-proxy.js";
 import { getExpectedNumberDescription, isValidNumberSchemaValue } from "./number-schema.js";
 import { findEntrypointPackageMetadata } from "./package-metadata.js";
@@ -717,7 +717,7 @@ function toToolError(error, reportPath) {
 function createResolvedMCPServer(root, options, runtime = {}) {
     const casing = options.casing ?? "snake";
     const services = (options.services ?? {});
-    const runtimeOptions = options.humanInLoop ?? {};
+    const humanInLoop = options.humanInLoop;
     const runtimeFetch = options.fetch ?? globalThis.fetch;
     const diagnostics = createRuntimeLogger({
         level: options.logLevel,
@@ -764,7 +764,7 @@ function createResolvedMCPServer(root, options, runtime = {}) {
         const baseContext = {
             ...services,
             ...requestServices,
-            runtimeOptions,
+            humanInLoop,
             root,
             secrets,
             fetch: runtimeFetch,
@@ -863,7 +863,7 @@ function createResolvedMCPServer(root, options, runtime = {}) {
                 const baseContext = {
                     ...services,
                     ...requestServices,
-                    runtimeOptions,
+                    humanInLoop,
                     root,
                     secrets,
                     fetch: runtimeFetch,
@@ -879,10 +879,13 @@ function createResolvedMCPServer(root, options, runtime = {}) {
                     env: options.env
                 });
                 params = validateToolArguments(tool.command.params, argumentsValue, casing);
-                const result = await invokeWithHumanInLoop(tool.command, {
+                const handlerContext = {
                     ...baseContext,
                     params
-                }, runtimeOptions, tool.commandPath);
+                };
+                const result = humanInLoop === undefined
+                    ? await tool.command.handler(handlerContext)
+                    : await humanInLoop.invoke(tool.command, handlerContext, tool.commandPath);
                 if (isHumanInLoopPending(result)) {
                     return renderPendingApproval(result);
                 }
@@ -960,7 +963,8 @@ function createDeferredMCPServer(root, options) {
 }
 export function createMCPServer(roots, options) {
     const normalizedRoot = normalizeRoots(roots);
-    const root = options.approvals === true ? mergeApprovalsGroup(normalizedRoot) : normalizedRoot;
+    const root = mergeApprovalsRoot(normalizedRoot, options);
+    assertHumanInLoopWired(root, options.humanInLoop);
     if (!hasMcpProxyGroups(root)) {
         return createResolvedMCPServer(root, options);
     }
@@ -969,14 +973,16 @@ export function createMCPServer(roots, options) {
 /** @internal */
 export async function createMCPServerForTransport(roots, options, runtime) {
     const normalizedRoot = normalizeRoots(roots);
-    const root = options.approvals === true ? mergeApprovalsGroup(normalizedRoot) : normalizedRoot;
+    const root = mergeApprovalsRoot(normalizedRoot, options);
+    assertHumanInLoopWired(root, options.humanInLoop);
     await resolveMcpProxies(root, { projectRoot: options.projectRoot });
     createResolvedMCPServer(root, options, runtime);
 }
 export async function runMCP(roots, options) {
     enableSourceMaps();
     const normalizedRoot = normalizeRoots(roots);
-    const root = options.approvals === true ? mergeApprovalsGroup(normalizedRoot) : normalizedRoot;
+    const root = mergeApprovalsRoot(normalizedRoot, options);
+    assertHumanInLoopWired(root, options.humanInLoop);
     await resolveMcpProxies(root, { projectRoot: options.projectRoot });
     const server = createResolvedMCPServer(root, options);
     await server.listen();

package/dist/sdk.compile-check.js

@@ -95,7 +95,10 @@ const ignoredOptions = {
     services: {
         logger: console,
     },
-    humanInLoop: {},
+    humanInLoop: {
+        invoke: async (node, ctx) => node.handler(ctx),
+        mergeApprovalsGroup: (root) => root,
+    },
 };
 const ignoredSdk = createSDK(ignoredRoot, ignoredOptions);
 const ignoredResult = ignoredSdk.poeCode.generate.text({

package/dist/sdk.d.ts

@@ -2,7 +2,7 @@ import "./node-require-shim.js";
 import type { ObjectSchema, Static } from "toolcraft-schema";
 import type { Group, HandlerFs, LogLevel, RuntimeLoggerInput, Scope } from "./index.js";
 import { type ErrorReportsOption } from "./error-report.js";
-import type { HumanInLoopPending, HumanInLoopRuntimeOptions } from "./human-in-loop/index.js";
+import type { HumanInLoopPending, HumanInLoopRuntime } from "./human-in-loop/types.js";
 import { type ValidationError } from "./validation-errors.js";
 import type { StreamConsumerOptions, ToolcraftStream } from "./stream.js";
 type ScopeInput = readonly Scope[] | undefined;
@@ -70,7 +70,7 @@ export interface CreateSDKOptions<TServices extends object = Record<string, unkn
     fs?: HandlerFs;
     services?: TServices;
     casing?: "camel";
-    humanInLoop?: HumanInLoopRuntimeOptions;
+    humanInLoop?: HumanInLoopRuntime;
     apiVersion?: string;
     projectRoot?: string;
     errorReports?: ErrorReportsOption;

package/dist/sdk.js

@@ -1,8 +1,7 @@
 import "./node-require-shim.js";
 import { ToolcraftBugError, UserError, assertCommandRequirements, resolveCommandSecrets } from "./index.js";
 import { writeErrorReport } from "./error-report.js";
-import { mergeApprovalsGroup } from "./human-in-loop/approvals-commands.js";
-import { invokeWithHumanInLoop } from "./human-in-loop/index.js";
+import { assertHumanInLoopWired, mergeApprovalsRoot } from "./human-in-loop/wiring.js";
 import { hasMcpProxyGroups, resolveMcpProxies } from "./mcp-proxy.js";
 import { getExpectedNumberDescription, isValidNumberSchemaValue } from "./number-schema.js";
 import { filterSchemaForScope } from "./schema-scope.js";
@@ -310,7 +309,8 @@ function defineMember(target, key, value) {
 }
 export function createSDK(root, options = {}) {
     enableSourceMaps();
-    const mergedRoot = options.approvals === true ? mergeApprovalsGroup(root) : root;
+    const mergedRoot = mergeApprovalsRoot(root, options);
+    assertHumanInLoopWired(mergedRoot, options.humanInLoop);
     if (!hasMcpProxyGroups(mergedRoot)) {
         return createResolvedSDK(mergedRoot, options);
     }
@@ -318,7 +318,7 @@ export function createSDK(root, options = {}) {
 }
 function createResolvedSDK(root, options = {}) {
     const services = options.services ?? {};
-    const runtimeOptions = options.humanInLoop ?? {};
+    const humanInLoop = options.humanInLoop;
     const runtimeFetch = options.fetch ?? globalThis.fetch;
     const diagnostics = createRuntimeLogger({
         level: options.logLevel,
@@ -344,7 +344,7 @@ function createResolvedSDK(root, options = {}) {
                             secrets = resolveCommandSecrets(node, options.env);
                             const baseContext = {
                                 ...services,
-                                runtimeOptions,
+                                humanInLoop,
                                 root,
                                 secrets,
                                 fetch: runtimeFetch,
@@ -395,7 +395,7 @@ function createResolvedSDK(root, options = {}) {
                     secrets = resolveCommandSecrets(node, options.env);
                     const baseContext = {
                         ...services,
-                        runtimeOptions,
+                        humanInLoop,
                         root,
                         secrets,
                         fetch: runtimeFetch,
@@ -415,10 +415,13 @@ function createResolvedSDK(root, options = {}) {
                         throw new ToolcraftBugError(`command "${node.name}" must define an object params schema for SDK.`);
                     }
                     validatedParams = validateSDKArguments(paramsSchema, params);
-                    return await invokeWithHumanInLoop(node, {
+                    const handlerContext = {
                         ...baseContext,
                         params: validatedParams
-                    }, runtimeOptions, commandPath);
+                    };
+                    return humanInLoop === undefined
+                        ? await node.handler(handlerContext)
+                        : await humanInLoop.invoke(node, handlerContext, commandPath);
                 }
                 catch (error) {
                     await writeErrorReport({

package/node_modules/@poe-code/task-list/dist/backends/markdown-dir.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { parseDocument, stringify } from "yaml";
-import taskSchema from "../schema/task.schema.json" with { type: "json" };
+import { TASK_SCHEMA_ID } from "../schema/ids.js";
 import { eventsFromState, findEvent } from "../state-machine.js";
 import { resolveStateMachine } from "../state.js";
 import { AnchorNotFoundError, InvalidTransitionError, MalformedTaskError, OrderMismatchError, TaskAlreadyExistsError, TaskNotFoundError } from "../types.js";
@@ -9,7 +9,6 @@ const ARCHIVE_DIRECTORY_NAME = "archive";
 const MARKDOWN_EXTENSION = ".md";
 const TASK_KIND = "task";
 const TASK_VERSION = 1;
-const TASK_SCHEMA_ID = taskSchema.$id;
 const MIN_PREFIX_WIDTH = 2;
 const RESERVED_FRONTMATTER_KEYS = new Set([
     "$schema",

package/node_modules/@poe-code/task-list/dist/backends/yaml-file.js

@@ -1,16 +1,13 @@
 import path from "node:path";
 import { isMap, parseDocument } from "yaml";
-import storeSchema from "../schema/store.schema.json" with { type: "json" };
-import taskSchema from "../schema/task.schema.json" with { type: "json" };
+import { STORE_SCHEMA_ID, TASK_SCHEMA_ID } from "../schema/ids.js";
 import { eventsFromState, findEvent } from "../state-machine.js";
 import { resolveStateMachine } from "../state.js";
 import { AnchorNotFoundError, InvalidTransitionError, MalformedTaskError, OrderMismatchError, TaskAlreadyExistsError, TaskNotFoundError } from "../types.js";
 import { applyOrder, isTrimmedPrintableIdentifier, isRecord, rejectSymbolicLinkComponents, sortStrings, statIfExists, validateTaskId, validateTaskName, withFileLock, writeAtomically } from "./utils.js";
 const STORE_KIND = "task-store";
-const STORE_SCHEMA_ID = storeSchema.$id;
 const STORE_VERSION = 1;
 const TASK_KIND = "task";
-const TASK_SCHEMA_ID = taskSchema.$id;
 const TASK_VERSION = 1;
 const RESERVED_TASK_KEYS = new Set([
     "$schema",

package/node_modules/@poe-code/task-list/dist/schema/ids.d.ts

@@ -0,0 +1,2 @@
+export declare const STORE_SCHEMA_ID = "https://poe-platform.github.io/poe-code/schemas/task-list/store.schema.json";
+export declare const TASK_SCHEMA_ID = "https://poe-platform.github.io/poe-code/schemas/task-list/task.schema.json";

package/node_modules/@poe-code/task-list/dist/schema/ids.js

@@ -0,0 +1,6 @@
+// Kept in sync with the sibling *.schema.json files by ids.test.ts. Inlined as
+// constants so every artifact surface (tsc dist, esbuild bundles) works without
+// runtime file lookups, and without JSON import attributes — a syntax error
+// before Node 18.20 despite the >=18.18 engines floor (#517).
+export const STORE_SCHEMA_ID = "https://poe-platform.github.io/poe-code/schemas/task-list/store.schema.json";
+export const TASK_SCHEMA_ID = "https://poe-platform.github.io/poe-code/schemas/task-list/task.schema.json";

package/node_modules/tiny-http-mcp-server/dist/cli.js

@@ -1,10 +1,14 @@
 #!/usr/bin/env node
 import { realpathSync } from "node:fs";
+import { createRequire } from "node:module";
 import { parseArgs } from "node:util";
 import { pathToFileURL } from "node:url";
 import { createHttpServer } from "./http-server.js";
 import { loadOAuthVerifier } from "./load-oauth-verifier.js";
-import packageJson from "../package.json" with { type: "json" };
+// createRequire instead of JSON import attributes: `with { type: "json" }` is a
+// syntax error before Node 18.20, and engines declares >=18.18 (#517).
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json");
 function readPackageInfo() {
     return {
         name: packageJson.name,

package/node_modules/tiny-stdio-mcp-server/dist/composition.json

@@ -8,7 +8,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.121",
+      "version": "0.0.123",
       "license": "MIT"
     }
   ]

package/node_modules/toolcraft-schema/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.121",
+  "version": "0.0.123",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.121",
+  "version": "0.0.123",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -22,10 +22,6 @@
       "types": "./dist/agent-defs.d.ts",
       "import": "./dist/agent-defs.js"
     },
-    "./agent-human-in-loop": {
-      "types": "./dist/agent-human-in-loop.d.ts",
-      "import": "./dist/agent-human-in-loop.js"
-    },
     "./agent-mcp-config": {
       "types": "./dist/agent-mcp-config.d.ts",
       "import": "./dist/agent-mcp-config.js"
@@ -94,10 +90,6 @@
       "types": "./dist/testing/index.d.ts",
       "import": "./dist/testing/index.js"
     },
-    "./task-list": {
-      "types": "./dist/task-list.d.ts",
-      "import": "./dist/task-list.js"
-    },
     "./tiny-mcp-client": {
       "types": "./dist/tiny-mcp-client.d.ts",
       "import": "./dist/tiny-mcp-client.js"
@@ -160,7 +152,7 @@
     "yaml"
   ],
   "optionalDependencies": {
-    "toolcraft-schema": "0.0.121",
+    "toolcraft-schema": "0.0.123",
     "toolcraft-design": "*",
     "@poe-code/frontmatter": "*",
     "@poe-code/agent-mcp-config": "*",

package/dist/agent-human-in-loop.d.ts

@@ -1 +0,0 @@
-export * from "@poe-code/agent-human-in-loop";

package/dist/agent-human-in-loop.js

@@ -1 +0,0 @@
-export * from "@poe-code/agent-human-in-loop";

package/dist/task-list.d.ts

@@ -1 +0,0 @@
-export * from "@poe-code/task-list";

package/dist/task-list.js

@@ -1 +0,0 @@
-export * from "@poe-code/task-list";

package/node_modules/@poe-code/task-list/dist/schema/store.schema.json

@@ -1,32 +0,0 @@
-{
-    "$schema": "https://json-schema.org/draft/2020-12/schema",
-    "$id": "https://poe-platform.github.io/poe-code/schemas/task-list/store.schema.json",
-    "title": "Task Store",
-    "description": "YAML multi-list task store.",
-    "type": "object",
-    "properties": {
-        "$schema": {
-            "type": "string",
-            "const": "https://poe-platform.github.io/poe-code/schemas/task-list/store.schema.json"
-        },
-        "kind": {
-            "type": "string",
-            "const": "task-store"
-        },
-        "version": {
-            "type": "integer",
-            "const": 1
-        },
-        "lists": {
-            "type": "object",
-            "additionalProperties": {
-                "type": "object",
-                "additionalProperties": {
-                    "$ref": "./task.schema.json"
-                }
-            }
-        }
-    },
-    "required": ["$schema", "kind", "version", "lists"],
-    "additionalProperties": false
-}

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

@@ -1,33 +0,0 @@
-{
-    "$schema": "https://json-schema.org/draft/2020-12/schema",
-    "$id": "https://poe-platform.github.io/poe-code/schemas/task-list/task.schema.json",
-    "title": "Task",
-    "description": "Persisted task payload used by task-list backends.",
-    "type": "object",
-    "properties": {
-        "$schema": {
-            "type": "string",
-            "const": "https://poe-platform.github.io/poe-code/schemas/task-list/task.schema.json"
-        },
-        "kind": {
-            "type": "string",
-            "const": "task"
-        },
-        "version": {
-            "type": "integer",
-            "const": 1
-        },
-        "name": {
-            "type": "string",
-            "minLength": 1
-        },
-        "state": {
-            "type": "string"
-        },
-        "description": {
-            "type": "string"
-        }
-    },
-    "required": ["name", "state"],
-    "additionalProperties": true
-}