@aopslabs/aops 0.3.31 → 0.3.33

package/dist/commands/runner.js

@@ -0,0 +1,257 @@
+import { randomUUID } from 'node:crypto';
+import { Command } from 'commander';
+import { compactPayload, normalizeNonEmpty } from '../utils/command.js';
+import { buildOperatorCookbook } from '../utils/hosted-sugar.js';
+import { GUIDE_PATHS } from '../utils/guide-paths.js';
+import { applyTaskerContextOptions, applyTaskerWriteOptions, executeTaskerTool, parseTaskerObject, } from './tasker.js';
+function required(value, flag) {
+    const normalized = normalizeNonEmpty(value);
+    if (!normalized)
+        throw new Error(`${flag} is required unless --input supplies the full hosted-tool input.`);
+    return normalized;
+}
+function fullInputOr(options, build) {
+    return options.input ? parseTaskerObject(options.input, '--input') : build();
+}
+function addRunnerReadOptions(command) {
+    return command
+        .option('--run-id <id>', 'Canonical Tasker runner run id')
+        .option('--input <json|@file>', 'Full hosted-tool input JSON escape hatch')
+        .option('--summary', 'Print a compact Runner projection and omit bulky event/meta payloads');
+}
+export function summarizeRunnerStatusResult(result) {
+    if (!result || typeof result !== 'object' || Array.isArray(result))
+        return result;
+    const envelope = result;
+    const data = envelope.data;
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        return result;
+    const record = data;
+    if (!record.summary || typeof record.summary !== 'object')
+        return result;
+    const scheduling = record.scheduling && typeof record.scheduling === 'object' && !Array.isArray(record.scheduling)
+        ? record.scheduling
+        : undefined;
+    return {
+        ...envelope,
+        data: compactPayload({
+            summary: record.summary,
+            scheduling: scheduling
+                ? compactPayload({
+                    ready: scheduling.ready,
+                    waiting: scheduling.waiting,
+                    blockedByFailure: scheduling.blockedByFailure,
+                    stalled: scheduling.stalled,
+                    terminal: scheduling.terminal,
+                    nextReady: scheduling.nextReady,
+                })
+                : undefined,
+        }),
+    };
+}
+async function runRead(options, params) {
+    await executeTaskerTool(options, {
+        command: params.command,
+        toolId: params.toolId,
+        successText: params.successText,
+        buildInput: () => fullInputOr(options, params.build),
+        summarizeResult: params.summarizeResult,
+    });
+}
+function buildControlInput(options, kind) {
+    if (options.input)
+        return parseTaskerObject(options.input, '--input');
+    const runId = required(options.runId, '--run-id');
+    const idempotencyKey = required(options.idempotencyKey, '--idempotency-key');
+    return {
+        reconcileState: {
+            schemaVersion: 'tasker.loop-runner.v2',
+            runId,
+            reconcileId: normalizeNonEmpty(options.reconcileId) ?? randomUUID(),
+            kind,
+            state: normalizeNonEmpty(options.state) ?? 'pending',
+            requestedBy: {
+                kind: 'operator',
+                id: normalizeNonEmpty(options.operatorId) ?? 'aops-cli',
+            },
+            requestedAt: normalizeNonEmpty(options.requestedAt) ?? new Date().toISOString(),
+            replaysCanonicalWrites: false,
+            idempotencyKey,
+        },
+        idempotencyKey,
+    };
+}
+function addControlCommand(root, name) {
+    applyTaskerContextOptions(applyTaskerWriteOptions(root.command(name)
+        .description(`${name === 'stop' ? 'Stop' : 'Resume'} a Tasker runner run through the guarded control surface`)
+        .option('--run-id <id>', 'Canonical Tasker runner run id')
+        .option('--input <json|@file>', 'Full hosted-tool input JSON escape hatch')
+        .option('--reconcile-id <id>', 'Optional reconcile id; defaults to a generated UUID')
+        .option('--state <state>', 'Reconcile state', 'pending')
+        .option('--operator-id <id>', 'Operator actor id', 'aops-cli')
+        .option('--requested-at <timestamp>', 'Operator request timestamp; defaults to now')).action(async (options) => {
+        await executeTaskerTool(options, {
+            command: `runner.${name}`,
+            toolId: `tasker.loop-runner-v2.control.${name}`,
+            write: true,
+            successText: `Tasker runner ${name} request completed.`,
+            buildInput: () => buildControlInput(options, name),
+        });
+    }));
+}
+export function makeRunnerCommand() {
+    const command = new Command('runner').description('Tasker Loop Runner v2 status and guarded control sugar');
+    applyTaskerContextOptions(addRunnerReadOptions(command.command('status').description('Get a Tasker runner status snapshot'))
+        .option('--include-events', 'Include recent events')
+        .option('--include-artifacts', 'Include artifact refs')
+        .action(async (options) => {
+        await runRead(options, {
+            command: 'runner.status',
+            toolId: 'tasker.loop-runner-v2.status.get',
+            successText: 'Tasker runner status loaded.',
+            summarizeResult: summarizeRunnerStatusResult,
+            build: () => compactPayload({
+                runId: required(options.runId, '--run-id'),
+                includeEvents: options.includeEvents === true ? true : undefined,
+                includeArtifacts: options.includeArtifacts === true ? true : undefined,
+            }),
+        });
+    }));
+    const event = command.command('event').description('Tasker runner event reads');
+    applyTaskerContextOptions(addRunnerReadOptions(event.command('list').description('List events for a Tasker runner run'))
+        .option('--slice-id <id>', 'Optional slice id filter')
+        .option('--after-sequence <value>', 'Return events after this sequence', (value) => Number.parseInt(String(value), 10))
+        .option('--limit <value>', 'Result limit', (value) => Number.parseInt(String(value), 10))
+        .action(async (options) => {
+        await runRead(options, {
+            command: 'runner.event.list',
+            toolId: 'tasker.loop-runner-v2.event.list',
+            successText: 'Tasker runner events loaded.',
+            build: () => compactPayload({
+                runId: required(options.runId, '--run-id'),
+                sliceId: options.sliceId,
+                afterSequence: options.afterSequence,
+                limit: options.limit,
+            }),
+        });
+    }));
+    const artifact = command.command('artifact').description('Tasker runner artifact reads');
+    applyTaskerContextOptions(addRunnerReadOptions(artifact.command('list').description('List artifact refs for a Tasker runner run'))
+        .option('--slice-id <id>', 'Optional slice id filter')
+        .option('--kind <kind>', 'Optional artifact kind filter')
+        .option('--limit <value>', 'Result limit', (value) => Number.parseInt(String(value), 10))
+        .action(async (options) => {
+        await runRead(options, {
+            command: 'runner.artifact.list',
+            toolId: 'tasker.loop-runner-v2.artifact.list',
+            successText: 'Tasker runner artifacts loaded.',
+            build: () => compactPayload({
+                runId: required(options.runId, '--run-id'),
+                sliceId: options.sliceId,
+                kind: options.kind,
+                limit: options.limit,
+            }),
+        });
+    }));
+    const worker = command.command('worker').description('Tasker runner atomic worker lease operations');
+    applyTaskerContextOptions(applyTaskerWriteOptions(worker.command('claim')
+        .description('Atomically claim the next ready slice, or one explicit ready slice with --slice-id')
+        .option('--run-id <id>', 'Canonical Tasker runner run id')
+        .option('--slice-id <id>', 'Optional explicit ready slice; omit for deterministic claim-next')
+        .option('--lease-id <id>', 'Lease id; defaults to a generated UUID')
+        .option('--worker-id <id>', 'Worker identity', 'aops-cli')
+        .option('--runtime-key <key>', 'Worker runtime key', 'aops-cli-loop')
+        .option('--claimed-at <timestamp>', 'Claim timestamp; defaults to now')
+        .option('--expires-at <timestamp>', 'Lease expiry; defaults to claimed-at plus --ttl-sec')
+        .option('--ttl-sec <seconds>', 'Default lease TTL when --expires-at is omitted', (value) => Number.parseInt(String(value), 10), 300)
+        .option('--input <json|@file>', 'Full hosted-tool input JSON escape hatch')).action(async (options) => {
+        await executeTaskerTool(options, {
+            command: 'runner.worker.claim',
+            toolId: 'tasker.loop-runner-v2.worker.claim',
+            write: true,
+            successText: 'Tasker runner worker lease claim completed.',
+            buildInput: () => fullInputOr(options, () => {
+                const claimedAt = new Date(normalizeNonEmpty(options.claimedAt) ?? Date.now());
+                const ttlSec = Number.isInteger(options.ttlSec) && Number(options.ttlSec) > 0 ? Number(options.ttlSec) : 300;
+                const expiresAt = normalizeNonEmpty(options.expiresAt)
+                    ? new Date(String(options.expiresAt))
+                    : new Date(claimedAt.getTime() + ttlSec * 1000);
+                return compactPayload({
+                    runId: required(options.runId, '--run-id'),
+                    sliceId: options.sliceId,
+                    leaseId: normalizeNonEmpty(options.leaseId) ?? randomUUID(),
+                    workerId: normalizeNonEmpty(options.workerId) ?? 'aops-cli',
+                    runtimeKey: normalizeNonEmpty(options.runtimeKey) ?? 'aops-cli-loop',
+                    permissions: {
+                        canSpawnNestedAgents: false,
+                        canMerge: false,
+                        canAccessSecrets: false,
+                        requiresForegroundSupervision: true,
+                    },
+                    claimedAt: claimedAt.toISOString(),
+                    expiresAt: expiresAt.toISOString(),
+                    idempotencyKey: required(options.idempotencyKey, '--idempotency-key'),
+                });
+            }),
+        });
+    }));
+    applyTaskerContextOptions(applyTaskerWriteOptions(worker.command('release')
+        .description('Atomically release, cancel, or fail one worker lease')
+        .option('--run-id <id>', 'Canonical Tasker runner run id')
+        .option('--lease-id <id>', 'Lease id')
+        .option('--worker-id <id>', 'Optional worker identity guard')
+        .option('--terminal-state <state>', 'released | cancelled | failed', 'released')
+        .option('--released-at <timestamp>', 'Terminal transition timestamp; defaults to now')
+        .option('--input <json|@file>', 'Full hosted-tool input JSON escape hatch')).action(async (options) => {
+        await executeTaskerTool(options, {
+            command: 'runner.worker.release',
+            toolId: 'tasker.loop-runner-v2.worker.release',
+            write: true,
+            successText: 'Tasker runner worker lease release completed.',
+            buildInput: () => fullInputOr(options, () => compactPayload({
+                runId: required(options.runId, '--run-id'),
+                leaseId: required(options.leaseId, '--lease-id'),
+                workerId: options.workerId,
+                terminalState: normalizeNonEmpty(options.terminalState) ?? 'released',
+                releasedAt: new Date(normalizeNonEmpty(options.releasedAt) ?? Date.now()).toISOString(),
+                idempotencyKey: required(options.idempotencyKey, '--idempotency-key'),
+            })),
+        });
+    }));
+    addControlCommand(command, 'stop');
+    addControlCommand(command, 'resume');
+    applyTaskerContextOptions(applyTaskerWriteOptions(command.command('reconcile')
+        .description('Request a guarded Tasker runner reconciliation')
+        .option('--run-id <id>', 'Canonical Tasker runner run id')
+        .option('--kind <kind>', 'Reconcile kind: cleanup, status, cost-usage, artifact, or review')
+        .option('--input <json|@file>', 'Full hosted-tool input JSON escape hatch')
+        .option('--reconcile-id <id>', 'Optional reconcile id; defaults to a generated UUID')
+        .option('--state <state>', 'Reconcile state', 'pending')
+        .option('--operator-id <id>', 'Operator actor id', 'aops-cli')
+        .option('--requested-at <timestamp>', 'Operator request timestamp; defaults to now')).action(async (options) => {
+        const kind = options.input ? 'status' : required(options.kind, '--kind');
+        await executeTaskerTool(options, {
+            command: 'runner.reconcile',
+            toolId: 'tasker.loop-runner-v2.control.reconcile',
+            write: true,
+            successText: 'Tasker runner reconcile request completed.',
+            buildInput: () => buildControlInput(options, kind),
+        });
+    }));
+    command.addHelpText('after', buildOperatorCookbook({
+        examples: [
+            'aops runner status --run-id <run-id> --include-events --json',
+            'aops runner worker claim --run-id <run-id> --worker-id <worker-id> --idempotency-key <key> --apply --json',
+            'aops runner worker release --run-id <run-id> --lease-id <lease-id> --terminal-state released --idempotency-key <key> --apply --json',
+            'aops runner stop --run-id <run-id> --idempotency-key <key> --preview --json',
+            'aops runner reconcile --run-id <run-id> --kind status --idempotency-key <key> --apply --json',
+            'aops agent schema --tool tasker.loop-runner-v2.status.get --summary --json',
+        ],
+        guide: GUIDE_PATHS.tasker,
+        notes: [
+            'Runner sugar delegates to Tasker Loop Runner v2 hosted operations; it is not a second executor.',
+            'Runner control writes require --preview or --apply.',
+        ],
+    }));
+    return command;
+}

