agent-trace: migrate diff capture to message.updated and add model attribution

.opencode/plugins/sce-agent-trace.ts

@@ -3,134 +3,148 @@ import type { Hooks, Plugin } from "@opencode-ai/plugin";
 
 type OpenCodeEvent = Parameters<NonNullable<Hooks["event"]>>[0]["event"];
 
-const REQUIRED_EVENTS = new Set(["session.diff"]);
+const REQUIRED_EVENTS = new Set(["message.updated"]);
 
 const ALL_CAPTURED_EVENTS = REQUIRED_EVENTS;
 
 type TraceInput = {
-  event?: OpenCodeEvent;
+	event?: OpenCodeEvent;
 };
 
 type DiffTracePayload = {
-  sessionID: string;
-  diff: string;
-  time: number;
+	sessionID: string;
+	diff: string;
+	time: number;
+	model_id: string;
 };
 
 function extractDiffTracePayload(
-  input: TraceInput,
+	input: TraceInput,
 ): DiffTracePayload | undefined {
-  const event = input.event;
-  if (event === undefined || event.type !== "session.diff") {
-    return undefined;
-  }
-
-  const properties = event.properties;
-  if (typeof properties !== "object" || properties === null) {
-    return undefined;
-  }
-
-  const propertiesObj = properties as Record<string, unknown>;
-
-  const sessionID =
-    typeof propertiesObj.sessionID === "string" &&
-    propertiesObj.sessionID.trim().length > 0
-      ? propertiesObj.sessionID
-      : "unknown";
-
-  const diffEntries = propertiesObj.diff;
-  if (!Array.isArray(diffEntries) || diffEntries.length === 0) {
-    return undefined;
-  }
-
-  const patches: string[] = [];
-  for (const entry of diffEntries) {
-    if (typeof entry !== "object" || entry === null) {
-      continue;
-    }
-    const entryObj = entry as Record<string, unknown>;
-    const patch =
-      typeof entryObj.patch === "string"
-        ? entryObj.patch
-        : typeof entryObj.diff === "string"
-          ? entryObj.diff
-          : undefined;
-    if (patch !== undefined && patch.trim().length > 0) {
-      patches.push(patch);
-    }
-  }
-
-  if (patches.length === 0) {
-    return undefined;
-  }
-
-  return {
-    sessionID,
-    diff: patches.join("\n"),
-    time: Date.now(),
-  };
+	const event = input.event;
+	if (event === undefined || event.type !== "message.updated") {
+		return undefined;
+	}
+
+	const properties = event.properties;
+	if (typeof properties !== "object" || properties === null) {
+		return undefined;
+	}
+
+	const propertiesObj = properties;
+
+	// Access properties.info (the Message object)
+	const info = propertiesObj.info;
+	if (typeof info !== "object" || info === null) {
+		return undefined;
+	}
+
+	const infoObj = info;
+
+	// Only capture user messages (filter out assistant, system, etc.)
+	if (infoObj.role !== "user") {
+		return undefined;
+	}
+
+	const sessionID =
+		typeof infoObj.sessionID === "string" && infoObj.sessionID.trim().length > 0
+			? infoObj.sessionID
+			: "unknown";
+
+	const model = infoObj.model;
+
+	// Access info.summary?.diffs via explicit checks
+	const summary = infoObj.summary;
+	const diffEntries =
+		typeof summary === "object" && summary !== null ? summary.diffs : undefined;
+
+	if (!Array.isArray(diffEntries) || diffEntries.length === 0) {
+		return undefined;
+	}
+
+	const patches: string[] = [];
+	for (const entry of diffEntries) {
+		if (typeof entry !== "object" || entry === null) {
+			continue;
+		}
+		const entryObj = entry as { patch?: string };
+		const patch = entryObj.patch || "";
+
+		patches.push(patch);
+	}
+
+	if (patches.length === 0) {
+		return undefined;
+	}
+
+	return {
+		sessionID,
+		diff: patches.join("\n"),
+		time: Date.now(),
+		model_id: `${model.providerID}/${model.modelID}`,
+	};
 }
 
 function shouldCaptureEvent(eventType: string): boolean {
-  return ALL_CAPTURED_EVENTS.has(eventType);
+	return ALL_CAPTURED_EVENTS.has(eventType);
 }
 
 async function buildTrace(repoRoot: string, input: TraceInput): Promise<void> {
-  const diffTracePayload = extractDiffTracePayload(input);
+	const diffTracePayload = extractDiffTracePayload(input);
 
-  if (diffTracePayload === undefined) {
-    return;
-  }
+	if (diffTracePayload === undefined) {
+		return;
+	}
 
-  await runDiffTraceHook(repoRoot, diffTracePayload);
+	await runDiffTraceHook(repoRoot, diffTracePayload);
 }
 
 async function runDiffTraceHook(
-  repoRoot: string,
-  payload: DiffTracePayload,
+	repoRoot: string,
+	payload: DiffTracePayload,
 ): Promise<void> {
-  await new Promise<void>((resolve, reject) => {
-    const child = spawn("sce", ["hooks", "diff-trace"], {
-      cwd: repoRoot,
-      stdio: ["pipe", "ignore", "inherit"],
-    });
-
-    child.on("error", reject);
-
-    child.on("close", (code, signal) => {
-      if (code === 0) {
-        resolve();
-        return;
-      }
-
-      const reason =
-        signal === null ? `exit code ${String(code)}` : `signal ${signal}`;
-      reject(
-        new Error(`Command 'sce hooks diff-trace' failed with ${reason}.`),
-      );
-    });
-
-    child.stdin.end(`${JSON.stringify(payload)}\n`);
-  });
+	await new Promise<void>((resolve, reject) => {
+		const child = spawn("sce", ["hooks", "diff-trace"], {
+			cwd: repoRoot,
+			stdio: ["pipe", "ignore", "inherit"],
+		});
+
+		child.on("error", reject);
+
+		child.on("close", (code, signal) => {
+			if (code === 0) {
+				resolve();
+				return;
+			}
+
+			const reason =
+				signal === null ? `exit code ${String(code)}` : `signal ${signal}`;
+			reject(
+				new Error(`Command 'sce hooks diff-trace' failed with ${reason}.`),
+			);
+		});
+
+		child.stdin.end(`${JSON.stringify(payload)}\n`);
+	});
 }
 
 export const SceAgentTracePlugin: Plugin = async ({ directory, worktree }) => {
-  const repoRoot = worktree ?? directory ?? process.cwd();
-
-  return {
-    event: async (input) => {
-      const eventType =
-        typeof input.event === "object" &&
-        input.event !== null &&
-        typeof input.event.type === "string"
-          ? input.event.type
-          : undefined;
-
-      if (eventType === undefined || !shouldCaptureEvent(eventType)) {
-        return;
-      }
-
-      await buildTrace(repoRoot, input);
-    },
-  };
+	const repoRoot = worktree ?? directory ?? process.cwd();
+
+	return {
+		event: async (input) => {
+			const eventType =
+				typeof input.event === "object" &&
+				input.event !== null &&
+				typeof input.event.type === "string"
+					? input.event.type
+					: undefined;
+
+			if (eventType === undefined || !shouldCaptureEvent(eventType)) {
+				return;
+			}
+
+			await buildTrace(repoRoot, input);
+		},
+	};
 };

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "editor.formatOnSave": true,
+  "[typescript]": {
+    "editor.defaultFormatter": "biomejs.biome"
+  }
+}

