wip v28

Author: geraldarthurdavis

BITCODE_SPEC_V28.md

@@ -504,6 +504,12 @@ Read/Fit result review remains fail-closed:
   parsed/typed output, usage/timing metadata, and phase/agent/step/failsafe
   correlation. A harness failure must still export the execution tree so
   operators can debug the last successful sub-execution.
+- tool telemetry includes both direct `tool-use` emissions and stored
+  `tools/*` status results from pipeline delivery work. Depository search,
+  evidence verification, branch creation, file write, and pull-request creation
+  must appear in the generic event stream and, when database streaming is
+  enabled, in `deliverable_pipeline_tool_executions` with sanitized input,
+  output, error, and phase/agent/step correlation.
 - artifact telemetry must subscribe to stream events even when database
   streaming is disabled; database persistence is an additional acceptance gate,
   not the only way to inspect a live failed run.

BITCODE_V28_QA.md

@@ -923,6 +923,11 @@ First-run execution boundary:
   provider/name, usage tokens, phase, agent, step, failsafe, and generation
   context. Missing prompts, missing parsed outputs, or uncorrelated
   generation/tool rows are blockers for debugging live Read/Fit execution.
+- Structured tool telemetry must include both direct tool-use events and stored
+  `tools/*` status results emitted by delivery work. Depository search,
+  evidence verification, branch creation, file writes, and pull-request
+  creation must be visible in the stream and, when database streaming is on,
+  in `deliverable_pipeline_tool_executions` without secret-bearing inputs.
 - Failed harness runs must still export `evidence.json` with the execution tree
   and the last visible stream event summaries. A failing command with no
   prompt/context, raw output, parsed/cast output, or phase/agent correlation is

packages/pipeline-hosts/README.md

@@ -58,9 +58,12 @@ verification readback tool for risk-admission and readiness work; a live
 `Tool not found` result for that tool is a registry failure, not acceptable
 blocked-readiness evidence. Tool-result events must carry summarized input
 and output/error so the database row and Terminal stream can show what the
-agent asked and what the tool returned. Artifact telemetry must preserve tool
-name, ok/error state, and input/output/error presence so the execution log can
-identify each phase-agent-step tool invocation.
+agent asked and what the tool returned. Stored `tools/*` status results from
+finish delivery are tool executions too; branch creation, file writes, and
+pull-request creation must land in the same structured table as explicit
+`tool-use` events. Artifact telemetry must preserve tool name, ok/error state,
+and input/output/error presence so the execution log can identify each
+phase-agent-step tool invocation.
 Failed runs must still export `evidence.json` with the execution tree and
 last-known stream events so staging operators can see which SDIVF phase, PTRR
 agent, generation, or tool last produced input/output evidence.

packages/pipelines-generics/src/streaming/__tests__/forkable-execution.test.ts

@@ -240,4 +240,49 @@ describe('enablePipelineStreaming + Execution emits DB events (snapshot stream)'
       tool_error: null,
     });
   });
+
+  it('persists stored delivery tool status events into structured tool execution rows', async () => {
+    const supabase = new MockSupabase() as any;
+    const runId = '55555555-5555-4555-8555-555555555555';
+    const userId = '66666666-6666-4666-8666-666666666666';
+    const agentName = 'finish:asset-pack-delivery-agent';
+
+    const exec = new Execution(`exec-${runId}`);
+    const streamer = enablePipelineStreaming(exec as any, {
+      runId,
+      userId,
+      supabase,
+      structuredToDatabase: true,
+    });
+
+    await ExecutionStreamAdapter.emitEvent(exec.id, 'phase-start' as any, {
+      phase: 'finish',
+    });
+    await ExecutionStreamAdapter.emitEvent(exec.id, 'agent-start' as any, {
+      agent: agentName,
+      executionState: { phase: 'finish', agent: agentName, step: 'try' },
+    });
+    await ExecutionStreamAdapter.emitEvent(exec.id, 'status' as any, {
+      namespace: 'tools',
+      key: 'vcs_create_pull_request:2',
+      executionState: { phase: 'finish', agent: agentName, step: 'try' },
+      data: {
+        tool: 'vcs_create_pull_request',
+        ok: true,
+        input: { repository: 'engineeredsoftware/ENGI', baseBranch: 'main' },
+        output: { pullRequestNumber: 4, pullRequestUrl: 'https://github.com/engineeredsoftware/ENGI/pull/4' },
+      },
+    });
+
+    await (streamer as any).flushStructuredWrites?.();
+
+    expect(supabase.tables.deliverable_pipeline_tool_executions).toHaveLength(1);
+    expect(supabase.tables.deliverable_pipeline_tool_executions[0]).toMatchObject({
+      agent_step_id: 'deliverable_pipeline_agent_steps-1',
+      tool_name: 'vcs_create_pull_request',
+      tool_input: { repository: 'engineeredsoftware/ENGI', baseBranch: 'main' },
+      tool_output: { pullRequestNumber: 4, pullRequestUrl: 'https://github.com/engineeredsoftware/ENGI/pull/4' },
+      tool_error: null,
+    });
+  });
 });

