harnery 0.33.0 → 0.34.1

package/dist/core/hooks/effects/image-capture.d.ts

@@ -1,43 +1,29 @@
 /**
- * Image-feed capture: a non-coordination side effect fired from the normalized
- * `agent-hook` tool handlers (see effects/index.ts for the family rationale).
+ * Privacy-safe image artifact capture for normalized tool hooks.
  *
- * When an agent VIEWS an image (Read tool on a `.png`/`.jpg`/…) or PRODUCES one
- * (a Bash command writes an image file via `harn browse`, `harn image`, `--diff`, …),
- * we content-address the bytes into `.harnery/images/<sha256>.<ext>` (dedup:
- * identical bytes collapse to one blob) and emit an `image.captured` event into
- * the canonical stream. The web image feed (`/images`) groups those events by
- * hash and streams them live over the existing SSE infra.
- *
- * Why this lives at the hook layer: it's the single adapter-agnostic chokepoint
- * that sees every tool call across Claude Code / Cursor / Codex with the full
- * `tool_input` (file paths) and `tool_response`. No per-command code needed.
- *
- * Everything here is best-effort and MUST NOT throw; callers wrap it in
- * try/catch + logError, matching every other effect.
+ * Image bytes are content-addressed under `.harnery/images/`. The canonical V3
+ * ledger receives an `artifact.observed` record after the source tool event is
+ * durable, so the web feed can recover provenance without retaining command,
+ * output, intent, or absolute paths.
  */
+import type { EventV3 } from "../../events/v3/contract.js";
 import type { ParsedPayload } from "../adapter/parse.js";
