@agent-native/core 0.94.1 → 0.94.3

package/corpus/templates/clips/desktop/src-tauri/src/native_screen.rs

@@ -147,6 +147,33 @@ impl NativeUploadMode {
             Self::Streaming => "streaming",
         }
     }
+
+    fn from_reset_response(body: &str) -> Self {
+        let value = serde_json::from_str::<serde_json::Value>(body).ok();
+        let upload_mode = value
+            .as_ref()
+            .and_then(|value| value.get("uploadMode"))
+            .and_then(serde_json::Value::as_str)
+            .map(str::to_string);
+        Self::from_option(upload_mode)
+    }
+}
+
+#[cfg(test)]
+mod native_upload_mode_tests {
+    use super::NativeUploadMode;
+
+    #[test]
+    fn uses_streaming_mode_when_retry_session_was_recreated() {
+        assert_eq!(
+            NativeUploadMode::from_reset_response(r#"{"uploadMode":"streaming"}"#),
+            NativeUploadMode::Streaming,
+        );
+        assert_eq!(
+            NativeUploadMode::from_reset_response(r#"{"ok":true}"#),
+            NativeUploadMode::Buffered,
+        );
+    }
 }
 
 #[derive(Default)]
@@ -2061,25 +2088,45 @@ pub async fn native_fullscreen_recording_retry_upload(
     saved.last_error = None;
     write_saved_recording_metadata(&app, &saved)?;
 
-    reset_upload_chunks(
-        &saved.server_url,
-        &saved.recording_id,
-        auth_token.as_deref().unwrap_or(""),
-        cookie.as_deref().unwrap_or(""),
-    )
-    .await
-    .map_err(|err| {
-        persist_saved_recording_error(&app, &mut saved, &err);
-        err
-    })?;
+    // Preparation can normalize or transcode the saved recording. The
+    // resumable session must be created with the MIME type we will actually
+    // upload, not the source file's potentially stale MIME type.
+    let result = async {
+        let (prepared, retry_combined_path) = prepare_saved_recording_file(&app, &saved)?;
+        let upload_mode = match reset_upload_chunks(
+            &saved.server_url,
+            &saved.recording_id,
+            &prepared.mime_type,
+            auth_token.as_deref().unwrap_or(""),
+            cookie.as_deref().unwrap_or(""),
+        )
+        .await
+        {
+            Ok(upload_mode) => upload_mode,
+            Err(err) => {
+                cleanup_prepared_saved_recording_files(&prepared, retry_combined_path);
+                return Err(err);
+            }
+        };
 
-    let result = upload_saved_recording_file(
-        &app,
-        &saved,
-        saved.server_url.clone(),
-        auth_token.unwrap_or_default(),
-        cookie.unwrap_or_default(),
-    )
+        let upload_result = upload_prepared_recording_file(
+            &app,
+            &prepared,
+            saved.server_url.clone(),
+            saved.recording_id.clone(),
+            auth_token.unwrap_or_default(),
+            cookie.unwrap_or_default(),
+            upload_mode,
+            saved.duration_ms,
+            saved.width,
+            saved.height,
+            saved.has_audio,
+            saved.has_camera,
+        )
+        .await;
+        cleanup_prepared_saved_recording_files(&prepared, retry_combined_path);
+        upload_result
+    }
     .await;
 
     match result {
@@ -3236,29 +3283,10 @@ async fn upload_recording_file(
     upload_result
 }
 
-async fn upload_saved_recording_file(
-    app: &AppHandle,
-    saved: &SavedNativeRecording,
-    server_url: String,
-    auth_token: String,
-    cookie: String,
-) -> Result<NativeFullscreenUploadResult, String> {
-    let (prepared, retry_combined_path) = prepare_saved_recording_file(app, saved)?;
-    let upload_result = upload_prepared_recording_file(
-        app,
-        &prepared,
-        server_url,
-        saved.recording_id.clone(),
-        auth_token,
-        cookie,
-        NativeUploadMode::Buffered,
-        saved.duration_ms,
-        saved.width,
-        saved.height,
-        saved.has_audio,
-        saved.has_camera,
-    )
-    .await;
+fn cleanup_prepared_saved_recording_files(
+    prepared: &PreparedRecordingFile,
+    retry_combined_path: Option<PathBuf>,
+) {
     if prepared.temporary {
         let _ = std::fs::remove_file(&prepared.path);
     }
@@ -3267,7 +3295,6 @@ async fn upload_saved_recording_file(
             let _ = std::fs::remove_file(path);
         }
     }
-    upload_result
 }
 
 fn prepare_saved_recording_file(
@@ -3509,9 +3536,10 @@ async fn upload_prepared_recording_file(
 async fn reset_upload_chunks(
     server_url: &str,
     recording_id: &str,
+    mime_type: &str,
     auth_token: &str,
     cookie: &str,
-) -> Result<(), String> {
+) -> Result<NativeUploadMode, String> {
     let base = server_url.trim_end_matches('/');
     let url = url::Url::parse(&format!("{base}/api/uploads/{recording_id}/reset-chunks"))
         .map_err(|e| format!("invalid reset URL: {e}"))?;
@@ -3523,7 +3551,10 @@ async fn reset_upload_chunks(
         .post(url)
         .header("Content-Type", "application/json")
         .header("X-Request-Source", "clips-desktop")
-        .body("{}");
+        .json(&serde_json::json!({
+            "requestStreaming": true,
+            "mimeType": mime_type,
+        }));
     let trimmed_token = auth_token.trim();
     if !trimmed_token.is_empty() {
         request = request.bearer_auth(trimmed_token);
@@ -3545,7 +3576,7 @@ async fn reset_upload_chunks(
             body.chars().take(400).collect::<String>()
         ));
     }
-    Ok(())
+    Ok(NativeUploadMode::from_reset_response(&body))
 }
 
 async fn upload_thumbnail_bytes(
@@ -3912,6 +3943,27 @@ impl AudioSignalProbe {
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum PreparedAudioSignalDecision {
+    AcceptCandidate,
+    UseOriginal,
+}
+
+fn decide_prepared_audio_signal(
+    candidate: AudioSignalProbe,
+    source: Option<AudioSignalProbe>,
+) -> PreparedAudioSignalDecision {
+    if !candidate.has_audible_signal()
+        && source
+            .map(AudioSignalProbe::has_audible_signal)
+            .unwrap_or(false)
+    {
+        PreparedAudioSignalDecision::UseOriginal
+    } else {
+        PreparedAudioSignalDecision::AcceptCandidate
+    }
+}
+
 fn parse_ffmpeg_volume_db(stderr: &str, label: &str) -> Option<f64> {
     stderr.lines().rev().find_map(|line| {
         let (_, value) = line.split_once(label)?;
@@ -3988,14 +4040,11 @@ fn verify_prepared_audio_signal(
     }
 
     let source_probe = audio_signal_probe_with_ffmpeg(ffmpeg_path, source_path);
-    let source_has_signal = source_probe
-        .as_ref()
-        .ok()
-        .copied()
-        .map(AudioSignalProbe::has_audible_signal)
-        .unwrap_or(false);
+    let source_signal = source_probe.as_ref().ok().copied();
     let source_summary = describe_audio_signal_probe(source_probe);
-    if source_has_signal {
+    if decide_prepared_audio_signal(candidate_probe, source_signal)
+        == PreparedAudioSignalDecision::UseOriginal
+    {
         eprintln!(
             "[clips-tray] AUDIO QUIET AFTER PREPARE: {label} is effectively silent ({}) but original has signal ({source_summary}) — uploading original instead",
             candidate_probe.summary()
@@ -4004,13 +4053,14 @@ fn verify_prepared_audio_signal(
     }
 
     eprintln!(
-        "[clips-tray] AUDIO CAPTURE TOO QUIET: prepared {label} has an audio track but no usable signal ({}) and original was not usable either ({source_summary})",
+        "[clips-tray] AUDIO CAPTURE QUIET: prepared {label} has an audio track but no usable signal ({}) and original was not usable either ({source_summary}) — publishing the playable candidate",
         candidate_probe.summary()
     );
-    Err(format!(
-        "Recorded file contains an audio track, but the captured audio is too quiet to publish ({})",
-        candidate_probe.summary()
-    ))
+    // Silence in both files is a capture outcome, not a processing regression.
+    // Rejecting it strands the recording in `uploading`, and every retry fails
+    // deterministically after re-running the same probes. Only fall back when
+    // preparation removed signal that was present in the source.
+    Ok(None)
 }
 
 fn prepare_recording_file(
@@ -4069,13 +4119,6 @@ fn prepare_recording_file(
 
     let mut smallest_attempt_bytes: Option<u64> = None;
     let ffmpeg_path = resolve_ffmpeg_path();
-    if has_audio {
-        if let Some(ffmpeg_path) = ffmpeg_path.as_deref() {
-            let raw_summary =
-                describe_audio_signal_probe(audio_signal_probe_with_ffmpeg(ffmpeg_path, path));
-            eprintln!("[clips-tray] raw recording audio signal before prepare: {raw_summary}");
-        }
-    }
 
     if !COMPRESSION_ENABLED || source_bytes < TRANSCODE_THRESHOLD_BYTES {
         if has_audio {
@@ -5125,7 +5168,8 @@ fn concat_mp4_segments(segments: &[PathBuf], output: &Path) -> Result<(), String
 #[cfg(test)]
 mod audio_track_probe_tests {
     use super::{
-        audio_filter_chain, mp4_has_audio_track, parse_ffmpeg_volume_db, AudioSignalProbe,
+        audio_filter_chain, decide_prepared_audio_signal, mp4_has_audio_track,
+        parse_ffmpeg_volume_db, AudioSignalProbe, PreparedAudioSignalDecision,
         AUDIO_DENOISE_FILTER, AUDIO_DOWNMIX_FILTER, AUDIO_DOWNMIX_MAKEUP_FILTER,
         AUDIO_LOUDNESS_FILTER, AUDIO_MIC_PREGAIN_FILTER,
     };
@@ -5301,6 +5345,27 @@ mod audio_track_probe_tests {
         assert!(!quiet_noise_peak.has_audible_signal());
         assert!(audible.has_audible_signal());
     }
+
+    #[test]
+    fn publishes_quiet_recordings_but_preserves_audible_source_audio() {
+        let silent = AudioSignalProbe {
+            mean_volume_db: Some(f64::NEG_INFINITY),
+            max_volume_db: Some(f64::NEG_INFINITY),
+        };
+        let audible = AudioSignalProbe {
+            mean_volume_db: Some(-21.5),
+            max_volume_db: Some(-1.4),
+        };
+
+        assert_eq!(
+            decide_prepared_audio_signal(silent, Some(silent)),
+            PreparedAudioSignalDecision::AcceptCandidate,
+        );
+        assert_eq!(
+            decide_prepared_audio_signal(silent, Some(audible)),
+            PreparedAudioSignalDecision::UseOriginal,
+        );
+    }
 }
 
 #[cfg(test)]

package/corpus/templates/clips/desktop/src-tauri/src/notifications.rs

@@ -64,7 +64,8 @@ pub fn show_meeting_notification_window(app: &AppHandle) -> Result<(), String> {
         return Ok(());
     }
 
-    let win = WebviewWindowBuilder::new(
+    #[allow(unused_mut)]
+    let mut builder = WebviewWindowBuilder::new(
         app,
         MEETING_NOTIFICATION_LABEL,
         build_overlay_url("meeting-notif"),
@@ -77,9 +78,14 @@ pub fn show_meeting_notification_window(app: &AppHandle) -> Result<(), String> {
     .resizable(false)
     .shadow(false)
     .visible(false)
-    .focused(false)
-    .build()
-    .map_err(|e| {
+    .focused(false);
+    // The reminder remains non-activating, but its first click should still
+    // reach the webview instead of only activating the window.
+    #[cfg(target_os = "macos")]
+    {
+        builder = builder.accept_first_mouse(true);
+    }
+    let win = builder.build().map_err(|e| {
         eprintln!("[clips-tray] meeting notification build failed: {e}");
         e.to_string()
     })?;

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/chunk.post.ts

@@ -832,6 +832,57 @@ async function handleResumableChunk(
     return { ok: true, finalized: true, ...result };
   } catch (err) {
     console.error(`[resumable-chunk-${recordingId}] finalize failed:`, err);
+    const db = getDb();
+    const [committed] = await db
+      .select({
+        id: schema.recordings.id,
+        status: schema.recordings.status,
+        videoUrl: schema.recordings.videoUrl,
+        durationMs: schema.recordings.durationMs,
+        width: schema.recordings.width,
+        height: schema.recordings.height,
+        hasAudio: schema.recordings.hasAudio,
+        hasCamera: schema.recordings.hasCamera,
+      })
+      .from(schema.recordings)
+      .where(
+        and(
+          eq(schema.recordings.id, recordingId),
+          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+        ),
+      );
+    if (committed?.status === "ready" && committed.videoUrl) {
+      console.warn(
+        `[resumable-chunk-${recordingId}] finalize reported an error after committing a ready recording; returning committed success.`,
+        { error: err instanceof Error ? err.message : String(err) },
+      );
+      await writeAppState(`recording-upload-${recordingId}`, {
+        recordingId,
+        status: "ready",
+        progress: 100,
+        videoUrl: committed.videoUrl,
+        finishedAt: new Date().toISOString(),
+      }).catch((stateErr) =>
+        console.warn(
+          `[resumable-chunk-${recordingId}] committed-ready state repair failed:`,
+          stateErr,
+        ),
+      );
+      return {
+        ok: true,
+        finalized: true,
+        recoveredAfterFinalizeError: true,
+        id: committed.id,
+        status: "ready",
+        videoUrl: committed.videoUrl,
+        durationMs: committed.durationMs,
+        width: committed.width,
+        height: committed.height,
+        hasAudio: committed.hasAudio,
+        hasCamera: committed.hasCamera,
+      };
+    }
+
     trackUploadBlockingFailure(ownerEmail, {
       stage: "finalize_recording",
       failureKind: "finalize_error",
@@ -839,10 +890,40 @@ async function handleResumableChunk(
       uploadMode: "resumable",
       errorMessage: err instanceof Error ? err.message : String(err),
     });
+    const failureReason =
+      err instanceof Error ? err.message : "Finalize failed";
+    const failedAt = new Date().toISOString();
+    await db
+      .update(schema.recordings)
+      .set({
+        status: "failed",
+        failureReason,
+        updatedAt: failedAt,
+      })
+      .where(
+        and(
+          eq(schema.recordings.id, recordingId),
+          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+        ),
+      );
+    const failedUploadStateRaw = await readAppState(
+      `recording-upload-${recordingId}`,
+    ).catch(() => null);
+    const failedUploadState =
+      failedUploadStateRaw && typeof failedUploadStateRaw === "object"
+        ? (failedUploadStateRaw as Record<string, unknown>)
+        : {};
+    await writeAppState(`recording-upload-${recordingId}`, {
+      ...failedUploadState,
+      recordingId,
+      status: "failed",
+      failureReason,
+      updatedAt: failedAt,
+    });
     setResponseStatus(event, 500);
     return {
       ok: false,
-      error: err instanceof Error ? err.message : "Finalize failed",
+      error: failureReason,
     };
   }
 }

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/reset-chunks.post.ts

@@ -28,7 +28,9 @@ import {
   writeAppState,
   deleteAppStateByPrefix,
 } from "@agent-native/core/application-state";
+import { getActiveFileUploadProviderForRequest } from "@agent-native/core/file-upload";
 import { runWithRequestContext } from "@agent-native/core/server";
+import type { UploadMode } from "@shared/recording-core.js";
 import { MAX_UPLOAD_BYTES as MAX_RECORDING_UPLOAD_BYTES } from "@shared/upload-limits.js";
 import { and, eq } from "drizzle-orm";
 import {
@@ -44,7 +46,12 @@ import {
   getEventOwnerContext,
   ownerEmailMatches,
 } from "../../../../lib/recordings.js";
-import { deleteResumableSession } from "../../../../lib/resumable-session.js";
+import {
+  deleteResumableSession,
+  setResumableSession,
+} from "../../../../lib/resumable-session.js";
+import { shouldEnableStreamingUpload } from "../../../../lib/streaming-upload-mode.js";
+import { allowsSqlRecordingChunkScratch } from "../../../../lib/video-storage.js";
 
 interface CompressionMeta {
   originalBytes?: number;
@@ -54,6 +61,16 @@ interface CompressionMeta {
   outputMimeType?: string;
 }
 
+function normalizeVideoMimeType(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const mimeType = value.split(";")[0]?.trim().toLowerCase();
+  return mimeType === "video/mp4" ||
+    mimeType === "video/quicktime" ||
+    mimeType === "video/webm"
+    ? mimeType
+    : null;
+}
+
 function pickNumber(value: unknown): number | undefined {
   if (typeof value !== "number") return undefined;
   if (!Number.isFinite(value) || value < 0) return undefined;
@@ -77,6 +94,8 @@ export default defineEventHandler(async (event: H3Event) => {
   const { userEmail: ownerEmail, orgId } = await getEventOwnerContext(event);
   const body = (await readBody(event).catch(() => null)) as {
     compression?: CompressionMeta | null;
+    requestStreaming?: boolean;
+    mimeType?: string;
   } | null;
 
   // Sanitize compression metadata. The recorder is the only client we trust
@@ -117,6 +136,67 @@ export default defineEventHandler(async (event: H3Event) => {
     // accidentally route through handleResumableChunk with stale offsets.
     await deleteResumableSession(recordingId).catch(() => {});
 
+    let uploadMode: UploadMode = "buffered";
+    if (body?.requestStreaming === true) {
+      const mimeType = normalizeVideoMimeType(body.mimeType);
+      if (!mimeType) {
+        setResponseStatus(event, 400);
+        return { error: "A supported video mimeType is required for retry" };
+      }
+
+      const bufferedFallbackAvailable = allowsSqlRecordingChunkScratch();
+      const uploadProvider = await getActiveFileUploadProviderForRequest();
+      if (
+        shouldEnableStreamingUpload({
+          client: "desktop",
+          mimeType,
+          bufferedFallbackAvailable,
+        }) &&
+        uploadProvider?.resumable
+      ) {
+        try {
+          const extension = /mp4|quicktime/.test(mimeType) ? "mp4" : "webm";
+          const filename = `${recordingId}.${extension}`;
+          const session = await uploadProvider.resumable.startSession(
+            filename,
+            mimeType,
+            MAX_RECORDING_UPLOAD_BYTES,
+          );
+          await setResumableSession(recordingId, {
+            providerId: uploadProvider.id,
+            sessionId: session.sessionId,
+            meta: {
+              ...session.meta,
+              stableUrl: true,
+              recordAsset: false,
+            },
+            bytesUploaded: 0,
+            lastCommittedIndex: -1,
+          });
+          uploadMode = "streaming";
+        } catch (err) {
+          if (!bufferedFallbackAvailable) {
+            setResponseStatus(event, 502);
+            return {
+              error: `Could not restart recording upload: ${
+                err instanceof Error ? err.message : String(err)
+              }`,
+            };
+          }
+          console.warn(
+            `[reset-chunks-${recordingId}] resumable restart failed; using buffered retry:`,
+            err,
+          );
+        }
+      } else if (!bufferedFallbackAvailable) {
+        setResponseStatus(event, 409);
+        return {
+          error:
+            "Recording upload storage could not start a resumable retry session.",
+        };
+      }
+    }
+
     // Reset the per-recording upload progress so the UI poller sees the
     // re-upload restart from 0 and doesn't briefly show "100% then
     // re-running" on the post-compression chunked upload pass.
@@ -158,6 +238,7 @@ export default defineEventHandler(async (event: H3Event) => {
       recordingId,
       chunksCleared: cleared,
       compressionRecorded: !!compression,
+      uploadMode,
     };
   });
 });

package/dist/a2a/artifact-response.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"artifact-response.d.ts","sourceRoot":"","sources":["../../src/a2a/artifact-response.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACtC;AAo8BD,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,oBAAoB,EAAE,EACnC,OAAO,GAAE,0BAA+B,GACvC,MAAM,CAsIR;AAED,wBAAgB,kCAAkC,CAChD,WAAW,EAAE,oBAAoB,EAAE,EACnC,OAAO,GAAE,0BAA+B,GACvC,MAAM,GAAG,IAAI,CA8Bf"}
+{"version":3,"file":"artifact-response.d.ts","sourceRoot":"","sources":["../../src/a2a/artifact-response.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACtC;AA6lCD,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,oBAAoB,EAAE,EACnC,OAAO,GAAE,0BAA+B,GACvC,MAAM,CAsIR;AAED,wBAAgB,kCAAkC,CAChD,WAAW,EAAE,oBAAoB,EAAE,EACnC,OAAO,GAAE,0BAA+B,GACvC,MAAM,GAAG,IAAI,CA8Bf"}

package/dist/a2a/artifact-response.js

@@ -123,6 +123,110 @@ function contentDatabaseSubmissionArtifact(parsed) {
         url,
     };
 }
+function documentUrlForId(parsed, id, additionalCandidates = [], options = {}) {
+    const candidates = [
+        stringValue(parsed.url),
+        stringValue(parsed.urlPath),
+        stringValue(parsed.deepLink),
+        stringValue(parsed.pageUrl),
+        stringValue(parsed.documentUrl),
+        ...additionalCandidates,
+    ].filter((value) => !!value);
+    return candidates.find((candidate) => {
+        if (!artifactUrlReferencesId(candidate, "document", id))
+            return false;
+        return !options.requireContentOrigin || isContentDocumentUrl(candidate);
+    });
+}
+function isContentDocumentUrl(rawUrl) {
+    try {
+        return new URL(rawUrl).origin === "https://content.agent-native.com";
+    }
+    catch {
+        return false;
+    }
+}
+function addDocumentReadArtifact(documents, parsed, options) {
+    const id = stringValue(parsed.documentId) ?? stringValue(parsed.id);
+    if (!id)
+        return;
+    const url = documentUrlForId(parsed, id, options.additionalUrlCandidates, {
+        requireContentOrigin: options.requireContentOrigin,
+    });
+    if (!url && !options.allowWithoutUrl)
+        return;
+    documents.set(id, {
+        id,
+        title: stringValue(parsed.title) ?? stringValue(parsed.name),
+        url,
+    });
+}
+function addContentDatabaseReadArtifacts(documents, parsed) {
+    const resultUrls = [
+        stringValue(parsed.url),
+        stringValue(parsed.urlPath),
+        stringValue(parsed.deepLink),
+    ];
+    const database = asRecord(parsed.database);
+    if (database) {
+        addDocumentReadArtifact(documents, database, {
+            allowWithoutUrl: true,
+            requireContentOrigin: true,
+            additionalUrlCandidates: resultUrls,
+        });
+    }
+    else {
+        // Unavailable database reads still return a documentId, but they do not
+        // prove that the page exists and must not authorize an artifact URL.
+        if (parsed.available !== false) {
+            addDocumentReadArtifact(documents, parsed, {
+                allowWithoutUrl: true,
+                requireContentOrigin: true,
+            });
+        }
+    }
+    if (!Array.isArray(parsed.items))
+        return;
+    for (const item of parsed.items) {
+        const itemRecord = asRecord(item);
+        const document = asRecord(itemRecord?.document);
+        if (!document)
+            continue;
+        addDocumentReadArtifact(documents, document, {
+            allowWithoutUrl: true,
+            requireContentOrigin: true,
+            additionalUrlCandidates: [
+                stringValue(itemRecord?.url),
+                stringValue(itemRecord?.urlPath),
+                stringValue(itemRecord?.deepLink),
+            ],
+        });
+    }
+}
+function isGenericReadTool(tool) {
+    return /^(?:find|get|list|query|read|search)-/i.test(tool);
+}
+function addGenericDocumentReadArtifact(documents, parsed) {
+    // Unknown read actions are accepted only when their result pairs a document
+    // ID with a canonical page URL containing that exact ID. An ID by itself is
+    // insufficient, preserving the fabrication guard for unrelated actions.
+    addDocumentReadArtifact(documents, parsed, {
+        allowWithoutUrl: false,
+        requireContentOrigin: true,
+    });
+    const document = asRecord(parsed.document);
+    if (!document)
+        return;
+    addDocumentReadArtifact(documents, document, {
+        allowWithoutUrl: false,
+        requireContentOrigin: true,
+        additionalUrlCandidates: [
+            stringValue(parsed.url),
+            stringValue(parsed.urlPath),
+            stringValue(parsed.deepLink),
+        ],
+    });
+}
 function addImageArtifact(images, parsed) {
     const id = imageIdValue(parsed);
     if (!id)
@@ -262,7 +366,6 @@ function collectArtifacts(results) {
             continue;
         }
         if (toolResult.tool === "create-document" ||
-            toolResult.tool === "get-document" ||
             toolResult.tool === "update-document") {
             const id = stringValue(parsed.id);
             if (id) {
@@ -274,6 +377,29 @@ function collectArtifacts(results) {
             }
             continue;
         }
+        if (toolResult.tool === "get-document" ||
+            toolResult.tool === "get-content-document") {
+            const document = asRecord(parsed.document);
+            addDocumentReadArtifact(documents, document ?? parsed, {
+                allowWithoutUrl: true,
+                requireContentOrigin: true,
+                additionalUrlCandidates: document
+                    ? [
+                        stringValue(parsed.url),
+                        stringValue(parsed.urlPath),
+                        stringValue(parsed.deepLink),
+                    ]
+                    : [],
+            });
+            continue;
+        }
+        if (toolResult.tool === "get-content-database") {
+            addContentDatabaseReadArtifacts(documents, parsed);
+            continue;
+        }
+        if (isGenericReadTool(toolResult.tool)) {
+            addGenericDocumentReadArtifact(documents, parsed);
+        }
         if (toolResult.tool === "create-deck" ||
             toolResult.tool === "duplicate-deck") {
             addDeckArtifact(decks, parsed, { requireReady: true });