packages/pipelines-generics/src/streaming/pipeline-stream-integration.ts

@@ -211,6 +211,42 @@ export function enablePipelineStreaming(
         context.generation || 'none',
       ].join(':');
 
+    const normalizeToolExecutionEvent = (event: any) => {
+      const type = String(event?.type || '');
+      if (type === 'tool-use') {
+        return {
+          toolName: event?.data?.tool || event?.metadata?.toolName || 'tool',
+          input: event?.data?.input ?? null,
+          output: event?.data?.output ?? null,
+          error: event?.data?.error ?? null,
+        };
+      }
+
+      const isStoredToolResult =
+        type === 'status' &&
+        event?.namespace === 'tools' &&
+        event?.data &&
+        typeof event.data === 'object' &&
+        event.data.tool;
+
+      if (!isStoredToolResult) {
+        return null;
+      }
+
+      return {
+        toolName: event.data.tool,
+        input: event.data.input ?? null,
+        output: event.data.output ?? null,
+        error: event.data.error ?? null,
+      };
+    };
+
+    const normalizeToolError = (error: unknown) => {
+      if (!error) return null;
+      if (typeof error === 'object') return error;
+      return { message: String(error) };
+    };
+
     const markDeliverableRun = async (status: 'completed' | 'failed', payload?: any) => {
       if (!(await ensureDeliverableRun())) return;
       const now = new Date().toISOString();
@@ -261,6 +297,23 @@ export function enablePipelineStreaming(
 
         await persistDeliverableEvent(event, phaseName, agentName);
 
+        const structuredTool = normalizeToolExecutionEvent(event);
+        if (structuredTool && await ensureDeliverableRun()) {
+          const phaseId = phaseState.currentPhaseId || (phaseName ? phaseIdByName.get(phaseName) : null);
+          const key = agentStepKey(phaseId ?? null, phaseName, agentName, stepType);
+          const agentStepId = agentStepMap.get(key) || null;
+          const row: import('../types/db').DPToolExecInsert = {
+            agent_step_id: agentStepId,
+            substep_id: null,
+            tool_name: structuredTool.toolName as any,
+            tool_input: structuredTool.input as any,
+            tool_output: structuredTool.output as any,
+            tool_error: normalizeToolError(structuredTool.error) as any,
+            created_at: now as any
+          } as any;
+          await insertRow('deliverable_pipeline_tool_executions', row);
+        }
+
         if (type === 'phase-start') {
           if (!(phaseName && await ensureDeliverableRun())) return;
           const row: import('../types/db').DPPhaseDelegationInsert = {
@@ -350,25 +403,6 @@ export function enablePipelineStreaming(
             created_at: now as any
           } as any;
           await insertRow('deliverable_pipeline_generations', row);
-        } else if (type === 'tool-use') {
-          if (!(await ensureDeliverableRun())) return;
-          const phaseId = phaseState.currentPhaseId || (phaseName ? phaseIdByName.get(phaseName) : null);
-          const key = agentStepKey(phaseId ?? null, phaseName, agentName, stepType);
-          const agentStepId = agentStepMap.get(key) || null;
-          const toolName = event?.data?.tool || event?.metadata?.toolName || 'tool';
-          const toolInput = event?.data?.input || null;
-          const toolOutput = event?.data?.output || null;
-          const toolError = event?.data?.error ? { message: event.data.error } : null;
-          const row: import('../types/db').DPToolExecInsert = {
-            agent_step_id: agentStepId,
-            substep_id: null,
-            tool_name: toolName as any,
-            tool_input: toolInput as any,
-            tool_output: toolOutput as any,
-            tool_error: toolError as any,
-            created_at: now as any
-          } as any;
-          await insertRow('deliverable_pipeline_tool_executions', row);
         } else if (type === 'status') {
           if (event?.namespace === 'llm' && event?.key === 'input') {
             const messages = event?.data?.messages;