@iaforged/context-code 1.2.9 → 1.2.12

package/dist/src/core/query/runtime.js

@@ -0,0 +1,117 @@
+import { getSessionId } from '../../bootstrap/state.js';
+function now() {
+    return Date.now();
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function readTextFromAssistantContent(content) {
+    const parts = asArray(content);
+    const text = parts
+        .filter(part => part && typeof part === 'object' && part.type === 'text')
+        .map(part => String(part.text ?? '').trim())
+        .filter(Boolean)
+        .join('\n')
+        .trim();
+    return text || undefined;
+}
+export class CoreQueryRuntimeEmitter {
+    sink;
+    turn = 1;
+    hasEmittedRunning = false;
+    constructor(sink) {
+        this.sink = sink;
+    }
+    setTurn(turn) {
+        this.turn = turn;
+    }
+    emit(event) {
+        this.sink?.(event);
+    }
+    emitRunning() {
+        if (this.hasEmittedRunning) {
+            return;
+        }
+        this.hasEmittedRunning = true;
+        this.emitSessionState('running');
+    }
+    emitSessionState(state, reason) {
+        this.emit({
+            type: 'session_state',
+            timestamp: now(),
+            sessionId: getSessionId(),
+            turn: this.turn,
+            state,
+            reason,
+        });
+    }
+    emitError(message, code) {
+        this.emit({
+            type: 'error',
+            timestamp: now(),
+            sessionId: getSessionId(),
+            turn: this.turn,
+            code,
+            message,
+        });
+    }
+    emitResult(isError, stopReason, result) {
+        this.emit({
+            type: 'result',
+            timestamp: now(),
+            sessionId: getSessionId(),
+            turn: this.turn,
+            isError,
+            result,
+            stopReason: stopReason ?? null,
+        });
+    }
+    emitFromQueryMessage(message) {
+        if (!message || typeof message !== 'object') {
+            return;
+        }
+        if (message.type === 'assistant') {
+            const content = message.message?.content;
+            this.emit({
+                type: 'assistant_message',
+                timestamp: now(),
+                sessionId: getSessionId(),
+                turn: this.turn,
+                text: readTextFromAssistantContent(content),
+            });
+            for (const part of asArray(content)) {
+                if (!part || typeof part !== 'object' || part.type !== 'tool_use') {
+                    continue;
+                }
+                this.emit({
+                    type: 'tool_call',
+                    timestamp: now(),
+                    sessionId: getSessionId(),
+                    turn: this.turn,
+                    toolName: String(part.name ?? 'unknown'),
+                    toolUseId: part.id,
+                    input: part.input,
+                });
+            }
+            return;
+        }
+        if (message.type === 'user') {
+            const content = message.message?.content;
+            for (const part of asArray(content)) {
+                if (!part || typeof part !== 'object' || part.type !== 'tool_result') {
+                    continue;
+                }
+                this.emit({
+                    type: 'tool_result',
+                    timestamp: now(),
+                    sessionId: getSessionId(),
+                    turn: this.turn,
+                    toolUseId: part.tool_use_id,
+                    isError: Boolean(part.is_error),
+                    content: part.content,
+                });
+            }
+            return;
+        }
+    }
+}

package/dist/src/core/query/runtime.smoke.js

@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict';
+import { CoreQueryRuntimeEmitter } from './runtime.js';
+const events = [];
+const emitter = new CoreQueryRuntimeEmitter(event => {
+    events.push(event);
+});
+emitter.emitSessionState('started');
+emitter.emitRunning();
+emitter.emitFromQueryMessage({
+    type: 'assistant',
+    message: {
+        content: [
+            { type: 'text', text: 'hello' },
+            { type: 'tool_use', id: 'tool-1', name: 'shell', input: { command: 'pwd' } },
+        ],
+    },
+});
+emitter.emitFromQueryMessage({
+    type: 'user',
+    message: {
+        content: [{ type: 'tool_result', tool_use_id: 'tool-1', is_error: false, content: 'ok' }],
+    },
+});
+emitter.emitError('cancelled by user', 'cancelled');
+emitter.emitResult(true, 'end_turn', 'partial result');
+emitter.emitSessionState('failed', 'cancelled');
+assert.equal(events[0]?.type, 'session_state');
+assert.equal(events[0]?.state, 'started');
+assert.equal(events[1]?.type, 'session_state');
+assert.equal(events[1]?.state, 'running');
+assert.equal(events[2]?.type, 'assistant_message');
+assert.equal(events[3]?.type, 'tool_call');
+assert.equal(events[4]?.type, 'tool_result');
+assert.equal(events[5]?.type, 'error');
+assert.equal(events[6]?.type, 'result');
+assert.equal(events[6]?.result, 'partial result');
+assert.equal(events[7]?.type, 'session_state');
+assert.equal(events[7]?.reason, 'cancelled');
+console.log('runtime.smoke PASS');

package/dist/src/core/query/timelineThinking.smoke.js

@@ -0,0 +1,25 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+function readText(absolutePath) {
+    return readFileSync(absolutePath, 'utf8');
+}
+const desktopRoot = resolve(process.cwd(), '..', 'apps', 'desktop', 'src');
+try {
+    readFileSync(resolve(desktopRoot, 'App.tsx'), 'utf8');
+}
+catch {
+    console.error('timeline-thinking smoke: no se encontro apps/desktop/src/App.tsx');
+    process.exit(1);
+}
+const appSrc = readText(resolve(desktopRoot, 'App.tsx'));
+const cliEventsSrc = readText(resolve(desktopRoot, 'lib', 'cliEvents.ts'));
+assert.ok(appSrc.includes('function isCoreQueryTerminalPayload('), 'App.tsx: falta detector terminal core_query para apagar thinking/spinner');
+assert.ok(appSrc.includes("payload.eventType === \"result\""), 'App.tsx: terminal detector debe tratar result como fin de turno');
+assert.ok(appSrc.includes('payload.eventType === "session_state"'), 'App.tsx: terminal detector debe revisar session_state');
+assert.ok(appSrc.includes('reason === "cancelled"') && appSrc.includes('reason === "canceled"'), 'App.tsx: session_state terminal debe cubrir reason cancelled/canceled');
+assert.ok(appSrc.includes('setThinkingByChat((prev) => {'), 'App.tsx: falta efecto de cierre de thinking por eventos terminales');
+assert.ok(cliEventsSrc.includes('case "core_query_event"'), 'cliEvents.ts: falta parser core_query_event para timeline Desktop');
+assert.ok(cliEventsSrc.includes('Sesi') && cliEventsSrc.includes('cancelada'), 'cliEvents.ts: timeline no refleja cancelacion de sesion');
+assert.ok(cliEventsSrc.includes('Resultado con error') && cliEventsSrc.includes('Resultado'), 'cliEvents.ts: timeline debe cubrir result success/error');
+console.log('timeline-thinking smoke PASS');

package/dist/src/core/query/wiring.smoke.js

@@ -0,0 +1,76 @@
+// Smoke estatico que valida el wiring del adapter Core Query → stream-json.
+//
+// Por que estatico (grep guard):
+//   Un E2E real requiere CLI compilado, credenciales y red. Para gate de
+//   regresion en CI/local basta con verificar que el codigo que conecta el
+//   sink y la emision NDJSON sigue presente. Si alguien borra el wiring por
+//   refactor, este smoke falla con un mensaje accionable.
+//
+// Que valida:
+//   1. `QueryEngine.ask()` declara y propaga `onCoreQueryEvent` al engine.
+//   2. `cli/print.ts` arma el sink condicional a `CORE_QUERY_ENABLED=1` y
+//      `outputFormat === 'stream-json'`, escribiendo NDJSON con el campo
+//      `type: "core_query_event"`.
+//   3. El emitter sigue traduciendo eventos del loop a la forma neutral.
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { CoreQueryRuntimeEmitter } from './runtime.js';
+const here = dirname(fileURLToPath(import.meta.url));
+// Soporta dos invocaciones:
+//   - tsx src/core/query/wiring.smoke.ts (here = .../CLI/src/core/query)
+//   - node dist/src/core/query/wiring.smoke.js (here = .../CLI/dist/src/core/query)
+const candidates = [
+    resolve(here, '..', '..'), // src
+    resolve(here, '..', '..', '..', '..', 'src'),
+];
+let repoSrc = '';
+for (const candidate of candidates) {
+    try {
+        readFileSync(resolve(candidate, 'QueryEngine.ts'), 'utf8');
+        repoSrc = candidate;
+        break;
+    }
+    catch {
+        // probar siguiente candidato
+    }
+}
+if (!repoSrc) {
+    console.error('wiring.smoke: no se encontro CLI/src/QueryEngine.ts');
+    process.exit(1);
+}
+function readSource(relative) {
+    const full = resolve(repoSrc, relative);
+    return readFileSync(full, 'utf8');
+}
+// 1) ask() declara onCoreQueryEvent y lo pasa al engine.
+const queryEngineSrc = readSource('QueryEngine.ts');
+assert.ok(queryEngineSrc.includes('onCoreQueryEvent?: CoreQueryEventSink'), 'QueryEngine.ts: tipo onCoreQueryEvent no declarado en ask() / config');
+assert.ok(/onCoreQueryEvent[\s,]/.test(queryEngineSrc.split('new QueryEngine({')[1] ?? ''), 'QueryEngine.ts: ask() ya no propaga onCoreQueryEvent al engine');
+// 2) print.ts arma el sink con los dos flags activos.
+const printSrc = readSource('cli/print.ts');
+assert.ok(printSrc.includes("CORE_QUERY_ENABLED === '1'"), 'cli/print.ts: feature flag CORE_QUERY_ENABLED ya no controla el sink');
+assert.ok(printSrc.includes("options.outputFormat === 'stream-json'"), 'cli/print.ts: gate por outputFormat=stream-json no esta presente');
+assert.ok(/type:\s*['"]core_query_event['"]/.test(printSrc), 'cli/print.ts: envelope no marca type:"core_query_event"');
+assert.ok(printSrc.includes('process.stdout.write(jsonStringify(envelope)'), 'cli/print.ts: el sink ya no escribe NDJSON al stdout');
+// 3) Emitter sigue traduciendo eventos del loop a la forma neutral.
+const events = [];
+const emitter = new CoreQueryRuntimeEmitter(event => {
+    events.push(event);
+});
+emitter.emitSessionState('started');
+emitter.emitFromQueryMessage({
+    type: 'assistant',
+    message: {
+        content: [{ type: 'text', text: 'hi' }],
+    },
+});
+emitter.emitResult(false, 'end_turn');
+emitter.emitSessionState('completed');
+assert.equal(events.length, 4, 'emitter deberia haber producido 4 eventos');
+assert.equal(events[0]?.type, 'session_state');
+assert.equal(events[1]?.type, 'assistant_message');
+assert.equal(events[2]?.type, 'result');
+assert.equal(events[3]?.type, 'session_state');
+console.log('core-query-wiring smoke PASS');

package/dist/src/core/skills/cliAdapter.js

@@ -0,0 +1,38 @@
+import { getBuiltinPluginSkillCommands } from '../../plugins/builtinPlugins.js';
+import { getBundledSkills } from '../../skills/bundledSkills.js';
+import { clearSkillCaches, getSkillDirCommands } from '../../skills/loadSkillsDir.js';
+import { clearPluginSkillsCache, getPluginSkills, } from '../../utils/plugins/loadPluginCommands.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { toError } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+import { CoreSkillsIndex, registerDefaultCoreSkillsIndex, } from './index.js';
+const cliSkillSourcesLoader = {
+    loadSkillDirCommands: async (cwd) => {
+        try {
+            return await getSkillDirCommands(cwd);
+        }
+        catch (err) {
+            logError(toError(err));
+            logForDebugging('Core skill directory commands failed to load, continuing without them');
+            return [];
+        }
+    },
+    loadPluginSkills: async () => {
+        try {
+            return await getPluginSkills();
+        }
+        catch (err) {
+            logError(toError(err));
+            logForDebugging('Core plugin skills failed to load, continuing without them');
+            return [];
+        }
+    },
+    loadBundledSkills: getBundledSkills,
+    loadBuiltinPluginCommands: getBuiltinPluginSkillCommands,
+};
+const cliSkillCacheManager = {
+    clearSkillCaches,
+    clearPluginSkillsCache,
+};
+export const coreSkillsIndex = new CoreSkillsIndex(cliSkillSourcesLoader, cliSkillCacheManager);
+registerDefaultCoreSkillsIndex(coreSkillsIndex);

package/dist/src/core/skills/index.js

@@ -0,0 +1,52 @@
+import { getBuiltinPluginSkillCommands } from '../../plugins/builtinPlugins.js';
+import { getBundledSkills } from '../../skills/bundledSkills.js';
+import { clearSkillCaches, getSkillDirCommands, } from '../../skills/loadSkillsDir.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { toError } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+import { clearPluginSkillsCache, getPluginSkills, } from '../../utils/plugins/loadPluginCommands.js';
+export function isCoreSkillsEnabled() {
+    return process.env.CORE_SKILLS_ENABLED === '1';
+}
+export async function loadCoreSkillCommandSources(cwd) {
+    const [skillDirCommands, pluginSkills] = await Promise.all([
+        getSkillDirCommands(cwd).catch(err => {
+            logError(toError(err));
+            logForDebugging('Core skill directory commands failed to load, continuing without them');
+            return [];
+        }),
+        getPluginSkills().catch(err => {
+            logError(toError(err));
+            logForDebugging('Core plugin skills failed to load, continuing without them');
+            return [];
+        }),
+    ]);
+    return {
+        skillDirCommands,
+        pluginSkills,
+        bundledSkills: getBundledSkills(),
+        builtinPluginSkills: getBuiltinPluginSkillCommands(),
+    };
+}
+export async function listCoreSkillCommands(cwd) {
+    const { skillDirCommands, pluginSkills, bundledSkills, builtinPluginSkills, } = await loadCoreSkillCommandSources(cwd);
+    return [
+        ...bundledSkills,
+        ...builtinPluginSkills,
+        ...skillDirCommands,
+        ...pluginSkills,
+    ];
+}
+export function clearCoreSkillsCaches() {
+    clearSkillCaches();
+    clearPluginSkillsCache();
+}
+export class CoreSkillsIndex {
+    async listSkills(cwd) {
+        return listCoreSkillCommands(cwd);
+    }
+    async listSkillSources(cwd) {
+        return loadCoreSkillCommandSources(cwd);
+    }
+}
+export const coreSkillsIndex = new CoreSkillsIndex();

package/dist/src/core/skills/runtime.smoke.js

@@ -0,0 +1,53 @@
+import assert from 'node:assert/strict';
+import { CoreSkillsIndex } from './index.js';
+const makeCommand = (name) => ({
+    type: 'prompt',
+    name,
+    description: `smoke ${name}`,
+    isEnabled: () => true,
+    userFacingName() {
+        return name;
+    },
+});
+const loader = {
+    async loadSkillDirCommands(_cwd) {
+        return [makeCommand('skill-dir')];
+    },
+    async loadPluginSkills() {
+        return [makeCommand('plugin-skill')];
+    },
+    loadBundledSkills() {
+        return [makeCommand('bundled-skill')];
+    },
+    loadBuiltinPluginCommands() {
+        return [makeCommand('builtin-plugin-skill')];
+    },
+};
+let clearSkillCachesCalls = 0;
+let clearPluginSkillsCacheCalls = 0;
+const cacheManager = {
+    clearSkillCaches: () => {
+        clearSkillCachesCalls += 1;
+    },
+    clearPluginSkillsCache: () => {
+        clearPluginSkillsCacheCalls += 1;
+    },
+};
+const index = new CoreSkillsIndex(loader, cacheManager);
+const listed = await index.listSkills(process.cwd());
+const names = listed.map(command => command.name);
+assert.deepEqual(names, [
+    'bundled-skill',
+    'builtin-plugin-skill',
+    'skill-dir',
+    'plugin-skill',
+]);
+const sources = await index.listSkillSources(process.cwd());
+assert.equal(sources.skillDirCommands.length, 1);
+assert.equal(sources.pluginSkills.length, 1);
+assert.equal(sources.bundledSkills.length, 1);
+assert.equal(sources.builtinPluginSkills.length, 1);
+index.clearCaches();
+assert.equal(clearSkillCachesCalls, 1);
+assert.equal(clearPluginSkillsCacheCalls, 1);
+console.log('skills.runtime.smoke PASS');

package/dist/src/core/tasks/runtime.js

@@ -0,0 +1,205 @@
+import { coreAgentsRegistry } from '../agents/registry.js';
+function now() {
+    return Date.now();
+}
+function asCoreTaskStatus(status) {
+    return status === 'stopped' ? 'killed' : status;
+}
+function inferAgentKind(taskId, taskType) {
+    if (taskType === 'in_process_teammate') {
+        return 'teammate';
+    }
+    if (taskType === 'local_agent') {
+        return taskId.startsWith('s') ? 'main-session' : 'subagent';
+    }
+    return 'unknown';
+}
+function buildAgentName(taskId, description, taskType) {
+    if (taskType === 'in_process_teammate') {
+        return description || taskId;
+    }
+    if (taskType === 'local_agent' && taskId.startsWith('s')) {
+        return 'main-session';
+    }
+    return description || taskId;
+}
+function toUsage(usage) {
+    if (!usage) {
+        return undefined;
+    }
+    return {
+        totalTokens: usage.total_tokens,
+        toolUses: usage.tool_uses,
+        durationMs: usage.duration_ms,
+    };
+}
+export class CoreTasksRuntime {
+    tasks = new Map();
+    agents;
+    constructor(agents = coreAgentsRegistry) {
+        this.agents = agents;
+    }
+    createTask(id, description, input = {}) {
+        const timestamp = now();
+        const task = {
+            id,
+            description,
+            taskType: input.taskType,
+            status: 'pending',
+            assignedAgentId: input.assignedAgentId,
+            assignedAgent: input.assignedAgentId
+                ? this.agents.getAgent(input.assignedAgentId)
+                : undefined,
+            toolUseId: input.toolUseId,
+            prompt: input.prompt,
+            startedAt: timestamp,
+            updatedAt: timestamp,
+            source: input.source ?? 'manual',
+        };
+        this.tasks.set(id, task);
+        return task;
+    }
+    assignAgent(taskId, agent) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            return undefined;
+        }
+        const resolved = typeof agent === 'string' ? this.agents.getAgent(agent) : agent;
+        const assignedAgentId = typeof agent === 'string' ? agent : agent.id;
+        const next = {
+            ...task,
+            assignedAgentId,
+            assignedAgent: resolved,
+            updatedAt: now(),
+        };
+        this.tasks.set(taskId, next);
+        return next;
+    }
+    updateStatus(taskId, status, result) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            return undefined;
+        }
+        const timestamp = now();
+        const next = {
+            ...task,
+            status,
+            result: result ?? task.result,
+            updatedAt: timestamp,
+            completedAt: status === 'completed' || status === 'failed' || status === 'killed'
+                ? timestamp
+                : task.completedAt,
+        };
+        this.tasks.set(taskId, next);
+        return next;
+    }
+    ingestSdkEvent(event) {
+        if (event.type !== 'system') {
+            return undefined;
+        }
+        switch (event.subtype) {
+            case 'task_started':
+                return this.upsertStartedTask(event);
+            case 'task_progress':
+                return this.upsertProgressTask(event);
+            case 'task_notification':
+                return this.completeTaskFromSdk(event);
+            default:
+                return undefined;
+        }
+    }
+    getTask(id) {
+        return this.tasks.get(id);
+    }
+    listTasks() {
+        return Array.from(this.tasks.values());
+    }
+    clear() {
+        this.tasks.clear();
+    }
+    upsertStartedTask(event) {
+        const assignedAgentId = event.task_type === 'local_agent' || event.task_type === 'in_process_teammate'
+            ? event.task_id
+            : undefined;
+        if (assignedAgentId && !this.agents.getAgent(assignedAgentId)) {
+            this.agents.registerAgent({
+                id: assignedAgentId,
+                kind: inferAgentKind(event.task_id, event.task_type),
+                name: buildAgentName(event.task_id, event.description, event.task_type),
+                allowedTools: [],
+                source: 'task-runtime',
+                metadata: {
+                    taskType: event.task_type,
+                    prompt: event.prompt,
+                },
+            });
+        }
+        const existing = this.tasks.get(event.task_id);
+        const timestamp = now();
+        const next = {
+            id: event.task_id,
+            description: event.description,
+            taskType: event.task_type,
+            status: 'running',
+            assignedAgentId,
+            assignedAgent: assignedAgentId
+                ? this.agents.getAgent(assignedAgentId)
+                : undefined,
+            toolUseId: event.tool_use_id,
+            prompt: event.prompt,
+            summary: existing?.summary,
+            lastToolName: existing?.lastToolName,
+            usage: existing?.usage,
+            result: existing?.result,
+            startedAt: existing?.startedAt ?? timestamp,
+            updatedAt: timestamp,
+            completedAt: undefined,
+            source: 'sdk_event',
+        };
+        this.tasks.set(event.task_id, next);
+        return next;
+    }
+    upsertProgressTask(event) {
+        const existing = this.tasks.get(event.task_id) ??
+            this.createTask(event.task_id, event.description, {
+                taskType: 'local_agent',
+                toolUseId: event.tool_use_id,
+                source: 'sdk_event',
+            });
+        const next = {
+            ...existing,
+            status: 'running',
+            description: event.description,
+            toolUseId: event.tool_use_id ?? existing.toolUseId,
+            usage: toUsage(event.usage),
+            summary: event.summary ?? existing.summary,
+            lastToolName: event.last_tool_name ?? existing.lastToolName,
+            updatedAt: now(),
+            source: 'sdk_event',
+        };
+        this.tasks.set(event.task_id, next);
+        return next;
+    }
+    completeTaskFromSdk(event) {
+        const existing = this.tasks.get(event.task_id) ??
+            this.createTask(event.task_id, event.summary || event.task_id, {
+                toolUseId: event.tool_use_id,
+                source: 'sdk_event',
+            });
+        const timestamp = now();
+        const next = {
+            ...existing,
+            status: asCoreTaskStatus(event.status),
+            toolUseId: event.tool_use_id ?? existing.toolUseId,
+            summary: event.summary || existing.summary,
+            result: event.summary || existing.result,
+            usage: toUsage(event.usage) ?? existing.usage,
+            updatedAt: timestamp,
+            completedAt: timestamp,
+            source: 'sdk_event',
+        };
+        this.tasks.set(event.task_id, next);
+        return next;
+    }
+}
+export const coreTasksRuntime = new CoreTasksRuntime();