biome.json

@@ -3,9 +3,9 @@
 	"files": {
 		"includes": [
 			"npm/**",
-			"config/lib/bash-policy-plugin/**",
+			"config/lib/**",
 			"!npm/node_modules",
-			"!config/lib/bash-policy-plugin/node_modules"
+			"!config/lib/node_modules"
 		]
 	},
 	"formatter": {

cli/migrations/agent-trace/005_add_diff_traces_model_id.sql

@@ -0,0 +1 @@
+ALTER TABLE diff_traces ADD COLUMN model_id TEXT;

cli/migrations/agent-trace/006_add_agent_traces_agent_trace_id.sql

@@ -0,0 +1 @@
+ALTER TABLE agent_traces ADD COLUMN agent_trace_id TEXT;

cli/src/services/agent_trace.rs

@@ -180,6 +180,9 @@ pub struct Contributor {
     /// Classification of this hunk's origin.
     #[serde(rename = "type")]
     pub kind: HunkContributor,
+    /// Model provenance for this contributor; omitted when unknown.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub model_id: Option<String>,
 }
 
 /// A single line range in the new file.
@@ -322,12 +325,28 @@ fn build_trace_file(
         .hunks
         .iter()
         .map(|post_commit_hunk| {
-            let contributor = match intersection_file {
-                Some(ifile) => classify_hunk(post_commit_hunk, &ifile.hunks),
-                None => HunkContributor::Unknown,
+            let (contributor_kind, contributor_model_id) = match intersection_file {
+                Some(ifile) => {
+                    let contributor_kind = classify_hunk(post_commit_hunk, &ifile.hunks);
+                    let matched_intersection_hunk = ifile
+                        .hunks
+                        .iter()
+                        .find(|h| h.old_start == post_commit_hunk.old_start);
+                    let contributor_model_id = match contributor_kind {
+                        HunkContributor::Ai | HunkContributor::Mixed => {
+                            matched_intersection_hunk.and_then(|hunk| hunk.model_id.clone())
+                        }
+                        HunkContributor::Unknown => None,
+                    };
+                    (contributor_kind, contributor_model_id)
+                }
+                None => (HunkContributor::Unknown, None),
             };
             Conversation {
-                contributor: Contributor { kind: contributor },
+                contributor: Contributor {
+                    kind: contributor_kind,
+                    model_id: contributor_model_id,
+                },
                 ranges: vec![line_range_from_hunk(post_commit_file, post_commit_hunk)],
             }
         })