portable-agent-layer 0.70.0 → 0.72.0

package/src/hooks/LedgerUnapplied.ts

@@ -20,27 +20,11 @@
  * Silent and fail-open, for the same reason as the other halves.
  */
 
-import { existsSync, readFileSync } from "node:fs";
-import {
-  claimPending,
-  type PendingSnapshot,
-  reapStalePending,
-  recordAction,
-} from "./lib/ledger";
-import { ledgeredCalls, unappliedVerdictOf } from "./lib/ledger-hook";
+import { reapStalePending } from "./lib/ledger";
+import { commitUnapplied, ledgeredCalls, unappliedVerdictOf } from "./lib/ledger-hook";
 import { logDebug } from "./lib/log";
 import { readStdinJSON } from "./lib/stdin";
 
-/**
- * The snapshot is the trustworthy source, but its absence is recoverable here
- * in a way it never is after a successful edit: nothing landed, so whatever is
- * on disk now is still the before-state.
- */
-function beforeState(pending: PendingSnapshot | null, target: string): string | null {
-  if (pending) return pending.before;
-  return existsSync(target) ? readFileSync(target, "utf-8") : null;
-}
-
 try {
   const input = await readStdinJSON<Record<string, unknown>>();
   if (!input) process.exit(0);
@@ -50,16 +34,7 @@ try {
   if (!verdict) process.exit(0);
 
   for (const call of calls) {
-    const entry = recordAction({
-      tool: call.tool,
-      target: call.target,
-      outcome: verdict.outcome,
-      before: beforeState(claimPending(call.toolUseId), call.target),
-      // Nothing landed. That is what this event means, and it is the difference
-      // between this entry and an applied one.
-      after: null,
-      reason: verdict.reason,
-    });
+    const entry = commitUnapplied(call, verdict);
     logDebug("LedgerUnapplied", `recorded ${entry.id} ${entry.outcome} ${entry.target}`);
   }
 

package/src/hooks/LoadContext.ts

@@ -1,97 +1,70 @@
 /**
  * Hook: SessionStart — Injects dynamic context + regenerates AGENTS.md if stale.
  *
- * Static context (TELOS, setup prompt) is loaded natively from AGENTS.md / CLAUDE.md.
- * This hook injects dynamic context only: wisdom principles, relationship notes,
- * learning digest, signal trends, failure patterns, active work state.
+ * Static context (TELOS, setup prompt) is loaded natively from AGENTS.md /
+ * CLAUDE.md. This hook injects dynamic context only: wisdom principles,
+ * relationship notes, learning digest, signal trends, failure patterns, work state.
  *
- * Copilot: the CLI reads additionalContext from this hook's stdout, while
- * ~/.copilot/instructions/ is read only by the VS Code extension. The merged
- * context goes to both so either surface picks it up.
+ * Which agent gets what, in which envelope, is in lib/session-context.ts.
  */
 
 import { mkdirSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { getActiveAgent, isCodex, isCopilot, isCursor } from "./lib/agent";
+import { getActiveAgent } from "./lib/agent";
 import { buildClaudeMd, regenerateIfNeeded } from "./lib/claude-md";
 import { type AgentTarget, buildSystemReminder } from "./lib/context";
 import { logContextSnapshot, logDebug, logError } from "./lib/log";
 import { platform } from "./lib/paths";
+import {
+  contextEnvelope,
+  copilotInstructions,
+  isSubagentSession,
+  needsAgentsMd,
+} from "./lib/session-context";
 import { isPalSpawnedInference } from "./lib/spawn-guard";
 
 // Recursion guard — when this process is a PAL-spawned inference subprocess,
 // skip all context loading so we don't trigger another inference call.
 if (isPalSpawnedInference()) process.exit(0);
 
-// --- Skip heavy context for subagents ---
-const isSubagent =
-  process.env.CLAUDE_PROJECT_DIR?.includes("/.claude/Agents/") ||
-  process.env.CLAUDE_AGENT_TYPE !== undefined;
-
-if (isSubagent) {
+if (isSubagentSession(process.env)) {
   logDebug("LoadContext", "Subagent session — skipping context loading");
   process.exit(0);
 }
 
-// --- Regenerate CLAUDE.md if telos or setup changed ---
 try {
-  const rebuilt = regenerateIfNeeded();
-  if (rebuilt) logDebug("LoadContext", "AGENTS.md regenerated");
+  if (regenerateIfNeeded()) logDebug("LoadContext", "AGENTS.md regenerated");
 } catch (err) {
   logError("LoadContext:regenerate", err);
 }
 
-// --- Context to stdout (or file for Copilot) ---
 try {
-  // Determine agent target — controls which sections are skipped (loaded natively instead).
   const active = getActiveAgent();
-  const agent: AgentTarget =
+  // The reminder is built for one of three targets; every other agent reads the
+  // same shape Claude Code does.
+  const target: AgentTarget =
     active === "copilot" || active === "cursor" ? active : "claude";
-  const reminder = buildSystemReminder({ agent });
+  const reminder = buildSystemReminder({ agent: target });
   if (!reminder) process.exit(0);
   logContextSnapshot(reminder);
 
-  if (isCopilot()) {
-    // Copilot: semi-static in ~/.copilot/instructions/pal-*.instructions.md (written at stop).
-    // Write AGENTS.md + dynamic context to pal-session.instructions.md on each session start.
-    const instructionsDir = resolve(platform.copilotDir(), "instructions");
-    mkdirSync(instructionsDir, { recursive: true });
-    const agentsMd = buildClaudeMd();
-    const context = [agentsMd, reminder].filter(Boolean).join("\n\n");
-    if (context) {
-      writeFileSync(
-        resolve(instructionsDir, "pal-session.instructions.md"),
-        `---\napplyTo: "**"\n---\n\n${context}`,
-        "utf-8"
-      );
-      process.stdout.write(JSON.stringify({ additionalContext: context }));
-    }
-    logDebug(
-      "LoadContext",
-      `Copilot session instructions written: ${context.length} chars`
-    );
-  } else if (isCursor()) {
-    // Cursor: semi-static in ~/.cursor/rules/pal-context.mdc; inject AGENTS.md + dynamic here
-    const agentsMd = buildClaudeMd();
-    const context = [agentsMd, reminder].filter(Boolean).join("\n\n");
-    process.stdout.write(JSON.stringify({ additional_context: context }));
-    logDebug("LoadContext", `Reminder injected: ${reminder.length} chars`);
-  } else if (isCodex()) {
-    // Codex: AGENTS.md already loaded via symlink; inject only dynamic context
-    process.stdout.write(
-      JSON.stringify({
-        hookSpecificOutput: {
-          hookEventName: "SessionStart",
-          additionalContext: reminder,
-        },
-      })
-    );
-    logDebug("LoadContext", `Codex reminder injected: ${reminder.length} chars`);
-  } else {
-    // Claude Code (and opencode, which uses the plugin path not this hook): raw text
-    console.log(reminder);
-    logDebug("LoadContext", `Reminder injected: ${reminder.length} chars`);
+  const envelope = contextEnvelope(
+    active,
+    reminder,
+    needsAgentsMd(active) ? buildClaudeMd() : ""
+  );
+  if (!envelope) process.exit(0);
+
+  if (envelope.file) {
+    const dir = resolve(platform.copilotDir(), "instructions");
+    mkdirSync(dir, { recursive: true });
+    const path = resolve(dir, "pal-session.instructions.md");
+    writeFileSync(path, copilotInstructions(envelope.file), "utf-8");
   }
+
+  if (envelope.kind === "text") console.log(envelope.payload);
+  else process.stdout.write(envelope.payload);
+  logDebug("LoadContext", `Reminder injected: ${reminder.length} chars`);
 } catch (err) {
   logError("LoadContext:reminder", err);
 }

package/src/hooks/SecurityValidator.ts

@@ -3,125 +3,32 @@
  * Emits the current agent's deny response to block, or exits silently to allow.
  *
  * Fail-open design: if anything goes wrong, the command is allowed through.
+ *
+ * The decision itself is in lib/security-gate.ts, where a test can import it.
  */
 
-import { blockResponse, normalizeToolUse } from "./lib/agent";
-import { logDebug } from "./lib/log";
-import { checkBashCommand, checkFilePath } from "./lib/security";
+import { blockResponse } from "./lib/agent";
+import { recordBlocked } from "./lib/ledger";
+import { logError } from "./lib/log";
+import { decideRefusal, type SecurityInput } from "./lib/security-gate";
 import { readStdinJSON } from "./lib/stdin";
 
-// beforeShellExecution shape (Cursor only) — flat, no tool-name wrapper
-interface ShellExecInput {
-  command: string;
-  sandbox?: boolean;
-}
-
-type SecurityInput = Record<string, unknown> | ShellExecInput;
-
-function isShellExec(input: SecurityInput): input is ShellExecInput {
-  return !("tool_name" in input) && !("toolName" in input) && "command" in input;
-}
-
-// A name this list misses is a command this hook waves through, so both sets mirror
-// the tool names VS Code's own Copilot build ships in its shell and edit tool sets.
-const SHELL_TOOLS = [
-  "bash",
-  "shell",
-  "powershell",
-  "local_shell",
-  "runinterminal",
-  "run_in_terminal",
-  "terminal",
-  "execute_command",
-];
-
-const FILE_WRITE_TOOLS = [
-  "write",
-  "edit",
-  "multiedit",
-  "write_file",
-  "apply_patch",
-  "applypatch",
-  "create",
-  "create_file",
-  "createfile",
-  "str_replace",
-  "str_replace_editor",
-  "insert",
-  "insert_edit_into_file",
-  "replace_string_in_file",
-  "multi_replace_string_in_file",
-  "replacestring",
-  "edit_notebook_file",
-  "notebookedit",
-];
-
-/** First of `keys` present as a non-empty string — agents disagree on argument spelling. */
-function firstStringArg(
-  args: Record<string, unknown>,
-  keys: string[]
-): string | undefined {
-  for (const key of keys) {
-    const value = args[key];
-    if (typeof value === "string" && value.length > 0) return value;
-  }
-  return undefined;
-}
-
-/** Tool names that run a shell command, across every agent's naming. */
-function runsShellCommand(toolName: string): boolean {
-  return SHELL_TOOLS.includes(toolName.toLowerCase());
-}
-
-/** Tool names that write to a file, across every agent's naming. */
-function writesFile(toolName: string): boolean {
-  return FILE_WRITE_TOOLS.includes(toolName.toLowerCase());
-}
-
 try {
   const input = await readStdinJSON<SecurityInput>();
   if (!input) process.exit(0);
 
-  if (isShellExec(input)) {
-    // beforeShellExecution — command is always a shell command
-    const reason = checkBashCommand(input.command);
-    if (reason) {
-      process.stdout.write(blockResponse(`Blocked: ${reason}`));
-    }
-    process.exit(0);
-  }
-
-  const toolUse = normalizeToolUse(input);
-  if (!toolUse) process.exit(0);
+  const refusal = decideRefusal(input, process.cwd());
+  if (!refusal) process.exit(0);
 
-  // Each agent names its shell/write tools differently; log the real name so an
-  // unrecognized one shows up here instead of silently skipping the check.
-  logDebug(
-    "SecurityValidator",
-    `toolName=${toolUse.toolName} args=${Object.keys(toolUse.toolInput).join(",")}`
-  );
-
-  const command = firstStringArg(toolUse.toolInput, ["command", "commandLine", "script"]);
-  if (runsShellCommand(toolUse.toolName) && typeof command === "string") {
-    const reason = checkBashCommand(command);
-    const verdict = reason ? `BLOCK(${reason})` : "ALLOW";
-    // "No output" from a downstream tool is indistinguishable between "denied,
-    // never ran" and "ran, produced nothing" — logging the verdict here, next
-    // to the literal command, is what actually tells the two apart.
-    logDebug("SecurityValidator", `bashVerdict=${verdict} command=${command}`);
-    if (reason) {
-      process.stdout.write(blockResponse(`Blocked: ${reason}`, toolUse.hookEventName));
-      process.exit(0);
-    }
-  }
+  process.stdout.write(blockResponse(refusal.message, refusal.hookEventName));
 
-  const filePath = firstStringArg(toolUse.toolInput, ["file_path", "filePath", "path"]);
-  if (writesFile(toolUse.toolName) && typeof filePath === "string") {
-    const reason = checkFilePath(filePath);
-    if (reason) {
-      process.stdout.write(blockResponse(reason, toolUse.hookEventName));
-      process.exit(0);
-    }
+  // After the deny has gone out, in its own try/catch: this hook is fail-open,
+  // and a ledger that threw on its way to recording a block would turn the
+  // block into an allow.
+  try {
+    recordBlocked(refusal);
+  } catch (err) {
+    logError("SecurityValidator:ledger", err);
   }
 } catch {
   // Fail open

package/src/hooks/handlers/agenda.ts

@@ -0,0 +1,223 @@
+/**
+ * Stop handler: what to do tomorrow morning.
+ *
+ * Two jobs, both too slow and too expensive for a page load, so both happen
+ * here and land in files the morning screen only reads.
+ *
+ * 1. Guess what each project serves, once, so importance can be ranked at all.
+ *    A guess never overwrites the user's own answer.
+ * 2. Write three moves for the day — sentences, not project names, because the
+ *    answer to "what now" is rarely "open a repository".
+ */
+
+import { matrix } from "../../tools/control-room/matrix";
+import { type AgendaMove, readAgenda, writeAgenda } from "../lib/agenda-store";
+import { canInfer, inference } from "../lib/inference";
+import { logDebug, logError } from "../lib/log";
+import { readAllProjects } from "../lib/projects";
+import { isServesKind, SERVES_KINDS, setServes } from "../lib/serves";
+import { readTelosGoals } from "../lib/telos-goals";
+import { logTokenUsage } from "../lib/token-usage";
+
+const FRESH_HOURS = 6;
+const MAX_PROJECTS_PER_GUESS = 40;
+
+function hoursSince(iso: string, now: Date): number {
+  const at = new Date(iso).getTime();
+  if (!Number.isFinite(at)) return Number.POSITIVE_INFINITY;
+  return (now.getTime() - at) / 3_600_000;
+}
+
+const SERVES_SCHEMA = {
+  type: "object" as const,
+  additionalProperties: false,
+  properties: {
+    projects: {
+      type: "array" as const,
+      description: "One entry per project you were given, no others",
+      items: {
+        type: "object" as const,
+        additionalProperties: false,
+        properties: {
+          name: { type: "string" as const },
+          serves: { type: "string" as const, enum: SERVES_KINDS },
+          note: {
+            type: "string" as const,
+            description: "Six words at most on what it serves",
+          },
+        },
+        required: ["name", "serves", "note"] as const,
+      },
+    },
+  },
+  required: ["projects"] as const,
+};
+
+const MOVES_SCHEMA = {
+  type: "object" as const,
+  additionalProperties: false,
+  properties: {
+    moves: {
+      type: "array" as const,
+      description: "Exactly three, most consequential first",
+      items: {
+        type: "object" as const,
+        additionalProperties: false,
+        properties: {
+          move: {
+            type: "string" as const,
+            description: "One sentence, an action the user can start today",
+          },
+          because: {
+            type: "string" as const,
+            description: "One short clause naming the evidence it came from",
+          },
+        },
+        required: ["move", "because"] as const,
+      },
+    },
+  },
+  required: ["moves"] as const,
+};
+
+function goalsBrief(): string {
+  const goals = readTelosGoals();
+  if (goals.length === 0) return "The user has not written any goals down yet.";
+  return goals
+    .map((g) => {
+      const by = g.due ? ` [by ${g.due}]` : "";
+      return `- ${g.text}${by}`;
+    })
+    .join("\n");
+}
+
+/** A model's JSON is untrusted input like any other payload. */
+function parsePayload<T>(raw: string, caller: string): T | null {
+  try {
+    return JSON.parse(raw) as T;
+  } catch (err) {
+    logError(caller, err);
+    return null;
+  }
+}
+
+/** Only projects with no purpose on record — a guess is made once, not nightly. */
+async function guessMissingServes(sessionId?: string): Promise<number> {
+  const missing = readAllProjects()
+    .filter((p) => !p.serves && (p.status === "active" || p.status === "paused"))
+    .slice(0, MAX_PROJECTS_PER_GUESS);
+  if (missing.length === 0) return 0;
+
+  const described = missing
+    .map((p) => {
+      const purpose = (p.goal ?? p.problem ?? "").replace(/\s+/g, " ").slice(0, 200);
+      return `- ${p.name}: ${purpose || "no description on record"}`;
+    })
+    .join("\n");
+
+  const result = await inference({
+    system: [
+      "You are told a person's goals and a list of their projects.",
+      "For each project, decide which of three things it serves:",
+      '"goal" — it moves one of the stated goals forward;',
+      '"revenue" — it is a way the work could pay, even speculatively;',
+      '"fun" — it is kept for its own sake.',
+      "Judge from the goals and the project description only. Never assume a project is unimportant because it is small or quiet.",
+      "Return one entry per project you were given.",
+    ].join("\n"),
+    user: `Their goals:\n${goalsBrief()}\n\nTheir projects:\n${described}`,
+    maxTokens: 700,
+    timeout: 90000,
+    jsonSchema: SERVES_SCHEMA,
+    caller: "agenda-serves",
+    sessionId,
+  });
+  if (result.usage) logTokenUsage("agenda-serves", result.usage);
+  if (!result.success || !result.output) return 0;
+
+  const parsed = parsePayload<{
+    projects: { name: string; serves: string; note: string }[];
+  }>(result.output, "agenda:serves");
+  if (!parsed?.projects) return 0;
+
+  const known = new Set(missing.map((p) => p.name));
+  let written = 0;
+  for (const guess of parsed.projects) {
+    if (!known.has(guess.name) || !isServesKind(guess.serves)) continue;
+    const outcome = setServes({
+      name: guess.name,
+      kind: guess.serves,
+      note: guess.note,
+      by: "inferred",
+    });
+    if (outcome === "written") written++;
+  }
+  return written;
+}
+
+function matrixBrief(): string {
+  const grid = matrix();
+  const lines = [...grid.now, ...grid.plan, ...grid.noise].map((item) => {
+    const why = item.urgentBecause.join(", ") || "nothing pressing";
+    const waiting = item.waitingOn ? ` — waiting on the user for: ${item.waitingOn}` : "";
+    return `- [${item.kind}] ${item.label}: ${item.importantBecause}; ${why}${waiting}`;
+  });
+  return lines.length > 0 ? lines.join("\n") : "Nothing is ranked yet.";
+}
+
+async function writeMoves(sessionId?: string): Promise<boolean> {
+  const result = await inference({
+    system: [
+      "You write the first three lines a person reads in the morning.",
+      "You are given their goals and a ranked list of their projects and goals with the reason each was ranked.",
+      "Write exactly three moves, most consequential first.",
+      "A move is a sentence naming an action, not a project name: 'Send ACE the mapping one-pager' beats 'work on ontology'.",
+      "Prefer what is blocked on the person themselves, then what serves a goal, then what is merely urgent.",
+      "Never invent a fact that is not in what you were given.",
+    ].join("\n"),
+    user: `Their goals:\n${goalsBrief()}\n\nWhat is ranked and why:\n${matrixBrief()}`,
+    maxTokens: 400,
+    timeout: 90000,
+    jsonSchema: MOVES_SCHEMA,
+    caller: "agenda-moves",
+    sessionId,
+  });
+  if (result.usage) logTokenUsage("agenda-moves", result.usage);
+  if (!result.success || !result.output) return false;
+
+  const parsed = parsePayload<{ moves: AgendaMove[] }>(result.output, "agenda:moves");
+  const moves = (parsed?.moves ?? []).filter((m) => m.move).slice(0, 3);
+  if (moves.length === 0) return false;
+
+  await writeAgenda({ generatedAt: new Date().toISOString(), moves });
+  return true;
+}
+
+/** Named so the caller — and a test — can tell a skip from a failure. */
+export type AgendaOutcome = "fresh" | "no-inference" | "written" | "failed";
+
+/** @lintignore exercised directly by test/agenda-handler.test.ts */
+export async function refreshAgenda(
+  now: Date = new Date(),
+  sessionId?: string
+): Promise<AgendaOutcome> {
+  const existing = readAgenda();
+  if (existing && hoursSince(existing.generatedAt, now) < FRESH_HOURS) return "fresh";
+  if (!canInfer()) return "no-inference";
+
+  const guessed = await guessMissingServes(sessionId);
+  const wrote = await writeMoves(sessionId);
+  logDebug("agenda", `serves guessed: ${guessed}, moves written: ${wrote}`);
+  return wrote ? "written" : "failed";
+}
+
+if (process.argv[2] === "--run") {
+  const sid = process.argv[3];
+  try {
+    const outcome = await refreshAgenda(new Date(), sid === "" ? undefined : sid);
+    logDebug("agenda", outcome);
+  } catch (err) {
+    logError("agenda:run", err);
+  }
+  process.exit(0);
+}

package/src/hooks/handlers/failure-principle.ts

@@ -11,24 +11,22 @@
 
 import { existsSync } from "node:fs";
 import { readFile, unlink } from "node:fs/promises";
-import { extractContent, parseMessages } from "../lib/transcript";
+import {
+  mergeInferredPrinciple,
+  needsInference,
+  type PendingFailure,
+  principleRequest,
+  recentExchange,
+} from "../lib/failure-principle";
 import { captureFailure } from "./failure";
 
-interface PendingFailure {
-  rating: number;
-  context: string;
-  detailedContext?: string;
-  principle?: string;
-  responsePreview?: string;
-  userPreview?: string;
-  cwd?: string;
-}
-
 /**
  * Inference the principle (if missing) and persist the failure record.
  * Reads pending data + transcript from the provided tmp paths and unlinks them.
+ *
+ * @lintignore exercised directly by test/failure-principle.test.ts
  */
-async function processFailurePrinciple(
+export async function processFailurePrinciple(
   pendingPath: string,
   transcriptPath: string
 ): Promise<void> {
@@ -47,42 +45,19 @@ async function processFailurePrinciple(
     logDebug("failure-principle", `processing rating=${pending.rating}`);
 
     let { principle, detailedContext } = pending;
-    if (!principle) {
+    if (needsInference(pending)) {
       try {
         const { inference } = await import("../lib/inference");
-        const msgs = parseMessages(transcript);
-        const recent = msgs
-          .slice(-10)
-          .map((m) => `${m.role.toUpperCase()}: ${extractContent(m).slice(0, 300)}`)
-          .join("\n\n");
-
-        const result = await inference({
-          system: `Analyze this failed AI interaction (rated ${pending.rating}/10). Return JSON: {"principle": "<verb-first actionable rule, 10-20 words — write a full sentence, not a fragment>", "detailed_context": "<root cause and what to do differently, 50-150 words>"}.`,
-          user: `User feedback: ${pending.context}\n\nConversation:\n${recent}`,
-          maxTokens: 400,
-          timeout: 90000,
-          jsonSchema: {
-            type: "object" as const,
-            properties: {
-              principle: { type: "string" as const },
-              detailed_context: { type: "string" as const },
-            },
-            required: ["principle", "detailed_context"],
-            additionalProperties: false,
-          },
-          caller: "failure-principle",
-        });
-
-        if (result.success && result.output) {
-          const parsed = JSON.parse(result.output) as {
-            principle?: string;
-            detailed_context?: string;
-          };
-          principle = parsed.principle || undefined;
-          detailedContext ??= parsed.detailed_context || undefined;
-        } else {
+        const result = await inference(
+          principleRequest(pending, recentExchange(transcript))
+        );
+        if (!result.success || !result.output) {
           logError("failure-principle", `inference failed (no output)`);
         }
+        ({ principle, detailedContext } = mergeInferredPrinciple(
+          pending,
+          result.output ?? null
+        ));
       } catch (err) {
         logError("failure-principle:inference", err);
       }

package/src/hooks/handlers/inject-retrieval.ts

@@ -14,6 +14,7 @@ import { ensureIndex } from "../lib/retrieval-index";
 import { isEnabled } from "../lib/settings";
 import { getSkillReminder } from "../lib/skill-match";
 import { getSteeringReminder } from "../lib/steering";
+import { getWallClockReminder } from "../lib/wall-clock";
 
 const BUDGET_MS = 250;
 
@@ -79,11 +80,14 @@ function writeForAgent(reminder: string): void {
   }
 }
 
-/** Merge every prompt-time source — contextual steering, skill matches, prior-lesson
- *  retrieval — into one payload, or null when none of them produced anything.
+/** Merge every prompt-time source — the wall clock, contextual steering, skill
+ *  matches, prior-lesson retrieval — into one payload, or null when none of them
+ *  produced anything. The clock leads: it is the only part that is true of the
+ *  moment rather than of the prompt.
  *  @lintignore dynamically imported by opencode plugin */
 export async function getPromptContext(prompt: string): Promise<string | null> {
   const parts = [
+    getWallClockReminder(),
     getSteeringReminder(prompt),
     getSkillReminder(prompt),
     await getRetrievalReminder(prompt),