package/dist/src/core/tasks/runtime.smoke.js

@@ -0,0 +1,63 @@
+import assert from 'node:assert/strict';
+import { coreAgentsRegistry } from '../agents/registry.js';
+import { coreTasksRuntime } from './runtime.js';
+import { runWithAgentContext } from '../../utils/agentContext.js';
+import { enqueueSdkEvent } from '../../utils/sdkEventQueue.js';
+coreAgentsRegistry.clear();
+coreTasksRuntime.clear();
+runWithAgentContext({
+    agentId: 'a123',
+    agentType: 'subagent',
+    subagentName: 'Explore',
+    parentSessionId: 'parent-1',
+    isBuiltIn: true,
+    invokingRequestId: 'req-1',
+    invocationKind: 'spawn',
+}, () => {
+    enqueueSdkEvent({
+        type: 'system',
+        subtype: 'task_started',
+        task_id: 'a123',
+        tool_use_id: 'tool-1',
+        description: 'Explore auth flow',
+        task_type: 'local_agent',
+        prompt: 'Trace the auth flow',
+    });
+    enqueueSdkEvent({
+        type: 'system',
+        subtype: 'task_progress',
+        task_id: 'a123',
+        tool_use_id: 'tool-1',
+        description: 'Explore auth flow',
+        summary: 'Reading auth sources',
+        last_tool_name: 'Read',
+        usage: {
+            total_tokens: 128,
+            tool_uses: 3,
+            duration_ms: 5000,
+        },
+    });
+    enqueueSdkEvent({
+        type: 'system',
+        subtype: 'task_notification',
+        task_id: 'a123',
+        tool_use_id: 'tool-1',
+        status: 'completed',
+        output_file: '',
+        summary: 'Auth flow mapped',
+    });
+});
+const task = coreTasksRuntime.getTask('a123');
+assert.ok(task);
+assert.equal(task.status, 'completed');
+assert.equal(task.assignedAgentId, 'a123');
+assert.equal(task.lastToolName, 'Read');
+assert.equal(task.usage?.toolUses, 3);
+assert.equal(task.result, 'Auth flow mapped');
+const agent = coreAgentsRegistry.getAgent('a123');
+assert.ok(agent);
+assert.equal(agent.kind, 'subagent');
+assert.equal(agent.source, 'subagent-context');
+assert.equal(agent.parentSessionId, 'parent-1');
+assert.equal(agent.metadata?.invocationKind, 'spawn');
+console.log('tasks.runtime.smoke PASS');

package/dist/src/core/tasks/sdkAdapter.js

@@ -0,0 +1,4 @@
+import { coreTasksRuntime } from './runtime.js';
+export function recordSdkEvent(event) {
+    coreTasksRuntime.ingestSdkEvent(event);
+}

package/dist/src/core/tools/contracts.js

@@ -0,0 +1,3 @@
+export function isCoreToolsEnabled() {
+    return process.env.CORE_TOOLS_ENABLED === '1';
+}