@aopslabs/aops 0.2.0

package/dist/lib/tui-launcher.js

@@ -0,0 +1,59 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const SUPPORTED_TUI_TARGETS = new Set([
+    'darwin-arm64',
+    'darwin-x64',
+    'linux-arm64',
+    'linux-x64',
+    'win32-x64',
+]);
+function packageRootFromModule() {
+    return fileURLToPath(new URL('../../', import.meta.url));
+}
+export function shouldLaunchBundledTui(argv, inputIsTerminal = process.stdin.isTTY === true, outputIsTerminal = process.stdout.isTTY === true) {
+    return argv.length <= 2 && inputIsTerminal && outputIsTerminal;
+}
+export function buildBundledTuiLaunch(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const arch = options.arch ?? process.arch;
+    const target = `${platform}-${arch}`;
+    if (!SUPPORTED_TUI_TARGETS.has(target)) {
+        throw new Error(`The bundled AOPS TUI does not support this platform (${target}). Use aops --help.`);
+    }
+    const packageRoot = path.resolve(options.packageRoot ?? packageRootFromModule());
+    const executableName = platform === 'win32' ? 'aops-tui.exe' : 'aops-tui';
+    const command = path.join(packageRoot, 'native', 'tui', target, executableName);
+    const cliEntrypoint = path.join(packageRoot, 'dist', 'main.js');
+    const env = {
+        ...(options.environment ?? process.env),
+        AOPS_TUI_CLI_ENTRYPOINT: cliEntrypoint,
+        AOPS_TUI_NODE: options.nodeExecutable ?? process.execPath,
+    };
+    delete env.AOPS_TUI_CLI;
+    return Object.freeze({
+        command,
+        args: Object.freeze([]),
+        options: Object.freeze({ stdio: 'inherit', env }),
+    });
+}
+export async function launchBundledTui(options = {}) {
+    const invocation = buildBundledTuiLaunch(options);
+    const fileExists = options.fileExists ?? existsSync;
+    if (!fileExists(invocation.command)) {
+        throw new Error('The bundled AOPS TUI is missing. Reinstall @aopslabs/aops or use aops --help.');
+    }
+    const spawnProcess = options.spawnProcess ?? spawn;
+    const child = spawnProcess(invocation.command, [...invocation.args], invocation.options);
+    return await new Promise((resolve, reject) => {
+        child.once('error', reject);
+        child.once('exit', (code, signal) => {
+            if (signal) {
+                reject(new Error(`The AOPS TUI stopped after receiving ${signal}.`));
+                return;
+            }
+            resolve(code ?? 1);
+        });
+    });
+}