package/dist/commands/skill.js

@@ -1197,7 +1197,7 @@ export function makeSkillCommand() {
         guide: GUIDE_PATHS.agentspace,
         notes: [
             'Canonical reusable skill truth lives in aops-server/DB; create/update/publish through these skill commands.',
-            '.aops/hosted/skills/** is a read-only repo mirror refreshed by sync pull/bootstrap, not an authoring source.',
+            '.aops-cache/hosted/skills/** is a read-only repo mirror refreshed by sync pull/bootstrap, not an authoring source.',
             'Skill version list/inspect/current are curated read surfaces and do not require --apply.',
             'skill search/ask inspect only current published package metadata; they do not load skill bodies or maintain a local search index.',
             'skill ask is a deterministic projection of one skill search result, not an LLM-generated semantic answer.',

package/dist/commands/start.js

@@ -11,7 +11,7 @@ import { buildSessionGuidancePack } from '../utils/session-guidance.js';
 import { buildReadOnlyRepoFirstMemoryBriefFromContext } from './memory.js';
 import { applyCommonOptions, compactPayload } from '../utils/command.js';
 import { START_DISCIPLINES, START_DISCIPLINE_PROFILES, startGuardrailsForDiscipline, } from './start-disciplines.js';
-export const START_PROMPT_MIRROR_PATH = '.aops/hosted/prompts/aops-collaborative-startup.md';
+export const START_PROMPT_MIRROR_PATH = '.aops-cache/hosted/prompts/aops-collaborative-startup.md';
 export const START_MODES = ['solo', 'solo+async-review', 'chat-room'];
 export const START_METHODS = START_DISCIPLINES;
 const MULTI_AGENT_MODES = new Set(['chat-room']);

package/dist/commands/tasker.js

@@ -0,0 +1,361 @@
+import { Command } from 'commander';
+import { logSuccess } from '@aopslabs/xf-cli-ui';
+import { applyCommonOptions, compactPayload, normalizeNonEmpty } from '../utils/command.js';
+import { invokeHostedToolWithApiState, parseJsonInput, requireApiState, resolveAgentGatewayContext, resolveProjectScopeOptionsWithApiState, unwrapHostedToolResult, } from '../utils/agent-gateway.js';
+import { buildHostedSugarEnvelope, buildOperatorCookbook, ensureGuardedWrite, } from '../utils/hosted-sugar.js';
+import { GUIDE_PATHS } from '../utils/guide-paths.js';
+const TASKER_SUMMARY_FIELDS = [
+    'id', 'scopeId', 'projectId', 'boardId', 'columnId', 'workGroupId', 'parentTaskId',
+    'runId', 'sliceId', 'eventId', 'eventType', 'sequence', 'artifactId', 'kind', 'uri',
+    'latestSequence', 'name', 'title', 'type', 'status', 'position', 'priority', 'assignee', 'dueAt',
+    'createdAt', 'updatedAt',
+];
+function summarizeTaskerRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    const record = value;
+    const summary = {};
+    for (const key of TASKER_SUMMARY_FIELDS) {
+        if (record[key] !== undefined)
+            summary[key] = record[key];
+    }
+    for (const [key, entry] of Object.entries(record)) {
+        if (!Array.isArray(entry))
+            continue;
+        summary[`${key}Count`] = entry.length;
+        if (key === 'events' || key === 'artifactRefs') {
+            summary[key] = entry.map(summarizeTaskerRecord);
+        }
+    }
+    return Object.keys(summary).length > 0 ? summary : value;
+}
+export function summarizeTaskerReadResult(result) {
+    if (!result || typeof result !== 'object' || Array.isArray(result))
+        return result;
+    const envelope = result;
+    const data = envelope.data;
+    if (Array.isArray(data)) {
+        return { ...envelope, data: data.map(summarizeTaskerRecord) };
+    }
+    if (!data || typeof data !== 'object')
+        return result;
+    const dataRecord = data;
+    if (Array.isArray(dataRecord.items)) {
+        return { ...envelope, data: { ...dataRecord, items: dataRecord.items.map(summarizeTaskerRecord) } };
+    }
+    return { ...envelope, data: summarizeTaskerRecord(dataRecord) };
+}
+export function applyTaskerContextOptions(command) {
+    applyCommonOptions(command, { withProject: false });
+    command.option('--scope-id <id>', 'Canonical Tasker owner scope override');
+    command.option('--project-id <id>', 'Project id used by Tasker scope-aware operations');
+    command.option('--project-name <name>', 'Project name override for repo-aware context resolution');
+    command.option('--project-slug <slug>', 'Project slug from the repo project registry');
+    command.option('--tenant-id <id>', 'Tenant id header (x-tenant-id)');
+    command.option('--locale <locale>', 'Locale header (x-locale)');
+    command.option('--fallback-locale <locale>', 'Fallback locale header (x-fallback-locale)');
+    return command;
+}
+export function applyTaskerWriteOptions(command) {
+    command.option('--preview', 'Validate and preview the hosted write without applying it');
+    command.option('--apply', 'Explicitly allow the hosted write');
+    command.option('--idempotency-key <key>', 'Optional guarded-write idempotency key');
+    return command;
+}
+export function parseTaskerObject(value, label) {
+    const parsed = parseJsonInput(value, label);
+    if (parsed === undefined)
+        return {};
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`${label} must be a JSON object.`);
+    }
+    return parsed;
+}
+function required(value, flag) {
+    const normalized = normalizeNonEmpty(value);
+    if (!normalized)
+        throw new Error(`${flag} is required unless --input supplies the full hosted-tool input.`);
+    return normalized;
+}
+function scopedFilter(filter, context, includeProject) {
+    return compactPayload({
+        scopeId: context.scopeId,
+        projectId: includeProject ? context.projectId : undefined,
+        ...filter,
+    });
+}
+function fullInputOr(options, build) {
+    return options.input ? parseTaskerObject(options.input, '--input') : build();
+}
+export async function executeTaskerTool(options, params) {
+    if (params.write) {
+        ensureGuardedWrite(options, 'This command mutates Tasker state.');
+    }
+    const apiState = await requireApiState(options);
+    if (!apiState)
+        return;
+    const scopedOptions = await resolveProjectScopeOptionsWithApiState(apiState, options);
+    const resolvedContext = await resolveAgentGatewayContext(scopedOptions);
+    const input = params.buildInput(resolvedContext);
+    const payload = await invokeHostedToolWithApiState(apiState, {
+        ...scopedOptions,
+        toolId: params.toolId,
+        input,
+        preview: options.preview,
+        apply: options.apply,
+        idempotencyKey: options.idempotencyKey,
+    });
+    const result = unwrapHostedToolResult(payload);
+    const outputResult = options.summary
+        ? (params.summarizeResult ?? summarizeTaskerReadResult)(result)
+        : result;
+    if (options.json) {
+        console.log(JSON.stringify(buildHostedSugarEnvelope({
+            command: params.command,
+            toolId: params.toolId,
+            surface: 'tasker hosted sugar',
+            resolvedContext: compactPayload(resolvedContext),
+            input,
+            result: outputResult,
+        }), null, 2));
+        return;
+    }
+    logSuccess(options.preview ? `${params.command} preview completed.` : params.successText);
+    console.log(JSON.stringify(outputResult, null, 2));
+}
+function listInput(options, context, includeProject) {
+    return fullInputOr(options, () => {
+        const listOptions = parseTaskerObject(options.options, '--options');
+        return compactPayload({
+            filter: scopedFilter(parseTaskerObject(options.filter, '--filter'), context, includeProject),
+            options: Object.keys(listOptions).length > 0 ? listOptions : undefined,
+        });
+    });
+}
+function getInput(options) {
+    return fullInputOr(options, () => {
+        const getOptions = parseTaskerObject(options.options, '--options');
+        return compactPayload({
+            id: required(options.id, '--id'),
+            options: Object.keys(getOptions).length > 0 ? getOptions : undefined,
+        });
+    });
+}
+function addListJsonOptions(command) {
+    return command
+        .option('--input <json|@file>', 'Full hosted-tool input JSON escape hatch')
+        .option('--filter <json|@file>', 'Filter JSON object')
+        .option('--options <json|@file>', 'List options JSON object')
+        .option('--summary', 'Print compact Tasker records and omit bulky fields');
+}
+function addGetJsonOptions(command) {
+    return command
+        .option('--id <id>', 'Canonical record id')
+        .option('--input <json|@file>', 'Full hosted-tool input JSON escape hatch')
+        .option('--options <json|@file>', 'Get options JSON object')
+        .option('--summary', 'Print a compact Tasker record and omit bulky fields');
+}
+function addBoardCommands(root) {
+    const board = root.command('board').description('Tasker kanban-board commands');
+    applyTaskerContextOptions(addListJsonOptions(board.command('list').description('List Tasker kanban boards'))
+        .action(async (options) => {
+        await executeTaskerTool(options, {
+            command: 'tasker.board.list',
+            toolId: 'tasker.kanban-board.list-boards',
+            successText: 'Tasker boards loaded.',
+            buildInput: (context) => listInput(options, context, true),
+        });
+    }));
+    applyTaskerContextOptions(addGetJsonOptions(board.command('get').description('Get a Tasker kanban board by id'))
+        .action(async (options) => {
+        await executeTaskerTool(options, {
+            command: 'tasker.board.get',
+            toolId: 'tasker.kanban-board.get-by-id',
+            successText: 'Tasker board loaded.',
+            buildInput: () => getInput(options),
+        });
+    }));
+    applyTaskerContextOptions(applyTaskerWriteOptions(board.command('create')
+        .description('Create a Tasker kanban board')
+        .option('--input <json|@file>', 'Full hosted-tool input JSON escape hatch')
+        .option('--data <json|@file>', 'Board data JSON object')
+        .option('--name <name>', 'Board name')
+        .option('--description <text>', 'Board description')).action(async (options) => {
+        await executeTaskerTool(options, {
+            command: 'tasker.board.create',
+            toolId: 'tasker.kanban-board.create',
+            write: true,
+            successText: 'Tasker board write completed.',
+            buildInput: (context) => fullInputOr(options, () => {
+                const data = parseTaskerObject(options.data, '--data');
+                return {
+                    data: compactPayload({
+                        scopeId: context.scopeId,
+                        projectId: context.projectId,
+                        ...data,
+                        name: normalizeNonEmpty(options.name) ?? data.name,
+                        description: normalizeNonEmpty(options.description) ?? data.description,
+                    }),
+                };
+            }),
+        });
+    }));
+    applyTaskerContextOptions(applyTaskerWriteOptions(board.command('update')
+        .description('Update a Tasker kanban board')
+        .option('--id <id>', 'Canonical board id')
+        .option('--input <json|@file>', 'Full hosted-tool input JSON escape hatch')
+        .option('--patch <json|@file>', 'Board patch JSON object')
+        .option('--name <name>', 'Updated board name')
+        .option('--description <text>', 'Updated board description')).action(async (options) => {
+        await executeTaskerTool(options, {
+            command: 'tasker.board.update',
+            toolId: 'tasker.kanban-board.update-board',
+            write: true,
+            successText: 'Tasker board write completed.',
+            buildInput: () => fullInputOr(options, () => ({
+                id: required(options.id, '--id'),
+                patch: compactPayload({
+                    ...parseTaskerObject(options.patch, '--patch'),
+                    name: options.name,
+                    description: options.description,
+                }),
+            })),
+        });
+    }));
+}
+function addTaskCommands(root) {
+    const task = root.command('task').description('Tasker task commands');
+    applyTaskerContextOptions(addListJsonOptions(task.command('list').description('Search Tasker tasks'))
+        .action(async (options) => {
+        await executeTaskerTool(options, {
+            command: 'tasker.task.list',
+            toolId: 'tasker.task.search-tasks',
+            successText: 'Tasker tasks loaded.',
+            buildInput: (context) => listInput(options, context, false),
+        });
+    }));
+    applyTaskerContextOptions(addGetJsonOptions(task.command('get').description('Get a Tasker task by id'))
+        .action(async (options) => {
+        await executeTaskerTool(options, {
+            command: 'tasker.task.get',
+            toolId: 'tasker.task.get-task',
+            successText: 'Tasker task loaded.',
+            buildInput: () => getInput(options),
+        });
+    }));
+    applyTaskerContextOptions(applyTaskerWriteOptions(task.command('create')
+        .description('Create a Tasker task')
+        .option('--input <json|@file>', 'Full hosted-tool input JSON escape hatch')
+        .option('--data <json|@file>', 'Task data JSON object')
+        .option('--title <title>', 'Task title')
+        .option('--column <id>', 'Canonical Tasker column id')
+        .option('--type <type>', 'Task type: epic, story, task, bug, chore, or spike')
+        .option('--position <index>', 'Optional column position', (value) => Number.parseInt(String(value), 10))
+        .option('--description <text>', 'Task description')
+        .option('--work-group-id <id>', 'Optional WorkGroup id')
+        .option('--assignee <value>', 'Optional assignee')
+        .option('--priority <value>', 'Optional numeric priority', (value) => Number.parseInt(String(value), 10))
+        .option('--due-at <timestamp>', 'Optional due timestamp')).action(async (options) => {
+        await executeTaskerTool(options, {
+            command: 'tasker.task.create',
+            toolId: 'tasker.task.create-task',
+            write: true,
+            successText: 'Tasker task write completed.',
+            buildInput: (context) => fullInputOr(options, () => {
+                const data = parseTaskerObject(options.data, '--data');
+                return {
+                    data: compactPayload({
+                        scopeId: context.scopeId,
+                        ...data,
+                        title: normalizeNonEmpty(options.title) ?? data.title,
+                        columnId: normalizeNonEmpty(options.column) ?? data.columnId,
+                        type: normalizeNonEmpty(options.type) ?? data.type ?? 'task',
+                        position: options.position ?? data.position,
+                        description: normalizeNonEmpty(options.description) ?? data.description,
+                        workGroupId: normalizeNonEmpty(options.workGroupId) ?? data.workGroupId,
+                        assignee: normalizeNonEmpty(options.assignee) ?? data.assignee,
+                        priority: options.priority ?? data.priority,
+                        dueAt: normalizeNonEmpty(options.dueAt) ?? data.dueAt,
+                    }),
+                };
+            }),
+        });
+    }));
+    applyTaskerContextOptions(applyTaskerWriteOptions(task.command('update')
+        .description('Update a Tasker task')
+        .option('--id <id>', 'Canonical task id')
+        .option('--input <json|@file>', 'Full hosted-tool input JSON escape hatch')
+        .option('--patch <json|@file>', 'Task patch JSON object')
+        .option('--title <title>', 'Updated title')
+        .option('--column <id>', 'Updated column id')
+        .option('--type <type>', 'Updated task type')
+        .option('--position <index>', 'Updated column position', (value) => Number.parseInt(String(value), 10))
+        .option('--description <text>', 'Updated description')
+        .option('--work-group-id <id>', 'Updated WorkGroup id')
+        .option('--assignee <value>', 'Updated assignee')
+        .option('--priority <value>', 'Updated numeric priority', (value) => Number.parseInt(String(value), 10))
+        .option('--due-at <timestamp>', 'Updated due timestamp')).action(async (options) => {
+        await executeTaskerTool(options, {
+            command: 'tasker.task.update',
+            toolId: 'tasker.task.update-task',
+            write: true,
+            successText: 'Tasker task write completed.',
+            buildInput: () => fullInputOr(options, () => ({
+                id: required(options.id, '--id'),
+                patch: compactPayload({
+                    ...parseTaskerObject(options.patch, '--patch'),
+                    title: options.title,
+                    columnId: options.column,
+                    type: options.type,
+                    position: options.position,
+                    description: options.description,
+                    workGroupId: options.workGroupId,
+                    assignee: options.assignee,
+                    priority: options.priority,
+                    dueAt: options.dueAt,
+                }),
+            })),
+        });
+    }));
+}
+function addWorkGroupCommands(root) {
+    const workGroup = root.command('work-group').alias('workgroup').description('Tasker WorkGroup read commands');
+    applyTaskerContextOptions(addListJsonOptions(workGroup.command('list').description('List Tasker WorkGroups'))
+        .action(async (options) => {
+        await executeTaskerTool(options, {
+            command: 'tasker.work-group.list',
+            toolId: 'tasker.work-group.list-work-groups',
+            successText: 'Tasker WorkGroups loaded.',
+            buildInput: (context) => listInput(options, context, false),
+        });
+    }));
+    applyTaskerContextOptions(addGetJsonOptions(workGroup.command('get').description('Get a Tasker WorkGroup by id'))
+        .action(async (options) => {
+        await executeTaskerTool(options, {
+            command: 'tasker.work-group.get',
+            toolId: 'tasker.work-group.get-work-group',
+            successText: 'Tasker WorkGroup loaded.',
+            buildInput: () => getInput(options),
+        });
+    }));
+}
+export function makeTaskerCommand() {
+    const command = new Command('tasker').description('Tasker board, task, and WorkGroup sugar over the hosted AOPS plane');
+    addBoardCommands(command);
+    addTaskCommands(command);
+    addWorkGroupCommands(command);
+    command.addHelpText('after', buildOperatorCookbook({
+        examples: [
+            'aops tasker board list --project-slug <slug> --json',
+            'aops tasker task create --scope-id <scope-id> --column <column-id> --title "Implement slice" --preview --json',
+            'aops tasker work-group list --scope-id <scope-id> --json',
+            'aops agent schema --tool tasker.task.create-task --summary --json',
+        ],
+        guide: GUIDE_PATHS.tasker,
+        notes: [
+            'Sugar accepts canonical ids; use `aops agent tools --domain tasker --summary --json` for the complete hosted operation catalog.',
+            'Tasker sugar contract checks are app-owned: `pnpm --filter @aopslabs/aops run test:tasker-sugar`.',
+        ],
+    }));
+    return command;
+}