diff --git a/app/src/dev/seedRoutines.ts b/app/src/dev/seedRoutines.ts
index 617e4447..7c5347e9 100644
--- a/app/src/dev/seedRoutines.ts
+++ b/app/src/dev/seedRoutines.ts
@@ -27,6 +27,7 @@ export function seedRoutines(fake: FakeBotloft, bots: { scout: BotId; analyst: B
       messageId: null,
       createdAt: fake.now - 2 * HOUR,
       finishedAt: fake.now - HOUR,
+      signal: null,
       ...run,
     };
   };
@@ -62,4 +63,14 @@ export function seedRoutines(fake: FakeBotloft, bots: { scout: BotId; analyst: B
   });
   backup.enabled = false;
   backup.nextRunAt = null;
+
+  // Spec 20.13: runs when Analyst says the numbers are in.
+  const recheck = create(bots.scout, {
+    name: "Recheck the sources",
+    prompt: "The numbers changed: check that every claim in the report still has a source.",
+    schedule: { kind: "signal", name: "numbers-updated" },
+  });
+  lastRun(recheck, {
+    signal: { name: "numbers-updated", fromBotId: bots.analyst, note: null },
+  });
 }
diff --git a/app/src/features/routines/MoreOptions.tsx b/app/src/features/routines/MoreOptions.tsx
index 994fe16d..6801776a 100644
--- a/app/src/features/routines/MoreOptions.tsx
+++ b/app/src/features/routines/MoreOptions.tsx
@@ -1,6 +1,7 @@
 // "More options" in the routine form (spec 20.9): the time zone, what to
 // do when the last run has not finished or the computer was off, and a
-// cron expression for those who want one.
+// cron expression for those who want one. A routine that waits for a
+// signal (spec 20.13) has no time: only the overlap rule is left.
 
 import { ChevronRight } from "lucide-react";
 import { useT } from "../../i18n";
