bazilion 0.16.0 → 0.17.0

package/dist/daemon.js

@@ -24915,14 +24915,16 @@ function safeReaddir(path) {
 import { chmodSync, existsSync as existsSync17, mkdirSync as mkdirSync10, writeFileSync as writeFileSync14 } from "fs";
 
 // ../daemon/src/core/repos/coding-commands.ts
+var CODING_COMMAND_TTL_MS = 7 * 864e5;
+var CODING_COMMAND_MAX_PER_TEAM = 200;
 function pruneCodingCommands(db, teamId) {
   db.raw.run(
     "DELETE FROM coding_commands WHERE team_id = ? AND state != 'running' AND created_at < ?",
-    [teamId, Date.now() - 7 * 864e5]
+    [teamId, Date.now() - CODING_COMMAND_TTL_MS]
   );
   db.raw.run(
-    "DELETE FROM coding_commands WHERE id IN (SELECT id FROM coding_commands WHERE team_id = ? AND state != 'running' ORDER BY created_at DESC, id DESC LIMIT -1 OFFSET 20)",
-    [teamId]
+    "DELETE FROM coding_commands WHERE id IN (SELECT id FROM coding_commands WHERE team_id = ? AND state != 'running' ORDER BY created_at DESC, id DESC LIMIT -1 OFFSET ?)",
+    [teamId, CODING_COMMAND_MAX_PER_TEAM]
   );
 }
 function saveCodingCommand(db, receipt) {
@@ -28690,6 +28692,41 @@ function qmdBackend(root, options = {}) {
   };
 }
 
+// ../daemon/src/lib/coding-environment/receipt-reference.ts
+function codingLogReference(content) {
+  const parsed = objectFrom(textContent(content));
+  if (!parsed) return null;
+  return referenceFrom(parsed) ?? referenceFrom(objectFrom(parsed.receipt));
+}
+function referenceFrom(value) {
+  if (!value) return null;
+  const commandId = value.id;
+  const teamId = value.teamId;
+  if (typeof commandId !== "string" || commandId.length === 0) return null;
+  if (typeof teamId !== "string" || teamId.length === 0) return null;
+  return { commandId, teamId };
+}
+function textContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let out = "";
+  for (const block of content) {
+    if (block && block.type === "text" && typeof block.text === "string") out += block.text;
+  }
+  return out;
+}
+function objectFrom(value) {
+  if (typeof value === "string") {
+    try {
+      return objectFrom(JSON.parse(value));
+    } catch {
+      return null;
+    }
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  return value;
+}
+
 // ../daemon/src/runtime/pi/events.ts
 function extractAssistantText(m2) {
   let out = "";
@@ -28759,14 +28796,22 @@ function piMessagesToProviderView(messages, questionResultVisible) {
       }
       case "toolResult": {
         const tr = m2;
-        if (["repository_context", "coding_environment", "coding_command", "coding_receipt"].includes(
-          tr.toolName ?? ""
-        )) {
+        if ([
+          "repository_context",
+          "coding_environment",
+          "coding_command",
+          "coding_receipt",
+          "coding_log",
+          // BAZ-042: a snapshot result names withheld paths, so history must not render it.
+          "source_snapshot"
+        ].includes(tr.toolName ?? "")) {
+          const codingLog = codingLogReference(tr.content);
           out.push({
             role: "tool",
             toolCallId: tr.toolCallId,
             toolName: tr.toolName,
-            content: "Coding context or command evidence retained privately. Captured transport output follows its communication approval; ask the Agent for the relevant result."
+            content: "Coding context or command evidence retained privately. Captured transport output follows its communication approval; ask the Agent for the relevant result.",
+            ...codingLog ? { codingLog } : {}
           });
           break;
         }
@@ -28803,14 +28848,10 @@ function extractResultReference(value) {
   return typeof id === "string" && /^[a-f0-9-]{36}$/.test(id) ? { resultId: id } : void 0;
 }
 
-// ../daemon/src/runtime/pi/coding.ts
-import {
-  createLocalBashOperations
-} from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-
 // ../daemon/src/lib/coding-environment/diagnostics.ts
 var CODING_OUTPUT_BYTES = 64 * 1024;
+var CODING_RETAINED_BYTES = 2 * 1024 * 1024;
+var CODING_LIVE_BYTES = 8 * 1024;
 function diagnosticTail(value, limit) {
   const bytes = Buffer.from(value);
   if (bytes.length <= limit) return { text: value, truncated: false };
@@ -28822,28 +28863,47 @@ var CodingDiagnostics = class {
   decoder = new TextDecoder();
   secrets;
   lookbehind;
+  retainBytes;
   pending = "";
   text = "";
   truncated = false;
+  observedBytes = 0;
+  redactions = 0;
   finished = false;
-  constructor(secrets) {
+  constructor(secrets, retainBytes = CODING_OUTPUT_BYTES) {
     this.secrets = [...new Set(secrets.filter(Boolean))].sort((a, b2) => b2.length - a.length);
     this.lookbehind = Math.max(1, ...this.secrets.map((secret) => secret.length)) - 1;
+    this.retainBytes = retainBytes;
   }
   append(bytes) {
     if (this.finished) throw new Error("Coding diagnostics already finalized");
+    this.observedBytes += bytes.length;
     for (let offset = 0; offset < bytes.length; offset += 8192) {
       this.pending += this.decoder.decode(bytes.subarray(offset, offset + 8192), { stream: true });
       this.flush(false);
     }
   }
+  /**
+   * Redacted cumulative tail for a live update. Unlike `finish()` this does not seal
+   * the diagnostics: more output may follow. It deliberately excludes the trailing
+   * lookbehind bytes so a credential split across chunks cannot leak before the next
+   * chunk resolves it.
+   */
+  preview(limit = CODING_LIVE_BYTES) {
+    return diagnosticTail(this.text, limit);
+  }
   finish() {
     if (!this.finished) {
       this.pending += this.decoder.decode();
       this.flush(true);
       this.finished = true;
     }
-    return { diagnostic: this.text, truncated: this.truncated };
+    return {
+      diagnostic: this.text,
+      truncated: this.truncated,
+      observedBytes: this.observedBytes,
+      redacted: this.redactions > 0
+    };
   }
   flush(final) {
     let end = final ? this.pending.length : Math.max(0, this.pending.length - this.lookbehind);
@@ -28855,6 +28915,7 @@ var CodingDiagnostics = class {
       const secret = this.secrets.find((value) => this.pending.startsWith(value, offset));
       if (secret) {
         safe += "[redacted]";
+        this.redactions++;
         offset += secret.length;
       } else {
         const code = this.pending.charCodeAt(offset);
@@ -28864,7 +28925,7 @@ var CodingDiagnostics = class {
       }
     }
     this.pending = this.pending.slice(offset);
-    const tail = diagnosticTail(this.text + safe, CODING_OUTPUT_BYTES);
+    const tail = diagnosticTail(this.text + safe, this.retainBytes);
     this.text = tail.text;
     this.truncated ||= tail.truncated;
   }
@@ -28888,6 +28949,12 @@ function codingSecrets(env) {
   return [...values];
 }
 
+// ../daemon/src/runtime/pi/coding.ts
+import {
+  createLocalBashOperations
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
 // ../daemon/src/runtime/shell/approval.ts
 import { defineTool } from "@earendil-works/pi-coding-agent";
 
@@ -29265,6 +29332,7 @@ function createApprovalGatedBashTool(base, host2) {
 
 // ../daemon/src/runtime/pi/coding.ts
 function codingTools(input) {
+  const readSecrets = () => typeof input.secrets === "function" ? input.secrets() : input.secrets ?? [];
   const hostOperations = input.docker ? null : createLocalBashOperations();
   return [
     {
@@ -29305,7 +29373,7 @@ function codingTools(input) {
         { additionalProperties: false }
       ),
       executionMode: "sequential",
-      async execute(toolCallId, params, signal) {
+      async execute(toolCallId, params, signal, onUpdate) {
         const command = validateCodingCommand(params);
         const context = await input.context(command.cwd);
         if (context.instructions.state !== "complete")
@@ -29315,7 +29383,27 @@ function codingTools(input) {
           toolCallId,
           input: command
         });
-        const output = new CodingDiagnostics(input.secrets ?? []);
+        const output = new CodingDiagnostics(readSecrets());
+        let lastProgressAt = 0;
+        const emitProgress = (force) => {
+          if (!onUpdate) return;
+          const now = Date.now();
+          if (!force && now - lastProgressAt < 400) return;
+          lastProgressAt = now;
+          const preview = output.preview(CODING_LIVE_BYTES);
+          onUpdate({
+            content: [{ type: "text", text: preview.text }],
+            details: {
+              codingProgress: {
+                id: toolCallId,
+                commandId: started.id,
+                output: preview.text,
+                truncated: preview.truncated,
+                elapsedMs: Math.max(0, now - started.startedAt)
+              }
+            }
+          });
+        };
         let outcome;
         try {
           if (input.approval)
@@ -29336,8 +29424,16 @@ function codingTools(input) {
           const result = await operations.exec(
             command.command,
             input.docker ? input.root : cwd.path,
-            { onData: (bytes) => output.append(bytes), signal, timeout: command.timeoutSeconds }
+            {
+              onData: (bytes) => {
+                output.append(bytes);
+                emitProgress(false);
+              },
+              signal,
+              timeout: command.timeoutSeconds
+            }
           );
+          emitProgress(true);
           outcome = {
             state: result.exitCode === 0 ? "succeeded" : result.exitCode === null ? "interrupted" : "failed",
             exitCode: result.exitCode,
@@ -29382,6 +29478,74 @@ function codingTools(input) {
           details: { codingEvidence: value }
         };
       }
+    },
+    {
+      name: "coding_log",
+      label: "Read retained command output",
+      description: "Read a bounded page of retained diagnostic output for a coding receipt, or search it. Producing Agents may read their own logs; a teammate must pass the id of the policy-authorized message that carried coding-receipt:<id>. Output is bounded and may be truncated, expired, deleted or unavailable \u2014 report that state honestly and do not infer completeness from an exit code.",
+      parameters: Type.Object(
+        {
+          id: Type.String({ maxLength: 64 }),
+          messageId: Type.Optional(Type.String({ maxLength: 64 })),
+          search: Type.Optional(Type.String({ minLength: 1, maxLength: 256 })),
+          offset: Type.Optional(Type.Integer({ minimum: 0 })),
+          limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 65536 }))
+        },
+        { additionalProperties: false }
+      ),
+      executionMode: "sequential",
+      async execute(_id, params) {
+        const values = params;
+        if (values.search !== void 0) {
+          const result = await input.host.invoke({
+            action: "log-search",
+            id: values.id,
+            query: values.search,
+            ...values.messageId !== void 0 ? { messageId: values.messageId } : {}
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            details: { codingLogSearch: result }
+          };
+        }
+        const value = await input.host.invoke({
+          action: "log",
+          id: values.id,
+          ...values.messageId !== void 0 ? { messageId: values.messageId } : {},
+          ...values.offset !== void 0 ? { offset: values.offset } : {},
+          ...values.limit !== void 0 ? { limit: values.limit } : {}
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(value) }],
+          details: { codingLog: value }
+        };
+      }
+    },
+    {
+      name: "source_snapshot",
+      label: "Capture the current source state",
+      description: "Capture a bounded snapshot of the repository source you are about to work from, and quote its reference in your summary. Call this once before you start editing: the reference is how a later change or verification is tied to the version it actually applies to. It is read-only and never changes the repository. The result may be incomplete \u2014 when it is, say so, because an incomplete snapshot cannot support a claim that code is unchanged. Untracked file content is never included unless you name each path.",
+      parameters: Type.Object(
+        {
+          includeUntracked: Type.Optional(
+            Type.Array(Type.String({ maxLength: 4096 }), { maxItems: 1e3 })
+          )
+        },
+        { additionalProperties: false }
+      ),
+      executionMode: "sequential",
+      async execute(toolCallId, params) {
+        const values = params;
+        const value = await input.host.invoke({
+          action: "snapshot",
+          toolCallId,
+          ...values.includeUntracked ? { includeUntracked: values.includeUntracked } : {}
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(value) }],
+          details: { sourceSnapshot: value }
+        };
+      }
     }
   ];
 }
@@ -29719,6 +29883,20 @@ function fallbackApi(providerName) {
       return "openai-completions";
   }
 }
+var UnknownModelError = class extends Error {
+  providerName;
+  modelId;
+  // Fields are declared explicitly, not as constructor parameter properties:
+  // worker subprocesses run Node's strip-only TypeScript, which rejects them.
+  constructor(providerName, modelId) {
+    super(
+      `Unknown model "${modelId}" for provider "${providerName}": it is not in that provider's catalog, and no endpoint is configured for it. Choose a catalogued model, or configure an endpoint for a custom one.`
+    );
+    this.name = "UnknownModelError";
+    this.providerName = providerName;
+    this.modelId = modelId;
+  }
+};
 function fallbackPiModel(providerName, modelId, baseUrl) {
   return {
     id: modelId,
@@ -29779,6 +29957,7 @@ async function createBazilionPiRuntime(options) {
 function resolvePiModel(runtime, providerName, modelId, baseUrl) {
   const known = runtime.getModel(piProviderName(providerName), modelId);
   if (known) return baseUrl ? { ...known, baseUrl } : known;
+  if (!baseUrl) throw new UnknownModelError(providerName, modelId);
   return fallbackPiModel(providerName, modelId, baseUrl);
 }
 
@@ -33218,6 +33397,7 @@ async function createBazilionSession(opts) {
   if (repository) bazilionTools.push(repository.tool);
   if (repository && opts.codingHost && shellTools && shellTools.config.sandboxMode === "docker" && !opts.preparedDocker)
     throw new Error("Coding commands require the admitted Docker runtime");
+  const redactionSecrets = uniqueSecrets(codingSecrets(env));
   if (repository && opts.codingHost && shellTools)
     bazilionTools.push(
       ...codingTools({
@@ -33228,7 +33408,7 @@ async function createBazilionSession(opts) {
         lifecycle: opts.dockerLifecycle,
         approval: shellTools.config.approvalMode === "dangerous",
         approvalHost: bashApprovalHost,
-        secrets: Object.entries(env).filter(([key3]) => /KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|AUTH/i.test(key3)).map(([, value]) => value ?? "")
+        secrets: () => redactionSecrets
       })
     );
   const customTools = shellTools?.customBash ? [...bazilionTools, shellTools.customBash] : bazilionTools;
@@ -33250,7 +33430,9 @@ async function createBazilionSession(opts) {
     session.agent.getApiKey = async (requestedProvider) => {
       if (requestedProvider !== piProviderName(providerName)) return void 0;
       try {
-        return await refreshApiKey(providerName);
+        const token = await refreshApiKey(providerName);
+        if (token && !redactionSecrets.includes(token)) redactionSecrets.push(token);
+        return token;
       } catch {
         return void 0;
       }
@@ -33263,6 +33445,9 @@ async function createBazilionSession(opts) {
     }
   };
 }
+function uniqueSecrets(values) {
+  return [...new Set(values.filter(Boolean))];
+}
 function splitModelString(s) {
   const idx = s.indexOf(":");
   if (idx === -1) {
@@ -34875,6 +35060,223 @@ function createBrowserHost(config2) {
 // ../daemon/src/lib/coding-environment/agent-host.ts
 import { createHash as createHash10, randomUUID as randomUUID30 } from "crypto";
 
+// ../daemon/src/core/repos/coding-command-logs.ts
+var CODING_LOG_BYTES = 2 * 1024 * 1024;
+var CODING_LOG_HOME_BYTES = 256 * 1024 * 1024;
+var CODING_LOG_TTL_MS = 7 * 864e5;
+var CODING_LOG_PAGE_BYTES = 64 * 1024;
+var CODING_LOG_SEARCH_HITS = 50;
+var CODING_LOG_SEARCH_SCAN_BYTES = 512 * 1024;
+function headBytes(value, limit) {
+  const bytes = Buffer.from(value);
+  if (bytes.length <= limit) return value;
+  let end = limit;
+  while (end < bytes.length && ((bytes[end] ?? 0) & 192) === 128) end++;
+  return bytes.subarray(0, end).toString("utf8");
+}
+function mayDisclose(view2, audience) {
+  return audience === "producer" || view2.releasedAt !== null;
+}
+var COLUMNS = `command_id, team_id, agent_id, turn_id, tool_call_id, state, text,
+  byte_length, observed_bytes, redacted, truncated, created_at, expires_at, released_at, retired_at`;
+function expiryDue(row, now) {
+  return row.state === "retained" && row.expires_at <= now;
+}
+function liveText(row, now) {
+  return row.state === "retained" && !expiryDue(row, now) ? row.text : null;
+}
+function availabilityOf(row, now) {
+  if (row.state === "deleted") return "deleted";
+  if (row.state === "expired" || expiryDue(row, now)) return "expired";
+  return row.truncated === 1 ? "truncated" : "available";
+}
+function toView(row, now) {
+  return {
+    commandId: row.command_id,
+    teamId: row.team_id,
+    agentId: row.agent_id,
+    turnId: row.turn_id,
+    toolCallId: row.tool_call_id,
+    availability: availabilityOf(row, now),
+    byteLength: row.byte_length,
+    observedBytes: row.observed_bytes,
+    redacted: row.redacted === 1,
+    createdAt: row.created_at,
+    expiresAt: row.expires_at,
+    releasedAt: row.released_at,
+    retiredAt: row.retired_at
+  };
+}
+function rowFor(db, commandId) {
+  return db.raw.query(`SELECT ${COLUMNS} FROM coding_command_logs WHERE command_id = ?`).get(commandId) ?? null;
+}
+function unavailableLog(commandId) {
+  return {
+    commandId,
+    teamId: "",
+    agentId: "",
+    turnId: "",
+    toolCallId: "",
+    availability: "unavailable",
+    byteLength: 0,
+    observedBytes: 0,
+    redacted: false,
+    createdAt: 0,
+    expiresAt: 0,
+    releasedAt: null,
+    retiredAt: null
+  };
+}
+function getCodingCommandLog(db, commandId, now = Date.now()) {
+  const row = rowFor(db, commandId);
+  return row ? toView(row, now) : unavailableLog(commandId);
+}
+function saveCodingCommandLog(db, input) {
+  const now = input.now ?? Date.now();
+  const retained = diagnosticTail(input.diagnostic, CODING_LOG_BYTES);
+  const byteLength = Buffer.byteLength(retained.text);
+  const observed = Math.max(input.observedBytes, byteLength);
+  const truncated = retained.truncated || input.truncated || !input.redacted && input.observedBytes > byteLength;
+  db.raw.run(
+    `INSERT INTO coding_command_logs (${COLUMNS})
+     VALUES (?, ?, ?, ?, ?, 'retained', ?, ?, ?, ?, ?, ?, ?, NULL, NULL)
+     ON CONFLICT(command_id) DO UPDATE SET
+       state = 'retained',
+       text = excluded.text,
+       byte_length = excluded.byte_length,
+       observed_bytes = excluded.observed_bytes,
+       redacted = excluded.redacted,
+       truncated = excluded.truncated,
+       -- created_at/expires_at stay pinned to the first write: a later update must not
+       -- extend the retention window. released_at is deliberately cleared, because
+       -- changed output cannot inherit an earlier approval to disclose it.
+       released_at = NULL,
+       retired_at = NULL`,
+    [
+      input.commandId,
+      input.teamId,
+      input.agentId,
+      input.turnId,
+      input.toolCallId,
+      retained.text,
+      byteLength,
+      observed,
+      input.redacted ? 1 : 0,
+      truncated ? 1 : 0,
+      now,
+      now + CODING_LOG_TTL_MS
+    ]
+  );
+  pruneCodingCommandLogs(db, now);
+  return getCodingCommandLog(db, input.commandId, now);
+}
+function codingCommandIdFromResult(result) {
+  try {
+    const parsed = JSON.parse(result);
+    return typeof parsed.id === "string" && parsed.id.length > 0 ? parsed.id : null;
+  } catch {
+    return null;
+  }
+}
+function releaseCodingCommandLog(db, commandId, now = Date.now()) {
+  db.raw.run(
+    `UPDATE coding_command_logs SET released_at = COALESCE(released_at, ?)
+     WHERE command_id = ? AND state = 'retained'`,
+    [now, commandId]
+  );
+}
+function readCodingCommandLog(db, commandId, options, now = Date.now()) {
+  const view2 = getCodingCommandLog(db, commandId, now);
+  if (!mayDisclose(view2, options.audience)) return null;
+  const row = rowFor(db, commandId);
+  const limit = Math.min(Math.max(options.limit ?? CODING_LOG_PAGE_BYTES, 1), CODING_LOG_BYTES);
+  const text3 = row ? liveText(row, now) : null;
+  if (!row || text3 === null) {
+    return {
+      commandId,
+      availability: view2.availability,
+      offset: 0,
+      text: "",
+      hasMore: false,
+      byteLength: view2.byteLength
+    };
+  }
+  const bytes = Buffer.from(text3);
+  let offset = Math.min(Math.max(options.offset ?? 0, 0), bytes.length);
+  while (offset < bytes.length && ((bytes[offset] ?? 0) & 192) === 128) offset++;
+  let end = Math.min(offset + limit, bytes.length);
+  while (end < bytes.length && ((bytes[end] ?? 0) & 192) === 128) end++;
+  return {
+    commandId,
+    availability: view2.availability,
+    offset,
+    text: bytes.subarray(offset, end).toString("utf8"),
+    hasMore: end < bytes.length,
+    byteLength: view2.byteLength
+  };
+}
+function searchCodingCommandLog(db, commandId, needle, options, now = Date.now()) {
+  const view2 = getCodingCommandLog(db, commandId, now);
+  if (!mayDisclose(view2, options.audience)) return null;
+  const row = rowFor(db, commandId);
+  const empty = {
+    commandId,
+    availability: view2.availability,
+    matches: [],
+    bounded: false
+  };
+  const text3 = row ? liveText(row, now) : null;
+  if (text3 === null || !needle) return empty;
+  const scanned = Buffer.byteLength(text3) > CODING_LOG_SEARCH_SCAN_BYTES;
+  const haystack = scanned ? headBytes(text3, CODING_LOG_SEARCH_SCAN_BYTES) : text3;
+  const matches = [];
+  let from = 0;
+  let hitLimit = false;
+  for (; ; ) {
+    if (matches.length === CODING_LOG_SEARCH_HITS) {
+      hitLimit = true;
+      break;
+    }
+    const at = haystack.indexOf(needle, from);
+    if (at < 0) break;
+    const prefix = haystack.slice(0, at);
+    matches.push({
+      offset: Buffer.byteLength(prefix),
+      line: prefix.split("\n").length,
+      excerpt: haystack.slice(Math.max(0, at - 40), at + needle.length + 40)
+    });
+    from = at + needle.length;
+  }
+  return {
+    commandId,
+    availability: view2.availability,
+    matches,
+    bounded: scanned || hitLimit
+  };
+}
+function pruneCodingCommandLogs(db, now = Date.now(), budgetBytes = CODING_LOG_HOME_BYTES) {
+  db.raw.run(
+    `UPDATE coding_command_logs SET state = 'expired', text = NULL, byte_length = 0, retired_at = ?
+     WHERE state = 'retained' AND expires_at <= ?`,
+    [now, now]
+  );
+  for (; ; ) {
+    const total = db.raw.query(
+      "SELECT SUM(byte_length) AS bytes FROM coding_command_logs"
+    ).get()?.bytes ?? 0;
+    if (total <= budgetBytes) return;
+    const oldest = db.raw.query(
+      `SELECT command_id FROM coding_command_logs
+         WHERE byte_length > 0 AND command_id NOT IN (
+           SELECT id FROM coding_commands WHERE state = 'running'
+         )
+         ORDER BY created_at ASC, command_id ASC LIMIT 1`
+    ).get();
+    if (!oldest) return;
+    db.raw.run("DELETE FROM coding_command_logs WHERE command_id = ?", [oldest.command_id]);
+  }
+}
+
 // ../daemon/src/lib/communication.ts
 import { randomUUID as randomUUID29 } from "crypto";
 
@@ -35273,11 +35675,15 @@ function authorizeHttpChatFrame(db, agentId, requestAttemptId, frameIndex, frame
   if (frame.kind === "event" && frame.event.type === "file") {
     releaseResultFile(db, agentId, frame.event.result);
   }
+  if (frame.kind === "event" && frame.event.type === "tool_result" && frame.event.name === "coding_command") {
+    const id = codingCommandIdFromResult(frame.event.result);
+    if (id) releaseCodingCommandLog(db, id);
+  }
 }
 function isUserFacingFrame(frame) {
   if (frame.kind === "fatal") return true;
   if (frame.kind !== "event") return false;
-  return frame.event.type === "assistant_message" || frame.event.type === "assistant_delta" || frame.event.type === "file" || frame.event.type === "tool_result" && (frame.event.name === "repository_context" || Boolean(frame.event.images?.length)) || frame.event.type === "error";
+  return frame.event.type === "assistant_message" || frame.event.type === "assistant_delta" || frame.event.type === "coding_progress" || frame.event.type === "file" || frame.event.type === "tool_result" && (frame.event.name === "repository_context" || frame.event.name === "coding_command" || Boolean(frame.event.images?.length)) || frame.event.type === "error";
 }
 function sendAgentMessage(db, input) {
   const attemptKind = input.attemptKind ?? "agent_tool";
@@ -35608,48 +36014,112 @@ function claimDeliverableInbox(db, agentId, onAllowed, conversationId) {
   return outcome.allowed;
 }
 
-// ../daemon/src/lib/repository-context/git.ts
+// ../daemon/src/core/repos/source-snapshots.ts
+var SOURCE_SNAPSHOT_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var COLUMNS2 = "snapshot_id, team_id, captured_by, agent_id, turn_id, tool_call_id, complete, head, base_oid, entry_count, captured_content_bytes, manifest_json, created_at, expires_at";
+function toRecord(row) {
+  return {
+    snapshotId: row.snapshot_id,
+    teamId: row.team_id,
+    capturedBy: row.captured_by === "agent" ? "agent" : "operator",
+    agentId: row.agent_id,
+    turnId: row.turn_id,
+    toolCallId: row.tool_call_id,
+    complete: row.complete === 1,
+    head: row.head,
+    baseOid: row.base_oid,
+    entryCount: row.entry_count,
+    capturedContentBytes: row.captured_content_bytes,
+    manifestJson: row.manifest_json,
+    createdAt: row.created_at,
+    expiresAt: row.expires_at
+  };
+}
+function saveSourceSnapshot(db, input) {
+  const now = input.now ?? Date.now();
+  db.raw.run(
+    `INSERT INTO source_snapshots (${COLUMNS2})
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(snapshot_id, team_id) DO NOTHING`,
+    [
+      input.snapshotId,
+      input.teamId,
+      input.capturedBy,
+      input.agentId,
+      input.turnId,
+      input.toolCallId,
+      input.complete ? 1 : 0,
+      input.head,
+      input.baseOid,
+      input.entryCount,
+      input.capturedContentBytes,
+      input.manifestJson,
+      now,
+      now + SOURCE_SNAPSHOT_TTL_MS
+    ]
+  );
+  pruneSourceSnapshots(db, now);
+}
+function getSourceSnapshot(db, teamId, snapshotId, now = Date.now()) {
+  const row = db.raw.query(
+    `SELECT ${COLUMNS2} FROM source_snapshots
+       WHERE team_id = ? AND snapshot_id = ? AND expires_at > ?`
+  ).get(teamId, snapshotId, now);
+  return row ? toRecord(row) : null;
+}
+function pruneSourceSnapshots(db, now = Date.now()) {
+  const result = db.raw.run("DELETE FROM source_snapshots WHERE expires_at <= ?", [now]);
+  return Number(result.changes);
+}
+function listSourceSnapshots(db, teamId, limit = 50, now = Date.now()) {
+  return db.raw.query(
+    `SELECT ${COLUMNS2} FROM source_snapshots
+       WHERE team_id = ? AND expires_at > ?
+       ORDER BY created_at DESC, snapshot_id LIMIT ?`
+  ).all(teamId, now, limit).map(toRecord);
+}
+
+// ../daemon/src/lib/git/capture.ts
 import { execFile } from "child_process";
 import { mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync4, rmSync as rmSync14, writeFileSync as writeFileSync12 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join25 } from "path";
-var emptyGit = () => ({
-  state: "not_repository",
-  root: null,
-  branch: null,
-  head: null,
-  headState: null,
-  staged: 0,
-  unstaged: 0,
-  untracked: 0,
-  conflicted: 0,
-  issues: []
-});
-async function inspectGit(ancestry) {
-  const report = emptyGit();
-  let scratch;
+var INSPECTION_BUDGET_MS = 5e3;
+var METADATA_BUDGET_MS = 2500;
+var METADATA_BYTES = 64 * 1024 * 1024;
+var METADATA_ENTRIES = 16384;
+var METADATA_DEPTH = 32;
+var METADATA_READ = 64 * 1024;
+var METADATA_READ_LARGE = 16 * 1024 * 1024;
+var RUN_MAX_BUFFER = 1024 * 1024;
+function findRepositoryRoot(ancestry) {
+  return [...ancestry].reverse().find((dir) => dir.entry(".git") !== null) ?? null;
+}
+async function captureRepositoryGit(root, budgetMs = INSPECTION_BUDGET_MS) {
+  const start = Date.now();
+  let bytes = 0;
+  let count3 = 0;
+  const marker = root.entry(".git");
+  if (!marker?.isDirectory() || marker.isSymbolicLink())
+    throw new ContextReadError("unsupported_git_metadata");
+  const git = root.directory(".git");
+  if (git.entry("commondir") || git.entry("gitdir")) {
+    throw new ContextReadError("unsupported_git_metadata");
+  }
+  const info = git.entry("info");
+  if (info) {
+    const dir = git.directory("info");
+    if (dir.entry("sparse-checkout")) throw new ContextReadError("unsupported_git_metadata");
+  }
+  const scratch = mkdtempSync4(join25(tmpdir4(), "bazilion-context-git-"));
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    rmSync14(scratch, { recursive: true, force: true });
+  };
   try {
-    const root = [...ancestry].reverse().find((dir) => dir.entry(".git") !== null);
-    if (!root) return report;
-    report.root = root.label;
-    report.state = "unavailable";
-    const marker = root.entry(".git");
-    if (!marker?.isDirectory() || marker.isSymbolicLink())
-      throw new ContextReadError("unsupported_git_metadata");
-    const git = root.directory(".git");
-    if (git.entry("commondir") || git.entry("gitdir")) {
-      throw new ContextReadError("unsupported_git_metadata");
-    }
-    const info = git.entry("info");
-    if (info) {
-      const dir = git.directory("info");
-      if (dir.entry("sparse-checkout")) throw new ContextReadError("unsupported_git_metadata");
-    }
-    const start = Date.now();
-    let bytes = 0;
-    let count3 = 0;
-    scratch = mkdtempSync4(join25(tmpdir4(), "bazilion-context-git-"));
-    const runGit = (args) => new Promise((resolve8, reject2) => {
+    const rawGit = (args) => new Promise((resolve8, reject2) => {
       execFile(
         "git",
         args,
@@ -35666,21 +36136,40 @@ async function inspectGit(ancestry) {
             GIT_OPTIONAL_LOCKS: "0",
             LC_ALL: "C"
           },
-          timeout: Math.max(1, 5e3 - (Date.now() - start)),
-          maxBuffer: 1024 * 1024,
+          timeout: Math.max(1, budgetMs - (Date.now() - start)),
+          maxBuffer: RUN_MAX_BUFFER,
           encoding: "utf8"
         },
         (error2, stdout) => error2 ? reject2(error2) : resolve8(stdout)
       );
     });
-    const capturedConfig = git.read("config", 64 * 1024);
+    const inspectionArgs = (args) => [
+      "--no-optional-locks",
+      `--git-dir=${scratch}`,
+      `--work-tree=/proc/${process.pid}/fd/${root.fd}`,
+      "-c",
+      "core.fsmonitor=false",
+      "-c",
+      "core.untrackedCache=false",
+      "-c",
+      "core.hooksPath=/dev/null",
+      "-c",
+      "core.excludesFile=/dev/null",
+      "-c",
+      "diff.renames=false",
+      "-c",
+      "submodule.recurse=false",
+      ...args
+    ];
+    const runGit = (args) => rawGit(inspectionArgs(args));
+    const capturedConfig = git.read("config", METADATA_READ);
     const configLines = ["[core]", "repositoryformatversion = 0", "bare = false", "filemode = true"];
     if (capturedConfig) {
       bytes += capturedConfig.length;
       count3++;
       const configPath = join25(scratch, "captured-config");
       writeFileSync12(configPath, capturedConfig, { mode: 384 });
-      const config2 = await runGit([
+      const config2 = await rawGit([
         "config",
         "--no-includes",
         "--file",
@@ -35728,7 +36217,7 @@ objectformat = ${value}`
       }
     }
     if (info) {
-      const exclude = git.directory("info").read("exclude", 64 * 1024);
+      const exclude = git.directory("info").read("exclude", METADATA_READ);
       if (exclude) {
         bytes += exclude.length;
         mkdirSync9(join25(scratch, "info"), { mode: 448 });
@@ -35736,9 +36225,9 @@ objectformat = ${value}`
       }
     }
     const copy = (source, destination, depth) => {
-      if (depth > 32) throw new ContextReadError("git_metadata_limit");
+      if (depth > METADATA_DEPTH) throw new ContextReadError("git_metadata_limit");
       for (const name of source.list()) {
-        if (++count3 > 16384 || Date.now() - start > 2500)
+        if (++count3 > METADATA_ENTRIES || Date.now() - start > METADATA_BUDGET_MS)
           throw new ContextReadError("git_metadata_limit");
         const entry = source.entry(name);
         if (!entry || entry.isSymbolicLink()) throw new ContextReadError("unsupported_git_metadata");
@@ -35748,7 +36237,7 @@ objectformat = ${value}`
           mkdirSync9(join25(destination, name), { mode: 448 });
           copy(source.directory(name), join25(destination, name), depth + 1);
         } else {
-          const content = source.read(name, 64 * 1024 * 1024 - bytes);
+          const content = source.read(name, METADATA_BYTES - bytes);
           if (!content) throw new ContextReadError("source_changed");
           bytes += content.length;
           writeFileSync12(join25(destination, name), content, { mode: 384 });
@@ -35756,38 +36245,873 @@ objectformat = ${value}`
       }
     };
     for (const name of ["HEAD", "index", "packed-refs", "shallow"]) {
-      const content = git.read(name, Math.min(16 * 1024 * 1024, 64 * 1024 * 1024 - bytes));
+      const content = git.read(name, Math.min(METADATA_READ_LARGE, METADATA_BYTES - bytes));
       if (content) {
         count3++;
         bytes += content.length;
         writeFileSync12(join25(scratch, name), content, { mode: 384 });
       }
     }
-    for (const name of ["refs", "objects"]) {
-      mkdirSync9(join25(scratch, name), { mode: 448 });
-      if (git.entry(name)) copy(git.directory(name), join25(scratch, name), 0);
+    for (const name of ["refs", "objects"]) {
+      mkdirSync9(join25(scratch, name), { mode: 448 });
+      if (git.entry(name)) copy(git.directory(name), join25(scratch, name), 0);
+    }
+    if (git.list().some((name) => name.startsWith("sharedindex.")))
+      throw new ContextReadError("unsupported_git_metadata");
+    writeFileSync12(join25(scratch, "config"), `${configLines.join("\n")}
+`, { mode: 384 });
+    const validate2 = () => git.validate();
+    validate2();
+    return { root, runGit, validate: validate2, cleanup };
+  } catch (error2) {
+    cleanup();
+    throw error2;
+  }
+}
+
+// ../../packages/api-types/src/entities.ts
+var REASONING_LEVELS2 = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+];
+
+// ../../packages/api-types/src/git-review.ts
+var REVIEW_LIMITS = {
+  files: 1e3,
+  fileBytes: 1024 * 1024,
+  totalBytes: 16 * 1024 * 1024,
+  patchBytes: 256 * 1024
+};
+
+// ../../packages/api-types/src/index.ts
+var PROFILE_FILES = [
+  "profile.json",
+  "SOUL.md",
+  "IDENTITY.md",
+  "BOOTSTRAP.md",
+  "AGENTS.md",
+  "TOOLS.md"
+];
+
+// ../daemon/src/lib/git-review/refs.ts
+var REF_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,254}$/;
+function isCommitOid(value) {
+  return /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(value);
+}
+var ReviewRefError = class extends Error {
+  value;
+  constructor(value) {
+    super("Comparison base must be a plain branch, tag or commit id.");
+    this.name = "ReviewRefError";
+    this.value = value;
+  }
+};
+function validateRefName(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 255) {
+    throw new ReviewRefError(typeof value === "string" ? value : "");
+  }
+  if (!REF_PATTERN.test(value)) throw new ReviewRefError(value);
+  if (value === "." || value === "..") throw new ReviewRefError(value);
+  if (value.includes("..") || value.includes("@{") || value.includes("//")) {
+    throw new ReviewRefError(value);
+  }
+  if (value.endsWith("/") || value.endsWith(".") || value.endsWith(".lock")) {
+    throw new ReviewRefError(value);
+  }
+  return value;
+}
+
+// ../daemon/src/lib/git-review/identity.ts
+var ReviewBaseError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ReviewBaseError";
+    this.code = code;
+  }
+};
+var BRANCH_MAX = 4096;
+async function readRepositoryIdentity(captured) {
+  const branch = await readOrNull(captured, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+  const head = await readOrNull(captured, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"]);
+  if (branch !== null && branch.length > BRANCH_MAX) {
+    throw new ReviewBaseError("git_output_limit", "Repository identity exceeds its bound.");
+  }
+  const resolvedHead = head !== null && isCommitOid(head) ? head : null;
+  return {
+    branch,
+    head: resolvedHead,
+    headState: resolvedHead ? branch ? "branch" : "detached" : "unborn"
+  };
+}
+async function resolveComparisonBase(captured, requestedRef = "HEAD") {
+  let ref;
+  try {
+    ref = validateRefName(requestedRef);
+  } catch (error2) {
+    if (error2 instanceof ReviewRefError) {
+      throw new ReviewBaseError("invalid_base", error2.message);
+    }
+    throw error2;
+  }
+  const resolved = await readOrNull(captured, [
+    "rev-parse",
+    "--verify",
+    "--quiet",
+    "--end-of-options",
+    `${ref}^{commit}`
+  ]);
+  if (resolved === null || !isCommitOid(resolved)) {
+    throw new ReviewBaseError(
+      "unknown_base",
+      `Comparison base "${ref}" does not name a commit in this repository.`
+    );
+  }
+  return { requestedRef: ref, resolvedOid: resolved };
+}
+async function readOrNull(captured, args) {
+  try {
+    const output = await captured.runGit(args);
+    const trimmed = output.trim();
+    return trimmed.length === 0 ? null : trimmed;
+  } catch (error2) {
+    const code = error2.code;
+    if (code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" || code === "ETIMEDOUT" || error2.killed) {
+      throw new ReviewBaseError("git_output_limit", "Repository identity exceeds its bound.");
+    }
+    return null;
+  }
+}
+
+// ../daemon/src/lib/git-review/scope.ts
+var BAZILION_STATE_PREFIXES = ["memory/"];
+var CREDENTIAL_SEGMENTS = /* @__PURE__ */ new Set([".ssh", ".gnupg", ".aws", ".docker"]);
+var CREDENTIAL_BASENAME_PATTERNS = [
+  /^\.env(\..*)?$/,
+  /^\.netrc$/,
+  /^_netrc$/,
+  /^\.npmrc$/,
+  /^\.pgpass$/,
+  /^\.git-credentials$/,
+  /^credentials(\..*)?$/,
+  /^secrets(\..*)?$/,
+  /^id_(rsa|dsa|ecdsa|ed25519)(\.pub)?$/
+];
+var CREDENTIAL_EXTENSIONS = [
+  ".pem",
+  ".key",
+  ".p12",
+  ".pfx",
+  ".jks",
+  ".keystore",
+  ".kdbx",
+  ".ppk",
+  ".asc"
+];
+function reviewScope(path) {
+  const segments = path.split("/");
+  const basename6 = segments[segments.length - 1] ?? "";
+  for (const prefix of BAZILION_STATE_PREFIXES) {
+    if (path === prefix.slice(0, -1) || path.startsWith(prefix)) {
+      return { included: false, reason: "bazilion_state" };
+    }
+  }
+  if (segments.some((segment) => CREDENTIAL_SEGMENTS.has(segment.toLowerCase()))) {
+    return { included: false, reason: "credential_shaped" };
+  }
+  const lower = basename6.toLowerCase();
+  if (CREDENTIAL_BASENAME_PATTERNS.some((pattern) => pattern.test(lower))) {
+    return { included: false, reason: "credential_shaped" };
+  }
+  if (CREDENTIAL_EXTENSIONS.some((extension) => lower.endsWith(extension))) {
+    return { included: false, reason: "credential_shaped" };
+  }
+  return { included: true };
+}
+
+// ../daemon/src/lib/git-review/changes.ts
+async function listChanges(captured, base, identity2, limits = REVIEW_LIMITS) {
+  const issues = [];
+  const raw2 = await readDiff(captured, base, [
+    "--raw",
+    "-M",
+    "--no-ext-diff",
+    "--no-textconv",
+    "-z"
+  ]);
+  const numstat = await readDiff(captured, base, [
+    "--numstat",
+    "-M",
+    "--no-ext-diff",
+    "--no-textconv",
+    "-z"
+  ]);
+  const counts = parseNumstat(numstat);
+  const entries = [];
+  let excludedTracked = 0;
+  for (const header of parseRaw(raw2)) {
+    const scoped = reviewScope(header.path);
+    if (!scoped.included) excludedTracked++;
+    const count3 = counts.get(header.path) ?? null;
+    entries.push({
+      path: header.path,
+      previousPath: header.previousPath,
+      status: header.status,
+      binary: count3?.binary ?? false,
+      addedLines: count3?.added ?? null,
+      deletedLines: count3?.deleted ?? null,
+      oldMode: header.oldMode,
+      newMode: header.newMode,
+      patch: null,
+      patchTruncated: false,
+      // A credential-shaped or Bazilion-owned tracked file may be listed, but never captured.
+      contentOmitted: scoped.included ? count3?.binary ? "binary" : null : "excluded",
+      excludedReason: scoped.included ? null : scoped.reason
+    });
+  }
+  const untrackedNames = parseNameList(
+    await captured.runGit(["ls-files", "--others", "--exclude-standard", "-z"])
+  );
+  let excludedUntracked = 0;
+  for (const path of untrackedNames) {
+    const scoped = reviewScope(path);
+    if (!scoped.included) {
+      excludedUntracked++;
+      continue;
+    }
+    entries.push({
+      path,
+      previousPath: null,
+      status: "untracked",
+      binary: false,
+      addedLines: null,
+      deletedLines: null,
+      oldMode: null,
+      newMode: null,
+      patch: null,
+      patchTruncated: false,
+      contentOmitted: "untracked_not_selected",
+      excludedReason: null
+    });
+  }
+  entries.sort((a, b2) => a.path < b2.path ? -1 : a.path > b2.path ? 1 : 0);
+  const truncated = entries.length > limits.files;
+  const kept = truncated ? entries.slice(0, limits.files) : entries;
+  if (truncated) {
+    issues.push({
+      code: "file_limit",
+      message: `The change list exceeded ${limits.files} files; it is incomplete.`
+    });
+  }
+  return {
+    base,
+    identity: identity2,
+    changes: kept,
+    truncated,
+    // Counts of what was *not* captured, so an omission is never invisible. Untracked
+    // credential-shaped names are counted here but never listed by name.
+    withheld: {
+      untracked: excludedUntracked,
+      excluded: excludedTracked,
+      binary: kept.filter((change) => change.binary).length,
+      tooLarge: 0
+    },
+    issues
+  };
+}
+async function readChangePatch(captured, base, change, patchBytes = REVIEW_LIMITS.patchBytes) {
+  if (change.excludedReason) return { patch: null, truncated: false, omitted: "excluded" };
+  if (change.binary) return { patch: null, truncated: false, omitted: "binary" };
+  if (change.status === "untracked") {
+    return { patch: null, truncated: false, omitted: "untracked_not_selected" };
+  }
+  const target = change.status === "deleted" ? change.previousPath ?? change.path : change.path;
+  let output;
+  try {
+    output = await captured.runGit([
+      "diff",
+      "--no-ext-diff",
+      "--no-textconv",
+      "--no-color",
+      "--unified=3",
+      "-M",
+      base.resolvedOid,
+      "--",
+      target
+    ]);
+  } catch (error2) {
+    if (error2 instanceof ReviewBaseError) throw error2;
+    return { patch: null, truncated: false, omitted: "unavailable" };
+  }
+  if (output.length <= patchBytes) return { patch: output, truncated: false, omitted: null };
+  return {
+    patch: `${output.slice(0, patchBytes)}
+[truncated: diff exceeds ${patchBytes} bytes]`,
+    truncated: true,
+    omitted: null
+  };
+}
+async function attachPatches(captured, report, limits = REVIEW_LIMITS, onlyPath) {
+  let total = 0;
+  let tooLarge = 0;
+  const changes = [];
+  for (const change of report.changes) {
+    if (onlyPath !== void 0 && change.path !== onlyPath) {
+      changes.push(change);
+      continue;
+    }
+    if (change.contentOmitted && change.contentOmitted !== "binary") {
+      changes.push(change);
+      continue;
+    }
+    if (total >= limits.totalBytes) {
+      changes.push({ ...change, contentOmitted: "total_limit" });
+      continue;
+    }
+    const read = await readChangePatch(captured, report.base, change, limits.patchBytes);
+    const bytes = read.patch ? Buffer.byteLength(read.patch) : 0;
+    if (bytes > limits.fileBytes && !read.truncated) {
+      tooLarge++;
+      changes.push({ ...change, patch: null, contentOmitted: "too_large" });
+      continue;
+    }
+    total += bytes;
+    changes.push({
+      ...change,
+      patch: read.patch,
+      patchTruncated: read.truncated,
+      contentOmitted: read.omitted
+    });
+  }
+  return { ...report, changes, withheld: { ...report.withheld, tooLarge } };
+}
+async function readDiff(captured, base, args) {
+  return captured.runGit(["diff", base.resolvedOid, ...args]);
+}
+function parseNameList(output) {
+  return output.split("\0").filter((name) => name.length > 0);
+}
+var RAW_HEADER = /^:(\d{6}) (\d{6}) ([0-9a-f]+) ([0-9a-f]+) ([A-Z])(\d*)$/;
+function parseRaw(output) {
+  const records2 = output.split("\0");
+  const headers = [];
+  for (let i = 0; i < records2.length; i++) {
+    const record3 = records2[i] ?? "";
+    if (record3.length === 0) continue;
+    const match = RAW_HEADER.exec(record3);
+    if (!match) continue;
+    const status2 = statusFrom(match[5] ?? "");
+    const paired = status2 === "renamed" || status2 === "copied";
+    const first = records2[++i] ?? "";
+    if (paired) {
+      const second = records2[++i] ?? "";
+      if (first.length === 0 || second.length === 0) continue;
+      headers.push({
+        path: second,
+        previousPath: first,
+        status: status2,
+        oldMode: match[1] ?? null,
+        newMode: match[2] ?? null
+      });
+      continue;
+    }
+    if (first.length === 0) continue;
+    headers.push({
+      path: first,
+      previousPath: null,
+      status: status2,
+      oldMode: match[1] ?? null,
+      newMode: match[2] ?? null
+    });
+  }
+  return headers;
+}
+function statusFrom(letter) {
+  switch (letter) {
+    case "A":
+      return "added";
+    case "M":
+      return "modified";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    case "C":
+      return "copied";
+    case "T":
+      return "type_changed";
+    case "U":
+      return "unmerged";
+    default:
+      return "unknown";
+  }
+}
+function parseNumstat(output) {
+  const records2 = output.split("\0");
+  const counts = /* @__PURE__ */ new Map();
+  for (let i = 0; i < records2.length; i++) {
+    const record3 = records2[i] ?? "";
+    if (record3.length === 0) continue;
+    const firstTab = record3.indexOf("	");
+    if (firstTab < 0) continue;
+    const secondTab = record3.indexOf("	", firstTab + 1);
+    if (secondTab < 0) continue;
+    const addedField = record3.slice(0, firstTab);
+    const deletedField = record3.slice(firstTab + 1, secondTab);
+    let path = record3.slice(secondTab + 1);
+    if (path.length === 0) {
+      i++;
+      path = records2[i + 1] ?? "";
+      i++;
+      if (path.length === 0) continue;
+    }
+    const binary = addedField === "-" || deletedField === "-";
+    counts.set(path, {
+      added: binary ? null : Number.parseInt(addedField, 10),
+      deleted: binary ? null : Number.parseInt(deletedField, 10),
+      binary
+    });
+  }
+  return counts;
+}
+
+// ../daemon/src/lib/git-review/snapshot.ts
+function snapshotReference(snapshot) {
+  return { id: snapshot.id, complete: snapshot.complete, capturedAt: snapshot.capturedAt };
+}
+function compareSnapshots(before, after) {
+  if (!before.complete || !after.complete) return "unknown";
+  return before.id === after.id ? "identical" : "changed";
+}
+async function captureSourceSnapshot(captured, base, identity2, input = {}) {
+  const limits = input.limits ?? REVIEW_LIMITS;
+  const issues = [];
+  const withheld = { excluded: 0, tooLarge: 0, notRegular: 0, unstable: 0 };
+  let incomplete = false;
+  const fail3 = (code, message) => {
+    incomplete = true;
+    issues.push({ code, message });
+  };
+  const index = await readIndexDigest(captured);
+  if (index === null) fail3("unstable", "The index could not be read at snapshot time.");
+  if (index && index.entries > limits.files)
+    fail3(
+      "file_limit",
+      `The index holds more than ${limits.files} entries; the snapshot is incomplete.`
+    );
+  const changes = await listChanges(captured, base, identity2, limits);
+  if (changes.truncated)
+    fail3("file_limit", "The change list was truncated; the snapshot is incomplete.");
+  const entries = [];
+  let totalBytes = 0;
+  for (const change of changes.changes) {
+    if (change.status === "untracked") continue;
+    if (change.path === ".git") continue;
+    if (change.status === "deleted") {
+      entries.push({
+        path: change.path,
+        layer: "worktree",
+        kind: "deleted",
+        digest: null,
+        bytes: null
+      });
+      continue;
+    }
+    const read = readWorktreeFile(captured.root, change.path, limits.fileBytes);
+    switch (read.kind) {
+      case "file":
+        totalBytes += read.bytes;
+        if (totalBytes > limits.totalBytes) {
+          fail3(
+            "file_limit",
+            `Captured content exceeded ${limits.totalBytes} bytes; the snapshot is incomplete.`
+          );
+          entries.push({
+            path: change.path,
+            layer: "worktree",
+            kind: "too_large",
+            digest: null,
+            bytes: read.bytes
+          });
+          break;
+        }
+        entries.push({
+          path: change.path,
+          layer: "worktree",
+          kind: "file",
+          digest: read.digest,
+          bytes: read.bytes
+        });
+        break;
+      case "deleted":
+        entries.push({
+          path: change.path,
+          layer: "worktree",
+          kind: "deleted",
+          digest: null,
+          bytes: null
+        });
+        break;
+      case "too_large":
+        withheld.tooLarge++;
+        fail3(
+          "file_limit",
+          `A changed file exceeds ${limits.fileBytes} bytes; the snapshot is incomplete.`
+        );
+        entries.push({
+          path: change.path,
+          layer: "worktree",
+          kind: "too_large",
+          digest: null,
+          bytes: null
+        });
+        break;
+      case "not_regular":
+        withheld.notRegular++;
+        fail3(
+          "unstable",
+          "A changed path is not a regular file (symlink or special); its content cannot be fingerprinted."
+        );
+        entries.push({
+          path: change.path,
+          layer: "worktree",
+          kind: "not_regular",
+          digest: null,
+          bytes: null
+        });
+        break;
+      case "unstable":
+        withheld.unstable++;
+        fail3(
+          "unstable",
+          "A changed file changed while it was being read; the snapshot is incomplete."
+        );
+        entries.push({
+          path: change.path,
+          layer: "worktree",
+          kind: "unstable",
+          digest: null,
+          bytes: null
+        });
+        break;
+    }
+  }
+  const untrackedIncluded = [];
+  const exclusions = [];
+  for (const path of [...new Set(input.includeUntracked ?? [])].sort()) {
+    const scoped = reviewScope(path);
+    if (!scoped.included) {
+      exclusions.push({ path, reason: scoped.reason });
+      withheld.excluded++;
+      continue;
+    }
+    if (totalBytes >= limits.totalBytes) {
+      fail3(
+        "file_limit",
+        `Captured content exceeded ${limits.totalBytes} bytes; the snapshot is incomplete.`
+      );
+      continue;
+    }
+    const read = readWorktreeFile(captured.root, path, limits.fileBytes);
+    if (read.kind === "file") {
+      totalBytes += read.bytes;
+      untrackedIncluded.push(path);
+      entries.push({
+        path,
+        layer: "untracked",
+        kind: "file",
+        digest: read.digest,
+        bytes: read.bytes
+      });
+      continue;
+    }
+    if (read.kind === "too_large") withheld.tooLarge++;
+    else if (read.kind === "not_regular") withheld.notRegular++;
+    else withheld.unstable++;
+    fail3(
+      read.kind === "too_large" ? "file_limit" : "unstable",
+      `Included untracked path "${path}" could not be fingerprinted (${read.kind}); the snapshot is incomplete.`
+    );
+    entries.push({
+      path,
+      layer: "untracked",
+      kind: read.kind === "too_large" ? "too_large" : read.kind === "not_regular" ? "not_regular" : "unstable",
+      digest: null,
+      bytes: null
+    });
+  }
+  entries.sort(
+    (a, b2) => a.layer === b2.layer ? a.path < b2.path ? -1 : a.path > b2.path ? 1 : 0 : a.layer < b2.layer ? -1 : 1
+  );
+  exclusions.sort((a, b2) => a.path < b2.path ? -1 : a.path > b2.path ? 1 : 0);
+  const canonical = {
+    identity: identity2,
+    base: base.resolvedOid,
+    head: index?.head ?? null,
+    indexDigest: index?.digest ?? null,
+    indexEntries: index?.entries ?? 0,
+    entries: entries.map((entry) => [
+      entry.layer,
+      entry.path,
+      entry.kind,
+      entry.digest,
+      entry.bytes
+    ]),
+    untrackedIncluded,
+    exclusions: exclusions.map((exclusion) => [exclusion.path, exclusion.reason]),
+    withheld,
+    limits,
+    complete: !incomplete
+  };
+  return {
+    id: hash3(JSON.stringify(canonical)),
+    capturedAt: Date.now(),
+    complete: !incomplete,
+    identity: identity2,
+    base,
+    head: canonical.head,
+    indexDigest: canonical.indexDigest,
+    indexEntries: canonical.indexEntries,
+    entries,
+    untrackedIncluded,
+    exclusions,
+    withheld,
+    limits,
+    issues
+  };
+}
+async function readIndexDigest(captured) {
+  try {
+    const output = await captured.runGit(["ls-files", "--stage", "-z"]);
+    const lines = [];
+    let entries = 0;
+    for (const record3 of output.split("\0")) {
+      if (record3.length === 0) continue;
+      const tab = record3.indexOf("	");
+      if (tab < 0) continue;
+      const meta2 = record3.slice(0, tab);
+      const path = record3.slice(tab + 1);
+      if (path.length === 0) continue;
+      entries++;
+      lines.push(`${meta2} ${path}`);
+    }
+    lines.sort();
+    const head = (await captured.runGit(["rev-parse", "--verify", "--quiet", "HEAD^{commit}"])).trim();
+    return {
+      digest: hash3(lines.join("\n")),
+      entries,
+      head: /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(head) ? head : null
+    };
+  } catch {
+    return null;
+  }
+}
+function readWorktreeFile(root, path, maxBytes) {
+  let parts;
+  try {
+    parts = relativeParts(path);
+  } catch {
+    return { kind: "not_regular" };
+  }
+  if (parts.length === 0) return { kind: "not_regular" };
+  let current = root;
+  try {
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      const entry = current.entry(part);
+      if (!entry) return { kind: "deleted" };
+      if (entry.isSymbolicLink()) return { kind: "not_regular" };
+      const last = i === parts.length - 1;
+      if (last) {
+        if (!entry.isFile()) return { kind: "not_regular" };
+        if (entry.size > maxBytes) return { kind: "too_large" };
+        const bytes = current.read(part, maxBytes);
+        if (!bytes) return { kind: "unstable" };
+        return { kind: "file", digest: hash3(bytes), bytes: bytes.length };
+      }
+      if (!entry.isDirectory()) return { kind: "not_regular" };
+      current = current.directory(part);
+    }
+  } catch {
+    return { kind: "unstable" };
+  }
+  return { kind: "not_regular" };
+}
+
+// ../daemon/src/lib/git-review/service.ts
+var ReviewUnavailableError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ReviewUnavailableError";
+    this.code = code;
+  }
+};
+function requireTeam(db, paths, teamId) {
+  const team = get3(db, teamId, paths);
+  if (!team) throw new ReviewUnavailableError("team_not_found", "Team not found.");
+  return { id: team.id, path: team.path };
+}
+async function withRepository(teamDir, fn) {
+  let directory;
+  try {
+    directory = new ContextDirectory(teamDir);
+  } catch (error2) {
+    throw new ReviewUnavailableError(
+      "unsupported_layout",
+      error2 instanceof ContextReadError ? `This Team's workspace cannot be inspected safely (${error2.code}).` : "This Team workspace cannot be inspected."
+    );
+  }
+  try {
+    const root = findRepositoryRoot([directory]);
+    if (!root) {
+      throw new ReviewUnavailableError("not_repository", "This Team is not a Git repository.");
     }
-    if (git.list().some((name) => name.startsWith("sharedindex.")))
-      throw new ContextReadError("unsupported_git_metadata");
-    writeFileSync12(join25(scratch, "config"), `${configLines.join("\n")}
-`, { mode: 384 });
-    git.validate();
-    const output = await runGit([
-      "--no-optional-locks",
-      `--git-dir=${scratch}`,
-      `--work-tree=/proc/${process.pid}/fd/${root.fd}`,
-      "-c",
-      "core.fsmonitor=false",
-      "-c",
-      "core.untrackedCache=false",
-      "-c",
-      "core.hooksPath=/dev/null",
-      "-c",
-      "core.excludesFile=/dev/null",
-      "-c",
-      "diff.renames=false",
-      "-c",
-      "submodule.recurse=false",
+    let captured;
+    try {
+      captured = await captureRepositoryGit(root);
+    } catch (error2) {
+      throw new ReviewUnavailableError(
+        "unsupported_layout",
+        error2 instanceof ContextReadError ? `This repository layout is not supported (${error2.code}).` : "This repository cannot be inspected."
+      );
+    }
+    try {
+      return await fn(captured);
+    } finally {
+      captured.cleanup();
+    }
+  } finally {
+    directory.close();
+  }
+}
+async function readTeamReview(db, paths, teamId, input = {}) {
+  const team = requireTeam(db, paths, teamId);
+  const changes = await withRepository(team.path, async (captured) => {
+    const base = await resolveComparisonBase(captured, input.base ?? "HEAD");
+    const identity2 = await readRepositoryIdentity(captured);
+    const listed = await listChanges(captured, base, identity2, input.limits);
+    return input.patches ? attachPatches(captured, listed, input.limits, input.patchPath) : listed;
+  });
+  return { teamId: team.id, changes };
+}
+async function captureTeamSnapshot(db, paths, teamId, input) {
+  const team = requireTeam(db, paths, teamId);
+  const snapshot = await withRepository(team.path, async (captured) => {
+    const base = await resolveComparisonBase(captured, input.base ?? "HEAD");
+    const identity2 = await readRepositoryIdentity(captured);
+    return captureSourceSnapshot(captured, base, identity2, {
+      ...input.includeUntracked ? { includeUntracked: input.includeUntracked } : {},
+      ...input.limits ? { limits: input.limits } : {}
+    });
+  });
+  saveSourceSnapshot(db, {
+    snapshotId: snapshot.id,
+    teamId: team.id,
+    capturedBy: input.capturedBy,
+    agentId: input.agentId ?? null,
+    turnId: input.turnId ?? null,
+    toolCallId: input.toolCallId ?? null,
+    complete: snapshot.complete,
+    head: snapshot.head,
+    baseOid: snapshot.base.resolvedOid,
+    entryCount: snapshot.entries.length,
+    capturedContentBytes: snapshot.entries.reduce((total, entry) => total + (entry.bytes ?? 0), 0),
+    manifestJson: JSON.stringify(snapshot)
+  });
+  return { snapshot, reference: snapshotReference(snapshot) };
+}
+async function readSnapshotApplicability(db, paths, teamId, snapshotId) {
+  const team = requireTeam(db, paths, teamId);
+  const record3 = getSourceSnapshot(db, team.id, snapshotId);
+  if (!record3) return { comparison: "unknown", reason: "no_snapshot", currentSnapshot: null };
+  let stored;
+  try {
+    stored = JSON.parse(record3.manifestJson);
+  } catch {
+    return { comparison: "unknown", reason: "no_snapshot", currentSnapshot: null };
+  }
+  if (!stored.complete) {
+    return { comparison: "unknown", reason: "incomplete_snapshot", currentSnapshot: null };
+  }
+  let current;
+  try {
+    current = await withRepository(team.path, async (captured) => {
+      const base = await resolveComparisonBase(captured, "HEAD");
+      const identity2 = await readRepositoryIdentity(captured);
+      return captureSourceSnapshot(captured, base, identity2, {
+        includeUntracked: stored.untrackedIncluded
+      });
+    });
+  } catch {
+    return { comparison: "unknown", reason: "capture_unavailable", currentSnapshot: null };
+  }
+  const comparison = compareSnapshots(stored, current);
+  return {
+    comparison,
+    reason: comparison === "identical" ? "source_unchanged" : "source_changed",
+    currentSnapshot: snapshotReference(current)
+  };
+}
+function listTeamSnapshots(db, paths, teamId, limit = 50) {
+  const team = requireTeam(db, paths, teamId);
+  return listSourceSnapshots(db, team.id, limit).map(toSummary);
+}
+function readTeamSnapshot(db, paths, teamId, snapshotId) {
+  const team = requireTeam(db, paths, teamId);
+  const record3 = getSourceSnapshot(db, team.id, snapshotId);
+  if (!record3) return null;
+  try {
+    return JSON.parse(record3.manifestJson);
+  } catch {
+    return null;
+  }
+}
+function toSummary(record3) {
+  return {
+    snapshotId: record3.snapshotId,
+    teamId: record3.teamId,
+    capturedBy: record3.capturedBy,
+    agentId: record3.agentId,
+    turnId: record3.turnId,
+    toolCallId: record3.toolCallId,
+    complete: record3.complete,
+    head: record3.head,
+    baseOid: record3.baseOid,
+    entryCount: record3.entryCount,
+    capturedContentBytes: record3.capturedContentBytes,
+    createdAt: record3.createdAt,
+    expiresAt: record3.expiresAt
+  };
+}
+
+// ../daemon/src/lib/repository-context/git.ts
+var emptyGit = () => ({
+  state: "not_repository",
+  root: null,
+  branch: null,
+  head: null,
+  headState: null,
+  staged: 0,
+  unstaged: 0,
+  untracked: 0,
+  conflicted: 0,
+  issues: []
+});
+async function inspectGit(ancestry) {
+  const report = emptyGit();
+  let capture2 = null;
+  try {
+    const root = findRepositoryRoot(ancestry);
+    if (!root) return report;
+    report.root = root.label;
+    report.state = "unavailable";
+    capture2 = await captureRepositoryGit(root);
+    const output = await capture2.runGit([
       "status",
       "--porcelain=v2",
       "--branch",
@@ -35795,7 +37119,7 @@ objectformat = ${value}`
       "--ignore-submodules=all",
       "-z"
     ]);
-    git.validate();
+    capture2.validate();
     const records2 = output.split("\0");
     for (let i = 0; i < records2.length; i++) {
       const line = records2[i] ?? "";
@@ -35824,7 +37148,7 @@ objectformat = ${value}`
       message: `Git inspection is unavailable (${code.replaceAll("_", " ")}); repository instructions are evaluated separately.`
     });
   } finally {
-    if (scratch) rmSync14(scratch, { recursive: true, force: true });
+    capture2?.cleanup();
   }
   return report;
 }
@@ -36030,6 +37354,19 @@ function createCodingHost(input) {
   const active = /* @__PURE__ */ new Set();
   const calls = /* @__PURE__ */ new Set();
   let starting = false;
+  let sourceBefore = null;
+  function authorizeEvidence(id, messageId) {
+    const receipt = getCodingCommand(input.db, id);
+    if (agents_exports.get(input.db, input.agentId)?.teamId !== input.teamId || !receipt || receipt.teamId !== input.teamId || agents_exports.get(input.db, receipt.agentId)?.teamId !== input.teamId)
+      throw new Error("Coding receipt unavailable");
+    if (receipt.agentId === input.agentId) return { receipt, producer: true };
+    const message = deliverableInbox(input.db, input.agentId, false).find(
+      (candidate) => candidate.id === messageId
+    );
+    if (!message || message.fromAgentId !== receipt.agentId || !message.payload.includes(`coding-receipt:${receipt.id}`) || receipt.state === "running")
+      throw new Error("Coding receipt requires an authorized producer message");
+    return { receipt, producer: false };
+  }
   async function snapshot(target) {
     input.assertActive();
     codingRelativePath(target);
@@ -36087,6 +37424,33 @@ function createCodingHost(input) {
       input.assertActive();
       if (!raw2 || typeof raw2 !== "object") throw new Error("Invalid coding request");
       if (raw2.action === "environment") return snapshot(raw2.target);
+      if (raw2.action === "snapshot") {
+        if (typeof raw2.toolCallId !== "string" || !raw2.toolCallId || raw2.toolCallId.length > 256 || calls.has(raw2.toolCallId))
+          throw new Error("Invalid or repeated coding tool call");
+        if (calls.size >= 64) throw new Error("Turn operation limit reached");
+        calls.add(raw2.toolCallId);
+        const requested = Array.isArray(raw2.includeUntracked) ? raw2.includeUntracked.filter((entry) => typeof entry === "string") : [];
+        if (requested.length > 1e3 || requested.some((entry) => entry.length > 4096))
+          throw new Error("Invalid untracked selection");
+        const captured = await captureTeamSnapshot(input.db, input.paths, input.teamId, {
+          capturedBy: "agent",
+          agentId: input.agentId,
+          turnId: input.turnId,
+          toolCallId: raw2.toolCallId,
+          ...requested.length > 0 ? { includeUntracked: requested } : {}
+        });
+        sourceBefore ??= captured.reference;
+        const result = {
+          reference: captured.reference,
+          head: captured.snapshot.head,
+          baseOid: captured.snapshot.base.resolvedOid,
+          entries: captured.snapshot.entries.length,
+          includedUntracked: captured.snapshot.untrackedIncluded,
+          exclusions: captured.snapshot.exclusions,
+          issues: captured.snapshot.issues
+        };
+        return result;
+      }
       if (raw2.action === "start") {
         if (starting || active.size || calls.size >= 64)
           throw new Error("Coding operation already active or turn operation limit reached");
@@ -36112,7 +37476,9 @@ function createCodingHost(input) {
             exitCode: null,
             diagnostic: "",
             truncated: false,
-            reason: null
+            reason: null,
+            sourceBefore,
+            sourceAfter: null
           };
           saveCodingCommand(input.db, receipt);
           active.add(receipt.id);
@@ -36131,35 +37497,53 @@ function createCodingHost(input) {
           value.state
         ) || typeof value.diagnostic !== "string" || Buffer.byteLength(value.diagnostic) > 256 * 1024 || value.exitCode !== null && !Number.isSafeInteger(value.exitCode) || value.reason !== null && (typeof value.reason !== "string" || value.reason.length > 4096) || typeof value.truncated !== "boolean" || value.state === "succeeded" && value.exitCode !== 0 || value.state === "failed" && (value.exitCode === null || value.exitCode === 0))
           throw new Error("Invalid coding terminal evidence");
-        const diagnostic = new CodingDiagnostics(input.secrets);
+        const diagnostic = new CodingDiagnostics(input.secrets, CODING_RETAINED_BYTES);
         diagnostic.append(Buffer.from(value.diagnostic));
-        const safe = diagnostic.finish();
+        const retained = diagnostic.finish();
+        const tail = diagnosticTail(retained.diagnostic, CODING_OUTPUT_BYTES);
         const reason = new CodingDiagnostics(input.secrets);
         reason.append(Buffer.from(value.reason ?? ""));
         Object.assign(receipt, {
           state: value.state,
           exitCode: value.exitCode,
-          diagnostic: safe.diagnostic,
-          truncated: safe.truncated || value.truncated,
+          diagnostic: tail.text,
+          truncated: tail.truncated || value.truncated,
           reason: reason.finish().diagnostic || null,
           finishedAt: Date.now()
         });
+        try {
+          const captured = await captureTeamSnapshot(input.db, input.paths, input.teamId, {
+            capturedBy: "agent",
+            agentId: input.agentId,
+            turnId: input.turnId,
+            toolCallId: receipt.toolCallId
+          });
+          receipt.sourceAfter = captured.reference;
+        } catch {
+          receipt.sourceAfter = null;
+        }
         saveCodingCommand(input.db, receipt);
+        try {
+          saveCodingCommandLog(input.db, {
+            commandId: receipt.id,
+            teamId: input.teamId,
+            agentId: input.agentId,
+            turnId: input.turnId,
+            toolCallId: receipt.toolCallId,
+            diagnostic: retained.diagnostic,
+            observedBytes: retained.observedBytes,
+            redacted: retained.redacted,
+            truncated: retained.truncated || value.truncated
+          });
+        } catch {
+        }
         active.delete(raw2.id);
         return receipt;
       }
       if (raw2.action === "read") {
         pruneCodingCommands(input.db, input.teamId);
-        const receipt = getCodingCommand(input.db, raw2.id);
-        if (agents_exports.get(input.db, input.agentId)?.teamId !== input.teamId || !receipt || receipt.teamId !== input.teamId || agents_exports.get(input.db, receipt.agentId)?.teamId !== input.teamId)
-          throw new Error("Coding receipt unavailable");
-        if (receipt.agentId !== input.agentId) {
-          const message = deliverableInbox(input.db, input.agentId, false).find(
-            (message2) => message2.id === raw2.messageId
-          );
-          if (!message || message.fromAgentId !== receipt.agentId || !message.payload.includes(`coding-receipt:${receipt.id}`) || receipt.state === "running")
-            throw new Error("Coding receipt requires an authorized producer message");
-        }
+        pruneCodingCommandLogs(input.db);
+        const { receipt } = authorizeEvidence(raw2.id, raw2.messageId);
         let current;
         try {
           current = await snapshot(receipt.input.cwd);
@@ -36170,6 +37554,28 @@ function createCodingHost(input) {
         const applicability = !current.inputFingerprint || !receipt.environment.inputFingerprint ? "unknown" : receipt.state === "interrupted" || Date.now() - receipt.startedAt > 15 * 6e4 || Date.now() < receipt.startedAt || current.rootIdentity !== receipt.environment.rootIdentity || current.posture !== receipt.environment.posture || current.imageId !== receipt.environment.imageId || current.inputFingerprint !== receipt.environment.inputFingerprint ? "stale" : "fresh";
         return { receipt, applicability };
       }
+      if (raw2.action === "log") {
+        pruneCodingCommandLogs(input.db);
+        const { producer } = authorizeEvidence(raw2.id, raw2.messageId);
+        if (!producer) releaseCodingCommandLog(input.db, raw2.id);
+        const page = readCodingCommandLog(input.db, raw2.id, {
+          audience: producer ? "producer" : "disclosure",
+          ...raw2.offset !== void 0 ? { offset: raw2.offset } : {},
+          ...raw2.limit !== void 0 ? { limit: raw2.limit } : {}
+        });
+        if (!page) throw new Error("Coding log unavailable");
+        return page;
+      }
+      if (raw2.action === "log-search") {
+        pruneCodingCommandLogs(input.db);
+        const { producer } = authorizeEvidence(raw2.id, raw2.messageId);
+        if (!producer) releaseCodingCommandLog(input.db, raw2.id);
+        const result = searchCodingCommandLog(input.db, raw2.id, raw2.query, {
+          audience: producer ? "producer" : "disclosure"
+        });
+        if (!result) throw new Error("Coding log unavailable");
+        return result;
+      }
       throw new Error("Unknown coding operation");
     }
   };
@@ -39684,6 +41090,8 @@ async function mirrorAgentTurnFrame(agentIdOrAgent, frame, attemptBase = `telegr
   if (!agent) return;
   const topicId = agents_exports.getTelegramTopicId(deps.db, agent.id);
   if (topicId === null) return;
+  const codingReleaseId = frame.kind === "event" && frame.event.type === "tool_result" && frame.event.name === "coding_command" ? codingCommandIdFromResult(frame.event.result) : null;
+  let codingReleased = false;
   const imagePayload = frameToolResultImages(frame);
   if (imagePayload) {
     await mirrorImages(deps, topicId, agent.id, imagePayload, `${attemptBase}:images`);
@@ -39715,6 +41123,10 @@ async function mirrorAgentTurnFrame(agentIdOrAgent, frame, attemptBase = `telegr
           ...isReply ? { parse_mode: "HTML" } : {}
         })
       );
+      if (codingReleaseId && !codingReleased) {
+        releaseCodingCommandLog(deps.db, codingReleaseId);
+        codingReleased = true;
+      }
     } catch (e) {
       if (isThreadGoneError(e)) {
         console.warn(
@@ -39890,6 +41302,8 @@ function renderFrame(frame, mode) {
       return null;
     case "command_approval":
       return null;
+    case "coding_progress":
+      return null;
     case "user_message":
     case "assistant_delta":
       return null;
@@ -40048,6 +41462,7 @@ async function* runAgentTurn(turn) {
     const selectedDocker = turn.protectedExecution?.docker ?? turn.configuredDocker?.docker;
     const codingHost = createCodingHost({
       db,
+      paths,
       agentId: agent.agent.id,
       teamId: agent.team.id,
       turnId,
@@ -41218,28 +42633,6 @@ async function authMiddleware(c, next) {
 import { randomUUID as randomUUID34 } from "crypto";
 import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
 import { join as join28 } from "path";
-
-// ../../packages/api-types/src/entities.ts
-var REASONING_LEVELS2 = [
-  "off",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh"
-];
-
-// ../../packages/api-types/src/index.ts
-var PROFILE_FILES = [
-  "profile.json",
-  "SOUL.md",
-  "IDENTITY.md",
-  "BOOTSTRAP.md",
-  "AGENTS.md",
-  "TOOLS.md"
-];
-
-// ../daemon/src/routes/agents.ts
 import { Hono } from "hono";
 
 // ../daemon/src/lib/agent-id.ts
@@ -45126,7 +46519,7 @@ function isChatFrame(value) {
     return isNonEmptyString3(event2.name) && isNonEmptyString3(event2.mimeType) && isBase64(event2.data);
   }
   if (event2.type === "tool_result") {
-    return isNonEmptyString3(event2.id) && isNonEmptyString3(event2.name) && typeof event2.result === "string" && Array.isArray(event2.images) && event2.images.length > 0 && event2.images.every(isToolResultImage);
+    return isNonEmptyString3(event2.id) && isNonEmptyString3(event2.name) && typeof event2.result === "string" && (event2.images === void 0 || Array.isArray(event2.images) && event2.images.every(isToolResultImage));
   }
   return false;
 }
@@ -45565,6 +46958,10 @@ async function deliver(plan) {
       capturedResultFile(getCtx().db, plan.payload.agentId, frame.event);
       releaseResultFile(getCtx().db, plan.payload.agentId, frame.event.result);
     }
+    if (frame.kind === "event" && frame.event.type === "tool_result" && frame.event.name === "coding_command") {
+      const id = codingCommandIdFromResult(frame.event.result);
+      if (id) releaseCodingCommandLog(getCtx().db, id);
+    }
     return;
   }
   if (plan.kind === "inbox_message") {
@@ -48807,6 +50204,128 @@ async function codingEnvironmentStatus(db, team, env = process.env) {
   };
 }
 
+// ../daemon/src/lib/git-review/feedback.ts
+var FEEDBACK_LIMITS = {
+  excerptChars: 4e3,
+  noteChars: 2e3
+};
+var feedbackReferencePrefix = "review-feedback:";
+function feedbackReference(document) {
+  return `${feedbackReferencePrefix}${document.snapshotId ?? "none"}:${document.path}`;
+}
+function composeFeedbackMessage(document, note) {
+  const lines = [
+    `${feedbackReferencePrefix}${document.snapshotId ?? "none"}`,
+    `Repository source snapshot: ${document.snapshotId ?? "(not captured)"}`,
+    `File: ${document.previousPath ? `${document.previousPath} -> ${document.path}` : document.path}`,
+    `Change: ${document.status}`
+  ];
+  if (document.lineRange)
+    lines.push(`Selected lines: ${document.lineRange.start}-${document.lineRange.end} (context)`);
+  lines.push(
+    `Source identity: ${document.applicability === "current" ? "unchanged since this snapshot" : document.applicability === "stale" ? "CHANGED since this snapshot \u2014 the selected lines may have moved" : `unknown (${document.applicabilityReason})`}`
+  );
+  if (document.excerpt !== null) {
+    lines.push(
+      "",
+      `Excerpt (${document.excerptSource === "current_read" ? "read now, not stored in the snapshot" : document.excerptSource}):`,
+      "```",
+      document.excerpt,
+      "```"
+    );
+  } else {
+    lines.push("", `Excerpt: unavailable (${document.excerptSource})`);
+  }
+  const trimmed = note?.trim();
+  if (trimmed) lines.push("", `Operator note: ${trimmed.slice(0, FEEDBACK_LIMITS.noteChars)}`);
+  return lines.join("\n");
+}
+async function buildReviewFeedback(db, paths, teamId, request2) {
+  const team = requireTeam(db, paths, teamId);
+  const record3 = request2.snapshotId ? getSourceSnapshot(db, team.id, request2.snapshotId) : null;
+  const stored = parseStoredSnapshot(record3);
+  return withRepository(team.path, async (captured) => {
+    const base = await resolveComparisonBase(captured, request2.base ?? "HEAD");
+    const identity2 = await readRepositoryIdentity(captured);
+    const listed = await attachPatches(
+      captured,
+      await listChanges(captured, base, identity2),
+      void 0,
+      request2.path
+    );
+    const change = listed.changes.find((entry) => entry.path === request2.path);
+    if (!change)
+      throw new FeedbackTargetError("unknown_path", "That path is not changed since this baseline.");
+    const current = await captureSourceSnapshot(captured, base, identity2);
+    return {
+      teamId: team.id,
+      path: change.path,
+      previousPath: change.previousPath,
+      status: change.status,
+      snapshotId: request2.snapshotId ?? null,
+      lineRange: lineRange(request2, captured),
+      excerpt: excerptOf(change),
+      excerptSource: excerptSource(change),
+      ...applicabilityOf(stored, current, change.path)
+    };
+  });
+}
+var FeedbackTargetError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "FeedbackTargetError";
+    this.code = code;
+  }
+};
+function applicabilityOf(stored, current, path) {
+  if (!stored) return { applicability: "unknown", applicabilityReason: "no_snapshot" };
+  if (!stored.complete)
+    return { applicability: "unknown", applicabilityReason: "incomplete_snapshot" };
+  if (!current.complete)
+    return { applicability: "unknown", applicabilityReason: "capture_incomplete" };
+  const before = stored.entries.find((entry) => entry.path === path) ?? null;
+  const after = current.entries.find((entry) => entry.path === path) ?? null;
+  if (before === null && after === null) {
+    return { applicability: "current", applicabilityReason: "path_unchanged" };
+  }
+  if (before?.digest && before.digest === after?.digest && before.kind === after?.kind) {
+    return { applicability: "current", applicabilityReason: "path_unchanged" };
+  }
+  return { applicability: "stale", applicabilityReason: "path_changed" };
+}
+function parseStoredSnapshot(record3) {
+  if (!record3) return null;
+  try {
+    return JSON.parse(record3.manifestJson);
+  } catch {
+    return null;
+  }
+}
+function excerptSource(change) {
+  if (change.excludedReason) return "excluded";
+  if (change.binary) return "binary";
+  if (change.patch === null) return "omitted";
+  return "current_read";
+}
+function excerptOf(change) {
+  if (change.excludedReason || change.binary || change.patch === null) return null;
+  return change.patch.slice(0, FEEDBACK_LIMITS.excerptChars);
+}
+function lineRange(request2, _captured) {
+  const { startLine, endLine } = request2;
+  if (startLine === void 0 && endLine === void 0) return null;
+  const start = startLine ?? endLine;
+  const end = endLine ?? startLine;
+  if (start === void 0 || end === void 0 || !Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 1 || end < start || end > 1e6) {
+    throw new FeedbackTargetError(
+      "invalid_range",
+      "Selected lines must be an ordered positive range."
+    );
+  }
+  return { start, end };
+}
+
 // ../daemon/src/routes/teams.ts
 var USER_MD_MAX_BYTES2 = 12e3;
 var teamsRouter = new Hono18();
@@ -48846,6 +50365,195 @@ teamsRouter.get("/:id/repository-context", async (c) => {
     })
   );
 });
+function codingLogCommand(c) {
+  const { db, paths } = getCtx();
+  const team = teams_exports.get(db, c.req.param("id") ?? "", paths);
+  if (!team) return { error: "Team not found", status: 404 };
+  const commandId = c.req.param("commandId") ?? "";
+  const receipt = getCodingCommand(db, commandId);
+  if (!receipt || receipt.teamId !== team.id)
+    return { error: "Coding command not found", status: 404 };
+  const view2 = getCodingCommandLog(db, commandId);
+  if (view2.releasedAt === null) return { error: "Coding log has not been shared", status: 403 };
+  return { db, commandId, view: view2 };
+}
+teamsRouter.get("/:id/coding-commands/:commandId/log", (c) => {
+  const resolved = codingLogCommand(c);
+  if ("error" in resolved) return c.json({ error: resolved.error }, resolved.status);
+  const offset = Number(c.req.query("offset") ?? "0");
+  const limit = Number(c.req.query("limit") ?? "65536");
+  if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit))
+    return c.json({ error: "Invalid page request" }, 400);
+  const page = readCodingCommandLog(resolved.db, resolved.commandId, {
+    offset,
+    limit,
+    audience: "disclosure"
+  });
+  c.header("Cache-Control", "no-store");
+  return c.json({ view: resolved.view, page });
+});
+teamsRouter.get("/:id/coding-commands/:commandId/log/search", (c) => {
+  const resolved = codingLogCommand(c);
+  if ("error" in resolved) return c.json({ error: resolved.error }, resolved.status);
+  const query = c.req.query("q") ?? "";
+  if (!query || query.length > 256) return c.json({ error: "Invalid search query" }, 400);
+  const result = searchCodingCommandLog(resolved.db, resolved.commandId, query, {
+    audience: "disclosure"
+  });
+  c.header("Cache-Control", "no-store");
+  return c.json({ view: resolved.view, result });
+});
+function reviewFailure(c, error2) {
+  if (error2 instanceof ReviewBaseError)
+    return c.json({ error: error2.message, code: error2.code }, 400);
+  if (error2 instanceof FeedbackTargetError)
+    return c.json({ error: error2.message, code: error2.code }, 400);
+  if (error2 instanceof ReviewUnavailableError) {
+    return c.json(
+      { error: error2.message, code: error2.code },
+      error2.code === "team_not_found" ? 404 : 409
+    );
+  }
+  throw error2;
+}
+teamsRouter.get("/:id/review", async (c) => {
+  const { db, paths } = getCtx();
+  c.header("Cache-Control", "no-store");
+  const base = c.req.query("base");
+  const patches = c.req.query("patches") === "1";
+  const patchPath = c.req.query("path");
+  if (patchPath !== void 0 && (patchPath.length === 0 || patchPath.length > 4096)) {
+    return c.json({ error: "Invalid path", code: "invalid_path" }, 400);
+  }
+  try {
+    const review = await readTeamReview(db, paths, c.req.param("id"), {
+      ...base === void 0 ? {} : { base },
+      patches,
+      ...patchPath === void 0 ? {} : { patchPath }
+    });
+    return c.json(review);
+  } catch (error2) {
+    return reviewFailure(c, error2);
+  }
+});
+teamsRouter.get("/:id/review/snapshots", (c) => {
+  const { db, paths } = getCtx();
+  c.header("Cache-Control", "no-store");
+  try {
+    return c.json({ snapshots: listTeamSnapshots(db, paths, c.req.param("id")) });
+  } catch (error2) {
+    return reviewFailure(c, error2);
+  }
+});
+teamsRouter.get("/:id/review/snapshots/:snapshotId", (c) => {
+  const { db, paths } = getCtx();
+  c.header("Cache-Control", "no-store");
+  try {
+    const snapshot = readTeamSnapshot(db, paths, c.req.param("id"), c.req.param("snapshotId"));
+    if (!snapshot) return c.json({ error: "Snapshot not found" }, 404);
+    return c.json({ snapshot });
+  } catch (error2) {
+    return reviewFailure(c, error2);
+  }
+});
+teamsRouter.post("/:id/review/feedback", async (c) => {
+  const { db, paths } = getCtx();
+  c.header("Cache-Control", "no-store");
+  const body = await c.req.json().catch(() => null);
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return c.json({ error: "Invalid feedback request" }, 400);
+  }
+  const input = body;
+  if (Object.keys(input).some(
+    (key3) => !["path", "base", "snapshotId", "startLine", "endLine", "note"].includes(key3)
+  )) {
+    return c.json({ error: "Invalid feedback request" }, 400);
+  }
+  if (typeof input.path !== "string" || input.path.length === 0 || input.path.length > 4096) {
+    return c.json({ error: "A changed path is required" }, 400);
+  }
+  if (input.base !== void 0 && (typeof input.base !== "string" || input.base.length > 4096)) {
+    return c.json({ error: "Invalid comparison base" }, 400);
+  }
+  if (input.snapshotId !== void 0 && (typeof input.snapshotId !== "string" || input.snapshotId.length > 128)) {
+    return c.json({ error: "Invalid snapshot reference" }, 400);
+  }
+  if (input.note !== void 0 && (typeof input.note !== "string" || input.note.length > FEEDBACK_LIMITS.noteChars)) {
+    return c.json({ error: "Invalid feedback note" }, 400);
+  }
+  for (const key3 of ["startLine", "endLine"]) {
+    const value = input[key3];
+    if (value !== void 0 && (typeof value !== "number" || !Number.isSafeInteger(value))) {
+      return c.json({ error: "Selected lines must be whole numbers" }, 400);
+    }
+  }
+  try {
+    const feedback = await buildReviewFeedback(db, paths, c.req.param("id"), {
+      path: input.path,
+      ...input.base === void 0 ? {} : { base: input.base },
+      ...input.snapshotId === void 0 ? {} : { snapshotId: input.snapshotId },
+      ...input.startLine === void 0 ? {} : { startLine: input.startLine },
+      ...input.endLine === void 0 ? {} : { endLine: input.endLine },
+      ...input.note === void 0 ? {} : { note: input.note }
+    });
+    return c.json({
+      feedback,
+      reference: feedbackReference(feedback),
+      message: composeFeedbackMessage(feedback, input.note)
+    });
+  } catch (error2) {
+    return reviewFailure(c, error2);
+  }
+});
+teamsRouter.get("/:id/review/snapshots/:snapshotId/applicability", async (c) => {
+  const { db, paths } = getCtx();
+  c.header("Cache-Control", "no-store");
+  try {
+    return c.json(
+      await readSnapshotApplicability(db, paths, c.req.param("id"), c.req.param("snapshotId"))
+    );
+  } catch (error2) {
+    return reviewFailure(c, error2);
+  }
+});
+teamsRouter.post("/:id/review/snapshots", async (c) => {
+  const { db, paths } = getCtx();
+  c.header("Cache-Control", "no-store");
+  const body = await c.req.json().catch(() => null);
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return c.json({ error: "Invalid snapshot request" }, 400);
+  }
+  const input = body;
+  if (Object.keys(input).some((key3) => !["base", "includeUntracked"].includes(key3))) {
+    return c.json({ error: "Invalid snapshot request" }, 400);
+  }
+  if (input.base !== void 0 && (typeof input.base !== "string" || input.base.length > 4096)) {
+    return c.json({ error: "Invalid comparison base" }, 400);
+  }
+  let includeUntracked;
+  if (input.includeUntracked !== void 0) {
+    if (!Array.isArray(input.includeUntracked) || input.includeUntracked.length > REVIEW_LIMITS.files) {
+      return c.json({ error: "Invalid untracked selection" }, 400);
+    }
+    includeUntracked = [];
+    for (const entry of input.includeUntracked) {
+      if (typeof entry !== "string" || entry.length === 0 || entry.length > 4096) {
+        return c.json({ error: "Invalid untracked selection" }, 400);
+      }
+      includeUntracked.push(entry);
+    }
+  }
+  try {
+    const captured = await captureTeamSnapshot(db, paths, c.req.param("id"), {
+      capturedBy: "operator",
+      ...input.base === void 0 ? {} : { base: input.base },
+      ...includeUntracked ? { includeUntracked } : {}
+    });
+    return c.json(captured);
+  } catch (error2) {
+    return reviewFailure(c, error2);
+  }
+});
 teamsRouter.get("/:id/coding-environment", async (c) => {
   const { db, paths } = getCtx();
   const team = teams_exports.get(db, c.req.param("id"), paths);