-import type { Adapter } from "../events/schema.js";
-export interface CaptureContext {
-    eventType: "tool.pre_use" | "tool.post_use";
-    /** The built event data (tool_name, tool_input string, intent, tool_use_id). */
-    data: Record<string, unknown>;
-    /** The full parsed payload, used for the un-clamped command + tool_response. */
-    payload: ParsedPayload | null;
-    instanceId: string;
-    sessionId: string;
-    adapter: Adapter;
+export interface CapturedImageArtifact {
+    hash: string;
+    ext: string;
+    bytes: number;
+    role: "viewed" | "produced";
+    workspace_path?: string;
 }
+/** Copy every qualifying image referenced by one tool hook into the blob store. */
+export declare function captureImages(coordRoot: string, eventType: "tool.requested" | "tool.completed", payload: ParsedPayload | null): CapturedImageArtifact[];
 /**
- * Inspect one tool event for image references and capture any that resolve to
- * a real image on disk. Emits zero or more `image.captured` events.
- */
-export declare function captureImages(coordRoot: string, ctx: CaptureContext): void;
-/**
- * Prune `.harnery/images/` past a size cap (default 2 GB) and an age cap
- * (default 30 days), oldest-mtime-first. Fired on session.start next to
- * journalJanitor. Pure-fs, fail-soft. Orphaned `image.captured` events whose
- * blob was pruned render as an "expired" placeholder in the gallery.
+ * Emit content-addressed image references as canonical V3 artifact events.
+ * Each observation uses a one-event producer boot, which preserves independent
+ * producer sequence continuity while the ledger writer serializes appends.
  */
+export declare function recordImageArtifactsV3(coordRoot: string, sourceEvent: EventV3, artifacts: readonly CapturedImageArtifact[]): void;
+export declare function buildImageArtifactEventV3(sourceEvent: EventV3, artifact: CapturedImageArtifact): EventV3;
+/** Prune the bounded blob store by age and total size, oldest first. */
 export declare function imageJanitor(coordRoot: string): void;
 //# sourceMappingURL=image-capture.d.ts.map

package/dist/core/hooks/effects/image-capture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-capture.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/effects/image-capture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAcH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAoBnD,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,cAAc,GAAG,eAAe,CAAC;IAC5C,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,gFAAgF;IAChF,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;CAClB;AAUD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,GAAG,IAAI,CAoC1E;AA2FD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAmDpD"}
+{"version":3,"file":"image-capture.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/effects/image-capture.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAeH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAgBzD,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAQD,mFAAmF;AACnF,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,gBAAgB,GAAG,gBAAgB,EAC9C,OAAO,EAAE,aAAa,GAAG,IAAI,GAC5B,qBAAqB,EAAE,CA0BzB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,SAAS,qBAAqB,EAAE,GAC1C,IAAI,CAKN;AAED,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,OAAO,EACpB,QAAQ,EAAE,qBAAqB,GAC9B,OAAO,CA4CT;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CA0CpD"}

package/dist/core/hooks/effects/image-capture.js

@@ -1,170 +1,116 @@
 /**
- * Image-feed capture: a non-coordination side effect fired from the normalized
- * `agent-hook` tool handlers (see effects/index.ts for the family rationale).
+ * Privacy-safe image artifact capture for normalized tool hooks.
  *
- * When an agent VIEWS an image (Read tool on a `.png`/`.jpg`/…) or PRODUCES one
- * (a Bash command writes an image file via `harn browse`, `harn image`, `--diff`, …),
- * we content-address the bytes into `.harnery/images/<sha256>.<ext>` (dedup:
- * identical bytes collapse to one blob) and emit an `image.captured` event into
- * the canonical stream. The web image feed (`/images`) groups those events by
- * hash and streams them live over the existing SSE infra.
- *
- * Why this lives at the hook layer: it's the single adapter-agnostic chokepoint
- * that sees every tool call across Claude Code / Cursor / Codex with the full
- * `tool_input` (file paths) and `tool_response`. No per-command code needed.
- *
- * Everything here is best-effort and MUST NOT throw; callers wrap it in
- * try/catch + logError, matching every other effect.
+ * Image bytes are content-addressed under `.harnery/images/`. The canonical V3
+ * ledger receives an `artifact.observed` record after the source tool event is
+ * durable, so the web feed can recover provenance without retaining command,
+ * output, intent, or absolute paths.
  */
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
-import { isAbsolute, join, resolve } from "node:path";
-import { emit } from "../events/emit.js";
-/** Raster + vector image extensions the feed accepts. PDF is intentionally
- * excluded: book renders aren't an "image feed" and don't thumbnail inline. */
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { buildEventV3 } from "../../events/v3/builder.js";
+import { writeEventV3 } from "../../events/v3/writer.js";
 const IMAGE_EXTS = new Set(["png", "jpg", "jpeg", "gif", "webp", "bmp", "svg"]);
-/** Skip hashing files larger than this; screenshots are tens of KB; a huge
- * file mentioned in passing isn't worth the read. */
+const MEDIA_TYPES = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    bmp: "image/bmp",
+    svg: "image/svg+xml",
+};
 const MAX_CAPTURE_BYTES = 25 * 1024 * 1024;
-/** A produced image must have been written within this window of the command
- * finishing, otherwise a path merely *mentioned* in output (an old baseline,
- * a doc reference) would be captured. Viewed images skip this gate. */
 const PRODUCED_MTIME_WINDOW_MS = 120_000;
