@saadnvd1/agent-os 0.3.550 → 0.3.552

package/lib/approvals/no-approvals.ts

@@ -0,0 +1,119 @@
+/**
+ * No approvals mode: while it's on, nothing AgentOS starts or runs waits on
+ * a person. Asks are approved as they're raised, brakes let starts through,
+ * plan-only tasks go on to implement, and agents launch with their harness's
+ * permission prompts off. Off by default; app-wide; every point that honours
+ * it reads it here and records what it did with recordAutoApproval.
+ */
+
+import { db } from "../db";
+import type { ChatAccess } from "../chat/events";
+import { addNote } from "../orchestrator/notes";
+import { markAllStatusDirty } from "../status/dirty";
+
+export const NO_APPROVALS_KEY = "approvals.none";
+
+export type AuditSource =
+  | "ask"
+  | "brake"
+  | "plan"
+  | "chat"
+  | "terminal"
+  | "merge-approval"
+  | "mode";
+
+export interface AuditRow {
+  id: number;
+  at: string;
+  source: AuditSource;
+  workspace_id: string | null;
+  session_id: string | null;
+  subject: string;
+  detail: string;
+}
+
+export function noApprovalsOn(): boolean {
+  const row = db
+    .prepare(`SELECT value FROM settings WHERE key = ?`)
+    .get(NO_APPROVALS_KEY) as { value: string } | undefined;
+  return row?.value === "1";
+}
+
+export function setNoApprovals(on: boolean): void {
+  db.prepare(
+    `INSERT INTO settings (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(NO_APPROVALS_KEY, on ? "1" : "0");
+  markAllStatusDirty();
+}
+
+export const AUTO_LABEL = "auto-approved by No approvals mode";
+
+const MAX_DETAIL = 500;
+
+// Writes the audit row, and a note in the workspace's orchestrator chat when
+// the approval belongs to one. Never throws: an audit failure must not turn
+// into a stuck approval.
+export function recordAutoApproval(a: {
+  source: AuditSource;
+  subject: string;
+  detail?: string;
+  workspaceId?: string | null;
+  sessionId?: string | null;
+}): void {
+  const detail = (a.detail ?? "").slice(0, MAX_DETAIL);
+  try {
+    db.prepare(
+      `INSERT INTO approval_audit (source, workspace_id, session_id, subject, detail)
+       VALUES (?, ?, ?, ?, ?)`
+    ).run(
+      a.source,
+      a.workspaceId ?? null,
+      a.sessionId ?? null,
+      a.subject,
+      detail
+    );
+  } catch (e) {
+    console.error("approval audit failed:", e);
+  }
+  console.log(`[no-approvals] ${a.source}: ${a.subject}`);
+  if (a.workspaceId) {
+    try {
+      addNote(
+        a.workspaceId,
+        `${AUTO_LABEL[0].toUpperCase()}${AUTO_LABEL.slice(1)}: ${a.subject}${detail ? ` (${detail})` : ""}`,
+        "ask"
+      );
+    } catch (e) {
+      console.error("approval note failed:", e);
+    }
+  }
+}
+
+// For a point that's judged again and again (a PR on every poll): one row
+// per source and subject.
+export function recordAutoApprovalOnce(
+  a: Parameters<typeof recordAutoApproval>[0]
+): void {
+  const seen = db
+    .prepare(`SELECT 1 FROM approval_audit WHERE source = ? AND subject = ?`)
+    .get(a.source, a.subject);
+  if (!seen) recordAutoApproval(a);
+}
+
+export function listAutoApprovals(limit = 20): AuditRow[] {
+  return db
+    .prepare(`SELECT * FROM approval_audit ORDER BY id DESC LIMIT ?`)
+    .all(limit) as AuditRow[];
+}
+
+// What an agent is launched or kept with: the mode forces the most access,
+// so no harness prompts. The stored choice is untouched and returns when the
+// mode goes off.
+export function effectiveChatAccess(stored: ChatAccess): ChatAccess {
+  return noApprovalsOn() ? "full" : stored;
+}
+
+export function effectiveAutoApprove(stored: boolean | number): boolean {
+  return !!stored || noApprovalsOn();
+}

package/lib/chat/events.ts

@@ -226,6 +226,8 @@ export type ChatItem =
       // Whether "always allow" is on offer.
       canAlways: boolean;
       status: "pending" | "allowed" | "denied" | "answered" | "expired";
+      // Allowed by No approvals mode, not by the reader.
+      auto?: boolean;
     })
   | (Base & {
       // Work the agent runs alongside the turn: a background shell, a

package/lib/chat/settings.ts

@@ -3,6 +3,7 @@
  * per-session settings that go with them: the model and the access level.
  */
 
+import { effectiveChatAccess, noApprovalsOn } from "../approvals/no-approvals";
 import os from "os";
 import { db, type Session } from "../db";
 import { agentEnv } from "../agents/launch";
@@ -73,8 +74,8 @@ export function emitCapabilities(session: Session, listener?: Listener): void {
     commands: visibleCommands(caps),
     models: caps.models,
     model: chatModel(session),
-    access: session.chat_access,
-    plan: canPlan(session) ? !!session.chat_plan : null,
+    access: effectiveChatAccess(session.chat_access),
+    plan: canPlan(session) ? !!session.chat_plan && !noApprovalsOn() : null,
     background: chatDriverFor(session.agent_type)?.backgroundTasks === true,
   };
   if (listener) listener(m);
@@ -352,3 +353,17 @@ export async function setChatPlan(
   registry.live.get(sessionId)?.worker.command({ type: "set_plan", plan });
   emitCapabilities(getSession(sessionId));
 }
+
+// No approvals mode was switched: every live worker takes its access and plan
+// settings again, now read through the mode, and waiting tool cards are
+// allowed (or, switched off, the stored choices return).
+export function reapplyChatModes(): void {
+  for (const [id, live] of registry.live) {
+    const session = getSession(id);
+    if (!session) continue;
+    live.worker.command({ type: "set_access", access: session.chat_access });
+    if (live.canPlan)
+      live.worker.command({ type: "set_plan", plan: !!session.chat_plan });
+    emitCapabilities(session);
+  }
+}

package/lib/chat/worker/host.ts

@@ -55,6 +55,11 @@ import { compactContext } from "../compact-context";
 import { COMPACT_BRIEF, COMPACT_INSTRUCTIONS } from "../working-state";
 import { compactionDue, staleLabel, type Staleness } from "../stale";
 import type { WorkerCommand, WorkerEvent } from "./protocol";
+import {
+  effectiveChatAccess,
+  noApprovalsOn,
+  recordAutoApproval,
+} from "../../approvals/no-approvals";
 
 // How soon after a stopped turn ends a turn the agent starts on its own
 // still counts as part of the stop: the agent starts what it queued the
@@ -131,6 +136,10 @@ export class ChatHost {
   private restTimer?: NodeJS.Timeout;
   // Background tasks seen running: one that ends is a notice the agent runs.
   private runningTasks = new Set<string>();
+  // Tool-permission cards waiting on the reader (questions are not: they
+  // need words), and the ones No approvals mode allowed.
+  private waitingCards = new Map<string, string>();
+  private autoAllowed = new Set<string>();
   // Whether its driver says when that is (lib/chat/driver atRest).
   private atRest = true;
   private restartedNote = false;
@@ -210,8 +219,9 @@ export class ChatHost {
         session.model?.trim() || resolveModelForAgent(session.agent_type, null),
       resumeId: session.claude_session_id,
       resumeAt: session.chat_resume_at,
-      access: session.chat_access ?? "full",
-      plan: !!session.chat_plan,
+      access: effectiveChatAccess(session.chat_access ?? "full"),
+      // A plan waits for a person to carry it out, so it isn't entered.
+      plan: !!session.chat_plan && !noApprovalsOn(),
       systemAppend: [
         extras.systemAppend,
         sessionRunningBrief(session.id),
@@ -273,6 +283,33 @@ export class ChatHost {
     this.done = this.pump();
   }
 
+  // No approvals mode: a tool-permission card is allowed as it appears, and
+  // marks itself so the transcript shows who allowed it.
+  private markAuto(item: ChatItem): ChatItem {
+    if (item.kind !== "approval" || item.questions) return item;
+    if (item.status === "pending") {
+      this.waitingCards.set(item.id, item.title);
+      return item;
+    }
+    this.waitingCards.delete(item.id);
+    if (!this.autoAllowed.delete(item.id)) return item;
+    return { ...item, auto: true };
+  }
+
+  private allowWaiting(): void {
+    if (!noApprovalsOn()) return;
+    for (const [id, title] of [...this.waitingCards]) {
+      this.waitingCards.delete(id);
+      this.autoAllowed.add(id);
+      recordAutoApproval({
+        source: "chat",
+        sessionId: this.session.id,
+        subject: title,
+      });
+      this.conversation.respond(id, { decision: "allow" });
+    }
+  }
+
   private record(item: ChatItem): void {
     // Streaming updates are written in batches; anything else right away.
     queueItem(this.session.id, item, {
@@ -325,7 +362,9 @@ export class ChatHost {
           if ("streaming" in e.item && e.item.streaming)
             this.streaming.set(e.item.id, e.item);
           else this.streaming.delete(e.item.id);
+          e.item = this.markAuto(e.item);
           this.record(e.item);
+          if (e.item.kind === "approval") this.allowWaiting();
           if (e.item.kind === "task" && !e.item.ambient) {
             if (e.item.status === "running")
               this.runningTasks.add(e.item.taskId);
@@ -705,9 +744,15 @@ export class ChatHost {
       case "set_model":
         return this.conversation.setModel(cmd.model);
       case "set_access":
-        return (this.modeChange = this.conversation.setAccess(cmd.access));
+        this.modeChange = this.conversation.setAccess(
+          effectiveChatAccess(cmd.access)
+        );
+        this.allowWaiting();
+        return this.modeChange;
       case "set_plan":
-        return (this.modeChange = this.conversation.setPlan(cmd.plan));
+        return (this.modeChange = this.conversation.setPlan(
+          cmd.plan && !noApprovalsOn()
+        ));
       case "respond":
         return this.conversation.respond(cmd.id, cmd);
       case "stop_task":

package/lib/db/migrations.ts

@@ -2010,6 +2010,24 @@ const migrations: Migration[] = [
       );
     },
   },
+  {
+    id: 84,
+    name: "approval_audit",
+    up: (db) => {
+      // Every approval No approvals mode made in place of a person.
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS approval_audit (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          at TEXT NOT NULL DEFAULT (datetime('now')),
+          source TEXT NOT NULL,
+          workspace_id TEXT,
+          session_id TEXT,
+          subject TEXT NOT NULL,
+          detail TEXT NOT NULL DEFAULT ''
+        )
+      `);
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/done/index.ts

@@ -10,6 +10,7 @@
 
 import { db, queries, type Session } from "../db";
 import { endSessionAgent } from "../sessions/end";
+import { clearQueue } from "../chat/queued";
 import { getProject } from "../projects";
 import { mergeSettled, type TaskPR } from "../tasks";
 import { syncTaskCardInBackground } from "../lumifyhub/task-cards";
@@ -61,6 +62,8 @@ export function getDoneTarget(id: string): Session {
 
 async function stopAgent(s: Session): Promise<void> {
   await endSessionAgent(s);
+  // Nothing is left to send them to; they'd only sit unread on a stopped agent.
+  clearQueue(s.id);
   releasePorts(s.id);
   // Never waited on: the row is read now, and Postgres can't hold this up.
   void dropSessionDatabase(s.id);

package/lib/models/plan-step.ts

@@ -19,6 +19,7 @@ import {
 } from "./resolve";
 import { ANTHROPIC } from "./roles";
 import { queueEvent } from "../orchestrator/events";
+import { noApprovalsOn, recordAutoApproval } from "../approvals/no-approvals";
 import { addNote } from "../orchestrator/notes";
 import { amendBrief, amendmentsOf } from "../orchestrator/amendments";
 import { PIECES_PROMPT, pieceBrief } from "../plans/pieces";
@@ -341,11 +342,26 @@ export async function handoffAfterPlan(
   deleteQueued(sessionId, planRetryMessageId(sessionId));
   const retried = waiting.get(sessionId)?.retried ?? false;
   forget(sessionId);
-  if (!s.plan_only)
-    return (
-      (await startImplementing(s, "planning", send, undefined, retried)) !==
-      null
+  // No approvals mode doesn't stop at the plan to wait for one.
+  const auto = !!s.plan_only && noApprovalsOn();
+  if (!s.plan_only || auto) {
+    const ref = await startImplementing(
+      s,
+      "planning",
+      send,
+      undefined,
+      retried
     );
+    if (ref && auto)
+      recordAutoApproval({
+        source: "plan",
+        workspaceId: sessionWorkspace(s),
+        sessionId,
+        subject: `plan for ${s.name}`,
+        detail: "implementing without waiting for approve_plan",
+      });
+    return ref !== null;
+  }
   const awaiting = db
     .prepare(
       `UPDATE sessions SET plan_phase = 'awaiting'
@@ -401,9 +417,13 @@ export async function recheckPlanning(
 
 // approvePlan, sending through the chat runner (imported when needed: it
 // imports this file).
-export async function approvePlanNow(sessionId: string, message?: string) {
+export async function approvePlanNow(
+  sessionId: string,
+  message?: string,
+  by: "saad" | "no-approvals" = "saad"
+) {
   const { sendQueuedNow } = await import("../chat/runner");
-  return approvePlan(sessionId, message, (id, m) => sendQueuedNow(id, m));
+  return approvePlan(sessionId, message, (id, m) => sendQueuedNow(id, m), by);
 }
 
 // Approves a waiting plan-only task: implementation starts on the
@@ -413,7 +433,8 @@ export async function approvePlanNow(sessionId: string, message?: string) {
 export async function approvePlan(
   sessionId: string,
   message: string | undefined,
-  send: Send
+  send: Send,
+  by: "saad" | "no-approvals" = "saad"
 ): Promise<{ ref: string; amendments: number }> {
   const s = getSession(sessionId);
   if (!s || s.plan_phase !== "awaiting" || s.task_status !== "running")
@@ -428,5 +449,13 @@ export async function approvePlan(
   }
   const ref = await startImplementing(s, "awaiting", send, text);
   if (!ref) throw new Error(`${s.name} isn't waiting for plan approval`);
+  if (by === "no-approvals")
+    recordAutoApproval({
+      source: "plan",
+      workspaceId,
+      sessionId,
+      subject: `plan for ${s.name}`,
+      detail: "already waiting when the mode was turned on",
+    });
   return { ref, amendments: amendmentsOf(s.id).length };
 }

package/lib/needs-you.ts

@@ -33,11 +33,13 @@ function latestChatItem(sessionId: string): ChatItem | null {
 // is routine for it.
 export function needsYou(
   session: Pick<Session, "id" | "view" | "updated_at" | "last_seen_at"> &
-    Partial<Pick<Session, "role" | "workspace_id">>,
+    Partial<Pick<Session, "role" | "workspace_id" | "task_status">>,
   chatState: ChatState | null
 ): boolean {
   const seen = sqliteMs(session.last_seen_at);
   if (session.view === "chat") {
+    // A finished task's agent is stopped: its last turn is history, not news.
+    if (session.task_status && session.task_status !== "running") return false;
     if (chatState === "waiting") return true;
     if (session.role === "orchestrator")
       return openAskCount(session.workspace_id) > 0;

package/lib/orchestrator/asks.ts

@@ -8,6 +8,11 @@
 
 import { pushAskRaised } from "../notify/push/events";
 import { db } from "../db";
+import {
+  AUTO_LABEL,
+  noApprovalsOn,
+  recordAutoApproval,
+} from "../approvals/no-approvals";
 import { answerKey, queueEvent } from "./events";
 import { addNote } from "./notes";
 import { cleanTitle, classifyKind, titleSubject } from "./ask-text";
@@ -210,11 +215,36 @@ export function raiseAsk(input: {
       created: true,
     };
   })();
+  // No approvals mode answers it at once, so nothing waits and the phone
+  // isn't buzzed for it.
+  if (noApprovalsOn()) {
+    const ask = autoApproveAsk(input.workspaceId, result.ask);
+    return { ask, created: result.created };
+  }
   // A new ask buzzes the phone; a refresh of an open one doesn't.
   if (result.created) pushAskRaised(result.ask.id, input.workspaceId);
   return result;
 }
 
+// Approves an open ask on No approvals mode's behalf, bound to the ask as it
+// is now, and records it.
+export function autoApproveAsk(workspaceId: string, ask: AskRow): AskRow {
+  const answered = answerAsk(
+    workspaceId,
+    ask.id,
+    { action: "approve" },
+    askBinding(ask),
+    "no-approvals"
+  );
+  recordAutoApproval({
+    source: "ask",
+    workspaceId,
+    subject: `${ask.kind} ask "${ask.title}"`,
+    detail: ask.sha ? `at ${short(ask.sha)}` : undefined,
+  });
+  return answered;
+}
+
 export function openAsks(workspaceId: string): AskRow[] {
   return db
     .prepare(
@@ -247,10 +277,14 @@ function approvalScope(ask: AskRow): string {
   return "";
 }
 
-export function answerLine(ask: AskRow, answer: AskAnswer): string {
+export function answerLine(
+  ask: AskRow,
+  answer: AskAnswer,
+  by: "saad" | "no-approvals" = "saad"
+): string {
   const head = `ask "${ask.title}"`;
   if (answer.action === "approve")
-    return `${head}: approved${approvalScope(ask)}`;
+    return `${head}: approved${approvalScope(ask)}${by === "no-approvals" ? ` (${AUTO_LABEL})` : ""}`;
   if (answer.action === "decline") return `${head}: declined`;
   return `${head}: reply: ${answer.text}`;
 }
@@ -269,7 +303,8 @@ export function answerAsk(
   workspaceId: string,
   id: number,
   answer: AskAnswer,
-  binding?: string
+  binding?: string,
+  by: "saad" | "no-approvals" = "saad"
 ): AskRow {
   const ask = getAsk(workspaceId, id);
   if (!ask) throw new Error("No such ask");
@@ -286,7 +321,8 @@ export function answerAsk(
   if (answer.action === "reply" && !text) throw new Error("The reply is empty");
   const line = answerLine(
     ask,
-    answer.action === "reply" ? { action: "reply", text } : answer
+    answer.action === "reply" ? { action: "reply", text } : answer,
+    by
   );
   db.transaction(() => {
     db.prepare(
@@ -295,7 +331,8 @@ export function answerAsk(
     if (ask.kind === "passkey") settlePasskeyAsk(ask, answer.action);
     else queueEvent(workspaceId, answerKey(id), null, line);
   })();
-  addNote(workspaceId, `Saad answered ${line}`, "ask");
+  // An auto-approval is noted once, by recordAutoApproval.
+  if (by === "saad") addNote(workspaceId, `Saad answered ${line}`, "ask");
   return getAsk(workspaceId, id)!;
 }
 

package/lib/orchestrator/brakes.ts

@@ -20,6 +20,7 @@ import { workspaceSessions } from "./facts";
 import { addNote } from "./notes";
 import { AskRefused, BRAKE_SUBJECT, raiseAsk, resolveAsks } from "./asks";
 import { spendApproval, unspentApproval, voidApprovals } from "./ask-approvals";
+import { noApprovalsOn, recordAutoApproval } from "../approvals/no-approvals";
 import { isPaused } from "./pause";
 import { readUsage, windowRefusal, type UsageState } from "./usage";
 
@@ -159,6 +160,16 @@ async function refusal(
   }
   const key = on.map((b) => b.name).join("+");
   const reason = on.map((b) => b.reason).join("; ");
+  // No approvals mode lets the start through: no brake ask, no wait.
+  if (noApprovalsOn()) {
+    recordAutoApproval({
+      source: "brake",
+      workspaceId,
+      subject: `one start past the brakes (${key})`,
+      detail: reason,
+    });
+    return null;
+  }
   // An approval is for the brake it was asked about, not whichever holds now.
   const approval = unspentApproval(
     workspaceId,

package/lib/orchestrator/brief.ts

@@ -5,12 +5,18 @@ import { TOOL_NAMES } from "./tool-names";
 import { UNTRUSTED_RULE } from "./untrusted";
 import { brakesEnabled } from "./brakes";
 import { mergeApprovalsOn } from "./merge-approvals";
+import { noApprovalsOn } from "../approvals/no-approvals";
 import { buildDigest } from "./digest";
 
 const BRAKES_ON = `Starting work (\`start_task\`, \`start_session\`, \`stack\`) is braked: at most a set number of sessions running in this workspace (4 by default), at most a set number of starts an hour (6 by default), and nothing new once the account's usage window would run out before it resets, or can't be read at all. Each card of a stack you start counts as a start of its own; a braked card waits in the stack. A brake refuses the start with its reason and writes one note; running work carries on. Don't retry a braked start in a loop: carry on with reviews, answers and merges, and start again when a later event gives you reason to.`;
 
 const BRAKES_OFF = `Starting work has no limits right now: no cap on running sessions or starts, and no usage-window check. Saad's Pause still stops new starts; the start tools say so when it's on.`;
 
+const NO_APPROVALS = `## No approvals mode is ON
+
+Saad turned it on: nothing waits for him. Every \`ask_saad\` is approved the moment you raise it (the event says so), and so are escalated gates and brakes. That is his decision, not a reason to skip care: the hard lines still describe what is risky, so say in your chat what you are about to do before you do it, and keep to the PR's scope.
+
+`;
 const APPROVALS_ON = `Merge approvals are on: anything touching CI config, deploy scripts or secrets handling (and build and hook scripts like package.json, agent config like .claude/, or AgentOS's own security code) goes to Saad the same way, whatever the gates say, as does a diff too big to review whole.`;
 
 const APPROVALS_OFF = `Merge approvals are off: a PR touching CI config, deploy scripts, secrets handling, build and hook scripts, agent config or AgentOS's own security code merges through the gates like any other. Don't park those PRs as asks with \`ask_saad\`; sign them off when the gates pass. A diff too big to review whole is reviewed in parts, each against the task, and the review passes only if every part does; one too big even in parts goes to Saad.`;
@@ -74,7 +80,7 @@ Tasks are woken by AgentOS itself when a check fails on their PR's head (with th
 
 "Not yet" (CI running or settling, no review of this commit yet) is not a failure: wait for the event and try again. A failure counts against the task once per commit, whichever path judges that commit and however often (a review that blocks counts when its verdict arrives); the same gate failing again on a different commit goes to Saad, with a note in your chat, and from then on only he merges or drops that task. Don't retry it; say so in your chat and move on. ${mergeApprovalsOn() ? APPROVALS_ON : APPROVALS_OFF} \`land\` merges a whole stack only if every open item passes the same gates, and judges each one again at its own head right before merging it.
 
-## Brakes
+${noApprovalsOn() ? NO_APPROVALS : ""}## Brakes
 
 ${brakesEnabled() ? BRAKES_ON : BRAKES_OFF}
 

package/lib/orchestrator/merge-approvals.ts

@@ -8,6 +8,7 @@
 
 import { db } from "../db";
 import { markAllStatusDirty } from "../status/dirty";
+import { noApprovalsOn } from "../approvals/no-approvals";
 
 const KEY = "orchestrator.merge_approvals";
 
@@ -15,13 +16,21 @@ const KEY = "orchestrator.merge_approvals";
 // no CI, goes to Saad either way.
 export const APPROVAL_GATES: readonly string[] = ["sensitive", "size"];
 
-export function mergeApprovalsOn(): boolean {
+// The switch as Saad set it, whatever No approvals mode is doing.
+export function mergeApprovalsSetting(): boolean {
   const row = db
     .prepare(`SELECT value FROM settings WHERE key = ?`)
     .get(KEY) as { value: string } | undefined;
   return row?.value === "1";
 }
 
+// What the gates act on. No approvals mode reads it as off, so sensitive and
+// large PRs go through the gates, review included, rather than waiting for
+// a person (or being waved through unreviewed by an auto-approval).
+export function mergeApprovalsOn(): boolean {
+  return mergeApprovalsSetting() && !noApprovalsOn();
+}
+
 export function setMergeApprovals(on: boolean): void {
   db.prepare(
     `INSERT INTO settings (key, value) VALUES (?, ?)

package/lib/orchestrator/presence-binding.ts

@@ -10,6 +10,7 @@ export const askPresence = (askId: number, binding: string) =>
 export const resumePresence = (workspaceId: string) => `resume:${workspaceId}`;
 export const revokePresence = (passkeyId: string) => `revoke:${passkeyId}`;
 export const APPROVALS_OFF_PRESENCE = "approvals-off";
+export const NO_APPROVALS_ON_PRESENCE = "no-approvals-on";
 // Writing a workspace's standing rules as Saad.
 export const rulesPresence = (workspaceId: string) => `rules:${workspaceId}`;
 
@@ -38,6 +39,8 @@ export function presenceBinding(b: {
       return "enroll";
     case "approvals-off":
       return APPROVALS_OFF_PRESENCE;
+    case "no-approvals-on":
+      return NO_APPROVALS_ON_PRESENCE;
     case "rules":
       if (!b.workspaceId) throw new PresenceError("Which workspace?");
       return rulesPresence(b.workspaceId);

package/lib/orchestrator/review.ts

@@ -25,7 +25,11 @@ import { diffParts } from "./diff-parts";
 import { countFailure, escalate } from "./escalate";
 import { checkGate, holdingEscalations } from "./gates";
 import { reviewWanted } from "./held-review";
-import { mergeApprovalsOn } from "./merge-approvals";
+import { mergeApprovalsOn, mergeApprovalsSetting } from "./merge-approvals";
+import {
+  noApprovalsOn,
+  recordAutoApprovalOnce,
+} from "../approvals/no-approvals";
 import {
   baseReviewSkill,
   checkout,
@@ -99,6 +103,13 @@ async function reviewJob(
   const judged = target.refs.base_branch;
   const base = await fetchRefs(repo, target.refs);
   const diff = await fullDiff(repo, base, sha);
+  if (diff.length > DIFF_CAP && mergeApprovalsSetting() && noApprovalsOn())
+    recordAutoApprovalOnce({
+      source: "merge-approval",
+      workspaceId,
+      subject: `PR #${pr.number} at ${short(sha)} is reviewed in parts`,
+      detail: `its diff is ${diff.length} characters`,
+    });
   const parts =
     diff.length <= DIFF_CAP
       ? [diff]

package/lib/orchestrator/signoff.ts

@@ -36,7 +36,11 @@ import { latestApproval, refundApproval, spendApproval } from "./ask-approvals";
 import { workSubject } from "./asks";
 import { carryApproval } from "./approval-carry";
 import { heldVerdict } from "./held";
-import { mergeApprovalsOn } from "./merge-approvals";
+import { mergeApprovalsOn, mergeApprovalsSetting } from "./merge-approvals";
+import {
+  noApprovalsOn,
+  recordAutoApprovalOnce,
+} from "../approvals/no-approvals";
 import { isPaused } from "./pause";
 import { commitTime, fetchRefs, repoOf } from "./repo";
 import { repoHasCI } from "./repo-ci";
@@ -214,6 +218,16 @@ export async function gateVerdict(
   const base = await fetchRefs(repo, work.refs);
   const files = await changedFiles(repo, base, sha);
   const sensitive = mergeApprovalsOn() ? sensitiveFiles(files) : [];
+  if (mergeApprovalsSetting() && noApprovalsOn()) {
+    const held = sensitiveFiles(files);
+    if (held.length)
+      recordAutoApprovalOnce({
+        source: "merge-approval",
+        workspaceId,
+        subject: `PR #${pr.number} at ${short(sha)} goes through the gates`,
+        detail: `touches ${held.map((s) => s.path).join(", ")}`,
+      });
+  }
   if (sensitive.length) {
     const what = sensitive.map((s) => `${s.path} (${s.why})`).join(", ");
     const why = `PR #${pr.number} at ${short(sha)} touches ${what}`;