@@ -18,6 +19,7 @@ export function MoreOptions({
 }) {
   const d = useT().routines.dialog;
   const zones = allZones();
+  const timed = form.frequency !== "signal" || form.useCron;
   return (
     <details className="group rounded-xl border border-line">
       <summary className="flex cursor-default items-center gap-1.5 px-3 py-2 font-medium text-ink-soft text-sm hover:text-ink">
@@ -25,12 +27,14 @@ export function MoreOptions({
         {d.more}
       </summary>
       <div className="flex flex-col gap-4 border-line border-t px-3 py-3">
-        <SelectField
-          label={d.timezone}
-          value={form.timezone}
-          onChange={(event) => change({ timezone: event.target.value })}
-          options={zones.map((zone) => ({ value: zone, label: zoneLabel(zone) }))}
-        />
+        {timed && (
+          <SelectField
+            label={d.timezone}
+            value={form.timezone}
+            onChange={(event) => change({ timezone: event.target.value })}
+            options={zones.map((zone) => ({ value: zone, label: zoneLabel(zone) }))}
+          />
+        )}
         <div className="flex flex-col gap-1.5">
           <p className="font-medium text-ink-soft text-sm">{d.overlap}</p>
           <Choices
@@ -43,27 +47,31 @@ export function MoreOptions({
             onChange={(overlap) => change({ overlap })}
           />
         </div>
-        <div className="flex flex-col gap-1.5">
-          <p className="font-medium text-ink-soft text-sm">{d.missed}</p>
-          <Choices
-            label={d.missed}
-            value={form.missed}
-            options={[
-              { value: "run_once", label: d.missedRunOnce },
-              { value: "skip", label: d.missedSkip },
-            ]}
-            onChange={(missed) => change({ missed })}
-          />
-          <p className="text-muted text-xs">{d.wakeNote}</p>
-        </div>
-        <label className="flex items-center gap-2 text-sm">
-          <input
-            type="checkbox"
-            checked={form.useCron}
-            onChange={(event) => change({ useCron: event.target.checked })}
-          />
-          {d.advanced}
-        </label>
+        {timed && (
+          <div className="flex flex-col gap-1.5">
+            <p className="font-medium text-ink-soft text-sm">{d.missed}</p>
+            <Choices
+              label={d.missed}
+              value={form.missed}
+              options={[
+                { value: "run_once", label: d.missedRunOnce },
+                { value: "skip", label: d.missedSkip },
+              ]}
+              onChange={(missed) => change({ missed })}
+            />
+            <p className="text-muted text-xs">{d.wakeNote}</p>
+          </div>
+        )}
+        {timed && (
+          <label className="flex items-center gap-2 text-sm">
+            <input
+              type="checkbox"
+              checked={form.useCron}
+              onChange={(event) => change({ useCron: event.target.checked })}
+            />
+            {d.advanced}
+          </label>
+        )}
         {form.useCron && (
           <TextField
             label={d.cron}
diff --git a/app/src/features/routines/RoutineDialog.tsx b/app/src/features/routines/RoutineDialog.tsx
index e016ea01..40a5db19 100644
--- a/app/src/features/routines/RoutineDialog.tsx
+++ b/app/src/features/routines/RoutineDialog.tsx
@@ -89,7 +89,7 @@ export function RoutineDialog({ bot, routine, onClose }: Props) {
           placeholder={d.promptPlaceholder}
           required
         />
-        <ScheduleFields form={form} change={change} />
+        <ScheduleFields form={form} change={change} bot={bot.name} />
         <MoreOptions form={form} change={change} />
         {error && (
           <p role="alert" className="text-danger text-sm">
diff --git a/app/src/features/routines/RoutineRequestCard.tsx b/app/src/features/routines/RoutineRequestCard.tsx
index 59cc4b5c..5221c35f 100644
--- a/app/src/features/routines/RoutineRequestCard.tsx
+++ b/app/src/features/routines/RoutineRequestCard.tsx
@@ -132,7 +132,7 @@ export function RoutineRequestCard({ approval, bot }: { approval: ApprovalItem;
           rows={4}
           onChange={(event) => change({ prompt: event.target.value })}
         />
-        <ScheduleFields form={form} change={change} />
+        <ScheduleFields form={form} change={change} bot={runner.name} />
         <MoreOptions form={form} change={change} />
         <p className="text-muted text-xs">{r.explain(runner.name)}</p>
         {error && (
diff --git a/app/src/features/routines/RoutineRow.tsx b/app/src/features/routines/RoutineRow.tsx
index c461baf3..053ce9bc 100644
--- a/app/src/features/routines/RoutineRow.tsx
+++ b/app/src/features/routines/RoutineRow.tsx
@@ -73,9 +73,13 @@ export function RoutineRow({
           {describeSchedule(routine.schedule, r.when)}
           <span className="text-muted">
             {" · "}
-            {routine.enabled && routine.nextRunAt !== null
-              ? r.next(nextText(routine.nextRunAt, routine.timezone, r))
-              : r.off}
+            {!routine.enabled
+              ? r.off
+              : routine.schedule.kind === "signal"
+                ? r.waitsSignal
+                : routine.nextRunAt !== null
+                  ? r.next(nextText(routine.nextRunAt, routine.timezone, r))
+                  : r.off}
           </span>
         </p>
         {routine.lastRun && <LastRun run={routine.lastRun} words={r.last} />}
@@ -112,12 +116,18 @@ export function RoutineRow({
 
 function LastRun({ run, words }: { run: RoutineRun; words: Messages["routines"]["last"] }) {
   const line = "mt-1 flex items-center gap-1.5 text-xs";
+  // Who sent the signal it ran for (spec 20.13), while that bot is around.
+  const sender = useApp((state) =>
+    run.signal?.fromBotId ? (state.bots[run.signal.fromBotId]?.name ?? null) : null,
+  );
+  const from = sender && <span className="text-muted">· {words.signalFrom(sender)}</span>;
   switch (run.status) {
     case "queued":
       return (
         <p className={`${line} text-work`}>
           <LoaderCircle aria-hidden size={12} className="animate-spin" />
           {words.queued}
+          {from}
         </p>
       );
     case "done":
@@ -125,6 +135,7 @@ function LastRun({ run, words }: { run: RoutineRun; words: Messages["routines"][
         <p className={`${line} text-ok`}>
           <CircleCheck aria-hidden size={12} />
           {words.done}
+          {from}
         </p>
       );
     case "failed":
@@ -132,6 +143,7 @@ function LastRun({ run, words }: { run: RoutineRun; words: Messages["routines"][
         <p className={`${line} text-danger`}>
           <CircleAlert aria-hidden size={12} />
           {words.failed}
+          {from}
         </p>
       );
     case "skipped": {
@@ -140,11 +152,14 @@ function LastRun({ run, words }: { run: RoutineRun; words: Messages["routines"][
           ? words.missed(run.skippedCount)
           : run.reason === "bot_paused"
             ? words.bot_paused
-            : words.overlap;
+            : run.reason === "too_soon"
+              ? words.too_soon
+              : words.overlap;
       return (
         <p className={`${line} text-muted`}>
           <SkipForward aria-hidden size={12} />
           {text}
+          {from}
         </p>
       );
     }
diff --git a/app/src/features/routines/ScheduleFields.tsx b/app/src/features/routines/ScheduleFields.tsx
index dc6930ce..6b9f3101 100644
--- a/app/src/features/routines/ScheduleFields.tsx
+++ b/app/src/features/routines/ScheduleFields.tsx
@@ -13,18 +13,23 @@ const control =
 export function ScheduleFields({
   form,
   change,
+  bot,
 }: {
   form: RoutineForm;
   change(patch: Partial<RoutineForm>): void;
+  /** The bot's name, for the signal's hint. */
+  bot: string;
 }) {
   const d = useT().routines.dialog;
   const timeId = useId();
   const everyId = useId();
+  const signalId = useId();
   const frequencies: { value: Frequency; label: string }[] = [
     { value: "daily", label: d.frequency.daily },
     { value: "weekdays", label: d.frequency.weekdays },
     { value: "days", label: d.frequency.days },
     { value: "interval", label: d.frequency.interval },
+    { value: "signal", label: d.frequency.signal },
   ];
 
   const toggleDay = (day: number) =>
@@ -65,7 +70,24 @@ export function ScheduleFields({
           })}
         </fieldset>
       )}
-      {form.frequency === "interval" ? (
+      {form.frequency === "signal" ? (
+        <div className="flex flex-col gap-1.5">
+          <div className="flex items-center gap-2">
+            <label htmlFor={signalId} className="text-ink-soft text-sm">
+              {d.signal}
+            </label>
+            <input
+              id={signalId}
+              required
+              value={form.signal}
+              placeholder={d.signalPlaceholder}
+              onChange={(event) => change({ signal: event.target.value })}
+              className={`${control} w-56`}
+            />
+          </div>
+          <p className="text-muted text-xs">{d.signalHint(bot)}</p>
+        </div>
+      ) : form.frequency === "interval" ? (
         <div className="flex items-center gap-2">
           <label htmlFor={everyId} className="text-ink-soft text-sm">
             {d.every}
diff --git a/app/src/features/routines/describe.ts b/app/src/features/routines/describe.ts
index dd6e8fb6..7e7add02 100644
--- a/app/src/features/routines/describe.ts
+++ b/app/src/features/routines/describe.ts
@@ -51,6 +51,8 @@ export function describeSchedule(schedule: Schedule, words: Words["when"]): stri
         : words.everyMinutes(schedule.minutes);
     case "cron":
       return words.cron(schedule.expr);
+    case "signal":
+      return words.signal(schedule.name);
   }
 }
 
diff --git a/app/src/features/routines/form.ts b/app/src/features/routines/form.ts
index 3660817e..f703b7af 100644
--- a/app/src/features/routines/form.ts
+++ b/app/src/features/routines/form.ts
@@ -1,11 +1,11 @@
 // The routine form's fields and the schedule they stand for (spec 20.9):
-// every day, weekdays, chosen days or every N minutes or hours, or a cron
-// expression under "More options".
+// every day, weekdays, chosen days, every N minutes or hours, or when a
+// bot signals (spec 20.13), or a cron expression under "More options".
 
 import type { Missed, Overlap, Routine, Schedule } from "../../lib/protocol.gen";
 import { systemZone } from "./describe";
 
-export type Frequency = "daily" | "weekdays" | "days" | "interval";
+export type Frequency = "daily" | "weekdays" | "days" | "interval" | "signal";
 export type Unit = "minutes" | "hours";
 
 export interface RoutineForm {
@@ -23,6 +23,8 @@ export interface RoutineForm {
   missed: Missed;
   useCron: boolean;
   cron: string;
+  /** The signal the routine waits for. */
+  signal: string;
 }
 
 const EVERY_DAY = [1, 2, 3, 4, 5, 6, 7];
@@ -42,6 +44,7 @@ export function blankForm(): RoutineForm {
     missed: "run_once",
     useCron: false,
     cron: "",
+    signal: "",
   };
 }
 
@@ -86,6 +89,10 @@ export function formOf(routine: RoutineFields): RoutineForm {
       form.useCron = true;
       form.cron = schedule.expr;
       break;
+    case "signal":
+      form.frequency = "signal";
+      form.signal = schedule.name;
+      break;
   }
   return form;
 }
@@ -107,5 +114,7 @@ export function scheduleOf(form: RoutineForm): Schedule {
         kind: "interval",
         minutes: Math.round(form.every) * (form.unit === "hours" ? 60 : 1),
       };
+    case "signal":
+      return { kind: "signal", name: form.signal.trim() };
   }
 }
diff --git a/app/src/features/routines/routines.test.tsx b/app/src/features/routines/routines.test.tsx
index f9fbb878..fa1e4f6c 100644
--- a/app/src/features/routines/routines.test.tsx
+++ b/app/src/features/routines/routines.test.tsx
@@ -218,6 +218,7 @@ describe("failed runs", () => {
           messageId: null,
           createdAt: Date.now(),
           finishedAt: Date.now() + 1000,
+          signal: null,
         },
       });
     });
diff --git a/app/src/features/routines/signals.test.tsx b/app/src/features/routines/signals.test.tsx
new file mode 100644
index 00000000..0c19cb8f
--- /dev/null
+++ b/app/src/features/routines/signals.test.tsx
@@ -0,0 +1,85 @@
+import { act, cleanup, fireEvent, screen, within } from "@testing-library/react";
+import { afterEach, describe, expect, test } from "vitest";
+import { en } from "../../i18n/en";
+import { FakeBotloft } from "../../lib/fake";
+import { crewOpened, openBot, openTab, renderApp } from "../../test/app";
+import { describeSchedule } from "./describe";
+
+afterEach(cleanup);
+
+/** A crew "Ops" with @scout and @writer, open on Scout's routines. */
+async function openRoutines() {
+  const fake = new FakeBotloft();
+  const ops = fake.addCrew("Ops");
+  const scout = fake.addBot(ops.id, "Scout");
+  const writer = fake.addBot(ops.id, "Writer");
+  fake.setBotState(scout.id, "idle");
+  renderApp(fake);
+  await crewOpened("Ops");
+  openBot("Scout");
+  await screen.findByRole("list", { name: "Messages" });
+  openTab(/^Routines/);
+  return { fake, scout, writer };
+}
+
+describe("routines that wait for a signal", () => {
+  test("the schedule reads as the signal", () => {
+    expect(describeSchedule({ kind: "signal", name: "report-ready" }, en.routines.when)).toBe(
+      "When a bot signals “report-ready”",
+    );
+  });
+
+  test("the owner makes one, and a bot's signal runs it", async () => {
+    const { fake, writer } = await openRoutines();
+    fireEvent.click(screen.getByRole("button", { name: "New routine" }));
+    const dialog = screen.getByRole("dialog", { name: "New routine for Scout" });
+    fireEvent.change(within(dialog).getByLabelText("Name"), { target: { value: "Review" } });
+    fireEvent.change(within(dialog).getByLabelText("What should Scout do?"), {
+      target: { value: "Review the report" },
+    });
+    fireEvent.click(within(dialog).getByRole("radio", { name: "When a bot signals" }));
+    expect(within(dialog).queryByLabelText("At")).toBeNull();
+    expect(within(dialog).getByText(/Scout runs this when a bot of the crew/)).toBeDefined();
+    fireEvent.change(within(dialog).getByLabelText("Signal"), {
+      target: { value: "Report Ready" },
+    });
+    // No time: the zone and "computer off" have nothing to say.
+    fireEvent.click(within(dialog).getByText("More options"));
+    expect(within(dialog).queryByLabelText("Time zone")).toBeNull();
+    expect(within(dialog).queryByLabelText("Use a cron expression")).toBeNull();
+    fireEvent.click(within(dialog).getByRole("button", { name: "Create routine" }));
+
+    await screen.findByText("Review");
+    const params = fake.calls.find((call) => call.method === "routines.create")?.params;
+    expect(params).toMatchObject({ schedule: { kind: "signal", name: "Report Ready" } });
+    expect(screen.getByText(/When a bot signals “report-ready”/)).toBeDefined();
+    expect(screen.getByText(/Waits for a signal/)).toBeDefined();
+
+    act(() => {
+      fake.routines.signal(writer.id, "report-ready", "In shared/report.md");
+    });
+    expect(await screen.findByText("Running now")).toBeDefined();
+    expect(screen.getByText(/signal from Writer/)).toBeDefined();
+  });
+
+  test("editing one opens on its signal", async () => {
+    const { fake, scout } = await openRoutines();
+    act(() => {
+      fake.routines.handlers()["routines.create"]({
+        botId: scout.id,
+        name: "Review",
+        prompt: "Review the report",
+        schedule: { kind: "signal", name: "report-ready" },
+        timezone: "UTC",
+      });
+    });
+    fireEvent.click(await screen.findByRole("button", { name: "More actions for Review" }));
+    fireEvent.click(screen.getByRole("menuitem", { name: "Edit" }));
+    const dialog = screen.getByRole("dialog", { name: "Edit Review" });
+    expect(within(dialog).getByRole("radio", { name: "When a bot signals" })).toHaveProperty(
+      "checked",
+      true,
+    );
+    expect(within(dialog).getByLabelText("Signal")).toHaveProperty("value", "report-ready");
+  });
+});
diff --git a/app/src/i18n/en/routines.ts b/app/src/i18n/en/routines.ts
index 01cff2e2..ed796c15 100644
--- a/app/src/i18n/en/routines.ts
+++ b/app/src/i18n/en/routines.ts
@@ -15,6 +15,7 @@ export const routines = {
   more: (name: string) => `More actions for ${name}`,
   next: (time: string) => `Next: ${time}`,
   off: "Off",
+  waitsSignal: "Waits for a signal",
   today: (time: string) => `today at ${time}`,
   tomorrow: (time: string) => `tomorrow at ${time}`,
   onDay: (day: string, time: string) => `${day} at ${time}`,
@@ -24,6 +25,8 @@ export const routines = {
     failed: "Last run failed",
     overlap: "Last time was skipped: the run before hadn't finished",
     bot_paused: "Last time was skipped: the bot was paused",
+    too_soon: "Last signal was skipped: it came less than 5 minutes after the one before",
+    signalFrom: (bot: string) => `signal from ${bot}`,
     missed: (count: number) =>
       count === 1
         ? "Last time was skipped: the computer was off"
@@ -37,6 +40,7 @@ export const routines = {
     everyMinutes: (count: number) => (count === 1 ? "Every minute" : `Every ${count} minutes`),
     everyHours: (count: number) => (count === 1 ? "Every hour" : `Every ${count} hours`),
     cron: (expr: string) => `Cron: ${expr}`,
+    signal: (name: string) => `When a bot signals “${name}”`,
   },
   tag: (name: string) => `Routine · ${name}`,
   dialog: {
@@ -52,6 +56,7 @@ export const routines = {
       weekdays: "Weekdays",
       days: "Chosen days",
       interval: "Every…",
+      signal: "When a bot signals",
     },
     at: "At",
     every: "Every",
@@ -68,6 +73,10 @@ export const routines = {
     wakeNote: "Botloft doesn't wake the computer to run a routine.",
     advanced: "Use a cron expression",
     cron: "Cron expression",
+    signal: "Signal",
+    signalPlaceholder: "report-ready",
+    signalHint: (bot: string) =>
+      `${bot} runs this when a bot of the crew sends this signal. Tell that bot, in its instructions, when to send it, like “send report-ready when the report is saved”.`,
     cronHint: "Minute, hour, day of the month, month and day of the week. It replaces When.",
     create: "Create routine",
     save: "Save",
@@ -80,6 +89,7 @@ export const routines = {
       cron_invalid: "That cron expression isn't valid.",
       too_often: "Runs must be at least 5 minutes apart.",
       never_runs: "This schedule never runs.",
+      signal_invalid: "A signal needs letters or digits, like report-ready.",
     },
   },
   removeTitle: (name: string) => `Delete ${name}?`,
diff --git a/app/src/i18n/es/routines.ts b/app/src/i18n/es/routines.ts
index cb984990..4f1c06c5 100644
--- a/app/src/i18n/es/routines.ts
+++ b/app/src/i18n/es/routines.ts
@@ -17,6 +17,7 @@ export const routines: Messages["routines"] = {
   more: (name: string) => `Más acciones de ${name}`,
   next: (time: string) => `Próxima: ${time}`,
   off: "Apagada",
+  waitsSignal: "Espera un aviso",
   today: (time: string) => `hoy a las ${time}`,
   tomorrow: (time: string) => `mañana a las ${time}`,
   onDay: (day: string, time: string) => `${day} a las ${time}`,
@@ -26,6 +27,8 @@ export const routines: Messages["routines"] = {
     failed: "La última falló",
     overlap: "La última vez se saltó: la anterior no había terminado",
     bot_paused: "La última vez se saltó: el bot estaba en pausa",
+    too_soon: "El último aviso se saltó: llegó menos de 5 minutos después del anterior",
+    signalFrom: (bot: string) => `aviso de ${bot}`,
     missed: (count: number) =>
       count === 1
         ? "La última vez se saltó: el ordenador estaba apagado"
@@ -39,6 +42,7 @@ export const routines: Messages["routines"] = {
     everyMinutes: (count: number) => (count === 1 ? "Cada minuto" : `Cada ${count} minutos`),
     everyHours: (count: number) => (count === 1 ? "Cada hora" : `Cada ${count} horas`),
     cron: (expr: string) => `Cron: ${expr}`,
+    signal: (name: string) => `Cuando un bot avise “${name}”`,
   },
   tag: (name: string) => `Rutina · ${name}`,
   dialog: {
@@ -54,6 +58,7 @@ export const routines: Messages["routines"] = {
       weekdays: "Días laborables",
       days: "Días elegidos",
       interval: "Cada…",
+      signal: "Cuando un bot avise",
     },
     at: "A las",
     every: "Cada",
@@ -70,6 +75,10 @@ export const routines: Messages["routines"] = {
     wakeNote: "Botloft no enciende el ordenador para ejecutar una rutina.",
     advanced: "Usar una expresión cron",
     cron: "Expresión cron",
+    signal: "Aviso",
+    signalPlaceholder: "informe-listo",
+    signalHint: (bot: string) =>
+      `${bot} hace esto cuando un bot del equipo manda este aviso. Dile a ese bot, en sus instrucciones, cuándo avisar, como “avisa informe-listo cuando guardes el informe”.`,
     cronHint: "Minuto, hora, día del mes, mes y día de la semana. Sustituye a Cuándo.",
     create: "Crear rutina",
     save: "Guardar",
@@ -82,6 +91,7 @@ export const routines: Messages["routines"] = {
       cron_invalid: "Esa expresión cron no es válida.",
       too_often: "Las ejecuciones deben tener al menos 5 minutos entre sí.",
       never_runs: "Ese horario nunca ocurre.",
+      signal_invalid: "El aviso necesita letras o números, como informe-listo.",
     },
   },
   removeTitle: (name: string) => `¿Eliminar ${name}?`,
diff --git a/app/src/i18n/pt-BR/routines.ts b/app/src/i18n/pt-BR/routines.ts
index e77b77b8..f1779bfc 100644
--- a/app/src/i18n/pt-BR/routines.ts
+++ b/app/src/i18n/pt-BR/routines.ts
@@ -17,6 +17,7 @@ export const routines: Messages["routines"] = {
   more: (name: string) => `Mais ações de ${name}`,
   next: (time: string) => `Próxima: ${time}`,
   off: "Desligada",
+  waitsSignal: "Espera um aviso",
   today: (time: string) => `hoje às ${time}`,
   tomorrow: (time: string) => `amanhã às ${time}`,
   onDay: (day: string, time: string) => `${day} às ${time}`,
@@ -26,6 +27,8 @@ export const routines: Messages["routines"] = {
     failed: "A última falhou",
     overlap: "A última vez foi pulada: a anterior ainda não tinha terminado",
     bot_paused: "A última vez foi pulada: o bot estava pausado",
+    too_soon: "O último aviso foi pulado: chegou menos de 5 minutos depois do anterior",
+    signalFrom: (bot: string) => `aviso de ${bot}`,
     missed: (count: number) =>
       count === 1
         ? "A última vez foi pulada: o computador estava desligado"
@@ -39,6 +42,7 @@ export const routines: Messages["routines"] = {
     everyMinutes: (count: number) => (count === 1 ? "A cada minuto" : `A cada ${count} minutos`),
     everyHours: (count: number) => (count === 1 ? "A cada hora" : `A cada ${count} horas`),
     cron: (expr: string) => `Cron: ${expr}`,
+    signal: (name: string) => `Quando um bot avisar “${name}”`,
   },
   tag: (name: string) => `Rotina · ${name}`,
   dialog: {
@@ -54,6 +58,7 @@ export const routines: Messages["routines"] = {
       weekdays: "Dias úteis",
       days: "Dias escolhidos",
       interval: "A cada…",
+      signal: "Quando um bot avisar",
     },
     at: "Às",
     every: "A cada",
@@ -70,6 +75,10 @@ export const routines: Messages["routines"] = {
     wakeNote: "O Botloft não liga o computador para rodar uma rotina.",
     advanced: "Usar uma expressão cron",
     cron: "Expressão cron",
+    signal: "Aviso",
+    signalPlaceholder: "relatorio-pronto",
+    signalHint: (bot: string) =>
+      `${bot} faz isto quando um bot da equipe mandar esse aviso. Diga a esse bot, nas instruções dele, quando avisar, como “avise relatorio-pronto quando salvar o relatório”.`,
     cronHint: "Minuto, hora, dia do mês, mês e dia da semana. Ela substitui o Quando.",
     create: "Criar rotina",
     save: "Salvar",
@@ -82,6 +91,7 @@ export const routines: Messages["routines"] = {
       cron_invalid: "Essa expressão cron não é válida.",
       too_often: "As execuções precisam de pelo menos 5 minutos entre si.",
       never_runs: "Esse horário nunca acontece.",
+      signal_invalid: "O aviso precisa de letras ou números, como relatorio-pronto.",
     },
   },
   removeTitle: (name: string) => `Apagar ${name}?`,
diff --git a/app/src/lib/fakeRoutines.ts b/app/src/lib/fakeRoutines.ts
index 9472295a..9c5de535 100644
--- a/app/src/lib/fakeRoutines.ts
+++ b/app/src/lib/fakeRoutines.ts
@@ -1,10 +1,17 @@
 // The fake daemon's `routines.*` methods (spec 20.8): routines kept in
-// memory, with "run now" sending the routine's message to the bot. The
-// schedule itself is the daemon's business and is not played here.
+// memory, with "run now" sending the routine's message to the bot, and
+// `signal` playing a bot's `send_signal` (spec 20.13). The schedule itself
+// is the daemon's business and is not played here.
 
 import type { FakeBotloft, Handlers } from "./fake";
-import { conflict, invalid, notFound } from "./fakeRules";
-import type { Routine, RoutineId, RoutineRun } from "./protocol.gen";
+import { conflict, invalid, notFound, slugify } from "./fakeRules";
+import type { BotId, Routine, RoutineId, RoutineRun, RunSignal, Schedule } from "./protocol.gen";
+
+const HOUR = 60 * 60_000;
+
+/** A signal's name normalized, as the daemon keeps it. */
+const kept = (schedule: Schedule): Schedule =>
+  schedule.kind === "signal" ? { kind: "signal", name: slugify(schedule.name, "") } : schedule;
 
 type RoutineMethods = Extract<keyof Handlers, `routines.${string}`>;
 
@@ -31,12 +38,12 @@ export class FakeRoutines {
           botId,
           name: name.trim(),
           prompt,
-          schedule,
+          schedule: kept(schedule),
           timezone,
           overlap: overlap ?? "skip",
           missed: missed ?? "run_once",
           enabled: true,
-          nextRunAt: this.fake.now + 60 * 60_000,
+          nextRunAt: schedule.kind === "signal" ? null : this.fake.now + HOUR,
           lastRun: null,
           createdAt: this.fake.now,
           updatedAt: this.fake.now,
@@ -49,43 +56,23 @@ export class FakeRoutines {
         const routine = this.routine(routineId);
         for (const [key, value] of Object.entries(changes)) {
           if (value !== undefined) {
-            Object.assign(routine, { [key]: value });
+            Object.assign(routine, { [key]: key === "schedule" ? kept(value as Schedule) : value });
           }
         }
+        if (routine.schedule.kind === "signal") {
+          routine.nextRunAt = null;
+        }
         routine.updatedAt = this.fake.now;
         return this.changed(routine);
       },
       "routines.setEnabled": ({ routineId, enabled }) => {
         const routine = this.routine(routineId);
         routine.enabled = enabled;
-        routine.nextRunAt = enabled ? this.fake.now + 60 * 60_000 : null;
+        routine.nextRunAt =
+          enabled && routine.schedule.kind !== "signal" ? this.fake.now + HOUR : null;
         return this.changed(routine);
       },
-      "routines.runNow": ({ routineId }) => {
-        const routine = this.routine(routineId);
-        const { message } = this.fake.conversation.say({
-          to: routine.botId,
-          body: routine.prompt,
-          kind: "routine",
-        });
-        message.routineId = routine.id;
-        const run: RoutineRun = {
-          id: this.fake.id("rrn"),
-          routineId,
-          scheduledFor: this.fake.now,
-          status: "queued",
-          reason: null,
-          skippedCount: 0,
-          messageId: message.id,
-          createdAt: this.fake.now,
-          finishedAt: null,
-        };
-        this.runs.push(run);
-        routine.lastRun = run;
-        this.fake.emit({ name: "routine.run", params: run });
-        this.changed(routine);
-        return run;
-      },
+      "routines.runNow": ({ routineId }) => this.run(this.routine(routineId), null),
       "routines.archive": ({ routineId }) => {
         const routine = this.routine(routineId, false);
         if (routine.archivedAt === null) {
@@ -105,6 +92,48 @@ export class FakeRoutines {
     };
   }
 
+  /** A bot sends a signal: the crew's enabled routines waiting for it run. */
+  signal(from: BotId, name: string, note: string | null = null): RoutineRun[] {
+    const crew = this.fake.bot(from).crewId;
+    const signal: RunSignal = { name: slugify(name, ""), fromBotId: from, note };
+    return [...this.routines.values()]
+      .filter(
+        (routine) =>
+          routine.enabled &&
+          routine.archivedAt === null &&
+          routine.schedule.kind === "signal" &&
+          routine.schedule.name === signal.name &&
+          this.fake.bots.get(routine.botId)?.crewId === crew,
+      )
+      .map((routine) => this.run(routine, signal));
+  }
+
+  private run(routine: Routine, signal: RunSignal | null): RoutineRun {
+    const { message } = this.fake.conversation.say({
+      to: routine.botId,
+      body: routine.prompt,
+      kind: "routine",
+    });
+    message.routineId = routine.id;
+    const run: RoutineRun = {
+      id: this.fake.id("rrn"),
+      routineId: routine.id,
+      scheduledFor: this.fake.now,
+      status: "queued",
+      reason: null,
+      skippedCount: 0,
+      messageId: message.id,
+      createdAt: this.fake.now,
+      finishedAt: null,
+      signal,
+    };
+    this.runs.push(run);
+    routine.lastRun = run;
+    this.fake.emit({ name: "routine.run", params: run });
+    this.changed(routine);
+    return run;
+  }
+
   private routine(id: RoutineId, active = true): Routine {
     const routine = this.routines.get(id);
     if (!routine) {
diff --git a/app/src/lib/protocol.gen.ts b/app/src/lib/protocol.gen.ts
index da62bf4f..0efc3d80 100644
--- a/app/src/lib/protocol.gen.ts
+++ b/app/src/lib/protocol.gen.ts
@@ -1067,7 +1067,7 @@ approvalWaitMinutes?: number, };
  * When a routine runs (spec 20.2), kept as structure rather than cron text
  * so the app can show and edit it without jargon.
  */
-export type Schedule = { "kind": "weekly", days: Array<number>, time: string, } | { "kind": "interval", minutes: number, } | { "kind": "cron", expr: string, };
+export type Schedule = { "kind": "weekly", days: Array<number>, time: string, } | { "kind": "interval", minutes: number, } | { "kind": "cron", expr: string, } | { "kind": "signal", name: string, };
 
 /**
  * What happens when a routine's time comes while its last run is still
@@ -1089,7 +1089,20 @@ export type RunStatus = "queued" | "done" | "failed" | "skipped";
 /**
  * Why a run was skipped.
  */
-export type SkipReason = "overlap" | "bot_paused" | "missed";
+export type SkipReason = "overlap" | "bot_paused" | "missed" | "too_soon";
+
+/**
+ * A signal a bot sent (spec 20.13).
+ */
+export type RunSignal = { name: string, 
+/**
+ * The bot that sent it; `null` once that bot was deleted.
+ */
+fromBotId: BotId | null, 
+/**
+ * What the bot wrote with it.
+ */
+note: string | null, };
 
 export type RoutineRun = { id: RoutineRunId, routineId: RoutineId, 
 /**
@@ -1103,7 +1116,11 @@ skippedCount: number,
 /**
  * The message it sent, unless skipped.
  */
-messageId: MessageId | null, createdAt: number, finishedAt: number | null, };
+messageId: MessageId | null, createdAt: number, finishedAt: number | null, 
+/**
+ * The signal that made it run, for a routine that waits for one.
+ */
+signal: RunSignal | null, };
 
 export type Routine = { id: RoutineId, botId: BotId, name: string, 
 /**
diff --git a/crates/botloft-core/src/envelope.rs b/crates/botloft-core/src/envelope.rs
index cc600987..8336b57d 100644
--- a/crates/botloft-core/src/envelope.rs
+++ b/crates/botloft-core/src/envelope.rs
@@ -77,19 +77,52 @@ impl Envelope<'_> {
 #[derive(Debug, Clone, Copy)]
 pub struct RoutineEnvelope<'a> {
     pub name: &'a str,
-    /// Local time in the routine's zone, like `2026-10-01 09:00`.
-    pub scheduled: &'a str,
-    pub timezone: &'a str,
+    pub when: RoutineWhen<'a>,
     pub body: &'a str,
 }
 
+/// What made a routine run.
+#[derive(Debug, Clone, Copy)]
+pub enum RoutineWhen<'a> {
+    /// Its time came, or the owner clicked "Run now".
+    Scheduled {
+        /// Local time in the routine's zone, like `2026-10-01 09:00`.
+        at: &'a str,
+        timezone: &'a str,
+    },
+    /// A bot of the crew sent the signal it waits for (spec 20.13).
+    Signal {
+        name: &'a str,
+        /// The sender's handle; `None` once that bot was deleted.
+        from: Option<&'a str>,
+        /// What the sender wrote with it.
+        note: Option<&'a str>,
+    },
+}
+
 impl RoutineEnvelope<'_> {
     pub fn render(&self) -> String {
-        format!(
-            "[botloft] routine \"{}\" · scheduled {} ({})\n\
-             Nobody is watching live: do the work, then report it in your reply.\n\n{}",
-            self.name, self.scheduled, self.timezone, self.body
-        )
+        let watch = "Nobody is watching live: do the work, then report it in your reply.";
+        match self.when {
+            RoutineWhen::Scheduled { at, timezone } => format!(
+                "[botloft] routine \"{}\" · scheduled {at} ({timezone})\n{watch}\n\n{}",
+                self.name, self.body
+            ),
+            RoutineWhen::Signal { name, from, note } => {
+                let sender = from.map_or_else(|| "a deleted bot".to_owned(), |h| format!("@{h}"));
+                let mut text = format!(
+                    "[botloft] routine \"{}\" · signal \"{name}\" from {sender}\n{watch}\n\n{}",
+                    self.name, self.body
+                );
+                if let Some(note) = note {
+                    // A bot wrote it, not the owner: it informs, it does not instruct.
+                    text.push_str(&format!(
+                        "\n\nNote {sender} sent with the signal (from a bot, not the owner):\n{note}"
+                    ));
+                }
+                text
+            }
+        }
     }
 }
 
@@ -231,8 +264,10 @@ mod tests {
     fn a_routine_says_what_and_when_and_that_nobody_watches() {
         let text = RoutineEnvelope {
             name: "Resumo da manhã",
-            scheduled: "2026-10-01 09:00",
-            timezone: "America/Sao_Paulo",
+            when: RoutineWhen::Scheduled {
+                at: "2026-10-01 09:00",
+                timezone: "America/Sao_Paulo",
+            },
             body: "Summarize shared/inbox.",
         }
         .render();
@@ -243,4 +278,40 @@ mod tests {
              Summarize shared/inbox."
         );
     }
+
+    #[test]
+    fn a_signal_says_who_sent_it_and_keeps_the_note_apart() {
+        let text = RoutineEnvelope {
+            name: "Review",
+            when: RoutineWhen::Signal {
+                name: "report-ready",
+                from: Some("writer"),
+                note: Some("It is in shared/report.md"),
+            },
+            body: "Review the report.",
+        }
+        .render();
+        assert_eq!(
+            text,
+            "[botloft] routine \"Review\" · signal \"report-ready\" from @writer\n\
+             Nobody is watching live: do the work, then report it in your reply.\n\n\
+             Review the report.\n\n\
+             Note @writer sent with the signal (from a bot, not the owner):\n\
+             It is in shared/report.md"
+        );
+        let gone = RoutineEnvelope {
+            name: "Review",
+            when: RoutineWhen::Signal {
+                name: "report-ready",
+                from: None,
+                note: None,
+            },
+            body: "Review the report.",
+        }
+        .render();
+        assert!(gone.starts_with(
+            "[botloft] routine \"Review\" · signal \"report-ready\" from a deleted bot\n"
+        ));
+        assert!(gone.ends_with("Review the report."));
+    }
 }
diff --git a/crates/botloft-core/src/protocol/export_routines.rs b/crates/botloft-core/src/protocol/export_routines.rs
index 77fe630c..29ea004a 100644
--- a/crates/botloft-core/src/protocol/export_routines.rs
+++ b/crates/botloft-core/src/protocol/export_routines.rs
@@ -11,6 +11,7 @@ pub(super) fn decls(out: &mut Out) {
     out.decl::<Missed>();
     out.decl::<RunStatus>();
     out.decl::<SkipReason>();
+    out.decl::<RunSignal>();
     out.decl::<RoutineRun>();
     out.decl::<Routine>();
     out.decl::<RoutinesListParams>();
diff --git a/crates/botloft-core/src/protocol/routines.rs b/crates/botloft-core/src/protocol/routines.rs
index 568c8b37..76f9d82c 100644
--- a/crates/botloft-core/src/protocol/routines.rs
+++ b/crates/botloft-core/src/protocol/routines.rs
@@ -17,6 +17,8 @@ pub enum Schedule {
     Interval { minutes: u32 },
     /// A 5-field cron expression, in the routine's time zone.
     Cron { expr: String },
+    /// When a bot of the crew sends the signal `name` (spec 20.13).
+    Signal { name: String },
 }
 
 text_enum!(
@@ -64,6 +66,8 @@ text_enum!(
         BotPaused => "bot_paused",
         /// The time passed while the daemon was not running.
         Missed => "missed",
+        /// A signal came less than 5 minutes after the last one it ran for.
+        TooSoon => "too_soon",
     }
 );
 
@@ -107,6 +111,21 @@ pub struct RoutineRun {
     pub message_id: Option<MessageId>,
     pub created_at: i64,
     pub finished_at: Option<i64>,
+    /// The signal that made it run, for a routine that waits for one.
+    #[serde(default)]
+    pub signal: Option<RunSignal>,
+}
+
+/// A signal a bot sent (spec 20.13).
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[cfg_attr(test, derive(ts_rs::TS))]
+pub struct RunSignal {
+    pub name: String,
+    /// The bot that sent it; `null` once that bot was deleted.
+    pub from_bot_id: Option<BotId>,
+    /// What the bot wrote with it.
+    pub note: Option<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
diff --git a/crates/botloft-store/migrations/0017_routine_signals.sql b/crates/botloft-store/migrations/0017_routine_signals.sql
new file mode 100644
index 00000000..be631ce6
--- /dev/null
+++ b/crates/botloft-store/migrations/0017_routine_signals.sql
@@ -0,0 +1,10 @@
+-- Signals between bots (spec 20.13): a run a signal caused keeps which
+-- signal, who sent it (no foreign key: a deleted sender only leaves its
+-- id behind) and the note that came with it.
+
+ALTER TABLE routine_runs ADD COLUMN signal_name TEXT;
+ALTER TABLE routine_runs ADD COLUMN signal_from TEXT;
+ALTER TABLE routine_runs ADD COLUMN signal_note TEXT;
+
+CREATE INDEX routine_runs_signal ON routine_runs (routine_id, created_at)
+    WHERE signal_name IS NOT NULL;
diff --git a/crates/botloft-store/src/delete/tests.rs b/crates/botloft-store/src/delete/tests.rs
index 77ddd0dc..f244f3e6 100644
--- a/crates/botloft-store/src/delete/tests.rs
+++ b/crates/botloft-store/src/delete/tests.rs
@@ -144,6 +144,7 @@ fn fill(fx: &Fixture) -> Owned {
         message_id: Some(fired.id.clone()),
         created_at: 100,
         finished_at: None,
+        signal: None,
     };
     fx.store.fire_run(&run, &fired, &delivery).expect("run");
 
diff --git a/crates/botloft-store/src/lib.rs b/crates/botloft-store/src/lib.rs
index 680fcf0d..9fd894c3 100644
--- a/crates/botloft-store/src/lib.rs
+++ b/crates/botloft-store/src/lib.rs
@@ -20,6 +20,7 @@ mod questions;
 mod routine_runs;
 mod routines;
 mod search;
+mod signals;
 mod tasks;
 mod usage;
 
diff --git a/crates/botloft-store/src/migrate.rs b/crates/botloft-store/src/migrate.rs
index a7f324b1..178dace7 100644
--- a/crates/botloft-store/src/migrate.rs
+++ b/crates/botloft-store/src/migrate.rs
@@ -23,6 +23,7 @@ const MIGRATIONS: &[(u32, &str)] = &[
     (14, include_str!("../migrations/0014_allow_rules.sql")),
     (15, include_str!("../migrations/0015_questions.sql")),
     (16, include_str!("../migrations/0016_chat_search.sql")),
+    (17, include_str!("../migrations/0017_routine_signals.sql")),
 ];
 
 /// Schema version after every migration has run.
diff --git a/crates/botloft-store/src/routine_runs.rs b/crates/botloft-store/src/routine_runs.rs
index 60791c15..6b1350fc 100644
--- a/crates/botloft-store/src/routine_runs.rs
+++ b/crates/botloft-store/src/routine_runs.rs
@@ -1,14 +1,15 @@
 //! `routine_runs` table (spec 20.7). A run that sends a message is saved
 //! with that message, its delivery and the chat item, in one transaction.
 
+use botloft_core::ids::BotId;
 use botloft_core::ids::{MessageId, RoutineId, RoutineRunId};
-use botloft_core::protocol::{ChatItem, Delivery, Message, RoutineRun, RunStatus};
+use botloft_core::protocol::{ChatItem, Delivery, Message, RoutineRun, RunSignal, RunStatus};
 use rusqlite::{OptionalExtension, Row, params};
 
 use crate::messages::optional_column;
 use crate::{Result, Store, parse_column};
 
-pub(crate) const RUN_COLUMNS: &str = "id, routine_id, scheduled_for, status, reason, skipped_count, message_id, created_at, finished_at";
+pub(crate) const RUN_COLUMNS: &str = "id, routine_id, scheduled_for, status, reason, skipped_count, message_id, created_at, finished_at, signal_name, signal_from, signal_note";
 
 pub(crate) fn run_from_row(row: &Row<'_>) -> rusqlite::Result<RoutineRun> {
     Ok(RoutineRun {
@@ -21,6 +22,14 @@ pub(crate) fn run_from_row(row: &Row<'_>) -> rusqlite::Result<RoutineRun> {
         message_id: optional_column(row, 6)?,
         created_at: row.get(7)?,
         finished_at: row.get(8)?,
+        signal: match row.get::<_, Option<String>>(9)? {
+            Some(name) => Some(RunSignal {
+                name,
+                from_bot_id: optional_column(row, 10)?,
+                note: row.get(11)?,
+            }),
+            None => None,
+        },
     })
 }
 
@@ -48,7 +57,7 @@ impl Store {
     fn insert_run_in(conn: &rusqlite::Connection, run: &RoutineRun) -> Result<()> {
         conn.execute(
             &format!(
-                "INSERT INTO routine_runs ({RUN_COLUMNS}) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)"
+                "INSERT INTO routine_runs ({RUN_COLUMNS}) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)"
             ),
             params![
                 run.id.as_str(),
@@ -60,6 +69,12 @@ impl Store {
                 run.message_id.as_ref().map(MessageId::as_str),
                 run.created_at,
                 run.finished_at,
+                run.signal.as_ref().map(|signal| signal.name.as_str()),
+                run.signal
+                    .as_ref()
+                    .and_then(|signal| signal.from_bot_id.as_ref())
+                    .map(BotId::as_str),
+                run.signal.as_ref().and_then(|signal| signal.note.as_deref()),
             ],
         )?;
         Ok(())
diff --git a/crates/botloft-store/src/routines.rs b/crates/botloft-store/src/routines.rs
index 8d6fa356..5f7cd14a 100644
--- a/crates/botloft-store/src/routines.rs
+++ b/crates/botloft-store/src/routines.rs
@@ -7,9 +7,9 @@ use rusqlite::{OptionalExtension, Row, params};
 
 use crate::{Result, Store, parse_column};
 
-const COLUMNS: &str = "id, bot_id, name, prompt, schedule, timezone, overlap, missed, enabled, \
+pub(crate) const COLUMNS: &str = "id, bot_id, name, prompt, schedule, timezone, overlap, missed, enabled, \
      next_run_at, created_at, updated_at, archived_at";
-fn from_row(row: &Row<'_>) -> rusqlite::Result<Routine> {
+pub(crate) fn from_row(row: &Row<'_>) -> rusqlite::Result<Routine> {
     let schedule: String = row.get(4)?;
     let schedule: Schedule = serde_json::from_str(&schedule)
         .map_err(|err| rusqlite::Error::FromSqlConversionFailure(4, Type::Text, Box::new(err)))?;
diff --git a/crates/botloft-store/src/routines/tests.rs b/crates/botloft-store/src/routines/tests.rs
index 9f870851..34059cd0 100644
--- a/crates/botloft-store/src/routines/tests.rs
+++ b/crates/botloft-store/src/routines/tests.rs
@@ -36,6 +36,7 @@ fn run(routine: &Routine, status: RunStatus, message: Option<MessageId>) -> Rout
         message_id: message,
         created_at: 100,
         finished_at: None,
+        signal: None,
     }
 }
 
diff --git a/crates/botloft-store/src/signals.rs b/crates/botloft-store/src/signals.rs
new file mode 100644
index 00000000..0fa9ab9d
--- /dev/null
+++ b/crates/botloft-store/src/signals.rs
@@ -0,0 +1,35 @@
+//! Routines that wait for a signal from a bot of their crew (spec 20.13).
+
+use botloft_core::ids::{CrewId, RoutineId};
+use botloft_core::protocol::Routine;
+use rusqlite::params;
+
+use crate::routines::{COLUMNS, from_row};
+use crate::{Result, Store};
+
+impl Store {
+    /// The enabled routines of active bots in `crew` that wait for a
+    /// signal: all of them, or only those for `name`. In creation order.
+    pub fn signal_routines(&self, crew: &CrewId, name: Option<&str>) -> Result<Vec<Routine>> {
+        let mut stmt = self.conn.prepare_cached(&format!(
+            "SELECT {COLUMNS} FROM routines \
+             WHERE enabled AND archived_at IS NULL \
+               AND json_extract(schedule, '$.kind') = 'signal' \
+               AND (?2 IS NULL OR json_extract(schedule, '$.name') = ?2) \
+               AND bot_id IN (SELECT id FROM bots WHERE crew_id = ?1 AND archived_at IS NULL) \
+             ORDER BY created_at, id"
+        ))?;
+        let rows = stmt.query_map(params![crew.as_str(), name], from_row)?;
+        Ok(rows.collect::<rusqlite::Result<_>>()?)
+    }
+
+    /// When a signal last made the routine run (a skip does not count).
+    pub fn last_signal_run_at(&self, routine: &RoutineId) -> Result<Option<i64>> {
+        Ok(self.conn.query_row(
+            "SELECT MAX(created_at) FROM routine_runs \
+             WHERE routine_id = ?1 AND signal_name IS NOT NULL AND status != 'skipped'",
+            [routine.as_str()],
+            |row| row.get(0),
+        )?)
+    }
+}
diff --git a/crates/botloftd/src/courier/context.rs b/crates/botloftd/src/courier/context.rs
index 00122be5..8e8ca7dd 100644
--- a/crates/botloftd/src/courier/context.rs
+++ b/crates/botloftd/src/courier/context.rs
@@ -1,16 +1,52 @@
 //! What the courier reads besides the message to write its line: the
 //! routine that sent it (spec 20.5) or the question it answers (spec 23.4).
 
+use botloft_core::envelope::{RoutineEnvelope, RoutineWhen};
 use botloft_core::protocol::Message;
 use botloft_store::{Store, StoreError};
 
 use crate::routines;
 
-/// A routine's name, the local time the run is for and the zone.
+/// The routine that sent a message and what made it run.
+pub(super) struct RoutineContext {
+    name: String,
+    trigger: Trigger,
+}
+
+enum Trigger {
+    /// The local time the run is for, and the zone.
+    Scheduled { at: String, timezone: String },
+    /// The signal, the sender's handle (gone with a deleted bot) and the note.
+    Signal {
+        name: String,
+        from: Option<String>,
+        note: Option<String>,
+    },
+}
+
+impl RoutineContext {
+    pub(super) fn envelope<'a>(&'a self, body: &'a str) -> RoutineEnvelope<'a> {
+        let when = match &self.trigger {
+            Trigger::Scheduled { at, timezone } => RoutineWhen::Scheduled { at, timezone },
+            Trigger::Signal { name, from, note } => RoutineWhen::Signal {
+                name,
+                from: from.as_deref(),
+                note: note.as_deref(),
+            },
+        };
+        RoutineEnvelope {
+            name: &self.name,
+            when,
+            body,
+        }
+    }
+}
+
+/// The routine that sent `message`, if one did.
 pub(super) fn routine(
     store: &Store,
     message: &Message,
-) -> Result<Option<(String, String, String)>, StoreError> {
+) -> Result<Option<RoutineContext>, StoreError> {
     let Some(id) = &message.routine_id else {
         return Ok(None);
     };
@@ -18,10 +54,26 @@ pub(super) fn routine(
     else {
         return Ok(None);
     };
-    let scheduled = routines::schedule::Plan::new(&routine.schedule, &routine.timezone)
-        .map(|plan| plan.local_time(run.scheduled_for))
-        .unwrap_or_default();
-    Ok(Some((routine.name, scheduled, routine.timezone)))
+    let trigger = match run.signal {
+        Some(signal) => Trigger::Signal {
+            from: match &signal.from_bot_id {
+                Some(bot) => store.bot(bot)?.map(|sender| sender.handle),
+                None => None,
+            },
+            name: signal.name,
+            note: signal.note,
+        },
+        None => Trigger::Scheduled {
+            at: routines::schedule::Plan::new(&routine.schedule, &routine.timezone)
+                .map(|plan| plan.local_time(run.scheduled_for))
+                .unwrap_or_default(),
+            timezone: routine.timezone,
+        },
+    };
+    Ok(Some(RoutineContext {
+        name: routine.name,
+        trigger,
+    }))
 }
 
 /// The id and text of the question a message answers.
diff --git a/crates/botloftd/src/courier/mod.rs b/crates/botloftd/src/courier/mod.rs
index 761f8962..209d6550 100644
--- a/crates/botloftd/src/courier/mod.rs
+++ b/crates/botloftd/src/courier/mod.rs
@@ -232,7 +232,7 @@ struct Draft {
     sender_handle: Option<String>,
     task: Option<Task>,
     workspace: PathBuf,
-    routine: Option<(String, String, String)>,
+    routine: Option<context::RoutineContext>,
     /// The question an answer is for: its id and text.
     question: Option<(String, String)>,
 }
@@ -245,10 +245,7 @@ impl Draft {
             sender_handle: self.sender_handle.as_deref(),
             task: self.task.as_ref(),
             workspace: &self.workspace,
-            routine: self
-                .routine
-                .as_ref()
-                .map(|(name, scheduled, zone)| (name.as_str(), scheduled.as_str(), zone.as_str())),
+            routine: self.routine.as_ref(),
             question: self
                 .question
                 .as_ref()
diff --git a/crates/botloftd/src/courier/render.rs b/crates/botloftd/src/courier/render.rs
index c2eefec5..ccacef79 100644
--- a/crates/botloftd/src/courier/render.rs
+++ b/crates/botloftd/src/courier/render.rs
@@ -4,13 +4,15 @@ use std::path::Path;
 
 use base64::Engine as _;
 use base64::engine::general_purpose::STANDARD as BASE64;
-use botloft_core::envelope::{self, Envelope, RoutineEnvelope, Sender};
+use botloft_core::envelope::{self, Envelope, Sender};
 use botloft_core::ids::random_uuid;
 use botloft_core::protocol::{Attachment, Message, SenderKind, Task};
 use bytes::Bytes;
 use serde_json::{Value, json};
 use tracing::debug;
 
+use super::context::RoutineContext;
+
 /// Images the API accepts inline (spec 9.5).
 const INLINE_IMAGES: &[&str] = &["image/png", "image/jpeg", "image/gif", "image/webp"];
 const INLINE_IMAGE_MAX: u64 = 5 * 1024 * 1024;
@@ -23,9 +25,9 @@ pub(super) struct Context<'a> {
     pub task: Option<&'a Task>,
     /// The recipient's workspace, where attachments were saved.
     pub workspace: &'a Path,
-    /// For a routine's message: its name, the local time it is for and the
-    /// zone (spec 20.5).
-    pub routine: Option<(&'a str, &'a str, &'a str)>,
+    /// For a routine's message: the routine and what made it run (spec
+    /// 20.5, 20.13).
+    pub routine: Option<&'a RoutineContext>,
     /// For the owner's answer to a question: its id and text (spec 23.4).
     pub question: Option<(&'a str, &'a str)>,
 }
@@ -56,13 +58,7 @@ pub(super) fn render(message: &Message, context: &Context<'_>, now: i64) -> Rend
             envelope(message, context, from, now)
         }
         SenderKind::System => match context.routine {
-            Some((name, scheduled, timezone)) => RoutineEnvelope {
-                name,
-                scheduled,
-                timezone,
-                body: &message.body,
-            }
-            .render(),
+            Some(routine) => routine.envelope(&message.body).render(),
             None => envelope(message, context, Sender::Botloft, now),
         },
     };
diff --git a/crates/botloftd/src/routines/fire.rs b/crates/botloftd/src/routines/fire.rs
index 911548b8..2c0562fa 100644
--- a/crates/botloftd/src/routines/fire.rs
+++ b/crates/botloftd/src/routines/fire.rs
@@ -4,8 +4,8 @@
 
 use botloft_core::ids::{MessageId, RoutineId, RoutineRunId};
 use botloft_core::protocol::{
-    Crew, Message, MessageKind, Missed, Overlap, Routine, RoutineRun, RunStatus, SenderKind,
-    SkipReason,
+    Crew, Message, MessageKind, Missed, Overlap, Routine, RoutineRun, RunSignal, RunStatus,
+    SenderKind, SkipReason,
 };
 use botloft_store::{BotRecord, Store};
 use tracing::{debug, warn};
@@ -66,7 +66,7 @@ pub(super) fn due(daemon: &Daemon, mut routine: Routine, now: i64) {
         record(daemon, &store, run);
     }
     if let Some(at) = fire_at
-        && let Err(err) = attempt(daemon, &store, &routine, &crew, &bot, at, true)
+        && let Err(err) = attempt(daemon, &store, &routine, &crew, &bot, at, Trigger::Schedule)
     {
         warn!(routine = %routine.id, "a routine could not run: {err}");
     }
@@ -87,7 +87,7 @@ pub fn fire_now(daemon: &Daemon, id: &RoutineId) -> ApiResult<RoutineRun> {
     }
     let (crew, bot) = bots::active(&store, &routine.bot_id)?;
     let now = daemon.clock.now_ms();
-    let run = attempt(daemon, &store, &routine, &crew, &bot, now, false)?;
+    let run = attempt(daemon, &store, &routine, &crew, &bot, now, Trigger::Now)?;
     drop(store);
     announce_routine(daemon, id);
     Ok(run)
@@ -100,22 +100,41 @@ pub fn next_run_at(routine: &Routine, from: i64, now: i64) -> Option<i64> {
         .next_after(from, now)
 }
 
+/// What makes a routine run.
+pub(super) enum Trigger {
+    /// Its time came.
+    Schedule,
+    /// The owner clicked "Run now".
+    Now,
+    /// A bot of the crew sent the signal it waits for (spec 20.13).
+    Signal(RunSignal),
+}
+
 /// Sends the routine's message, unless the bot is paused (for a scheduled
-/// time) or a run is still open.
-fn attempt(
+/// time or a signal) or a run is still open.
+pub(super) fn attempt(
     daemon: &Daemon,
     store: &Store,
     routine: &Routine,
     crew: &Crew,
     bot: &BotRecord,
     at: i64,
-    scheduled: bool,
+    trigger: Trigger,
 ) -> ApiResult<RoutineRun> {
     let now = daemon.clock.now_ms();
-    if scheduled && (bot.paused || crew.paused) {
-        let run = skipped(routine, at, SkipReason::BotPaused, 1, now);
+    let (waits, signal) = match trigger {
+        Trigger::Schedule => (true, None),
+        Trigger::Now => (false, None),
+        Trigger::Signal(signal) => (true, Some(signal)),
+    };
+    let skip = |reason| {
+        let mut run = skipped(routine, at, reason, 1, now);
+        run.signal.clone_from(&signal);
         record(daemon, store, run.clone());
-        return Ok(run);
+        Ok(run)
+    };
+    if waits && (bot.paused || crew.paused) {
+        return skip(SkipReason::BotPaused);
     }
     let open = store.open_runs(&routine.id)?;
     let room = match routine.overlap {
@@ -123,9 +142,7 @@ fn attempt(
         Overlap::Queue => 2,
     };
     if open >= room {
-        let run = skipped(routine, at, SkipReason::Overlap, 1, now);
-        record(daemon, store, run.clone());
-        return Ok(run);
+        return skip(SkipReason::Overlap);
     }
     let message = Message {
         id: MessageId::generate(),
@@ -152,6 +169,7 @@ fn attempt(
         message_id: Some(message.id.clone()),
         created_at: now,
         finished_at: None,
+        signal,
     };
     let item = store.fire_run(&run, &message, &delivery)?;
     debug!(routine = %routine.id, run = %run.id, "routine fired");
@@ -160,7 +178,13 @@ fn attempt(
     Ok(run)
 }
 
-fn skipped(routine: &Routine, at: i64, reason: SkipReason, count: usize, now: i64) -> RoutineRun {
+pub(super) fn skipped(
+    routine: &Routine,
+    at: i64,
+    reason: SkipReason,
+    count: usize,
+    now: i64,
+) -> RoutineRun {
     RoutineRun {
         id: RoutineRunId::generate(),
         routine_id: routine.id.clone(),
@@ -171,10 +195,11 @@ fn skipped(routine: &Routine, at: i64, reason: SkipReason, count: usize, now: i6
         message_id: None,
         created_at: now,
         finished_at: Some(now),
+        signal: None,
     }
 }
 
-fn record(daemon: &Daemon, store: &Store, run: RoutineRun) {
+pub(super) fn record(daemon: &Daemon, store: &Store, run: RoutineRun) {
     match store.insert_run(&run) {
         Ok(()) => daemon.emit(Event::RoutineRun(run)),
         Err(err) => warn!(routine = %run.routine_id, "could not record a skipped run: {err}"),
diff --git a/crates/botloftd/src/routines/mod.rs b/crates/botloftd/src/routines/mod.rs
index bc4839e2..749d4cda 100644
--- a/crates/botloftd/src/routines/mod.rs
+++ b/crates/botloftd/src/routines/mod.rs
@@ -8,6 +8,7 @@
 mod cron;
 mod fire;
 pub mod schedule;
+pub mod signal;
 
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex, MutexGuard};
diff --git a/crates/botloftd/src/routines/schedule.rs b/crates/botloftd/src/routines/schedule.rs
index 83020804..19fb8591 100644
--- a/crates/botloftd/src/routines/schedule.rs
+++ b/crates/botloftd/src/routines/schedule.rs
@@ -53,9 +53,16 @@ pub struct Plan {
 
 #[derive(Debug, Clone)]
 enum Kind {
-    Weekly { days: u8, time: Time },
-    Interval { ms: i64 },
+    Weekly {
+        days: u8,
+        time: Time,
+    },
+    Interval {
+        ms: i64,
+    },
     Cron(Cron),
+    /// Runs when a bot sends the signal, never by the clock.
+    Signal,
 }
 
 impl Plan {
@@ -107,12 +114,25 @@ impl Plan {
             Schedule::Cron { expr } => {
                 Kind::Cron(Cron::parse(expr).map_err(|err| Problem::new("cron_invalid", err))?)
             }
+            Schedule::Signal { name } => {
+                if name.is_empty() || signal_name(name) != *name {
+                    return Err(Problem::new(
+                        "signal_invalid",
+                        "a signal name needs letters or digits, like report-ready",
+                    ));
+                }
+                Kind::Signal
+            }
         };
         Ok(Self { kind, tz })
     }
 
     /// Checks that runs are never closer than five minutes, from `now` on.
     pub fn check_spacing(&self, now: i64) -> Result<(), Problem> {
+        // Signals are kept apart when they come (spec 20.13).
+        if matches!(self.kind, Kind::Signal) {
+            return Ok(());
+        }
         let mut last = self.next_after(now, now);
         let mut samples = 0;
         while let Some(at) = last
@@ -160,6 +180,7 @@ impl Plan {
                         .collect()
                 })
             }),
+            Kind::Signal => None,
         }
     }
 
@@ -224,6 +245,23 @@ impl Plan {
     }
 }
 
+/// A signal's name as it is kept: lowercase letters, digits and single
+/// hyphens, without accents (`Relatório pronto` -> `relatorio-pronto`).
+/// Empty when nothing usable is left.
+pub fn signal_name(text: &str) -> String {
+    botloft_core::slug::slugify(text, "")
+}
+
+/// The schedule as it is kept: a signal's name normalized.
+pub fn normalized(schedule: Schedule) -> Schedule {
+    match schedule {
+        Schedule::Signal { name } => Schedule::Signal {
+            name: signal_name(&name),
+        },
+        other => other,
+    }
+}
+
 /// `HH:MM`, 24-hour.
 fn clock_time(text: &str) -> Result<Time, Problem> {
     let bad = || {
diff --git a/crates/botloftd/src/routines/signal.rs b/crates/botloftd/src/routines/signal.rs
new file mode 100644
index 00000000..a8135635
--- /dev/null
+++ b/crates/botloftd/src/routines/signal.rs
@@ -0,0 +1,90 @@
+//! Signals between bots (spec 20.13): a bot says something happened, and
+//! the routines of its crew that wait for that signal run.
+
+use botloft_core::ids::BotId;
+use botloft_core::protocol::{Routine, RoutineRun, RunSignal, SkipReason};
+use tracing::{debug, warn};
+
+use super::fire::{self, Trigger};
+use super::schedule::signal_name;
+use crate::service::{ApiError, ApiResult, bots};
+use crate::state::Daemon;
+
+/// Closest two runs of one routine may be when signals cause them, as for
+/// schedules: a bot that signals in a loop cannot spend the owner's plan.
+const SIGNAL_SPACING_MS: i64 = 5 * 60 * 1000;
+/// Longest note a signal carries, in characters.
+pub const NOTE_MAX_CHARS: usize = 2_000;
+
+/// A routine the signal reached, and what became of it.
+pub struct Reached {
+    pub routine: Routine,
+    pub run: RoutineRun,
+}
+
+/// `from` sends the signal `name` to its crew. Every enabled routine of an
+/// active bot there that waits for it runs, unless it ran for a signal less
+/// than five minutes ago, its bot is paused or its last run is still open.
+pub fn send(
+    daemon: &Daemon,
+    from: &BotId,
+    name: &str,
+    note: Option<&str>,
+) -> ApiResult<(String, Vec<Reached>)> {
+    let name = signal_name(name);
+    if name.is_empty() {
+        return Err(ApiError::validation(
+            "a signal name needs letters or digits, like report-ready",
+        ));
+    }
+    let note = note.map(str::trim).filter(|note| !note.is_empty());
+    if note.is_some_and(|note| note.chars().count() > NOTE_MAX_CHARS) {
+        return Err(ApiError::validation(format!(
+            "note must be at most {NOTE_MAX_CHARS} characters"
+        )));
+    }
+    let store = daemon.store();
+    let (crew, _) = bots::active(&store, from)?;
+    let signal = RunSignal {
+        name: name.clone(),
+        from_bot_id: Some(from.clone()),
+        note: note.map(str::to_owned),
+    };
+    let now = daemon.clock.now_ms();
+    let mut reached = Vec::new();
+    for routine in store.signal_routines(&crew.id, Some(&name))? {
+        let Ok((crew, bot)) = bots::active(&store, &routine.bot_id) else {
+            continue;
+        };
+        let last = store.last_signal_run_at(&routine.id)?;
+        let run = if last.is_some_and(|at| now - at < SIGNAL_SPACING_MS) {
+            let mut run = fire::skipped(&routine, now, SkipReason::TooSoon, 1, now);
+            run.signal = Some(signal.clone());
+            fire::record(daemon, &store, run.clone());
+            run
+        } else {
+            match fire::attempt(
+                daemon,
+                &store,
+                &routine,
+                &crew,
+                &bot,
+                now,
+                Trigger::Signal(signal.clone()),
+            ) {
+                Ok(run) => run,
+                Err(err) => {
+                    warn!(routine = %routine.id, "a signal could not run a routine: {err}");
+                    continue;
+                }
+            }
+        };
+        debug!(routine = %routine.id, status = %run.status, "signal reached a routine");
+        reached.push(Reached { routine, run });
+    }
+    drop(store);
+    for each in &reached {
+        fire::announce_routine(daemon, &each.routine.id);
+    }
+    Ok((name, reached))
+}
diff --git a/crates/botloftd/src/service/routines.rs b/crates/botloftd/src/service/routines.rs
index 17ae4c8a..e99ee107 100644
--- a/crates/botloftd/src/service/routines.rs
+++ b/crates/botloftd/src/service/routines.rs
@@ -12,7 +12,7 @@ use tracing::warn;
 
 use super::{ApiError, ApiResult, bots};
 use crate::routines;
-use crate::routines::schedule::{Plan, Problem};
+use crate::routines::schedule::{Plan, Problem, normalized};
 use crate::state::{Daemon, Event};
 
 const NAME_MAX_CHARS: usize = 80;
@@ -31,7 +31,8 @@ pub fn create(daemon: &Daemon, params: RoutinesCreateParams) -> ApiResult<Routin
     let name = name(&params.name)?;
     let prompt = validate::message("prompt", &params.prompt)?;
     let now = daemon.clock.now_ms();
-    let plan = plan(&params.schedule, &params.timezone, now)?;
+    let schedule = normalized(params.schedule);
+    let plan = plan(&schedule, &params.timezone, now)?;
     let store = daemon.store();
     bots::active(&store, &params.bot_id)?;
     let routine = Routine {
@@ -39,7 +40,7 @@ pub fn create(daemon: &Daemon, params: RoutinesCreateParams) -> ApiResult<Routin
         bot_id: params.bot_id,
         name,
         prompt,
-        schedule: params.schedule,
+        schedule,
         timezone: params.timezone,
         overlap: params.overlap.unwrap_or(Overlap::Skip),
         missed: params.missed.unwrap_or(Missed::RunOnce),
@@ -59,7 +60,8 @@ pub fn create(daemon: &Daemon, params: RoutinesCreateParams) -> ApiResult<Routin
 pub(crate) fn check(daemon: &Daemon, params: &RoutinesCreateParams) -> ApiResult<()> {
     name(&params.name)?;
     validate::message("prompt", &params.prompt)?;
-    plan(&params.schedule, &params.timezone, daemon.clock.now_ms())?;
+    let schedule = normalized(params.schedule.clone());
+    plan(&schedule, &params.timezone, daemon.clock.now_ms())?;
     Ok(())
 }
 
@@ -81,7 +83,7 @@ pub fn update(daemon: &Daemon, params: RoutinesUpdateParams) -> ApiResult<Routin
     let now = daemon.clock.now_ms();
     let timing = params.schedule.is_some() || params.timezone.is_some();
     if let Some(schedule) = params.schedule {
-        routine.schedule = schedule;
+        routine.schedule = normalized(schedule);
     }
     if let Some(timezone) = params.timezone {
         routine.timezone = timezone;
diff --git a/crates/botloftd/src/tools/calls.rs b/crates/botloftd/src/tools/calls.rs
index 05312a44..5ff17151 100644
--- a/crates/botloftd/src/tools/calls.rs
+++ b/crates/botloftd/src/tools/calls.rs
@@ -18,6 +18,7 @@ use super::Failure;
 use super::catalog::{COMPLETE_TASK, CREW_ROSTER, MY_TASKS, SEND_MESSAGE};
 use super::question::{self, ASK_OWNER};
 use super::share::{self, SHARE_FILE};
+use super::signal::{self, SEND_SIGNAL};
 use crate::service::tasks::{self, BotMessage};
 use crate::service::{ApiError, bots, lead};
 use crate::state::Daemon;
@@ -40,6 +41,7 @@ pub(super) fn call(daemon: &Daemon, bot: &BotId, params: &Value) -> Result<Value
         MY_TASKS => parse(arguments).and_then(|args| my_tasks(daemon, bot, args)),
         SHARE_FILE => parse(arguments).and_then(|args| share::share(daemon, bot, args)),
         ASK_OWNER => parse(arguments).and_then(|args| question::ask(daemon, bot, args)),
+        SEND_SIGNAL => parse(arguments).and_then(|args| signal::send(daemon, bot, args)),
         other => return Err(invalid(&format!("Unknown tool: {other}"))),
     };
     Ok(tool_result(outcome))
@@ -104,6 +106,7 @@ fn roster(daemon: &Daemon, bot: &BotId) -> Outcome {
         "you": me.handle,
         "you_lead": lead::is_lead(&crew, &me.id),
         "bots": others,
+        "signals": signal::waited_for(daemon, bot)?,
     }))
 }
 
diff --git a/crates/botloftd/src/tools/catalog.rs b/crates/botloftd/src/tools/catalog.rs
index c18d13b5..afb2d9ae 100644
--- a/crates/botloftd/src/tools/catalog.rs
+++ b/crates/botloftd/src/tools/catalog.rs
@@ -24,9 +24,13 @@ pub fn tools() -> Value {
     if let Value::Array(list) = &mut tools {
         // Before permission_prompt, which stays last.
         let at = list.len() - 1;
-        let more = [super::share::tool(), super::question::tool()]
-            .into_iter()
-            .chain(super::browser_catalog::tools());
+        let more = [
+            super::share::tool(),
+            super::question::tool(),
+            super::signal::tool(),
+        ]
+        .into_iter()
+        .chain(super::browser_catalog::tools());
         list.splice(at..at, more);
     }
     tools
@@ -169,7 +173,8 @@ fn crew_tools() -> Value {
             "name": SCHEDULE_ROUTINE,
             "title": "Schedule a routine",
             "description": "Asks the owner for a routine: work done at set times, such as every \
-                weekday at 08:00 or every 2 hours. Each time, the bot gets your prompt as a \
+                weekday at 08:00 or every 2 hours, or whenever a bot of the crew sends a signal \
+                (send_signal), such as \"report-ready\". Each time, the bot gets your prompt as a \
                 message, even after restarts. The owner sees the routine in your chat, may change \
                 it, and approves or declines it; the call waits for that. Approved, it shows among \
                 the bot's routines in the Botloft app. This is the only way to schedule work.",
@@ -227,6 +232,19 @@ fn crew_tools() -> Value {
                                 "required": ["kind", "expr"],
                                 "additionalProperties": false,
                             },
+                            {
+                                "type": "object",
+                                "properties": {
+                                    "kind": { "const": "signal" },
+                                    "name": {
+                                        "type": "string",
+                                        "description": "The signal it waits for, like \
+                                            \"report-ready\".",
+                                    },
+                                },
+                                "required": ["kind", "name"],
+                                "additionalProperties": false,
+                            },
                         ],
                     },
                     "bot": {
diff --git a/crates/botloftd/src/tools/mod.rs b/crates/botloftd/src/tools/mod.rs
index 37487012..069b574c 100644
--- a/crates/botloftd/src/tools/mod.rs
+++ b/crates/botloftd/src/tools/mod.rs
@@ -18,6 +18,7 @@ mod era;
 mod question;
 mod routine;
 mod share;
+mod signal;
 mod suggest;
 
 use std::sync::Arc;
@@ -42,7 +43,7 @@ const CACHE_TTL_MS: u64 = 60 * 60 * 1000;
 
 const INSTRUCTIONS: &str = "Tools to work with your Botloft crew: see who is in it, send notes \
     or tasks to other bots, report the result of tasks assigned to you and, for the crew's chief, \
-    suggest new bots. schedule_routine asks the owner for work at set times. ask_owner asks the owner a question without waiting; the answer arrives later as a message. share_file shows the \
+    suggest new bots. schedule_routine asks the owner for work at set times. ask_owner asks the owner a question without waiting; the answer arrives later as a message. send_signal tells the crew something happened, and the routines waiting for it run. share_file shows the \
     owner files you made, as cards in the chat they can open and save. The browser_ tools drive your own web browser, which the owner can watch \
     live and take over when you ask with browser_ask_owner. The owner writes to you directly; messages from other bots and from Botloft start with \
     [botloft].";
diff --git a/crates/botloftd/src/tools/signal.rs b/crates/botloftd/src/tools/signal.rs
new file mode 100644
index 00000000..5c7c06c5
--- /dev/null
+++ b/crates/botloftd/src/tools/signal.rs
@@ -0,0 +1,121 @@
+//! `send_signal` (spec 20.13): the bot tells its crew that something
+//! happened, and the routines that wait for that signal run.
+
+use std::collections::HashMap;
+
+use botloft_core::ids::BotId;
+use botloft_core::protocol::{RunStatus, Schedule, SkipReason};
+use serde::Deserialize;
+use serde_json::{Value, json};
+
+use super::calls::explain;
+use crate::routines::signal::{self, NOTE_MAX_CHARS};
+use crate::service::bots;
+use crate::state::Daemon;
+
+pub const SEND_SIGNAL: &str = "send_signal";
+
+pub(super) fn tool() -> Value {
+    json!({
+        "name": SEND_SIGNAL,
+        "title": "Send a signal",
+        "description": "Tells your crew that something happened, by the name of a signal: every \
+            routine of the crew that waits for that signal runs now, each in its own bot's chat. \
+            crew_roster lists the signals the routines wait for. Send one when the thing it names \
+            is done (\"report-ready\" once the report is saved), not to talk to a bot: for that, \
+            use send_message.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "The signal, as crew_roster lists it (\"report-ready\").",
+                },
+                "note": {
+                    "type": "string",
+                    "maxLength": NOTE_MAX_CHARS,
+                    "description": "What the bots that run should know, such as where the file is.",
+                },
+            },
+            "required": ["name"],
+            "additionalProperties": false,
+        },
+    })
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct SignalArgs {
+    name: String,
+    #[serde(default)]
+    note: Option<String>,
+}
+
+pub(super) fn send(daemon: &Daemon, bot: &BotId, args: SignalArgs) -> Result<Value, String> {
+    let (name, reached) =
+        signal::send(daemon, bot, &args.name, args.note.as_deref()).map_err(explain)?;
+    let handles = handles(daemon, bot)?;
+    let routines: Vec<Value> = reached
+        .iter()
+        .map(|each| {
+            let mut out = json!({
+                "routine": each.routine.name,
+                "bot": handles.get(&each.routine.bot_id).map(|h| format!("@{h}")),
+                "ran": each.run.status == RunStatus::Queued,
+            });
+            if let Some(reason) = each.run.reason {
+                out["why_not"] = json!(why_not(reason));
+            }
+            out
+        })
+        .collect();
+    let note = if routines.is_empty() {
+        "No routine of your crew waits for this signal, so nothing ran. crew_roster lists the \
+         signals the routines wait for."
+    } else {
+        "Each routine that ran works in its own bot's chat; you don't get its answer."
+    };
+    Ok(json!({ "signal": name, "routines": routines, "note": note }))
+}
+
+fn why_not(reason: SkipReason) -> &'static str {
+    match reason {
+        SkipReason::TooSoon => "it ran for a signal less than 5 minutes ago",
+        SkipReason::BotPaused => "its bot is paused",
+        SkipReason::Overlap => "its last run has not finished",
+        SkipReason::Missed => "missed",
+    }
+}
+
+/// The signals the crew's routines wait for, for `crew_roster`.
+pub(super) fn waited_for(daemon: &Daemon, bot: &BotId) -> Result<Vec<Value>, String> {
+    let handles = handles(daemon, bot)?;
+    let store = daemon.store();
+    let (crew, _) = bots::active(&store, bot).map_err(explain)?;
+    let routines = store
+        .signal_routines(&crew.id, None)
+        .map_err(|err| explain(err.into()))?;
+    Ok(routines
+        .into_iter()
+        .filter_map(|routine| match routine.schedule {
+            Schedule::Signal { name } => Some(json!({
+                "signal": name,
+                "routine": routine.name,
+                "bot": handles.get(&routine.bot_id).map(|h| format!("@{h}")),
+            })),
+            _ => None,
+        })
+        .collect())
+}
+
+/// The handles of the bot's crew, by id.
+fn handles(daemon: &Daemon, bot: &BotId) -> Result<HashMap<BotId, String>, String> {
+    let store = daemon.store();
+    let (crew, _) = bots::active(&store, bot).map_err(explain)?;
+    Ok(store
+        .bots(Some(&crew.id), true)
+        .map_err(|err| explain(err.into()))?
+        .into_iter()
+        .map(|record| (record.id, record.handle))
+        .collect())
+}
diff --git a/crates/botloftd/src/workspace/files.rs b/crates/botloftd/src/workspace/files.rs
index 7f6f88d7..bcd129ff 100644
--- a/crates/botloftd/src/workspace/files.rs
+++ b/crates/botloftd/src/workspace/files.rs
@@ -160,6 +160,8 @@ app; the other bots of your crew send you messages too.
   - `send_message`: send a note, or a task with `kind: \"task\"`, to another bot by handle.
   - `complete_task`: report the result of a task assigned to you; the requester is told.
   - `my_tasks`: open tasks assigned to you or requested by you.
+  - `send_signal`: when something a routine waits for is done (`crew_roster`
+    lists the signals), send that signal; those routines run.
 - Never call `permission_prompt` yourself; Claude Code uses it for approvals.
 - You can only reach bots of your own crew.
 - A task you receive ends with `complete_task`, also when you could not do it
diff --git a/crates/botloftd/tests/mcp.rs b/crates/botloftd/tests/mcp.rs
index 55d8f9bd..c374f015 100644
--- a/crates/botloftd/tests/mcp.rs
+++ b/crates/botloftd/tests/mcp.rs
@@ -75,6 +75,7 @@ async fn claude_code_discovers_the_server_and_lists_the_tools() {
             "schedule_routine",
             "share_file",
             "ask_owner",
+            "send_signal",
             "browser_open",
             "browser_look",
             "browser_click",
@@ -130,7 +131,7 @@ async fn earlier_revisions_start_with_initialize() {
     let listed = mcp::post(t.addr, &legacy, &list).await;
     assert_eq!(
         listed.body["result"]["tools"].as_array().map(Vec::len),
-        Some(20)
+        Some(21)
     );
     let unknown = json!({ "jsonrpc": "2.0", "id": 2, "method": "prompts/list" }).to_string();
     let unknown = mcp::post(t.addr, &legacy, &unknown).await;
diff --git a/crates/botloftd/tests/routine_signals.rs b/crates/botloftd/tests/routine_signals.rs
new file mode 100644
index 00000000..51a3aad6
--- /dev/null
+++ b/crates/botloftd/tests/routine_signals.rs
@@ -0,0 +1,223 @@
+//! Signals between bots (spec 20.13): a routine that waits for a signal
+//! runs when a bot of its crew sends it, at most once every 5 minutes.
+
+mod common;
+
+use botloft_core::protocol::{
+    BotsCreateParams, CrewsCreateParams, Missed, Overlap, RoutinesSetEnabledParams, RunStatus,
+    Schedule, SkipReason,
+};
+use botloftd::routines::{self, signal};
+use botloftd::service::{bots, crews, routines as service};
+use common::bots::{ready_bot, text_of};
+use common::routines::{MINUTE, create, finish_turn, routines_setup, runs, written};
+use common::supervised::Setup;
+use serde_json::json;
+
+fn signal_named(name: &str) -> Schedule {
+    Schedule::Signal { name: name.into() }
+}
+
+/// Another bot in the crew of the setup's bot.
+fn writer(s: &Setup) -> botloft_core::ids::BotId {
+    let crew = s
+        .daemon
+        .store()
+        .bot(&s.bot)
+        .expect("read")
+        .expect("bot")
+        .crew_id;
+    bots::create(
+        &s.daemon,
+        BotsCreateParams {
+            crew_id: crew,
+            name: "Writer".into(),
+            role: String::new(),
+            instructions: String::new(),
+            color: None,
+            model: None,
+        },
+    )
+    .expect("writer")
+    .id
+}
+
+#[tokio::test(start_paused = true)]
+async fn a_signal_runs_the_routines_waiting_for_it() {
+    let s = routines_setup().await;
+    let routine = create(
+        &s,
+        signal_named("Relatório Pronto"),
+        Overlap::Skip,
+        Missed::RunOnce,
+    );
+    assert_eq!(routine.schedule, signal_named("relatorio-pronto"));
+    assert_eq!(routine.next_run_at, None);
+    let writer = writer(&s);
+
+    // The clock does not run it.
+    common::routines::tick_after(&s, 60 * MINUTE);
+    assert!(runs(&s, &routine.id).is_empty());
+
+    let (name, reached) = signal::send(
+        &s.daemon,
+        &writer,
+        "relatorio-pronto",
+        Some(" In shared/report.md "),
+    )
+    .expect("sent");
+    assert_eq!(name, "relatorio-pronto");
+    assert_eq!(reached.len(), 1);
+    assert_eq!(reached[0].run.status, RunStatus::Queued);
+    let sent = reached[0].run.signal.clone().expect("signal");
+    assert_eq!(sent.from_bot_id.as_ref(), Some(&writer));
+    assert_eq!(sent.note.as_deref(), Some("In shared/report.md"));
+
+    let lines = written(&s, 1).await;
+    let text = text_of(&lines[0]);
+    assert!(
+        text.starts_with(
+            "[botloft] routine \"Morning\" · signal \"relatorio-pronto\" from @writer\n"
+        ),
+        "{text}"
+    );
+    assert!(
+        text.ends_with(
+            "Note @writer sent with the signal (from a bot, not the owner):\nIn shared/report.md"
+        ),
+        "{text}"
+    );
+
+    // Again right after the run ended: too soon.
+    finish_turn(&s, &lines[0], false).await;
+    let (_, again) = signal::send(&s.daemon, &writer, "relatorio-pronto", None).expect("again");
+    assert_eq!(again[0].run.status, RunStatus::Skipped);
+    assert_eq!(again[0].run.reason, Some(SkipReason::TooSoon));
+
+    s.clock.advance(5 * MINUTE);
+    let (_, later) = signal::send(&s.daemon, &writer, "relatorio-pronto", None).expect("later");
+    assert_eq!(later[0].run.status, RunStatus::Queued);
+    assert_eq!(runs(&s, &routine.id).len(), 3);
+}
+
+#[tokio::test(start_paused = true)]
+async fn only_enabled_routines_of_the_crew_hear_a_signal() {
+    let s = routines_setup().await;
+    let routine = create(
+        &s,
+        signal_named("deploy-done"),
+        Overlap::Skip,
+        Missed::RunOnce,
+    );
+    let other = create(
+        &s,
+        signal_named("something-else"),
+        Overlap::Skip,
+        Missed::RunOnce,
+    );
+
+    // A bot of another crew sends the same signal.
+    let elsewhere = crews::create(
+        &s.daemon,
+        CrewsCreateParams {
+            name: "Home".into(),
+            work_folder: None,
+            lead: None,
+        },
+    )
+    .expect("crew");
+    let stranger = bots::create(
+        &s.daemon,
+        BotsCreateParams {
+            crew_id: elsewhere.id,
+            name: "Cook".into(),
+            role: String::new(),
+            instructions: String::new(),
+            color: None,
+            model: None,
+        },
+    )
+    .expect("bot");
+    let (_, reached) = signal::send(&s.daemon, &stranger.id, "deploy-done", None).expect("sent");
+    assert!(reached.is_empty());
+
+    service::set_enabled(
+        &s.daemon,
+        RoutinesSetEnabledParams {
+            routine_id: routine.id.clone(),
+            enabled: false,
+        },
+    )
+    .expect("off");
+    let (_, reached) = signal::send(&s.daemon, &s.bot, "deploy-done", None).expect("sent");
+    assert!(reached.is_empty());
+    assert!(runs(&s, &other.id).is_empty());
+    routines::tick(&s.daemon);
+
+    for bad in ["", "  ", "!!"] {
+        assert!(
+            signal::send(&s.daemon, &s.bot, bad, None).is_err(),
+            "{bad:?}"
+        );
+    }
+    let note = "x".repeat(2001);
+    assert!(signal::send(&s.daemon, &s.bot, "deploy-done", Some(&note)).is_err());
+}
+
+#[tokio::test]
+async fn bots_see_the_signals_and_send_them() {
+    let t = common::TestDaemon::start_supervised().await;
+    let mut app = t.session().await;
+    let crew = app
+        .call("crews.create", json!({ "name": "Ops" }))
+        .await
+        .expect("crew");
+    let (reviewer, _, _) = ready_bot(&t, &mut app, &crew, "Reviewer").await;
+    let (_, _, mut writer) = ready_bot(&t, &mut app, &crew, "Writer").await;
+    let routine = app
+        .call(
+            "routines.create",
+            json!({
+                "botId": reviewer["id"],
+                "name": "Review the report",
+                "prompt": "Review the report in shared/.",
+                "schedule": { "kind": "signal", "name": "report-ready" },
+                "timezone": "UTC",
+            }),
+        )
+        .await
+        .expect("routine");
+    assert_eq!(routine["nextRunAt"], json!(null));
+
+    let roster = writer.tool("crew_roster", json!({})).await.expect("roster");
+    assert_eq!(
+        roster["signals"],
+        json!([{ "signal": "report-ready", "routine": "Review the report", "bot": "@reviewer" }])
+    );
+
+    let sent = writer
+        .tool(
+            "send_signal",
+            json!({ "name": "Report Ready", "note": "shared/report.md" }),
+        )
+        .await
+        .expect("sent");
+    assert_eq!(sent["signal"], "report-ready");
+    assert_eq!(sent["routines"][0]["routine"], "Review the report");
+    assert_eq!(sent["routines"][0]["ran"], true);
+    let run = app.notification("routine.run").await;
+    assert_eq!(run["signal"]["name"], "report-ready");
+
+    let again = writer
+        .tool("send_signal", json!({ "name": "report-ready" }))
+        .await
+        .expect("again");
+    assert_eq!(again["routines"][0]["ran"], false);
+    assert!(again["routines"][0]["why_not"].as_str().is_some());
+
+    let nobody = writer
+        .tool("send_signal", json!({ "name": "nobody-listens" }))
+        .await
+        .expect("nobody");
+    assert_eq!(nobody["routines"], json!([]));
+}
diff --git a/docs/spec.md b/docs/spec.md
index 60da44d5..3b0bc802 100644
--- a/docs/spec.md
+++ b/docs/spec.md
@@ -537,13 +537,14 @@ Transporte: Streamable HTTP, só POST e resposta `application/json`, sem sessão
 
 | Tool | Entrada | Saída (JSON em texto) |
 |---|---|---|
-| `crew_roster` | nenhuma | `crew`, `you`, `you_lead` e os outros bots da crew: handle, nome, papel, estado e `chief` |
+| `crew_roster` | nenhuma | `crew`, `you`, `you_lead`, os outros bots da crew (handle, nome, papel, estado e `chief`) e `signals`, os avisos que as rotinas da crew esperam (20.13) |
 | `send_message` | `to` (handle, com ou sem `@`), `body`, `kind?` (`note` padrão, `task`), `deadline_minutes?` (só task) | `message_id`, `task_id` e `due` (task), e um lembrete de que a resposta chega depois |
 | `complete_task` | `task_id`, `result`, `status?` (`done` padrão, `failed`) | `task_id`, `status` e quem recebe o resultado |
 | `my_tasks` | `role?` (`assigned`, `requested`) | tasks `open` e `expired`: id, de, para, status, prazo relativo, hops e o pedido original |
 | `suggest_bot` | `name`, `role`, `instructions` (até 8 000 caracteres), `model?`, `reason` (até 1 000) | `created` e, criado, `handle`, `name`, `role`, `model` e um lembrete para mandar a primeira task; recusado ou sem resposta, o porquê (10.2). Só o chefe |
 | `schedule_routine` | `name`, `prompt` (até 8 000 caracteres), `schedule` (como em 20.2), `bot?` (handle de outro bot da crew) | `created` e, criada, `routine_id`, nome, pedido, horário, fuso e a próxima vez; recusada ou sem resposta, o aviso de que nada foi agendado (20.12) |
 | `share_file` | `files` (1 a 10 caminhos, absolutos ou relativos à pasta do bot) | `shown` (um `BotFile` por arquivo, 8.4) e um lembrete de que o dono vê cada um como cartão no chat; um arquivo fora das pastas do bot e não escrito por ele, ou que não existe, recusa a chamada inteira e diz qual e por quê |
+| `send_signal` | `name`, `note?` (até 2 000 caracteres) | o aviso normalizado e, para cada rotina da crew que o espera, se rodou e por que não (20.13) |
 | `ask_owner` | `question` (até 2 000 caracteres), `options?` (2 a 5, até 100 caracteres cada) | `question_id` e o lembrete de que a resposta chega depois, como mensagem; a tool não espera (23.2) |
 | `permission_prompt` | `tool_name`, `input`, `tool_use_id` | decisão do dono (10.1). Chamada pelo Claude Code, não pelo modelo |
 | `browser_*` | seção 21.4 | o navegador do bot: abrir, ler, clicar, digitar, rolar, ver a tela, pedir a mão do dono |
@@ -1009,7 +1010,7 @@ M2 a M4 foram entregues com ConPTY, terminal com replay, inbox por named pipe e
 4. Busca FTS5 em mensagens e no chat. Feito (8.8).
 5. Histórico de versões das instruções do bot.
 6. Acesso remoto com token por dispositivo (Tailscale).
-7. Sinais entre bots disparando rotinas.
+7. Sinais entre bots disparando rotinas. Feito (20.13).
 8. Suporte Linux/macOS. Em fatias: (1) CI com Ubuntu e macOS para o daemon; (2) runtime do bot (grupo de processos, ambiente, `claude`, navegador); (3) iniciar com o sistema (`systemd --user`, LaunchAgent); (4) app; (5) empacotamento e release. Feitas: 1 a 5 (14.1, 15.2, 15.4 a 15.6). O macOS sai sem notarização (sem conta Apple Developer por enquanto).
 9. Navegador dos bots, com o dono assistindo ao vivo. Desenho na seção 21.
 
@@ -1091,6 +1092,7 @@ O horário fica guardado como JSON estruturado (`schedule`), e não como texto c
 | `weekly` | `days` (1 = segunda … 7 = domingo, ao menos um), `time` (`HH:MM`) | "Todo dia às 09:00", "Dias úteis às 09:00", "Segunda e quinta às 14:30" |
 | `interval` | `minutes` (de 5 a 10 080) | "A cada 2 horas" |
 | `cron` | `expr` (5 campos, sem segundos) | só em "Avançado"; o app mostra a expressão como está |
+| `signal` | `name` (o aviso, normalizado) | "Quando um bot avisar “relatorio-pronto”"; roda quando um bot da crew manda o aviso (20.13) |
 
 - Horários de calendário (`weekly`, `cron`) valem no fuso da rotina (`timezone`, nome IANA como `America/Sao_Paulo`). O app manda o fuso do sistema ao criar (`Intl.DateTimeFormat().resolvedOptions().timeZone`). Mudar o fuso do Windows depois não mexe em rotinas existentes.
 - `interval` conta a partir do último horário marcado, e não do fim do trabalho: `próximo = último marcado + minutes`, ancorado na criação. Não deriva.
@@ -1108,7 +1110,7 @@ Cada disparo vira uma `routine_run`, com o horário marcado (`scheduled_for`), u
 | `queued` | a message foi gravada e espera a entrega ou o fim do turno dela |
 | `done` | o turno que começou com essa message terminou |
 | `failed` | a delivery morreu (`dead`) ou o turno terminou com erro |
-| `skipped` | não disparou; `reason`: `overlap`, `bot_paused` ou `missed` |
+| `skipped` | não disparou; `reason`: `overlap`, `bot_paused`, `missed` ou `too_soon` (um aviso menos de 5 minutos depois do anterior, 20.13) |
 
 - **Fim de uma execução:** o daemon já sabe quando o bot pega uma message (o replay com o mesmo `uuid`, 9.1 passo 7). O `result` seguinte fecha o turno em que ela entrou, também quando outra message entrou no mesmo turno: a execução vira `done`, ou `failed` se o `result` trouxer erro. Se o processo morrer antes de ler a message, a delivery volta para a fila (9.1 passo 8) e a execução continua `queued`; se morrer no meio do turno, a execução vira `failed`, porque ninguém mais vai fechar aquele turno. Pelo mesmo motivo, ao subir, o daemon marca `failed` as execuções cujo turno começou sob o daemon anterior. Uma delivery `dead` também leva a execução a `failed`.
 - **Sobreposição:** o horário chega com a execução anterior ainda `queued` (o bot está lento, parado por limite de uso, sem login ou fora do ar).
@@ -1158,6 +1160,7 @@ Migration nova:
 | `routines` | `id` (`rtn_`), `bot_id`, `name`, `prompt`, `schedule` (JSON), `timezone`, `overlap` (`skip`, `queue`), `missed` (`run_once`, `skip`), `enabled`, `next_run_at`, `created_at`, `updated_at`, `archived_at` |
 | `routine_runs` | `id` (`rrn_`), `routine_id`, `scheduled_for`, `status`, `reason`, `skipped_count`, `message_id`, `created_at`, `finished_at` |
 | `messages` | `kind` ganha `routine`; coluna nova `routine_id` |
+| `routine_runs` (0017) | `signal_name`, `signal_from`, `signal_note`: o aviso que fez a execução rodar (20.13) |
 
 Índices: `routines(enabled, next_run_at)` e `routine_runs(routine_id, id)`.
 
@@ -1174,7 +1177,7 @@ Migration nova:
 | `routines.runs` | `routineId, before?, limit?` | `RoutineRun[]`, mais nova primeiro |
 
 - Notificações: `routine.changed` e `routine.run`.
-- Validação (`-32004`): nome de 1 a 80 caracteres; pedido dentro do limite de uma message; `days` não vazio e de 1 a 7; `time` válido; `minutes` de 5 a 10 080; `cron` válido e com espaçamento de pelo menos 5 minutos; `timezone` conhecido. Os problemas do horário vêm com `data.reason` (`timezone_unknown`, `days_empty`, `days_range`, `time_invalid`, `interval_range`, `cron_invalid`, `too_often`, `never_runs`), que o app escreve no idioma do dono (15.6); a mensagem em inglês fica para quem não conhece o código.
+- Validação (`-32004`): nome de 1 a 80 caracteres; pedido dentro do limite de uma message; `days` não vazio e de 1 a 7; `time` válido; `minutes` de 5 a 10 080; `cron` válido e com espaçamento de pelo menos 5 minutos; `timezone` conhecido. Os problemas do horário vêm com `data.reason` (`timezone_unknown`, `days_empty`, `days_range`, `time_invalid`, `interval_range`, `cron_invalid`, `too_often`, `never_runs`, `signal_invalid`), que o app escreve no idioma do dono (15.6); a mensagem em inglês fica para quem não conhece o código.
 
 ### 20.9 App
 
@@ -1195,7 +1198,7 @@ Sem jargão (15.2): o dono não vê "cron", "overlap" nem "timezone" no caminho
 
 ### 20.10 Fora desta etapa
 
-- Sinais entre bots disparando rotinas (seção 18, item 7).
+- Sinais entre bots disparando rotinas (seção 18, item 7). Feito depois, em 20.13.
 - Notificação do Windows quando uma rotina termina ou falha.
 - Acordar o PC para uma rotina.
 
@@ -1219,6 +1222,20 @@ Pedido para fazer algo em horário marcado ("confere o e-mail todo dia às 8"),
 - **Regras do bot** (5.1): trabalho em horário marcado é `schedule_routine`; é a única forma de agendar, e o bot só diz que agendou depois que a tool diz que criou.
 - Mudar, pausar e apagar rotinas continua sendo só do dono, pelo app.
 
+### 20.13 Sinais entre bots
+
+Uma rotina pode esperar um **aviso** (sinal) em vez de um horário: ela roda quando um bot da equipe diz que algo aconteceu. Exemplo: o @writer salva o relatório e avisa `relatorio-pronto`; a rotina "Revisar o relatório" do @revisor roda na hora, sem o dono no meio e sem o @writer precisar saber quem revisa.
+
+- **Agendamento.** Um `kind` novo em `schedule` (20.2): `{"kind": "signal", "name": "relatorio-pronto"}`. O nome é guardado normalizado, como um slug (minúsculas, números e hífens, sem acento, até 32 caracteres: "Relatório Pronto" vira `relatorio-pronto`); sem letra nem número, é `validation` com `data.reason: signal_invalid`. A rotina não tem horário: `next_run_at` fica `null`, o agendador nunca a dispara, e `missed` e o fuso não valem para ela. "Rodar agora" e ligar e desligar valem como em qualquer rotina.
+- **Mandar.** A tool `send_signal {name, note?}` (10): o nome é normalizado igual, e a nota (até 2 000 caracteres) vai junto para quem roda. Para cada rotina ligada de um bot ativo da **mesma crew** que espera aquele nome, o daemon tenta uma execução agora, pelas regras de 20.3: bot ou crew pausados viram `skipped` (`bot_paused`), e a sobreposição vale como sempre. O próprio bot que avisa também pode ter uma rotina esperando o aviso.
+- **Espaçamento.** Uma rotina roda por aviso no máximo uma vez a cada 5 minutos, como o espaçamento dos horários (20.2): um aviso que chega antes disso vira `skipped` com `reason: too_soon`. Assim dois bots que se avisam em círculo não gastam o plano do dono.
+- **Resposta ao bot.** O nome normalizado e, para cada rotina alcançada, o nome, o bot e se rodou, com o porquê quando não rodou. Nenhuma rotina esperando não é erro: a resposta diz que nada rodou.
+- **O que o bot que roda recebe** (9.3): `[botloft] routine "<nome>" · signal "<aviso>" from @writer` (ou `from a deleted bot`), a linha de que ninguém está olhando, o pedido do dono e, se veio nota, a nota depois, marcada como escrita por um bot e não pelo dono.
+- **Execução.** `RoutineRun.signal` guarda `{name, fromBotId, note}`; `routine_runs` ganha `signal_name`, `signal_from` (sem chave estrangeira: um bot excluído só deixa o id) e `signal_note` (migration 0017).
+- **Achar os avisos.** `crew_roster` lista em `signals` cada aviso que uma rotina da crew espera, com a rotina e o bot. As regras do bot (5.1) dizem para mandar o aviso quando o que ele nomeia estiver feito. `schedule_routine` (20.12) aceita o mesmo `kind`, então um bot pode pedir ao dono uma rotina por aviso.
+- **App.** Em "Quando", a opção "Quando um bot avisar", com o campo "Aviso" e a explicação de que o dono deve dizer ao outro bot, nas instruções dele, quando avisar. Em "Mais opções" sobra só a regra de sobreposição. Na lista: "Quando um bot avisar “relatorio-pronto”" e "Espera um aviso" no lugar da próxima vez; a última execução diz de quem veio o aviso ("aviso de Writer"), e um aviso cedo demais aparece como pulado.
+- **Fora desta etapa:** escolher de qual bot o aviso precisa vir; avisos entre crews; o dono mandar um aviso pelo app.
+
 ## 21. Navegador
 
 Status: **N1, N2, N3, N3.1, N3.2 e N3.3 implementados** (21.11); N4 é a seção 22.