@skrr-ai/cli 0.1.110 → 0.1.111

package/dist/commands/tasks/create-tree.js

@@ -11,11 +11,15 @@ exports.normalizeTreeRoots = normalizeTreeRoots;
 exports.planTree = planTree;
 const core_1 = require("@oclif/core");
 const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const prompt_1 = require("../../lib/prompt");
 const task_batch_1 = require("../../lib/task-batch");
 const write_target_1 = require("../../lib/write-target");
+const json_output_1 = require("../../lib/json-output");
+const web_url_1 = require("../../lib/web-url");
+const task_spec_verification_1 = require("../../lib/task-spec-verification");
 const tasks_1 = require("../../lib/tasks");
 /**
  * Nodes a re-run could not recognize: no externalKey of their own and no
@@ -95,10 +99,12 @@ function partialFailureResult(args) {
         mapping,
         failedAt,
         ...(args.failures ? { failures: args.failures } : {}),
-        rerun: prefix || args.keyed
-            ? 'Re-run the same keyed file with --resume to confirm existing IDs and create only missing nodes; --verify lists what exists and what is missing without writing. A submitted write may still finish; stable keys prevent duplicates.'
-            : 'Re-running creates un-keyed nodes again. Use mapping to continue by hand, or re-run with --external-key-prefix.',
-        ...(args.next && (prefix || args.keyed) ? { next: args.next } : {}),
+        rerun: !prefix && !args.keyed
+            ? 'Re-running creates un-keyed nodes again. Use mapping to continue by hand, or re-run with --external-key-prefix.'
+            : !failedAt.error.retryable
+                ? `Correct the rejected input before retrying: ${failedAt.error.message}. No automatic retry is suggested for this refusal.`
+                : 'Re-run the same keyed file with --resume to confirm existing IDs and create only missing nodes; --verify lists what exists and what is missing without writing. A submitted write may still finish; stable keys prevent duplicates.',
+        ...(args.next && failedAt.error.retryable && (prefix || args.keyed) ? { next: args.next } : {}),
         ...(warnings.length > 0 ? { warnings } : {}),
     };
 }
@@ -165,7 +171,8 @@ class TasksCreateTree extends base_command_1.BaseCommand {
         '(a "nodes" array, each node with optional "children"; {"root":{...,"children":[...]}} is accepted too). ' +
         'Put "me" in assigneeUserIds for yourself and "blockedByTempIds":["<tempId>"] for dependencies. ' +
         'Setting executionMode human with an explicit assignee avoids inheriting a Space lead agent. ' +
-        'Nodes with an externalKey (or under --external-key-prefix) are created once: a re-run, --resume or --verify finds them again.';
+        'Nodes with an externalKey (or under --external-key-prefix) are created once: a re-run, --resume or --verify finds them again. ' +
+        'A nodes array also creates sibling tasks. Use --readback to check declared structured fields after applying, or --verify-spec for a read-only field comparison.';
     static examples = [
         '<%= config.bin %> tasks create-tree --from-json tree.json --space <space-id> --json',
         '<%= config.bin %> tasks create-tree --from-json tree.json --space <space-id> --default-agent auto',
@@ -174,6 +181,8 @@ class TasksCreateTree extends base_command_1.BaseCommand {
         '<%= config.bin %> tasks create-tree --from-json tree.json --external-key-prefix mine/ --verify --json',
         '<%= config.bin %> tasks create-tree --from-json tree.json --external-key-prefix mine/ --resume',
         '<%= config.bin %> tasks create-tree --from-json tree.json --space <space-id> --project OSK-P-1 --expect-target skrr.ai',
+        '<%= config.bin %> tasks create-tree --from-json tasks.json --unassigned --readback --json',
+        '<%= config.bin %> tasks create-tree --from-json tasks.json --verify-spec --json',
     ];
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output the create-tree result as JSON' }),
@@ -186,8 +195,17 @@ class TasksCreateTree extends base_command_1.BaseCommand {
         }),
         verify: core_1.Flags.boolean({
             description: 'Read-only: report which nodes of this tree already exist (matched by externalKey) and which are missing, and write nothing. Exits 1 when any is missing or cannot be checked.',
-            exclusive: ['fresh', 'resume', 'dry-run', 'no-batch'],
+            exclusive: ['fresh', 'resume', 'dry-run', 'no-batch', 'verify-spec', 'readback'],
         }),
+        'verify-spec': core_1.Flags.boolean({
+            description: 'Read-only: find keyed tasks and compare the declared structured fields, including Expectations, labels and assignment. Rich-text description content is explicitly not compared. Never repairs drift.',
+            exclusive: ['fresh', 'resume', 'dry-run', 'no-batch', 'verify', 'readback', 'default-agent'],
+        }),
+        readback: core_1.Flags.boolean({
+            description: 'After applying, reread every confirmed Task and report declared structured-field mismatches and read failures. This checks declarations, not whether Expectations are met. No repair or retry is performed by the readback.',
+            exclusive: ['verify', 'verify-spec', 'dry-run'],
+        }),
+        unassigned: core_1.Flags.boolean({ description: 'Explicitly clear assignees on every node, suppressing session/parent/Space defaults while retaining any declared executor intent. Does not start tasks.', exclusive: ['default-agent'] }),
         'external-key-prefix': core_1.Flags.string({
             description: 'Generate externalKey for nodes that omit one; enables idempotent re-runs. Defaults to a prefix derived from the file content (see --fresh)',
         }),
@@ -214,6 +232,10 @@ class TasksCreateTree extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { flags } = await this.parse(TasksCreateTree);
+        this.setJsonOperation({ command: 'tasks:create-tree', mode: flags['verify-spec'] || flags.verify ? 'verify' : flags['dry-run'] ? 'dry_run' : 'execute' });
+        const unassignmentError = (0, tasks_1.taskUnassignmentFlagError)(flags);
+        if (unassignmentError)
+            this.failWithCliError({ message: unassignmentError, code: 'TASK_UNASSIGNED_CONFLICT', exit: 2, retryable: false });
         let input = {};
         try {
             input = await (0, prompt_1.readJsonBody)(flags['from-json']);
@@ -264,12 +286,42 @@ class TasksCreateTree extends base_command_1.BaseCommand {
         const scopes = new Map();
         for (const item of planned) {
             try {
+                (0, tasks_1.applyExplicitTaskUnassignment)(item.payload, Boolean(flags.unassigned));
+                const parentSpace = item.parentKey ? plannedByKey.get(item.parentKey)?.payload.spaceId : undefined;
+                if (!item.payload.spaceId && typeof parentSpace === 'string')
+                    item.payload.spaceId = parentSpace;
+                await this.resolveTaskResourceReferences(item.payload);
+                if (parentSpace && item.payload.spaceId && parentSpace !== item.payload.spaceId) {
+                    throw new Error('The Task Space contradicts its planned parent Space; no tasks were written.');
+                }
                 scopes.set(item.key, await (0, tasks_1.resolveTaskCreateScope)(item.payload, { parentTaskCache, projectCache }));
             }
             catch (err) {
                 defaultAgentErrors.push(`${item.key}: ${err.message}`);
             }
         }
+        // Validate project references through the same scoped read as `projects show`.
+        // A supplied Space must not bypass project validation during a dry run.
+        const scopedProjects = new Map();
+        for (const item of planned) {
+            const { spaceId, projectId } = item.payload;
+            if (typeof spaceId !== 'string' || typeof projectId !== 'string')
+                continue;
+            const cacheKey = JSON.stringify([spaceId, projectId]);
+            try {
+                if (!scopedProjects.has(cacheKey)) {
+                    scopedProjects.set(cacheKey, data_provider_1.dataService.getSpaceProject(spaceId, projectId));
+                }
+                const project = await scopedProjects.get(cacheKey);
+                if (!project || typeof project.id !== 'string')
+                    throw new Error('Project lookup returned no canonical id');
+                item.payload.projectId = project.id;
+            }
+            catch (err) {
+                const failure = (0, task_batch_1.describeApiFailure)(err);
+                defaultAgentErrors.push(`${item.key}: project '${projectId}' was not found or could not be read in space '${spaceId}': ${failure.message}`);
+            }
+        }
         // 2. Which nodes already exist? One bulk read, not one request per node.
         const lookups = planned
             .filter((item) => scopes.has(item.key) &&
@@ -299,7 +351,12 @@ class TasksCreateTree extends base_command_1.BaseCommand {
                 existingByKey.set(key, hit?.task ?? null);
             }
         }
-        if (flags.verify) {
+        if (flags.verify || flags['verify-spec']) {
+            for (const error of defaultAgentErrors) {
+                const item = planned.find((node) => error.startsWith(`${node.key}:`));
+                if (item)
+                    unverifiable.push({ tempId: item.key, reason: error });
+            }
             await this.verifyTree(planned, existingByKey, unverifiable, flags);
             return;
         }
@@ -355,7 +412,7 @@ class TasksCreateTree extends base_command_1.BaseCommand {
         if (errors.length > 0) {
             const result = { object: 'task_create_tree_validation', ok: false, errors, planned };
             if (flags.json)
-                this.log(JSON.stringify(result, null, 2));
+                this.printJsonOperation(result, { writeState: 'not_attempted' });
             else
                 this.log(`Create-tree validation failed:\n- ${errors.join('\n- ')}`);
             this.exit(1);
@@ -367,10 +424,12 @@ class TasksCreateTree extends base_command_1.BaseCommand {
         // Say so before anything is written, not only inside a dry run (OSK-S-440 #9).
         const agentAssignment = describeDefaultAgentAssignment(defaultAgentResolutions);
         const noteworthyAssignment = agentAssignment ? [agentAssignment] : [];
+        const target = await this.assertWriteTarget(flags['expect-target'], { preview: flags['dry-run'] });
         if (flags['dry-run']) {
             const result = {
                 object: 'task_create_tree_dry_run',
                 ok: true,
+                target,
                 count: planned.length,
                 ...(() => {
                     const dryWarnings = [
@@ -393,10 +452,11 @@ class TasksCreateTree extends base_command_1.BaseCommand {
                     externalKey: item.payload.externalKey,
                     action: plannedAction(existingByKey.get(item.key), Boolean(flags.resume)),
                     payload: item.payload,
+                    assignmentPreview: (0, tasks_1.taskAssignmentPreview)(item.payload),
                 })),
             };
             if (flags.json)
-                this.log(JSON.stringify(result, null, 2));
+                this.printJsonOperation(result);
             else {
                 this.log(`Dry run passed. ${planned.length} task(s) would be created/upserted.`);
                 for (const item of planned) {
@@ -419,99 +479,160 @@ class TasksCreateTree extends base_command_1.BaseCommand {
         if (agentAssignment && process.stderr.isTTY) {
             process.stderr.write(`Warning: ${agentAssignment.hint}\n`);
         }
-        // Everything above only read. From here a request writes, so say where, and
-        // honour a caller's `--expect-target` before the first one.
-        const target = await this.assertWriteTarget(flags['expect-target']);
+        // Every preflight passed. Track confirmed and submitted work separately:
+        // a request can continue on the server after its client is interrupted.
         const mapping = {};
         const results = [];
         const startedAt = Date.now();
         let rounds = 0;
         const next = this.nextCommand(flags);
-        // A half-applied tree reports the ids it did create; the only way back.
-        const reportPartial = (item, failure, err, failures) => {
-            if (results.length === 0 && !failures)
-                this.handleApiError(err);
-            const partial = partialFailureResult({
-                results,
-                mapping,
-                total: planned.length,
-                prefix: keyPrefix,
-                keyed: unkeyedNodes(planned).length === 0,
-                warnings,
-                failures,
-                next,
-                failedAt: {
-                    tempId: item.key,
-                    ...(item.parentKey ? { parentTempId: item.parentKey } : {}),
-                    title: item.payload.title,
-                    error: failure,
-                },
-            });
-            if (flags.json) {
-                this.log(JSON.stringify({ ...partial, target }, null, 2));
-                process.exitCode = partial.failedAt.error.retryable ? 5 : 1;
-                this.exit(partial.failedAt.error.retryable ? 5 : 1);
+        const submitted = new Set();
+        const interrupt = (signal) => {
+            const confirmed = Object.keys(mapping).length;
+            const unknown = [...submitted].filter((key) => !mapping[key]).length;
+            const recovery = unkeyedNodes(planned).length === 0
+                ? `Run ${next.replace(/ --resume$/, ' --verify')} to reconcile, then ${next} to continue.`
+                : 'Inspect the Space using the mapping before retrying: unkeyed nodes may be duplicated.';
+            // Signals can arrive while the network request is pending. Do not wait for
+            // it or claim it was cancelled: the server may still complete submitted rows.
+            try {
+                (0, node_fs_1.writeSync)(2, `Interrupted (${signal}). Confirmed ${confirmed} of ${planned.length}; ${unknown} submitted outcome(s) unknown. The server may still finish submitted writes. ${recovery}\n`);
+                if (!flags.json && confirmed > 0)
+                    (0, node_fs_1.writeSync)(2, `Confirmed mapping: ${JSON.stringify(mapping)}\n`);
+                if (flags.json)
+                    (0, node_fs_1.writeSync)(1, JSON.stringify((0, json_output_1.withCliOperation)({
+                        object: 'task_create_tree_result', ok: false, interrupted: true, signal,
+                        total: planned.length, count: confirmed, mapping: { ...mapping }, target,
+                        summary: { confirmed, unknown, notAttempted: planned.length - confirmed - unknown },
+                        recovery,
+                    }, { command: 'tasks:create-tree', mode: 'execute', outcome: 'failed', writeState: 'unknown' }), null, 2) + '\n');
             }
-            this.log(`Confirmed ${results.length} of ${planned.length} task(s); stopped at "${item.key}":`);
-            for (const [tempId, id] of Object.entries(mapping))
-                this.log(`- ${tempId} -> ${id}`);
-            this.log(partial.rerun);
-            if (partial.next)
-                this.log(`Next: ${partial.next}`);
-            if (failures) {
-                for (const row of failures) {
-                    const detail = row.error;
-                    this.log(`- ${String(row.tempId)}: ${String(row.outcome)} — ${detail.message}`);
-                }
-                this.exit(failure.retryable ? 5 : 1);
-                return;
+            finally {
+                process.exit(signal === 'SIGINT' ? 130 : 143);
             }
-            this.handleApiError(err);
         };
-        // Blockers a node names by tempId, as the real ids the serial path needs.
-        const blockerIdsFor = (item) => {
-            const ids = [];
-            for (const blockerKey of item.blockerKeys ?? []) {
-                const id = mapping[blockerKey];
-                if (!id) {
-                    this.error(`Blocker tempId "${blockerKey}" was not created before "${item.key}"`, {
-                        exit: 1,
-                    });
+        const onSigint = () => interrupt('SIGINT');
+        const onSigterm = () => interrupt('SIGTERM');
+        process.on('SIGINT', onSigint);
+        process.on('SIGTERM', onSigterm);
+        try {
+            // A half-applied tree reports the ids it did create; the only way back.
+            const reportPartial = (item, failure, err, failures) => {
+                if (failure.code === 'PROJECT_NOT_FOUND') {
+                    failure = { ...failure, message: `Project '${String(item.payload.projectId)}' was not found in space '${String(item.payload.spaceId)}'. Correct --project or the node's projectId` };
                 }
-                ids.push(id);
-            }
-            return ids;
-        };
-        // The serial path: one request per node. Used for updates of existing keyed
-        // nodes, for every create against a server without the batch route, and for
-        // everything under --no-batch.
-        const applySerial = async (item) => {
-            const payload = { ...item.payload };
-            if (item.parentKey) {
-                payload.parentId = mapping[item.parentKey];
-                if (!payload.parentId) {
-                    this.error(`Parent tempId "${item.parentKey}" was not created before "${item.key}"`, {
-                        exit: 1,
+                const failureRows = failures ?? [{
+                        tempId: item.key,
+                        externalKey: item.payload.externalKey,
+                        outcome: !failure.status || failure.status === 408 || failure.status >= 500 ? 'unknown' : 'failed',
+                        error: failure,
+                    }];
+                const accountedFor = new Set([...Object.keys(mapping), ...failureRows.map((row) => String(row.tempId))]);
+                for (const node of planned) {
+                    if (accountedFor.has(node.key))
+                        continue;
+                    failureRows.push({
+                        tempId: node.key,
+                        externalKey: node.payload.externalKey,
+                        outcome: 'not_attempted',
+                        error: { message: 'Not attempted because an earlier node stopped the tree', retryable: true },
                     });
                 }
-            }
-            const blockerIds = blockerIdsFor(item);
-            let action;
-            let task;
-            try {
-                if (typeof payload.externalKey === 'string' && payload.externalKey.trim()) {
-                    const existingTask = existingByKey.get(item.key) ?? null;
-                    if (existingTask) {
-                        action = 'updated';
-                        const patch = (0, tasks_1.removeUndefinedFields)((0, tasks_1.createPatchFromCreatePayload)(payload));
-                        // Adding is idempotent, so a re-run never duplicates or drops an edge.
-                        if (blockerIds.length > 0)
-                            patch.addBlockedByIds = blockerIds;
-                        task = await data_provider_1.dataService.updateTask({
-                            taskId: (0, tasks_1.taskId)(existingTask),
-                            data: patch,
+                const partial = partialFailureResult({
+                    results,
+                    mapping,
+                    total: planned.length,
+                    prefix: keyPrefix,
+                    keyed: unkeyedNodes(planned).length === 0,
+                    warnings,
+                    failures: failureRows,
+                    next,
+                    failedAt: {
+                        tempId: item.key,
+                        ...(item.parentKey ? { parentTempId: item.parentKey } : {}),
+                        title: item.payload.title,
+                        error: failure,
+                    },
+                });
+                if (flags.json) {
+                    this.printJsonOperation({ ...partial, target }, { outcome: 'failed', writeState: partial.summary.unknown > 0 ? 'unknown' : 'confirmed' });
+                    process.exitCode = partial.failedAt.error.retryable ? 5 : 1;
+                    this.exit(partial.failedAt.error.retryable ? 5 : 1);
+                }
+                this.log(`Confirmed ${results.length} of ${planned.length} task(s); stopped at "${item.key}": ${failure.message}`);
+                for (const [tempId, id] of Object.entries(mapping))
+                    this.log(`- ${tempId} -> ${id}`);
+                this.log(partial.rerun);
+                if (partial.next)
+                    this.log(`Next: ${partial.next}`);
+                if (failures) {
+                    for (const row of failures) {
+                        const detail = row.error;
+                        this.log(`- ${String(row.tempId)}: ${String(row.outcome)} — ${detail.message}`);
+                    }
+                    this.exit(failure.retryable ? 5 : 1);
+                    return;
+                }
+                this.handleApiError(err);
+            };
+            // Blockers a node names by tempId, as the real ids the serial path needs.
+            const blockerIdsFor = (item) => {
+                const ids = [];
+                for (const blockerKey of item.blockerKeys ?? []) {
+                    const id = mapping[blockerKey];
+                    if (!id) {
+                        this.error(`Blocker tempId "${blockerKey}" was not created before "${item.key}"`, {
+                            exit: 1,
+                        });
+                    }
+                    ids.push(id);
+                }
+                return ids;
+            };
+            // The serial path: one request per node. Used for updates of existing keyed
+            // nodes, for every create against a server without the batch route, and for
+            // everything under --no-batch.
+            const applySerial = async (item) => {
+                const payload = { ...item.payload };
+                if (item.parentKey) {
+                    payload.parentId = mapping[item.parentKey];
+                    if (!payload.parentId) {
+                        this.error(`Parent tempId "${item.parentKey}" was not created before "${item.key}"`, {
+                            exit: 1,
                         });
                     }
+                }
+                const blockerIds = blockerIdsFor(item);
+                let action;
+                let task;
+                try {
+                    submitted.add(item.key);
+                    if (typeof payload.externalKey === 'string' && payload.externalKey.trim()) {
+                        const existingTask = existingByKey.get(item.key) ?? null;
+                        if (existingTask) {
+                            action = 'updated';
+                            const patch = (0, tasks_1.removeUndefinedFields)((0, tasks_1.createPatchFromCreatePayload)(payload));
+                            // Adding is idempotent, so a re-run never duplicates or drops an edge.
+                            if (blockerIds.length > 0)
+                                patch.addBlockedByIds = blockerIds;
+                            task = await data_provider_1.dataService.updateTask({
+                                taskId: (0, tasks_1.taskId)(existingTask),
+                                data: patch,
+                            });
+                        }
+                        else {
+                            action = 'created';
+                            if (blockerIds.length > 0) {
+                                payload.blockedByIds = [
+                                    ...new Set([
+                                        ...(payload.blockedByIds ?? []),
+                                        ...blockerIds,
+                                    ]),
+                                ];
+                            }
+                            task = await data_provider_1.dataService.createTask(payload);
+                        }
+                    }
                     else {
                         action = 'created';
                         if (blockerIds.length > 0) {
@@ -525,147 +646,183 @@ class TasksCreateTree extends base_command_1.BaseCommand {
                         task = await data_provider_1.dataService.createTask(payload);
                     }
                 }
-                else {
-                    action = 'created';
-                    if (blockerIds.length > 0) {
-                        payload.blockedByIds = [
-                            ...new Set([
-                                ...(payload.blockedByIds ?? []),
-                                ...blockerIds,
-                            ]),
-                        ];
-                    }
-                    task = await data_provider_1.dataService.createTask(payload);
+                catch (err) {
+                    reportPartial(item, (0, task_batch_1.describeApiFailure)(err), err);
+                    return;
                 }
-            }
-            catch (err) {
-                reportPartial(item, (0, task_batch_1.describeApiFailure)(err), err);
-                return;
-            }
-            const id = (0, tasks_1.taskId)(task);
-            mapping[item.key] = id;
-            results.push({
-                tempId: item.key,
-                parentTempId: item.parentKey,
-                id,
-                action,
-                externalKey: payload.externalKey,
-                title: task.title ?? payload.title,
-                task,
-            });
-        };
-        // A person watching sees the tree being built; anything capturing output
-        // sees nothing extra (the answer is the JSON / summary at the end).
-        const onProgress = process.stderr.isTTY
-            ? (p) => {
-                process.stderr.write(p.waiting
-                    ? `Waiting ${Math.max(1, Math.round(p.waiting.ms / 1000))}s before trying again (${p.waiting.reason}); ${p.confirmed} of ${p.total} confirmed.\n`
-                    : `Confirmed ${p.confirmed} of ${p.total} (request ${p.round}, ${Math.round(p.elapsedMs / 1000)}s).\n`);
-            }
-            : undefined;
-        // New nodes go to POST /api/tasks/batch, and the batch is driven until every
-        // one exists (createNodesViaBatch). `batchAvailable` flips off the first time
-        // the server answers 404/405, or under --no-batch, and every later node is serial.
-        let batchAvailable = !flags['no-batch'];
-        let pending = [];
-        const flushPending = async () => {
-            const nodes = pending;
-            pending = [];
-            if (nodes.length === 0)
-                return;
-            if (batchAvailable) {
-                const outcome = await (0, task_batch_1.createNodesViaBatch)(nodes.map((n) => ({
-                    key: n.key,
-                    parentKey: n.parentKey,
-                    blockerKeys: n.blockerKeys,
-                    payload: n.payload,
-                })), mapping, { onProgress });
-                if (outcome.supported) {
-                    rounds += outcome.rounds;
-                    const byKey = new Map(nodes.map((n) => [n.key, n]));
-                    for (const row of outcome.rows) {
-                        const node = byKey.get(row.key);
-                        results.push({
-                            tempId: row.key,
-                            parentTempId: node.parentKey,
-                            id: row.id,
-                            action: row.status === 'exists' ? 'existing' : 'created',
-                            externalKey: row.externalKey ?? node.payload.externalKey,
-                            title: node.payload.title,
-                            task: {
+                const id = (0, tasks_1.taskId)(task);
+                mapping[item.key] = id;
+                results.push({
+                    tempId: item.key,
+                    parentTempId: item.parentKey,
+                    id,
+                    action,
+                    externalKey: payload.externalKey,
+                    title: task.title ?? payload.title,
+                    task,
+                });
+            };
+            // A person watching sees the tree being built; anything capturing output
+            // sees nothing extra (the answer is the JSON / summary at the end).
+            const onProgress = (p) => {
+                submitted.clear();
+                for (const key of p.unknownKeys ?? [])
+                    submitted.add(key);
+                if (process.stderr.isTTY) {
+                    process.stderr.write(p.waiting
+                        ? `Waiting ${Math.max(1, Math.round(p.waiting.ms / 1000))}s before trying again (${p.waiting.reason}); ${p.confirmed} of ${p.total} confirmed.\n`
+                        : `Confirmed ${p.confirmed} of ${p.total} (request ${p.round}, ${Math.round(p.elapsedMs / 1000)}s).\n`);
+                }
+            };
+            // New nodes go to POST /api/tasks/batch, and the batch is driven until every
+            // one exists (createNodesViaBatch). `batchAvailable` flips off the first time
+            // the server answers 404/405, or under --no-batch, and every later node is serial.
+            let batchAvailable = !flags['no-batch'];
+            let pending = [];
+            const flushPending = async () => {
+                const nodes = pending;
+                pending = [];
+                if (nodes.length === 0)
+                    return;
+                if (batchAvailable) {
+                    const outcome = await (0, task_batch_1.createNodesViaBatch)(nodes.map((n) => ({
+                        key: n.key,
+                        parentKey: n.parentKey,
+                        blockerKeys: n.blockerKeys,
+                        payload: n.payload,
+                    })), mapping, { onProgress, onSubmit: (nodes) => nodes.forEach((node) => submitted.add(node.key)) });
+                    if (outcome.supported) {
+                        rounds += outcome.rounds;
+                        const byKey = new Map(nodes.map((n) => [n.key, n]));
+                        for (const row of outcome.rows) {
+                            const node = byKey.get(row.key);
+                            results.push({
+                                tempId: row.key,
+                                parentTempId: node.parentKey,
                                 id: row.id,
-                                ...(row.identifier ? { identifier: row.identifier } : {}),
+                                action: row.status === 'exists' ? 'existing' : 'created',
+                                externalKey: row.externalKey ?? node.payload.externalKey,
                                 title: node.payload.title,
-                            },
-                        });
+                                task: {
+                                    id: row.id,
+                                    ...(row.identifier ? { identifier: row.identifier } : {}),
+                                    title: node.payload.title,
+                                },
+                            });
+                        }
+                        const failure = outcome.failures.find((f) => !f.skipped) ?? outcome.failures[0];
+                        if (failure) {
+                            const node = byKey.get(failure.key);
+                            const err = Object.assign(new Error(failure.error.message), {
+                                ...(failure.error.status ? { status: failure.error.status } : {}),
+                                ...(failure.error.code ? { code: failure.error.code } : {}),
+                            });
+                            reportPartial(node, failure.error, err, outcome.failures.map((f) => ({
+                                tempId: f.key,
+                                outcome: f.outcome ?? (f.skipped ? 'not_attempted' : 'failed'),
+                                externalKey: f.externalKey ?? byKey.get(f.key)?.payload.externalKey,
+                                error: f.error,
+                            })));
+                        }
+                        return;
                     }
-                    const failure = outcome.failures.find((f) => !f.skipped) ?? outcome.failures[0];
-                    if (failure) {
-                        const node = byKey.get(failure.key);
-                        const err = Object.assign(new Error(failure.error.message), {
-                            ...(failure.error.status ? { status: failure.error.status } : {}),
-                            ...(failure.error.code ? { code: failure.error.code } : {}),
+                    batchAvailable = false;
+                }
+                for (const node of nodes)
+                    await applySerial(node);
+            };
+            for (const item of planned) {
+                const existingTask = existingByKey.get(item.key) ?? null;
+                if (existingTask) {
+                    // An update must see its parent's id, and a later create its own parent's.
+                    await flushPending();
+                    if (flags.resume) {
+                        const id = (0, tasks_1.taskId)(existingTask);
+                        mapping[item.key] = id;
+                        results.push({
+                            tempId: item.key,
+                            parentTempId: item.parentKey,
+                            id,
+                            action: 'existing',
+                            externalKey: item.payload.externalKey,
+                            title: existingTask.title ?? item.payload.title,
+                            task: existingTask,
                         });
-                        reportPartial(node, failure.error, err, outcome.failures.map((f) => ({
-                            tempId: f.key,
-                            outcome: f.outcome ?? (f.skipped ? 'not_attempted' : 'failed'),
-                            externalKey: f.externalKey ?? byKey.get(f.key)?.payload.externalKey,
-                            error: f.error,
-                        })));
                     }
-                    return;
+                    else
+                        await applySerial(item);
                 }
-                batchAvailable = false;
-            }
-            for (const node of nodes)
-                await applySerial(node);
-        };
-        for (const item of planned) {
-            const existingTask = existingByKey.get(item.key) ?? null;
-            if (existingTask) {
-                // An update must see its parent's id, and a later create its own parent's.
-                await flushPending();
-                if (flags.resume) {
-                    const id = (0, tasks_1.taskId)(existingTask);
-                    mapping[item.key] = id;
-                    results.push({
-                        tempId: item.key,
-                        parentTempId: item.parentKey,
-                        id,
-                        action: 'existing',
-                        externalKey: item.payload.externalKey,
-                        title: existingTask.title ?? item.payload.title,
-                        task: existingTask,
-                    });
+                else {
+                    pending.push(item);
                 }
-                else
-                    await applySerial(item);
             }
-            else {
-                pending.push(item);
+            await flushPending();
+            for (const result of results) {
+                result.url = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, result.task);
             }
+            const verification = flags.readback
+                ? await this.readbackSpecifications(planned, mapping)
+                : undefined;
+            const summary = {
+                object: 'task_create_tree_result',
+                ok: verification ? verification.ok : true,
+                ...(warnings.length > 0 ? { warnings } : {}),
+                count: results.length,
+                defaultAgents: defaultAgentResolutions,
+                target,
+                timing: { elapsedMs: Date.now() - startedAt, requests: rounds },
+                mapping,
+                results,
+                ...(verification ? { verification } : {}),
+            };
+            if (flags.json) {
+                this.printJsonOperation(summary, { writeState: 'confirmed' });
+                if (verification && !verification.ok)
+                    this.exit(1);
+                return;
+            }
+            this.log(`Created task tree (${results.length} task(s)).`);
+            for (const item of results) {
+                const task = item.task;
+                this.log(`- ${item.tempId}: ${item.action} ${(0, tasks_1.formatTaskLabel)(task)}`);
+                if (item.url)
+                    this.log(`  ${item.url}`);
+            }
+            if (verification)
+                this.printSpecificationSummary(verification);
+            if (verification && !verification.ok)
+                this.exit(1);
         }
-        await flushPending();
-        const summary = {
-            object: 'task_create_tree_result',
-            ok: true,
-            ...(warnings.length > 0 ? { warnings } : {}),
-            count: results.length,
-            defaultAgents: defaultAgentResolutions,
-            target,
-            timing: { elapsedMs: Date.now() - startedAt, requests: rounds },
-            mapping,
-            results,
-        };
-        if (flags.json) {
-            this.log(JSON.stringify(summary, null, 2));
-            return;
+        finally {
+            process.removeListener('SIGINT', onSigint);
+            process.removeListener('SIGTERM', onSigterm);
         }
-        this.log(`Created task tree (${results.length} task(s)).`);
-        for (const item of results) {
-            const task = item.task;
-            this.log(`- ${item.tempId}: ${item.action} ${(0, tasks_1.formatTaskLabel)(task)}`);
+    }
+    async readbackSpecifications(planned, mapping) {
+        const inputs = planned.map(item => {
+            const expected = { ...item.payload };
+            if (item.parentKey)
+                expected.parentId = mapping[item.parentKey];
+            if (item.blockerKeys?.length)
+                expected.blockedByIds = [...new Set([
+                        ...(expected.blockedByIds ?? []),
+                        ...item.blockerKeys.map(key => mapping[key]),
+                    ])];
+            return { tempId: item.key, id: mapping[item.key], expected };
+        });
+        return (0, task_spec_verification_1.verifyTaskSpecifications)(inputs, id => data_provider_1.dataService.getTask(id, { enrich: false }));
+    }
+    printSpecificationSummary(verification) {
+        const { summary } = verification;
+        this.log(`Structured-field readback: ${summary.matched} match; ${summary.mismatched} differ; ${summary.unavailable} unavailable.`);
+        for (const row of verification.results) {
+            for (const mismatch of row.mismatches)
+                this.log(`- ${row.tempId}: ${mismatch.field} differs`);
+            if (row.error)
+                this.log(`- ${row.tempId}: cannot read — ${row.error}`);
         }
+        if (summary.withUncheckedFields)
+            this.log('Some authored fields are explicitly unchecked; inspect verification.results[].uncheckedFields. No Expectation assessment was performed.');
     }
     /**
      * `--verify`: which nodes of this tree exist, and which do not. Read-only by
@@ -692,6 +849,7 @@ class TasksCreateTree extends base_command_1.BaseCommand {
                     ...(typeof task.identifier === 'string' ? { identifier: task.identifier } : {}),
                     externalKey: item.payload.externalKey,
                     title: task.title ?? item.payload.title,
+                    url: (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, task),
                 });
             }
             else {
@@ -703,7 +861,26 @@ class TasksCreateTree extends base_command_1.BaseCommand {
                 });
             }
         }
-        const ok = missing.length === 0 && cannotCheck.size === 0;
+        let verification;
+        if (flags['verify-spec']) {
+            const mapping = Object.fromEntries(existing.map(row => [String(row.tempId), String(row.id)]));
+            const checkable = [];
+            for (const item of planned) {
+                if (!mapping[item.key] || cannotCheck.has(item.key))
+                    continue;
+                const unresolved = [item.parentKey, ...(item.blockerKeys ?? [])].filter(key => key && !mapping[key]);
+                if (unresolved.length) {
+                    cannotCheck.set(item.key, `Cannot resolve related node(s): ${unresolved.join(', ')}`);
+                    continue;
+                }
+                // Resolve only explicitly authored names. Read-only verification must
+                // not re-derive who a current Space lead would assign today.
+                await this.resolveAssigneesInPayload(item.payload);
+                checkable.push(item);
+            }
+            verification = await this.readbackSpecifications(checkable, mapping);
+        }
+        const ok = missing.length === 0 && cannotCheck.size === 0 && (!verification || verification.ok);
         const result = {
             object: 'task_create_tree_verification',
             ok,
@@ -716,11 +893,12 @@ class TasksCreateTree extends base_command_1.BaseCommand {
             existing,
             missing,
             unverifiable: [...cannotCheck].map(([tempId, reason]) => ({ tempId, reason })),
+            ...(verification ? { verification } : {}),
             target: await this.describeWriteTarget(),
             ...(missing.length > 0 ? { next: this.nextCommand(flags) } : {}),
         };
         if (flags.json) {
-            this.log(JSON.stringify(result, null, 2));
+            this.printJsonOperation(result);
         }
         else {
             this.log(`${existing.length} of ${planned.length} node(s) exist; ${missing.length} missing` +
@@ -732,6 +910,8 @@ class TasksCreateTree extends base_command_1.BaseCommand {
                 this.log(`- cannot check: ${tempId} — ${reason}`);
             if (result.next)
                 this.log(`Next: ${result.next}`);
+            if (verification)
+                this.printSpecificationSummary(verification);
         }
         if (!ok)
             this.exit(1);