package/dist/main.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { logError } from '@aopslabs/xf-cli-ui';
+import { resolveCommunityCliIdentity } from './lib/community-client-contract.js';
+import { makeInitCommand } from './commands/init.js';
+import { makeCommunitySetupCommand } from './commands/community-setup.js';
+import { makeAssetsCommand } from './commands/assets.js';
+import { makeStartCommand } from './commands/start.js';
+import { makePlanCommand } from './commands/plan.js';
+import { makeAgentsMdCommand } from './commands/agents-md.js';
+import { makeAgentCommand } from './commands/agent.js';
+import { makeSyncCommand } from './commands/repo-sync.js';
+import { makeArchiveCommand } from './commands/archive.js';
+import { makeViewCommand } from './commands/view.js';
+import { makeHostCommand } from './commands/host.js';
+import { makeApiCommand } from './commands/api.js';
+import { guardCommunitySecretArgv, makeCommunityAuthCommand } from './commands/community-auth.js';
+import { makeMemoryCommand } from './commands/memory.js';
+import { makeCheckpointCommand } from './commands/checkpoint.js';
+import { makeExperienceCommand } from './commands/experience.js';
+import { makeDiscussCommand } from './commands/discuss.js';
+import { makeChatCommand } from './commands/chat.js';
+import { guardChatv3UnknownSubcommand, makeChatv3Command } from './commands/chatv3.js';
+import { makeAgentProfileCommand } from './commands/agent-profile.js';
+import { makePromptCommand } from './commands/prompt.js';
+import { makeProjectCommand } from './commands/project.js';
+import { makeMissionCommand } from './commands/mission.js';
+import { makePlaybookCommand } from './commands/playbook.js';
+import { makeResourceCommand } from './commands/resource.js';
+import { makeArtifactCommand } from './commands/artifact.js';
+import { makeCommercialLicenseCommand } from './commands/commercial-license.js';
+import { makeActivityCommand } from './commands/activity.js';
+import { makeSkillCommand } from './commands/skill.js';
+import { makeDocCommand } from './commands/doc.js';
+import { makePmCommand } from './commands/pm/index.js';
+import { makeCommunityServerCommand } from './commands/community-server.js';
+import { makeCommunityCockpitCommand } from './commands/community-cockpit.js';
+import { makeCommunityDoctorCommand } from './commands/community-doctor.js';
+import { makeCommunityConsoleCommand } from './commands/community-console.js';
+import { makeTargetCommand } from './commands/target.js';
+import { makeVersionCommand } from './commands/version.js';
+import { launchBundledTui, shouldLaunchBundledTui } from './lib/tui-launcher.js';
+import { CommunityDiagnosticError, formatCommunityDiagnostic, } from './lib/community-diagnostic.js';
+for (const stream of [process.stdout, process.stderr]) {
+    stream.on('error', (error) => {
+        if (error?.code === 'EPIPE') {
+            process.exit(typeof process.exitCode === 'number' ? process.exitCode : 0);
+        }
+        throw error;
+    });
+}
+export function buildCommunityProgram() {
+    const program = new Command();
+    const version = resolveCommunityCliIdentity().version;
+    program
+        .name('aops')
+        .description('AOPS Community operator CLI for local-trusted, self-hosted workflows')
+        .enablePositionalOptions()
+        .version(version)
+        .version(version, '--cli-version', 'output the CLI version (legacy alias)');
+    program.addCommand(makeInitCommand());
+    program.addCommand(makeCommunitySetupCommand());
+    program.addCommand(makeAssetsCommand());
+    program.addCommand(makeStartCommand());
+    program.addCommand(makePlanCommand());
+    program.addCommand(makeAgentsMdCommand());
+    program.addCommand(makeAgentCommand());
+    program.addCommand(makeSyncCommand());
+    program.addCommand(makeArchiveCommand());
+    program.addCommand(makeViewCommand());
+    program.addCommand(makeHostCommand());
+    program.addCommand(makeApiCommand());
+    program.addCommand(makeCommunityAuthCommand());
+    program.addCommand(makeMemoryCommand());
+    program.addCommand(makeCheckpointCommand());
+    program.addCommand(makeExperienceCommand());
+    program.addCommand(makeDiscussCommand());
+    program.addCommand(makeChatCommand());
+    program.addCommand(makeChatv3Command());
+    program.addCommand(makeAgentProfileCommand());
+    program.addCommand(makePromptCommand());
+    program.addCommand(makeProjectCommand());
+    program.addCommand(makeMissionCommand());
+    program.addCommand(makePlaybookCommand());
+    program.addCommand(makeResourceCommand());
+    program.addCommand(makeArtifactCommand());
+    program.addCommand(makeCommercialLicenseCommand());
+    program.addCommand(makeActivityCommand());
+    program.addCommand(makeSkillCommand());
+    program.addCommand(makeDocCommand());
+    program.addCommand(makePmCommand());
+    program.addCommand(makeCommunityServerCommand());
+    program.addCommand(makeCommunityCockpitCommand());
+    program.addCommand(makeCommunityDoctorCommand());
+    program.addCommand(makeCommunityConsoleCommand());
+    program.addCommand(makeTargetCommand());
+    program.addCommand(makeVersionCommand());
+    program.addHelpText('after', `
+AOPS Community is a single-user, self-hosted/local-trusted distribution.
+Canonical writes go to the local AOPS server; .aops/** remains a read-only cache.
+
+Quick checks:
+  aops setup ai
+  aops setup guide
+  aops host health
+  aops agent tools
+  aops view dashboard --style agent
+`);
+    return program;
+}
+async function main() {
+    const program = buildCommunityProgram();
+    const jsonOutputRequested = process.argv.includes('--json');
+    try {
+        if (process.argv.length <= 2) {
+            if (shouldLaunchBundledTui(process.argv)) {
+                process.exitCode = await launchBundledTui();
+            }
+            else {
+                process.stdout.write('AOPS TUI requires an interactive terminal. Use aops --help or run an explicit aops command.\n');
+            }
+            return;
+        }
+        const argv = process.argv[2] === '--'
+            ? [process.argv[0], process.argv[1], ...process.argv.slice(3)]
+            : process.argv;
+        guardChatv3UnknownSubcommand(argv);
+        guardCommunitySecretArgv(argv);
+        await program.parseAsync(argv);
+    }
+    catch (error) {
+        if (error instanceof CommunityDiagnosticError) {
+            if (jsonOutputRequested) {
+                process.stderr.write(`${JSON.stringify({
+                    schemaVersion: 1,
+                    ok: false,
+                    error: error.diagnostic,
+                }, null, 2)}\n`);
+            }
+            else {
+                logError(formatCommunityDiagnostic(error.diagnostic));
+            }
+        }
+        else {
+            logError(String(error?.message ?? error));
+        }
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/seeds/agents-md.js

@@ -0,0 +1,54 @@
+export const AOPS_AGENTS_MD_TEMPLATE_SEEDS = [
+    {
+        slug: 'aops-collaborative-startup',
+        title: 'AOPS Collaborative Startup',
+        description: 'Default solo-first session starter; boots the aops-collaborative-work skill (collaboration and chat are operator-opt-in).',
+        mirrorPath: '.aops/hosted/prompts/aops-collaborative-startup.md',
+        promptRef: 'prompt:aops-collaborative-startup',
+        tags: ['default', 'starter', 'solo-first', 'coordination-optional'],
+        snippet: [
+            'Boot the aops-collaborative-work skill and pick the mode once at kickoff: solo (default) | solo+async-review | chat-room.',
+            'Run the skill startup block with compact output; prefer aops-cli start --json --out <file> and follow result.promptRef.path instead of inline prompt JSON.',
+            'Read layered rules only as needed: repo AGENTS.md / ChatV3 room rules, selected working-discipline guardrails, accepted playbook briefs, and ranked experience briefs.',
+            'Use aops-cli mission resume --id <mission-id> --json or aops-cli start --resume <mission-id> --json when a mission exists; use aops-cli start --reminder --task "<current task>" --area <area> --json for mid-session refresh.',
+            'Pull detail through the skill detail ladder (sub-skill section, command --help, aops-cli agent schema).',
+            'Every task lands in PM before implementation; validate honestly; UI slices are verified live via Chrome MCP.',
+            'Solo modes may leave async PM review requests for a future session; chat-room mode posts the PM review-request ref into the hosted room as a wake.',
+            'Closeout (board/room) is operator-only; ordinary turn end writes status/handoff and keeps surfaces open.',
+            'When the operator asks for the bootstrapper/starter prompt, paste the prompt mirror body verbatim.',
+        ],
+    },
+    {
+        slug: 'aops-task-execution-template',
+        title: 'AOPS Task Execution Template',
+        description: 'Operator-fillable, PM-backed generic execution checklist template.',
+        mirrorPath: '.aops/hosted/prompts/aops-task-execution-template.md',
+        promptRef: 'prompt:aops-task-execution-template',
+        tags: ['pm', 'closeout', 'template'],
+        snippet: [
+            'Use AOPS PM for substantive work: inspect or create the board/task/sprint window before implementation.',
+            'Build project context from AGENTS.md, repo memory, Projectman state, and relevant docs before changing files.',
+            'Track meaningful work as sprint microtasks; promote review findings or blockers to PM issues.',
+            'Validate, commit only scoped changes, then run the PM closeout sequence requested by the operator.',
+            'Write a short memory closeout for durable decisions, follow-ups, and resume context.',
+        ],
+    },
+    {
+        slug: 'aops-cli-discuss',
+        title: 'AOPS Discuss / Decision Protocol',
+        description: 'Standalone discuss decision/consensus discipline; coordination via aops-cli-chat, review via aops-cli-projectman; canonical mechanics in the aops-cli-discuss hosted skill.',
+        mirrorPath: '.aops/hosted/skills/aops-cli-discuss.md',
+        promptRef: 'skill:aops-cli-discuss',
+        tags: ['discuss', 'decision', 'consensus'],
+        snippet: [
+            'Run a standalone discuss topic for material design decisions; give every peer enough independent context to research and form its own stance.',
+            'Drive at least four substantive non-final turns, then each agent files a kind=final-stance turn before concluding.',
+            'Confirm completeness from JSON (lifecycleState / missingTurnFinalStances), then conclude and finalize the outputs with no _TBD_ placeholders.',
+            'Surface decisions explicitly: there is no auto bridge — carry the discussion-topic ref into a PM review-request/issue and ping the hosted chat room.',
+            'Coordination/wake lives in aops-cli-chat; review + execution truth lives in aops-cli-projectman.',
+            'Conclude only after final stances are recorded; session/board closeout stays operator-only.',
+        ],
+    },
+];
+export const DEFAULT_AGENTS_MD_TEMPLATE_SLUG = 'aops-collaborative-startup';
+export const DISCUSS_AGENTS_MD_TEMPLATE_SLUG = 'aops-cli-discuss';

package/dist/utils/agent-gateway.js

@@ -0,0 +1,275 @@
+import { logError } from '@aopslabs/xf-cli-ui';
+import { buildHostedToolInvokeRequestBody, buildOperatorHeaders, } from './operator-runtime.js';
+export { parseJsonInput } from './operator-runtime.js';
+import { createCliApiClientFromOptions, isCliHostReachable, isCliAuthRequired, } from './api.js';
+import { normalizeNonEmpty, } from './command.js';
+import { hydrateProjectIdFromServerLookup, resolveProjectBindingContext, } from './project-context.js';
+function normalizeScopeResolution(value) {
+    return value === 'explicit' || value === 'cascade' ? value : undefined;
+}
+export async function resolveAgentGatewayContext(options) {
+    const resolvedContext = await resolveProjectBindingContext(options, {
+        requireProject: false,
+    });
+    const projectName = normalizeNonEmpty(options.projectName) ?? normalizeNonEmpty(resolvedContext.projectName);
+    return {
+        tenantId: normalizeNonEmpty(options.tenantId),
+        locale: normalizeNonEmpty(options.locale),
+        fallbackLocale: normalizeNonEmpty(options.fallbackLocale),
+        scopeId: normalizeNonEmpty(options.scopeId) ?? normalizeNonEmpty(resolvedContext.scopeId),
+        projectId: normalizeNonEmpty(options.projectId) ?? resolvedContext.projectId,
+        projectName,
+        scopeResolution: normalizeScopeResolution(options.scopeResolution),
+    };
+}
+function buildProjectLookupDeps(apiState, options) {
+    return {
+        invokeHostedTool: ({ toolId, input }) => invokeHostedToolWithApiState(apiState, {
+            apiBaseUrl: options.apiBaseUrl,
+            accessToken: options.accessToken,
+            refreshToken: options.refreshToken,
+            timeoutMs: options.timeoutMs,
+            tenantId: options.tenantId,
+            locale: options.locale,
+            fallbackLocale: options.fallbackLocale,
+            toolId,
+            input,
+            disableDurableActivityLog: true,
+        }),
+    };
+}
+export async function resolveProjectScopeOptionsWithApiState(apiState, options) {
+    if (normalizeNonEmpty(options.projectId) ?? normalizeNonEmpty(options.scopeId)) {
+        return options;
+    }
+    if (!normalizeNonEmpty(options.projectSlug) && !normalizeNonEmpty(options.projectName)) {
+        return options;
+    }
+    const baseContext = await resolveProjectBindingContext(options, {
+        requireProject: false,
+    });
+    if (!baseContext.pendingServerProjectLookup) {
+        return options;
+    }
+    const hydrated = await hydrateProjectIdFromServerLookup(baseContext, buildProjectLookupDeps(apiState, options));
+    const projectId = normalizeNonEmpty(hydrated.projectId);
+    if (!projectId)
+        return options;
+    return {
+        ...options,
+        projectId,
+        scopeId: normalizeNonEmpty(options.scopeId) ?? normalizeNonEmpty(hydrated.scopeId) ?? projectId,
+        projectName: normalizeNonEmpty(hydrated.projectName) ?? normalizeNonEmpty(options.projectName),
+    };
+}
+export async function hydrateProjectContextWithApiState(apiState, options, context) {
+    if (normalizeNonEmpty(context.projectId) || !context.pendingServerProjectLookup) {
+        return context;
+    }
+    try {
+        return await hydrateProjectIdFromServerLookup(context, buildProjectLookupDeps(apiState, options));
+    }
+    catch {
+        return context;
+    }
+}
+export async function buildAgentContextHeaders(options) {
+    const resolved = await resolveAgentGatewayContext(options);
+    return buildOperatorHeaders({
+        tenantId: resolved.tenantId,
+        locale: resolved.locale,
+        fallbackLocale: resolved.fallbackLocale,
+        scopeId: resolved.scopeId,
+        projectId: resolved.projectId,
+        projectName: normalizeNonEmpty(options.projectName) ?? normalizeNonEmpty(resolved.projectName),
+        scopeResolution: resolved.scopeResolution,
+    });
+}
+export async function requireApiState(options) {
+    const apiState = await createCliApiClientFromOptions(options);
+    const accessToken = apiState.getAccessToken();
+    if (!accessToken) {
+        if ((await isCliAuthRequired(apiState, { timeoutMs: options.timeoutMs })) === false) {
+            return apiState;
+        }
+        if ((await isCliHostReachable(apiState, { timeoutMs: options.timeoutMs })) === false) {
+            logError(`Cannot reach the API host at ${apiState.baseUrl}. Start the target host or provide --api-base-url. Trusted-local auth can only be detected while the host is running.`);
+            process.exitCode = 1;
+            return null;
+        }
+        logError('Missing access token. Run `aops-cli auth login` or provide --access-token / AOPS_API_ACCESS_TOKEN.');
+        process.exitCode = 1;
+        return null;
+    }
+    return apiState;
+}
+export async function invokeHostedToolWithApiState(apiState, options) {
+    const resolvedOptions = await resolveProjectScopeOptionsWithApiState(apiState, options);
+    const requestBody = buildHostedToolInvokeRequestBody(resolvedOptions);
+    const headers = await buildAgentContextHeaders(resolvedOptions);
+    if (resolvedOptions.disableDurableActivityLog !== true) {
+        headers['x-activity-source-kind'] = 'aops-cli';
+    }
+    return apiState.client.fetchJson(`/api/agent/tools/${encodeURIComponent(resolvedOptions.toolId)}/invoke`, {
+        method: 'POST',
+        body: requestBody,
+        headers,
+        timeoutMs: resolvedOptions.timeoutMs,
+    });
+}
+export function unwrapHostedToolResult(payload) {
+    if (Object.prototype.hasOwnProperty.call(payload, 'response')) {
+        return payload.response;
+    }
+    return payload;
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function sanitizeActivityValue(value, depth = 0) {
+    if (depth > 3)
+        return '[truncated]';
+    if (typeof value === 'string') {
+        const normalized = value.trim();
+        if (normalized.length <= 400)
+            return normalized;
+        return `${normalized.slice(0, 397)}...`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean' || value === null || value === undefined) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.slice(0, 12).map((entry) => sanitizeActivityValue(entry, depth + 1));
+    }
+    if (!isRecord(value))
+        return String(value);
+    const next = {};
+    for (const [key, entry] of Object.entries(value)) {
+        const lower = key.toLowerCase();
+        if (lower.includes('token') || lower.includes('secret') || lower.includes('password') || lower.includes('authorization')) {
+            continue;
+        }
+        next[key] = sanitizeActivityValue(entry, depth + 1);
+    }
+    return next;
+}
+function maybePushRef(target, type, id, label) {
+    const normalizedId = normalizeNonEmpty(id);
+    if (!normalizedId)
+        return;
+    if (target.some((entry) => entry.type === type && entry.id === normalizedId))
+        return;
+    target.push(label ? { type, id: normalizedId, label } : { type, id: normalizedId });
+}
+function collectRefsFromObject(value, refs) {
+    if (!isRecord(value))
+        return;
+    maybePushRef(refs, 'project', value.projectId);
+    maybePushRef(refs, 'scope', value.scopeId);
+    maybePushRef(refs, 'task', value.taskId);
+    maybePushRef(refs, 'sprint', value.sprintId);
+    maybePushRef(refs, 'microtask', value.microtaskId);
+    maybePushRef(refs, 'issue', value.issueId);
+    maybePushRef(refs, 'feedback', value.feedbackId);
+    maybePushRef(refs, 'prompt', value.promptId);
+    maybePushRef(refs, 'prompt-version', value.promptVersionId);
+    maybePushRef(refs, 'skill', value.skillId);
+    maybePushRef(refs, 'skill-version', value.skillVersionId);
+    maybePushRef(refs, 'resource', value.resourceId);
+    maybePushRef(refs, 'artifact', value.artifactId);
+    maybePushRef(refs, 'run', value.runId);
+    maybePushRef(refs, 'run-record', value.runRecordId);
+    maybePushRef(refs, 'workflow', value.workflowId ?? value.workflowInstanceId);
+    maybePushRef(refs, 'workflow-definition', value.workflowDefinitionId);
+    maybePushRef(refs, 'document', value.documentId);
+    maybePushRef(refs, 'document-version', value.documentVersionId);
+    maybePushRef(refs, 'page', value.pageId);
+    maybePushRef(refs, 'page-version', value.pageVersionId);
+    maybePushRef(refs, 'section', value.sectionId);
+    if (isRecord(value.data))
+        collectRefsFromObject(value.data, refs);
+    if (isRecord(value.input))
+        collectRefsFromObject(value.input, refs);
+    if (isRecord(value.result))
+        collectRefsFromObject(value.result, refs);
+    if (isRecord(value.response))
+        collectRefsFromObject(value.response, refs);
+}
+async function resolveProjectContextById(apiState, options, projectId) {
+    try {
+        const headers = await buildAgentContextHeaders(options);
+        const payload = await apiState.client.fetchJson(`/api/agentspace/projects/${encodeURIComponent(projectId)}`, {
+            method: 'GET',
+            headers,
+            timeoutMs: options.timeoutMs,
+        });
+        if (isRecord(payload)) {
+            const data = isRecord(payload.data) ? payload.data : payload;
+            return {
+                scopeId: normalizeNonEmpty(data.id) ?? normalizeNonEmpty(data.projectId) ?? projectId,
+            };
+        }
+    }
+    catch {
+    }
+    return {};
+}
+async function resolveDurableActivityContext(apiState, options, resolved, payload) {
+    const scopeIdFromPayload = normalizeNonEmpty(isRecord(options.input) ? options.input.scopeId : undefined) ??
+        normalizeNonEmpty(isRecord(payload) ? payload.scopeId : undefined);
+    const projectId = normalizeNonEmpty(resolved.projectId) ??
+        normalizeNonEmpty(isRecord(options.input) ? options.input.projectId : undefined) ??
+        normalizeNonEmpty(isRecord(payload) ? payload.projectId : undefined);
+    let scopeId = normalizeNonEmpty(resolved.scopeId) ?? scopeIdFromPayload;
+    if (projectId && !scopeId) {
+        const projectContext = await resolveProjectContextById(apiState, options, projectId);
+        if (!scopeId)
+            scopeId = normalizeNonEmpty(projectContext.scopeId);
+    }
+    return {
+        scopeId,
+        projectId,
+        projectName: resolved.projectName,
+    };
+}
+export async function appendCliDurableActivityLogBestEffort(params) {
+    const resolved = await resolveAgentGatewayContext(params.options);
+    const context = await resolveDurableActivityContext(params.apiState, { ...params.options, toolId: params.sourceId, apply: true }, resolved, isRecord(params.payload) ? params.payload : undefined);
+    const scopeId = context.scopeId;
+    const projectId = context.projectId;
+    if (!scopeId || !projectId)
+        return;
+    const refs = [];
+    maybePushRef(refs, 'scope', scopeId);
+    maybePushRef(refs, 'project', projectId);
+    params.refs?.forEach((entry) => maybePushRef(refs, entry.type, entry.id, entry.label));
+    collectRefsFromObject(params.payload, refs);
+    try {
+        const headers = await buildAgentContextHeaders({
+            ...params.options,
+            scopeId,
+            projectId: context.projectId,
+            projectName: context.projectName,
+        });
+        await params.apiState.client.fetchJson('/api/agentspace/operations/activity-item/add-activity-item', {
+            method: 'POST',
+            headers,
+            body: {
+                data: {
+                    scopeId,
+                    projectId,
+                    sourceKind: params.sourceKind ?? 'aops-cli',
+                    sourceId: params.sourceId,
+                    action: params.action,
+                    status: params.status,
+                    summary: params.summary,
+                    refs,
+                    payload: sanitizeActivityValue(params.payload),
+                },
+            },
+            timeoutMs: params.options.timeoutMs,
+        });
+    }
+    catch {
+    }
+}