-/** Matches image-ish paths in a command string or its output. Deliberately
- * permissive on the path body (`~`, `@`, `.`, `-`, `/`); existence + ext + the
- * mtime gate do the real filtering. */
-const IMAGE_PATH_RE = /[\w./~@+-]+\.(?:png|jpe?g|gif|webp|bmp|svg)\b/gi;
-/**
- * Inspect one tool event for image references and capture any that resolve to
- * a real image on disk. Emits zero or more `image.captured` events.
- */
-export function captureImages(coordRoot, ctx) {
-    const imagesDir = join(coordRoot, ".harnery", "images");
-    const cwd = resolveCwd(ctx.payload);
-    const toolName = String(ctx.data.tool_name ?? "");
-    const candidates = ctx.eventType === "tool.pre_use"
-        ? collectViewed(toolName, ctx.data, cwd)
-        : collectProduced(toolName, ctx.payload, cwd);
-    if (candidates.length === 0)
-        return;
-    for (const cand of candidates) {
-        // Never re-capture our own blob store (would loop on Reads of the gallery).
-        if (cand.path.startsWith(`${imagesDir}/`))
+const IMAGE_PATH_RE = /[\w./~@:+-]+\.(?:png|jpe?g|gif|webp|bmp|svg)\b/gi;
+/** Copy every qualifying image referenced by one tool hook into the blob store. */
+export function captureImages(coordRoot, eventType, payload) {
+    const images = join(coordRoot, ".harnery", "images");
+    const cwd = payload?.cwd ? resolve(payload.cwd) : process.cwd();
+    const toolName = payload?.tool_name ?? "";
+    const candidates = eventType === "tool.requested"
+        ? collectViewed(toolName, payload?.tool_input, cwd)
+        : collectProduced(toolName, payload, cwd);
+    const captured = [];
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (candidate.path.startsWith(`${images}${sep}`))
             continue;
-        const captured = captureOne(imagesDir, cand);
-        if (!captured)
+        const blob = captureOne(images, candidate);
+        if (!blob)
             continue;
-        emit(coordRoot, {
-            event_type: "image.captured",
-            instance_id: ctx.instanceId,
-            session_id: ctx.sessionId,
-            adapter: ctx.adapter,
-            data: {
-                hash: captured.hash,
-                ext: captured.ext,
-                bytes: captured.bytes,
-                role: cand.role,
-                source_path: canonicalize(coordRoot, cand.path),
-                tool_name: toolName,
-                tool_use_id: ctx.data.tool_use_id,
-                ...(cand.intent ? { intent: cand.intent } : {}),
-                ...(cand.commandHead ? { command_head: cand.commandHead } : {}),
-            },
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        });
-    }
-}
-/** Read tool → the file_path it's about to show (the "agent saw this" signal). */
-function collectViewed(toolName, data, cwd) {
-    if (toolName !== "Read")
-        return [];
-    const input = parseToolInput(data.tool_input);
-    const filePath = input?.file_path;
-    if (typeof filePath !== "string" || !filePath)
-        return [];
-    if (!hasImageExt(filePath))
-        return [];
-    return [
-        {
-            path: toAbsolute(filePath, cwd),
-            role: "viewed",
-            intent: typeof data.intent === "string" ? data.intent : undefined,
-            requireRecentMtime: false,
-        },
-    ];
-}
-/** Bash tool → scan the command + its output for freshly-written image files. */
-function collectProduced(toolName, payload, cwd) {
-    if (toolName !== "Bash")
-        return [];
-    const command = bashCommand(payload);
-    const responseText = stringifyResponse(payload?.tool_response);
-    const commandHead = command ? command.slice(0, 120) : undefined;
-    const seen = new Set();
-    const out = [];
-    for (const text of [command, responseText]) {
-        if (!text)
+        const dedupeKey = `${blob.hash}:${candidate.role}`;
+        if (seen.has(dedupeKey))
             continue;
-        for (const m of text.matchAll(IMAGE_PATH_RE)) {
-            const raw = m[0];
-            const abs = toAbsolute(raw, cwd);
-            if (seen.has(abs))
-                continue;
-            seen.add(abs);
-            out.push({ path: abs, role: "produced", commandHead, requireRecentMtime: true });
-        }
+        seen.add(dedupeKey);
+        const workspacePath = safeWorkspacePath(coordRoot, candidate.path);
+        captured.push({
+            ...blob,
+            role: candidate.role,
+            ...(workspacePath ? { workspace_path: workspacePath } : {}),
+        });
     }
-    return out;
+    return captured;
 }
 /**
- * Validate the candidate on disk, hash it, and copy into the content-addressed
- * store (skipping the copy when the blob already exists). Returns null when the
- * candidate doesn't qualify.
+ * Emit content-addressed image references as canonical V3 artifact events.
+ * Each observation uses a one-event producer boot, which preserves independent
+ * producer sequence continuity while the ledger writer serializes appends.
  */
-function captureOne(imagesDir, cand) {
-    let st;
-    try {
-        st = statSync(cand.path);
-    }
-    catch {
-        return null; // path doesn't exist (common for "produced" false-positives)
-    }
-    if (!st.isFile() || st.size === 0 || st.size > MAX_CAPTURE_BYTES)
-        return null;
-    if (cand.requireRecentMtime && Date.now() - st.mtimeMs > PRODUCED_MTIME_WINDOW_MS) {
-        return null; // mentioned but not freshly produced by this command
-    }
-    const ext = extOf(cand.path);
-    if (!ext || !IMAGE_EXTS.has(ext))
-        return null;
-    let bytes;
-    try {
-        bytes = readFileSync(cand.path);
-    }
-    catch {
-        return null;
+export function recordImageArtifactsV3(coordRoot, sourceEvent, artifacts) {
+    if (!("generation_id" in sourceEvent.scope) || !sourceEvent.attestation_id)
+        return;
+    for (const artifact of artifacts) {
+        writeEventV3(coordRoot, buildImageArtifactEventV3(sourceEvent, artifact));
     }
-    const hash = createHash("sha256").update(bytes).digest("hex");
-    const dest = join(imagesDir, `${hash}.${ext}`);
-    if (!existsSync(dest)) {
-        try {
-            mkdirSync(imagesDir, { recursive: true });
-            const tmp = `${dest}.tmp.${process.pid}`;
-            writeFileSync(tmp, bytes);
-            renameSync(tmp, dest);
-        }
-        catch {
-            return null; // couldn't store, don't emit a dangling event
-        }
+}
+export function buildImageArtifactEventV3(sourceEvent, artifact) {
+    if (!("generation_id" in sourceEvent.scope) || !sourceEvent.attestation_id) {
+        throw new Error("image artifacts require a generation-scoped source event");
     }
-    return { hash, ext, bytes: st.size };
+    return buildEventV3("artifact.observed", {
+        producer: {
+            producer_id: "prd_agent-hook-image-capture",
+            boot_id: `boot_${randomUUID()}`,
+            sequence: 1,
+            component: "agent-hook",
+            build_id: sourceEvent.producer.build_id,
+            platform: sourceEvent.producer.platform,
+            ...(sourceEvent.producer.bridge ? { bridge: sourceEvent.producer.bridge } : {}),
+        },
+        scope: {
+            root_id: sourceEvent.scope.root_id,
+            instance_id: sourceEvent.scope.instance_id,
+            session_id: sourceEvent.scope.session_id,
+            generation_id: sourceEvent.scope.generation_id,
+            ...(sourceEvent.scope.run_id ? { run_id: sourceEvent.scope.run_id } : {}),
+            ...(sourceEvent.scope.workflow_id ? { workflow_id: sourceEvent.scope.workflow_id } : {}),
+            ...(sourceEvent.scope.workflow_agent_id
+                ? { workflow_agent_id: sourceEvent.scope.workflow_agent_id }
+                : {}),
+        },
+        attestation_id: sourceEvent.attestation_id,
+        links: { caused_by: [sourceEvent.event_id] },
+        provenance: {
+            ...sourceEvent.provenance,
+            attestation: "derived",
+            confidence: "high",
+        },
+        payload: {
+            artifact: {
+                artifact_id: `art_${artifact.hash}`,
+                kind: "image",
+                media_type: MEDIA_TYPES[artifact.ext] ?? "image/png",
+                bytes: artifact.bytes,
+                retention_class: "bounded_local",
+                ...(artifact.workspace_path ? { workspace_path: artifact.workspace_path } : {}),
+            },
+            operation: artifact.role === "viewed" ? "viewed" : "created",
+        },
+    });
 }
-/**
- * Prune `.harnery/images/` past a size cap (default 2 GB) and an age cap
- * (default 30 days), oldest-mtime-first. Fired on session.start next to
- * journalJanitor. Pure-fs, fail-soft. Orphaned `image.captured` events whose
- * blob was pruned render as an "expired" placeholder in the gallery.
- */
+/** Prune the bounded blob store by age and total size, oldest first. */
 export function imageJanitor(coordRoot) {
     try {
         const dir = join(coordRoot, ".harnery", "images");
@@ -176,113 +122,158 @@ export function imageJanitor(coordRoot) {
         const entries = [];
         for (const name of readdirSync(dir)) {
             if (name.endsWith(".tmp") || name.includes(".tmp.")) {
-                // Orphaned temp from a crashed copy; sweep it.
                 rmSync(join(dir, name), { force: true });
                 continue;
             }
             const full = join(dir, name);
-            let st;
             try {
-                st = statSync(full);
+                const stat = statSync(full);
+                if (stat.isFile())
+                    entries.push({ path: full, size: stat.size, mtimeMs: stat.mtimeMs });
             }
             catch {
-                continue;
+                // A concurrent cleanup or write can make one entry disappear.
             }
-            if (!st.isFile())
-                continue;
-            entries.push({ path: full, size: st.size, mtimeMs: st.mtimeMs });
         }
-        // Age cap.
         let total = 0;
         const survivors = [];
-        for (const e of entries) {
-            if (now - e.mtimeMs > maxAgeMs) {
-                rmSync(e.path, { force: true });
-                continue;
+        for (const entry of entries) {
+            if (now - entry.mtimeMs > maxAgeMs) {
+                rmSync(entry.path, { force: true });
             }
-            total += e.size;
-            survivors.push(e);
-        }
-        // Size cap: drop oldest first until under.
-        if (total > maxBytes) {
-            survivors.sort((a, b) => a.mtimeMs - b.mtimeMs);
-            for (const e of survivors) {
-                if (total <= maxBytes)
-                    break;
-                rmSync(e.path, { force: true });
-                total -= e.size;
+            else {
+                total += entry.size;
+                survivors.push(entry);
             }
         }
+        survivors.sort((a, b) => a.mtimeMs - b.mtimeMs);
+        for (const entry of survivors) {
+            if (total <= maxBytes)
+                break;
+            rmSync(entry.path, { force: true });
+            total -= entry.size;
+        }
     }
     catch {
-        // best-effort
+        // Hook effects are always best-effort.
     }
 }
-/* ── helpers ─────────────────────────────────────────────────────────────── */
-function envInt(name, fallback) {
-    const v = process.env[name];
-    if (!v)
-        return fallback;
-    const n = Number(v);
-    return Number.isFinite(n) && n > 0 ? n : fallback;
+function collectViewed(toolName, toolInput, cwd) {
+    const name = normalizedToolName(toolName);
+    if (name !== "read" && name !== "view_image" && name !== "image")
+        return [];
+    const input = objectInput(toolInput);
+    const filePath = input?.file_path ?? input?.path ?? input?.image_path;
+    if (typeof filePath !== "string" || !hasImageExt(filePath))
+        return [];
+    return [{ path: toAbsolute(filePath, cwd), role: "viewed", requireRecentMtime: false }];
 }
-function parseToolInput(raw) {
-    if (typeof raw !== "string")
-        return null;
+function collectProduced(toolName, payload, cwd) {
+    const name = normalizedToolName(toolName);
+    const producerTools = new Set([
+        "bash",
+        "shell",
+        "exec_command",
+        "imagegen",
+        "image_gen",
+        "browse",
+        "browse_ai",
+        "screenshot",
+    ]);
+    if (!producerTools.has(name))
+        return [];
+    const input = objectInput(payload?.tool_input);
+    const command = [input?.command, input?.cmd].find((value) => typeof value === "string") ?? "";
+    const response = stringify(payload?.tool_response).slice(0, 2_000_000);
+    const seen = new Set();
+    const out = [];
+    for (const text of [String(command), response]) {
+        for (const match of text.matchAll(IMAGE_PATH_RE)) {
+            const absolute = toAbsolute(match[0], cwd);
+            if (seen.has(absolute))
+                continue;
+            seen.add(absolute);
+            out.push({ path: absolute, role: "produced", requireRecentMtime: true });
+        }
+    }
+    return out;
+}
+function captureOne(imagesDir, candidate) {
     try {
-        const parsed = JSON.parse(raw);
-        return parsed && typeof parsed === "object" ? parsed : null;
+        const stat = statSync(candidate.path);
+        if (!stat.isFile() || stat.size === 0 || stat.size > MAX_CAPTURE_BYTES)
+            return null;
+        if (candidate.requireRecentMtime && Date.now() - stat.mtimeMs > PRODUCED_MTIME_WINDOW_MS) {
+            return null;
+        }
+        const ext = extOf(candidate.path);
+        if (!IMAGE_EXTS.has(ext))
+            return null;
+        const bytes = readFileSync(candidate.path);
+        const hash = createHash("sha256").update(bytes).digest("hex");
+        const destination = join(imagesDir, `${hash}.${ext}`);
+        if (!existsSync(destination)) {
+            mkdirSync(imagesDir, { recursive: true });
+            const temporary = `${destination}.tmp.${process.pid}.${randomUUID().slice(0, 8)}`;
+            writeFileSync(temporary, bytes, { mode: 0o600 });
+            renameSync(temporary, destination);
+        }
+        return { hash, ext, bytes: stat.size };
     }
     catch {
         return null;
     }
 }
-/** The un-clamped Bash command from the raw payload (falls back to clamped). */
-function bashCommand(payload) {
-    const ti = payload?.raw?.tool_input;
-    const cmd = ti?.command;
-    return typeof cmd === "string" ? cmd : "";
+function normalizedToolName(value) {
+    return (value.split(/[.:/]/).pop() ?? value).toLowerCase().replaceAll("-", "_");
 }
-function stringifyResponse(value) {
-    if (value == null)
-        return "";
+function objectInput(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value !== "string")
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function stringify(value) {
     if (typeof value === "string")
         return value;
     try {
-        return JSON.stringify(value);
+        return JSON.stringify(value ?? "");
     }
     catch {
         return "";
     }
 }
-function resolveCwd(payload) {
-    const raw = payload?.raw;
-    const cwd = raw?.cwd;
-    return typeof cwd === "string" && cwd ? cwd : process.cwd();
+function toAbsolute(value, cwd) {
+    if (value.startsWith("~/") && process.env.HOME)
+        return resolve(process.env.HOME, value.slice(2));
+    return isAbsolute(value) ? resolve(value) : resolve(cwd, value);
 }
-function hasImageExt(p) {
-    const ext = extOf(p);
-    return !!ext && IMAGE_EXTS.has(ext);
+function safeWorkspacePath(coordRoot, value) {
+    const rel = relative(resolve(coordRoot), resolve(value));
+    if (!rel || isAbsolute(rel) || rel === ".." || rel.startsWith(`..${sep}`))
+        return undefined;
+    const normalized = rel.split(sep).join("/");
+    return normalized.length <= 240 && !normalized.startsWith("/") ? normalized : undefined;
 }
-function extOf(p) {
-    const clean = p.split(/[?#]/)[0] ?? p; // drop any query/fragment
-    const dot = clean.lastIndexOf(".");
-    if (dot < 0)
-        return "";
-    return clean.slice(dot + 1).toLowerCase();
+function hasImageExt(value) {
+    return IMAGE_EXTS.has(extOf(value));
 }
-function toAbsolute(p, cwd) {
-    let path = p;
-    if (path.startsWith("~/")) {
-        const home = process.env.HOME;
-        if (home)
-            path = join(home, path.slice(2));
-    }
-    return isAbsolute(path) ? path : resolve(cwd, path);
+function extOf(value) {
+    const clean = value.split(/[?#]/)[0] ?? value;
+    const dot = clean.lastIndexOf(".");
+    return dot < 0 ? "" : clean.slice(dot + 1).toLowerCase();
 }
-/** Strip the coordRoot prefix so the feed shows repo-relative paths. */
-function canonicalize(coordRoot, p) {
-    if (p.startsWith(`${coordRoot}/`))
-        return p.slice(coordRoot.length + 1);
-    return p;
+function envInt(name, fallback) {
+    const parsed = Number(process.env[name]);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }

package/dist/core/hooks/effects/index.d.ts

@@ -11,8 +11,7 @@
  * Everything here is best-effort: it never throws and never blocks the hook on a
  * slow dependency (telemetry runs detached).
  */
-export type { CaptureContext } from "./image-capture.js";
-export { captureImages, imageJanitor } from "./image-capture.js";
+export { captureImages, imageJanitor, recordImageArtifactsV3 } from "./image-capture.js";
 /**
  * Play a notification sound via the cross-platform utility
  * (afplay on macOS, powershell.exe on WSL). The
@@ -49,13 +48,6 @@ export declare function journalArchive(repoRoot: string, owner: string): void;
  * adapter.
  */
 export declare function runSessionSyncExtension(repoRoot: string, force: boolean): void;
-/**
- * Fire the turn-summary extension (Haiku auto-summary of the turn → heartbeat
- * `turn_summary`). Detached + unref'd; it makes an Anthropic API call and must
- * never block the Stop hook. Claude-Code-only. The
- * script self-guards on ANTHROPIC_API_KEY / curl / jq / matching session.
- */
-export declare function runTurnSummary(repoRoot: string, owner: string, sessionId: string, transcriptPath: string | undefined): void;
 /** Reset per-turn sound rate-limit counters at the start of a new turn. */
 export declare function resetSoundCounters(sessionId: string): void;
 /**

package/dist/core/hooks/effects/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/effects/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AASH,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEjE;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,QAAQ,SAAI,GACX,IAAI,CAYN;AAED,mFAAmF;AACnF,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAW3F;AAMD,oFAAoF;AACpF,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAYrD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAa3D;AAED,2DAA2D;AAC3D,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAYpE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAqB9E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,IAAI,CAqBN;AAED,2EAA2E;AAC3E,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAa1D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAOnD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/effects/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AASH,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAEzF;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,QAAQ,SAAI,GACX,IAAI,CAYN;AAED,mFAAmF;AACnF,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAW3F;AAMD,oFAAoF;AACpF,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAYrD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAa3D;AAED,2DAA2D;AAC3D,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAYpE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAqB9E;AAED,2EAA2E;AAC3E,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAa1D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAOnD"}

package/dist/core/hooks/effects/index.js

@@ -17,7 +17,7 @@ import os from "node:os";
 import { join } from "node:path";
 import { applyDetection } from "../../../lib/presence.js";
 import { coordBinPath } from "../../agents/coord-bin.js";
-export { captureImages, imageJanitor } from "./image-capture.js";
+export { captureImages, imageJanitor, recordImageArtifactsV3 } from "./image-capture.js";
 /**
  * Play a notification sound via the cross-platform utility
  * (afplay on macOS, powershell.exe on WSL). The
@@ -137,29 +137,6 @@ export function runSessionSyncExtension(repoRoot, force) {
         // best-effort
     }
 }
-/**
- * Fire the turn-summary extension (Haiku auto-summary of the turn → heartbeat
- * `turn_summary`). Detached + unref'd; it makes an Anthropic API call and must
- * never block the Stop hook. Claude-Code-only. The
- * script self-guards on ANTHROPIC_API_KEY / curl / jq / matching session.
- */
-export function runTurnSummary(repoRoot, owner, sessionId, transcriptPath) {
-    try {
-        if (!transcriptPath || !existsSync(transcriptPath))
-            return;
-        const script = join(repoRoot, "scripts", "hooks", "harness", "claude-code", "extensions", "turn-summary.sh");
-        if (!existsSync(script))
-            return;
-        const child = spawn("bash", [script, owner, sessionId, transcriptPath], {
-            detached: true,
-            stdio: "ignore",
-        });
-        child.unref();
-    }
-    catch {
-        // best-effort
-    }
-}
 /** Reset per-turn sound rate-limit counters at the start of a new turn. */
 export function resetSoundCounters(sessionId) {
     try {