presubmit 0.1.0

package/dist/packages/agent-pi/src/task-tools.js

@@ -0,0 +1,53 @@
+import { Type } from 'typebox';
+import { parseTaskResult } from '../../protocol/src/delegation.js';
+import { createPlanningTools } from './planning.js';
+export function createResearchTools(cwd) {
+    return createPlanningTools(cwd, async () => {
+        throw new Error('Planning mutation is not a research capability.');
+    }).filter((tool) => ['list_repository', 'read_repository'].includes(tool.name));
+}
+export function createTaskReportTools(report, question) {
+    return [
+        {
+            name: 'report_task_result',
+            label: 'Report task result',
+            description: 'Report completion evidence to the coordinator. A successful finished turn completes the task once queued follow-ups are handled, unless a blocking question remains. This does not commit or merge code.',
+            parameters: Type.Object({
+                summary: Type.String({ minLength: 1, maxLength: 8000 }),
+                changedAreas: Type.String({ maxLength: 4000 }),
+                verification: Type.String({ minLength: 1, maxLength: 8000 }),
+                unresolved: Type.String({ maxLength: 4000 }),
+            }),
+            execute: async (_id, args) => {
+                report(parseTaskResult(args));
+                return {
+                    content: [
+                        { type: 'text', text: 'Result reported. Finish the turn to complete the task.' },
+                    ],
+                    details: {},
+                };
+            },
+        },
+        {
+            name: 'ask_coordinator',
+            label: 'Ask coordinator',
+            description: 'Report a blocking question to the parent. Finish this turn and wait for a coordinator or user follow-up rather than guessing.',
+            parameters: Type.Object({ question: Type.String({ minLength: 1, maxLength: 2000 }) }),
+            execute: async (_id, args) => {
+                const text = args.question;
+                if (typeof text !== 'string' || !text.trim() || text.length > 2000)
+                    throw new Error('Invalid task question.');
+                question(text);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Question sent to coordinator. Finish now; the coordinator can use send_child_message, or the user can reply through the task or this child session.',
+                        },
+                    ],
+                    details: {},
+                };
+            },
+        },
+    ];
+}

package/dist/packages/agent-pi/src/types.js

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

package/dist/packages/agent-pi/src/usage.js

@@ -0,0 +1,30 @@
+/** Publish cumulative run totals only when the provider has finalized usage. */
+export function createUsageTracker(publish, now = () => performance.now()) {
+    const total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    let assistantStartedAt;
+    let measuredOutputTokens = 0;
+    let measuredDurationMs = 0;
+    return (event) => {
+        if (event.type === 'message_start' && event.message.role === 'assistant') {
+            assistantStartedAt = now();
+            return;
+        }
+        const usage = event.type === 'message_end' && event.message.role === 'assistant'
+            ? event.message.usage
+            : event.type === 'compaction_end'
+                ? event.result?.usage
+                : undefined;
+        if (!usage)
+            return;
+        for (const key of ['input', 'output', 'cacheRead', 'cacheWrite'])
+            total[key] += usage[key];
+        if (event.type === 'message_end' && assistantStartedAt !== undefined) {
+            measuredOutputTokens += usage.output;
+            measuredDurationMs += Math.max(1, Math.round(now() - assistantStartedAt));
+            assistantStartedAt = undefined;
+        }
+        publish({ ...total }, measuredDurationMs > 0
+            ? { outputTokens: measuredOutputTokens, durationMs: measuredDurationMs }
+            : undefined);
+    };
+}