phaedo-mcp 0.3.13 → 0.3.15

package/README.md

@@ -435,9 +435,13 @@ ask me before posting in #eng". When the answer is no, it stays quiet.
 - **Outcomes are yours, never inferred.** The hook records `approved` only when it has
   evidence you were asked: Claude Code fired PermissionRequest for that call, and the
   call then ran. In auto mode that counts only when Phaedo itself asked (the prompt it forced
-  is yours; any other is the classifier's); in dontAsk, never. Decline and the agent records `rejected` (Claude Code fires no hook for a
-  decline). No prompt shown, nothing recorded; the agent is told so, and records your
-  reaction only if you give one.
+  is yours; any other is the classifier's); in dontAsk, never. **Decline and that is recorded too:**
+  Claude Code fires no hook for a decline, but it marks it in the session's own transcript, so
+  at your next message (or when the turn ends) the hook reads the end of the transcript for its
+  open calls and records `rejected` — or `modified` if you said what to do instead. Only a
+  person's no counts (auto mode's classifier saying no, or quitting the app, records nothing),
+  and an outcome the agent already recorded is kept. No prompt shown, nothing recorded; the
+  agent is told so, and records your reaction only if you give one.
 - **What a merge changes.** Before `gh pr merge` the hook reads the PR from GitHub (read-only):
   failing or unfinished checks, a large diff (> 1,000 code lines or > 20 files), or a sensitive
   path (CI/deploy config, auth/crypto/secrets by name, or your repo's `.phaedo-sensitive` list,
@@ -524,8 +528,15 @@ Quick readout on your own machine:
 cd mcp && npm run receipts                          # decrypts locally, lists the last 50 (with a short id per line)
 node receipts.js mark <id|prefix|latest> approved   # record what YOU did → approved | rejected | modified | unknown
 npm run agreement                                   # per-domain agreement rate (oracle vs your actual decisions)
+npm run asks                                        # are you being asked less? last 4 weeks vs the 4 before
+npm run asks -- --weeks 12 --table                  # …week by week
 ```
 
+`npm run asks` is the number Phaedo is judged by: how often it brought an action to you, whether
+that is falling, how often you reversed what it decided alone, and which asks were about things
+that could be undone and you approved as-is (the asks it should learn to drop). `/phaedo:status`
+adds the headline once each half of the window holds 5 checks.
+
 `user_action` is **subject-authored**: set it from what *you* decided, not from whether an
 agent proceeded. Until receipts carry one, `npm run agreement` shows `—`
 (no data ≠ 0%); each one you mark makes the rate live. Metric definition:

package/agreement.js

@@ -30,7 +30,7 @@
 export const DECISIVE = ['proceed', 'proceed_with_note', 'decline'];
 export const DEFAULT_WINDOW_DAYS = 30;
 
-function agrees(signal, userAction) {
+export function agrees(signal, userAction) {
   if (userAction === 'approved') return signal === 'proceed' || signal === 'proceed_with_note';
   if (userAction === 'rejected') return signal === 'decline';
   return false; // 'modified' — the action was not accepted as-judged

package/asks.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+// "Are you being asked less?" — the number Phaedo's purpose is judged by.
+//
+// Phaedo's promise: agents stop interrupting you for things you'd have said yes to, and still
+// bring you the irreversible, high-stakes ones. weekly.js counts one week; this reads the local
+// decision records (receipts.js) week by week so the trend shows, together with the two checks
+// that keep a falling number honest:
+//
+//   checked    — every action an agent brought to Phaedo
+//   asked      — Phaedo sent it to you (escalate / clarify)
+//   quiet      — Phaedo decided without asking (proceed / proceed_with_note / decline)
+//   overruled  — a quiet call you then reversed (agreement.js scoring). The cost of asking less.
+//   confirmed  — a quiet call you then agreed with
+//   avoidable  — an ask about something that could be undone, which you approved as-is: the asks
+//                Phaedo should learn to stop making. An ask about an irreversible action is never
+//                avoidable — those are the subject's to decide.
+//   unsure     — insufficient_signal: neither an ask nor a call
+//
+// The trend compares the ask rate of the recent half of the window with the half before it, and
+// says nothing until each half holds MIN_TO_COMPARE checks — a rate over a handful is noise.
+// Pure over the receipts list; the CLI reads the local store.
+//
+//   npm run asks                       last 8 weeks, in plain lines
+//   npm run asks -- --weeks 12 --table week by week
+
+import { readReceipts } from './receipts.js';
+import { defaultStateDir } from './cache.js';
+import { DECISIVE, agrees } from './agreement.js';
+import { isMainModule } from './lib/is-main.js';
+
+export const DEFAULT_WEEKS = 8;
+export const MIN_TO_COMPARE = 5;
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+const ASKED = new Set(['escalate', 'clarify']);
+
+const empty = () => ({ checked: 0, asked: 0, quiet: 0, overruled: 0, confirmed: 0, avoidable: 0, unsure: 0 });
+
+function tally(row, r) {
+  const signal = r?.response?.signal;
+  const action = r?.user_action;
+  if (ASKED.has(signal)) {
+    row.checked++; row.asked++;
+    if (action === 'approved' && r?.request?.action_descriptor?.reversible === true) row.avoidable++;
+  } else if (DECISIVE.includes(signal)) {
+    row.checked++; row.quiet++;
+    if (action && action !== 'unknown') { if (agrees(signal, action)) row.confirmed++; else row.overruled++; }
+  } else if (signal === 'insufficient_signal') {
+    row.checked++; row.unsure++;
+  }
+}
+
+function sum(rows) {
+  const out = empty();
+  for (const row of rows) for (const k of Object.keys(out)) out[k] += row[k];
+  out.ask_rate = out.checked ? out.asked / out.checked : null;
+  return out;
+}
+
+/**
+ * (receipts, { now, weeks }) -> { weeks: [row…] oldest first, recent, earlier, half_weeks, total }.
+ * `recent` is the newest half of the window, `earlier` the equal span before it (an odd oldest week
+ * is left out of the comparison, never folded into one side).
+ */
+export function asksByWeek(receipts, { now = Date.now(), weeks = DEFAULT_WEEKS } = {}) {
+  const n = Math.max(2, Math.floor(Number(weeks)) || DEFAULT_WEEKS);
+  const start = now - n * WEEK_MS;
+  const rows = Array.from({ length: n }, (_, i) => ({ start: new Date(start + i * WEEK_MS).toISOString(), ...empty() }));
+  for (const r of Array.isArray(receipts) ? receipts : []) {
+    const t = Date.parse(r?.created_at);
+    if (!Number.isFinite(t) || t < start || t > now) continue;
+    tally(rows[Math.min(n - 1, Math.floor((t - start) / WEEK_MS))], r);
+  }
+  for (const row of rows) row.ask_rate = row.checked ? row.asked / row.checked : null;
+  const half = Math.floor(n / 2);
+  return {
+    weeks: rows,
+    half_weeks: half,
+    recent: sum(rows.slice(n - half)),
+    earlier: sum(rows.slice(n - 2 * half, n - half)),
+    total: sum(rows),
+  };
+}
+
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+const pct = (x) => `${Math.round(x * 100)}%`;
+
+/** The headline: how often Phaedo asked lately, and whether that is falling. */
+export function headline(rep) {
+  const { recent: r, earlier: e, half_weeks: h } = rep;
+  const span = plural(h, 'week');
+  if (!r.checked) return `No actions came to Phaedo in the last ${span}.`;
+  const first = `In the last ${span} Phaedo checked ${plural(r.checked, 'action')} and asked you about ${r.asked} (${pct(r.ask_rate)}).`;
+  if (r.checked < MIN_TO_COMPARE || e.checked < MIN_TO_COMPARE) return `${first} Not enough yet to say whether that is falling.`;
+  const diff = Math.round(r.ask_rate * 100) - Math.round(e.ask_rate * 100);
+  if (diff === 0) return `${first} That's the same as the ${span} before.`;
+  return `${first} That's ${diff < 0 ? 'down' : 'up'} from ${pct(e.ask_rate)} the ${span} before.`;
+}
+
+/** Plain lines for a person: the headline, what asking less cost, and the asks it could drop. */
+export function formatAsks(rep) {
+  const r = rep.recent;
+  const lines = [headline(rep)];
+  if (r.quiet) {
+    const answered = r.confirmed + r.overruled;
+    // An answer on a quiet call means the subject was in the loop anyway — from the ship and
+    // agent hooks, only ever because the app showed its own approval prompt. Said plainly: it
+    // is the next interruption to remove, not a win to count.
+    lines.push(answered
+      ? `It decided ${plural(r.quiet, 'time')} without asking. You still had to answer ${answered} of those yourself, and reversed ${r.overruled}.`
+      : `It decided ${plural(r.quiet, 'time')} without asking; none of those has an answer from you yet.`);
+  }
+  if (r.avoidable) {
+    lines.push(`${r.avoidable === 1 ? 'One ask was' : `${r.avoidable} asks were`} about something that could be undone and you said yes as-is — ${r.avoidable === 1 ? 'that is' : 'those are'} what it should learn to stop asking.`);
+  }
+  return lines.join('\n');
+}
+
+/** For /phaedo:status: the headline only once there is a trend to show; '' until then. */
+export function trendLine(rep) {
+  return rep.recent.checked >= MIN_TO_COMPARE && rep.earlier.checked >= MIN_TO_COMPARE ? headline(rep) : '';
+}
+
+/** Week by week, for the curious: `--table`. */
+export function formatTable(rep) {
+  return rep.weeks.map((w) => {
+    const day = new Date(w.start).toLocaleDateString('en-US', { month: 'short', day: '2-digit', timeZone: 'UTC' });
+    if (!w.checked) return `${day}  —`;
+    return `${day}  ${String(w.checked).padStart(3)} checked  ${String(w.asked).padStart(3)} asked (${pct(w.ask_rate).padStart(4)})  ${w.overruled} reversed  ${w.avoidable} could have gone ahead`;
+  }).join('\n');
+}
+
+if (isMainModule(import.meta.url)) {
+  const args = process.argv.slice(2);
+  const i = args.indexOf('--weeks');
+  const weeks = i >= 0 ? Number(args[i + 1]) : DEFAULT_WEEKS;
+  const receipts = await readReceipts(defaultStateDir()).catch(() => []);
+  const rep = asksByWeek(receipts, { weeks });
+  console.log(formatAsks(rep));
+  if (args.includes('--table')) console.log(`\n${formatTable(rep)}`);
+}

package/hooks/pre-ship.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // Phaedo — Claude Code ship hook (PreToolUse, PermissionRequest, PostToolUse,
-// PostToolUseFailure on Bash).
+// PostToolUseFailure on Bash; UserPromptSubmit and Stop to catch a "no").
 //
 // WHY THIS EXISTS. The precedent track is starved: no consultation has been written since
 // 2026-07-28, so agreement, calibration and override learning have nothing to read. The
@@ -25,7 +25,13 @@
 //     consult answered, and in any permission mode — a yes on a `proceed` is the scoreable
 //     case agreement needs.
 //   - prompt shown, then declined → Claude Code fires NO hook for a manual denial
-//     (documented), so the agent is told the receipt id up front and records `rejected`.
+//     (documented). It does write the denial into the session transcript, marked
+//     `toolDenialKind: "user-rejected"` on the call's tool_result. So at the subject's next
+//     prompt (UserPromptSubmit), or when the turn ends (Stop — a "no, do this instead"
+//     continues the turn), the hook reads the transcript's tail for its own open calls and
+//     records `rejected`, or `modified` when the subject said what to do instead. A denial by
+//     auto mode's classifier or a permission rule carries a different kind and records
+//     nothing: only a person's no counts. An outcome the agent already recorded is kept.
 //   - no prompt (bypass mode, an allow rule) → nothing recorded. After the run the agent is
 //     told so, and records the subject's reaction only if they give one. Silence is never
 //     approval.
@@ -43,6 +49,7 @@ import { createHash } from 'crypto';
 import { execFile } from 'child_process';
 import { classifyShipCommand, classifyToolCall } from '../ship-actions.js';
 import { isMainModule } from '../lib/is-main.js';
+import { isDirectoryEdition } from '../lib/config-dir.js';
 
 const MCP_DIR = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 
@@ -62,6 +69,13 @@ export const ASKING_SIGNALS = new Set(['escalate', 'clarify', 'decline']);
 // reviewer's whole point, so a yes on it is the subject's and is recorded.
 const NO_HUMAN_MODES = new Set(['auto', 'dontAsk']);
 
+// The turn events that look for a "no". Every prompt fires one, so they stay cheap: a small
+// state read, and the transcript only when this session has a consult still open.
+export const TURN_EVENTS = new Set(['UserPromptSubmit', 'Stop']);
+// How a person's denial is marked in the transcript (Claude Code), and how far back to read.
+export const USER_DENIAL = 'user-rejected';
+export const TRANSCRIPT_TAIL_BYTES = 4 * 1024 * 1024;
+
 // The profile is read from the at-rest cache, which only a live read refreshes. Past this
 // age the agent is told once a day, so the subject hears about it in plain words.
 export const STALE_PROFILE_DAYS = 14;
@@ -248,9 +262,14 @@ export function promptReason(signal, summary, why, personal = '') {
 
 // What the agent reads before the command. It carries the receipt id — the one handle
 // that attributes an outcome to THIS decision rather than whatever receipt is newest.
-export function preContext({ summary, signal, receiptId, asked, hint }) {
+export function preContext({ summary, signal, receiptId, asked, hint, recordsNo = false }) {
   const head = `Phaedo was consulted before this action (${summary}) and answered "${signal}"` +
     (hint ? ` — ${hint}` : '') + `. receipt_id: ${receiptId}.`;
+  if (asked && recordsNo) {
+    return `${head} Phaedo flagged it for the user, so they may be asked to confirm. A yes or a no on ` +
+      `the prompt is recorded automatically. If they later say they wanted it done differently, call ` +
+      `phaedo_record_outcome with this receipt_id and "modified".`;
+  }
   if (asked) {
     return `${head} Phaedo flagged it for the user, so they may be asked to confirm. If they decline, ` +
       `call phaedo_record_outcome with this receipt_id and "rejected" (or "modified" if they want it ` +
@@ -276,18 +295,64 @@ export function staleContext(days, mcpDir) {
     `\`cd ${mcpDir} && npm run pull\` and approving on their phone.`;
 }
 
+/**
+ * What the transcript says became of each call in `ids`: Map id → { denied }, where `denied` is
+ * `rejected` or `modified` for a person's no (modified when they said what to do instead), and
+ * null for any other result (it ran, failed, or something other than a person refused it).
+ * A call with no result yet is absent. Reads only the tool_result entries. PURE.
+ */
+export function callResults(jsonl, ids) {
+  const want = new Set(ids);
+  const out = new Map();
+  if (!want.size) return out;
+  const words = (c) => (typeof c === 'string' ? c : Array.isArray(c) ? c.map((p) => (typeof p?.text === 'string' ? p.text : '')).join('\n') : '');
+  for (const line of String(jsonl || '').split('\n')) {
+    if (!line.includes('tool_use_id')) continue;
+    let j;
+    try { j = JSON.parse(line); } catch { continue; }
+    for (const c of Array.isArray(j?.message?.content) ? j.message.content : []) {
+      if (c?.type !== 'tool_result' || !want.has(c.tool_use_id)) continue;
+      // Quitting the app mid-prompt is marked as a denial too; it is not a decision.
+      const byPerson = j.toolDenialKind === USER_DENIAL && !j.interruptedByShutdown;
+      out.set(c.tool_use_id, { denied: byPerson ? (/the user said:/i.test(words(c.content)) ? 'modified' : 'rejected') : null });
+    }
+  }
+  return out;
+}
+
 /**
  * One hook invocation. Pure apart from injected deps, so the whole flow is testable
  * without a vault, a receipt store or Claude Code.
  *
  * deps: { consult(req) → { response, drivers, source? }, writeReceipt({request,response,drivers}) → id,
- *         markOutcome(id, action), statePath, now, mcpDir? }
+ *         markOutcome(id, action, { keepExisting }?), statePath, now, mcpDir?,
+ *         readTranscript(path)? — present only where a transcript records denials (Claude Code) }
  * Returns the JSON object to print, or null for no output.
  */
 export async function runShipHook(input, deps) {
-  if (!reviewable(input)) return null;
   const now = deps.now ?? Date.now();
-  const ev = input.hook_event_name;
+  const ev = input?.hook_event_name;
+
+  if (TURN_EVENTS.has(ev)) {
+    // A denied prompt leaves its call open: no PostToolUse ever comes. Close this session's.
+    const state = readState(deps.statePath);
+    const open = Object.entries(state.pending).filter(([, e]) => e?.session_id && e.session_id === input.session_id);
+    if (!open.length || !input.transcript_path || !deps.readTranscript) return null;
+    let text = '';
+    try { text = await deps.readTranscript(input.transcript_path); } catch { return null; }
+    const results = callResults(text, open.map(([id]) => id));
+    let closed = false;
+    for (const [id, entry] of open) {
+      const r = results.get(id);
+      if (!r) continue;              // still running, or not written yet — the next event looks again
+      delete state.pending[id]; closed = true;
+      if (r.denied) await deps.markOutcome(entry.receipt_id, r.denied, { keepExisting: true });
+    }
+    if (closed) writeState(deps.statePath, state, now);
+    return null;
+  }
+
+  if (!reviewable(input)) return null;
 
   if (ev === 'PreToolUse') {
     const ship = classifyToolCall(input.tool_name, input.tool_input);
@@ -320,12 +385,12 @@ export async function runShipHook(input, deps) {
     const state = readState(deps.statePath);
     if (input.tool_use_id) {
       state.pending[input.tool_use_id] = {
-        receipt_id: receiptId, cmd_hash: callHash(input),
+        receipt_id: receiptId, cmd_hash: callHash(input), session_id: input.session_id || null,
         asked, prompt_shown: false, at: new Date(now).toISOString(),
       };
     }
     let context = preContext({
-      summary: ship.summary, signal, receiptId, asked,
+      summary: ship.summary, signal, receiptId, asked, recordsNo: Boolean(deps.readTranscript),
       hint: typeof response?.rationale_hint === 'string' ? response.rationale_hint : '',
     });
     if (raised) context += ` GitHub shows ${why}, so Phaedo treated this merge as high-stakes.`;
@@ -388,7 +453,7 @@ export async function runShipHook(input, deps) {
 export async function realDeps({ agentId = AGENT_ID, statePath } = {}) {
   const { loadConsultVd, buildConsultOpts } = await import('../consult-runtime.js');
   const { resolveConsultation, consultDrivers, withRevision } = await import('../consult.js');
-  const { buildReceipt, appendReceipt, receiptsCapFromEnv, markOutcome } = await import('../receipts.js');
+  const { buildReceipt, appendReceipt, receiptsCapFromEnv } = await import('../receipts.js');
   const { sourceOf } = await import('../fingerprint-source.js');
   const { defaultStateDir } = await import('../cache.js');
   const stateDir = defaultStateDir();
@@ -411,7 +476,42 @@ export async function realDeps({ agentId = AGENT_ID, statePath } = {}) {
       await appendReceipt(stateDir, r, { cap: receiptsCapFromEnv(process.env) });
       return r.receipt_id;
     },
-    async markOutcome(id, action) { await markOutcome(stateDir, id, action); },
+    async markOutcome(id, action, opts) { await markOutcomeKeeping(stateDir, id, action, opts); },
+    // Only Claude Code's transcript marks a person's denial; other agents' hooks have none. The
+    // directory edition never reads chat history, so it does not wire the turn events either.
+    ...(agentId === AGENT_ID && !isDirectoryEdition(MCP_DIR) ? { readTranscript: readTail } : {}),
+  };
+}
+
+// The hook's own outcomes never overwrite one already recorded (the agent's, or a yes).
+async function markOutcomeKeeping(stateDir, id, action, { keepExisting = false } = {}) {
+  const { readReceipts, markOutcome } = await import('../receipts.js');
+  if (keepExisting && (await readReceipts(stateDir)).some((r) => r.receipt_id === id && r.user_action)) return;
+  await markOutcome(stateDir, id, action);
+}
+
+// The last few MB of the transcript — a denial is near the end; the first, cut line is dropped.
+async function readTail(path, max = TRANSCRIPT_TAIL_BYTES) {
+  const { openSync, fstatSync, readSync, closeSync } = await import('fs');
+  const fd = openSync(path, 'r');
+  try {
+    const size = fstatSync(fd).size;
+    const len = Math.min(size, max);
+    const buf = Buffer.alloc(len);
+    readSync(fd, buf, 0, len, size - len);
+    const text = buf.toString('utf8');
+    return len < size ? text.slice(text.indexOf('\n') + 1) : text;
+  } finally { closeSync(fd); }
+}
+
+// The turn events' deps: no consult and no vault — only the state, the transcript, the receipts.
+export async function turnDeps({ statePath } = {}) {
+  const { defaultStateDir } = await import('../cache.js');
+  const stateDir = defaultStateDir();
+  return {
+    statePath: statePath || join(stateDir, 'ship-hook.json'),
+    readTranscript: readTail,
+    async markOutcome(id, action, opts) { await markOutcomeKeeping(stateDir, id, action, opts); },
   };
 }
 
@@ -419,6 +519,10 @@ async function main() {
   let raw = '';
   for await (const chunk of process.stdin) raw += chunk;
   const input = JSON.parse(raw);
+  if (TURN_EVENTS.has(input.hook_event_name)) {
+    await runShipHook(input, await turnDeps());
+    return;                          // never says anything on a prompt or a stop
+  }
   // Cheap exit before importing the vault stack: most Bash calls are not ship actions.
   if (!reviewable(input)) return;
   if (input.hook_event_name === 'PreToolUse' && !classifyToolCall(input.tool_name, input.tool_input)) return;

package/install.mjs

@@ -49,6 +49,9 @@ const SHIP_HOOK_MARKER = 'hooks/pre-ship.mjs';           // identifies our ship-
 // it ran or failed (to record that person's yes). Its own budget is 12s; the timeout is
 // the backstop.
 export const SHIP_HOOK_EVENTS = ['PreToolUse', 'PermissionRequest', 'PostToolUse', 'PostToolUseFailure'];
+// The same hook on the turn events, to record a "no" from the transcript (full install only:
+// the directory edition does not read chat history). No matcher — these events have no tool.
+export const SHIP_TURN_EVENTS = ['UserPromptSubmit', 'Stop'];
 // Shell commands, plus connected-tool calls whose name says they send, pay, delete or merge
 // (ship-actions.js MCP_HOOK_MATCHER) — the personal reviewer covers both.
 export const SHIP_HOOK_MATCHER = `Bash|${MCP_HOOK_MATCHER}`;
@@ -245,7 +248,7 @@ export function applyCodeHook({ action, dryRun = false, home = homedir() } = {})
     const stop = removeHookEntry(both.settings, 'Stop', STOP_CAPTURE_HOOK_MARKER);
     let s = stop.settings;
     let shipChanged = false;
-    for (const ev of SHIP_HOOK_EVENTS) {
+    for (const ev of [...SHIP_HOOK_EVENTS, ...SHIP_TURN_EVENTS]) {
       const r = removeHookEntry(s, ev, SHIP_HOOK_MARKER);
       s = r.settings; shipChanged = shipChanged || r.changed;
     }
@@ -282,6 +285,10 @@ export function applyCodeHook({ action, dryRun = false, home = homedir() } = {})
     const r = mergeHookEntry(settings, ev, hookCommand({ hookPath: SHIP_HOOK_PATH }), SHIP_HOOK_MARKER, SHIP_HOOK_ENTRY);
     settings = r.settings; shipChanged = shipChanged || r.changed;
   }
+  for (const ev of SHIP_TURN_EVENTS) {
+    const r = mergeHookEntry(settings, ev, hookCommand({ hookPath: SHIP_HOOK_PATH }), SHIP_HOOK_MARKER, { timeout: SHIP_HOOK_ENTRY.timeout });
+    settings = r.settings; shipChanged = shipChanged || r.changed;
+  }
   const changed = start.changed || captureChanged || shipChanged;
   if (!changed) return { name, status: 'unchanged', detail: `already configured${captureNote}` };
   if (!dryRun) { if (read.existed) backup(path); writeConfig(path, settings); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phaedo-mcp",
-  "version": "0.3.13",
+  "version": "0.3.15",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",
@@ -51,6 +51,7 @@
     "receipts-sync.js",
     "agreement.js",
     "weekly.js",
+    "asks.js",
     "precedent.js",
     "rules-files.js",
     "learned.js",
@@ -99,7 +100,7 @@
     "unsetup": "node install.mjs --uninstall",
     "pair": "node pair.js",
     "pull": "node pull.js",
-    "test": "node test-smoke.mjs && node test-no-profile.mjs && node test-phone-boundary.mjs && node test-cache.mjs && node test-pairing.mjs && node test-revoke.mjs && node test-install.mjs && node test-consult.mjs && node test-consult-policy.mjs && node test-amount-bands.mjs && node test-resolver-revision.mjs && node test-ship-actions.mjs && node test-ship-hook.mjs && node test-ship-readout.mjs && node test-action-binding.mjs && node test-autonomy-promotion.mjs && node test-ap2.mjs && node test-delegation-sync.mjs && node test-delegation-relay.mjs && node test-capture-sync.mjs && node test-capture-hook.mjs && node test-stop-capture.mjs && node test-capture-local.mjs && node test-capture-a11y.mjs && node test-vendored-capture.mjs && node test-escalation.mjs && node test-domain.mjs && node test-receipts.mjs && node test-receipts-sync.mjs && node test-agreement.mjs && node test-weekly.mjs && node test-precedent.mjs && node test-rules-files.mjs && node test-agent-hook.mjs && node test-learned.mjs && node test-history-import.mjs && node test-calibration.mjs && node test-identity.mjs && node test-signing.mjs && node test-sign-request.mjs && node test-signing-audit.mjs && node test-delegation-domain-fragmentation.mjs && node test-stale-authority.mjs && node test-config-home-fold.mjs && node test-precedence-and-ceiling.mjs && node test-package-closure.mjs && node test-plugin.mjs",
+    "test": "node test-smoke.mjs && node test-no-profile.mjs && node test-phone-boundary.mjs && node test-cache.mjs && node test-pairing.mjs && node test-revoke.mjs && node test-install.mjs && node test-consult.mjs && node test-consult-policy.mjs && node test-amount-bands.mjs && node test-resolver-revision.mjs && node test-ship-actions.mjs && node test-ship-hook.mjs && node test-ship-readout.mjs && node test-action-binding.mjs && node test-autonomy-promotion.mjs && node test-ap2.mjs && node test-delegation-sync.mjs && node test-delegation-relay.mjs && node test-capture-sync.mjs && node test-capture-hook.mjs && node test-stop-capture.mjs && node test-capture-local.mjs && node test-capture-a11y.mjs && node test-vendored-capture.mjs && node test-escalation.mjs && node test-domain.mjs && node test-receipts.mjs && node test-receipts-sync.mjs && node test-agreement.mjs && node test-weekly.mjs && node test-asks.mjs && node test-precedent.mjs && node test-rules-files.mjs && node test-agent-hook.mjs && node test-learned.mjs && node test-history-import.mjs && node test-calibration.mjs && node test-identity.mjs && node test-signing.mjs && node test-sign-request.mjs && node test-signing-audit.mjs && node test-delegation-domain-fragmentation.mjs && node test-stale-authority.mjs && node test-config-home-fold.mjs && node test-precedence-and-ceiling.mjs && node test-package-closure.mjs && node test-plugin.mjs",
     "receipts": "node receipts.js list",
     "agreement": "node agreement.js",
     "ship-readout": "node ship-readout.js",
@@ -123,6 +124,7 @@
     "smoke:autonomy": "node test-autonomy-promotion.mjs",
     "smoke:ap2": "node test-ap2.mjs",
     "week": "node weekly.js",
+    "asks": "node asks.js",
     "rules": "node rules-files.js",
     "learned": "node learned.js",
     "import": "node history-import.js"

package/pull.js

@@ -11,12 +11,18 @@ import { loadFingerprint, sourceOf, summarizeStarter } from './fingerprint-sourc
 import { readReceipts } from './receipts.js';
 import { defaultStateDir } from './cache.js';
 import { weeklyHandled, formatWeekly } from './weekly.js';
+import { asksByWeek, trendLine } from './asks.js';
 import { learnedItems, readLearnedState, reviewLine } from './learned.js';
 
 const BASE_DIR = dirname(fileURLToPath(import.meta.url));
 
-// Every outcome ends with what Phaedo did for the subject this week — the reason to have it.
-const week = async () => `  ${formatWeekly(weeklyHandled(await readReceipts(defaultStateDir()).catch(() => [])))}\n`;
+// Every outcome ends with what Phaedo did for the subject this week — the reason to have it —
+// and, once there is enough to compare, whether it is asking them less than before.
+const week = async () => {
+  const receipts = await readReceipts(defaultStateDir()).catch(() => []);
+  const trend = trendLine(asksByWeek(receipts));
+  return `  ${formatWeekly(weeklyHandled(receipts))}\n${trend ? `  ${trend}\n` : ''}`;
+};
 // …and, when there is any, what Phaedo learned that the subject hasn't looked at yet.
 const review = (vd) => { const line = reviewLine(learnedItems(vd), readLearnedState(defaultStateDir())); return line ? `  ${line}\n` : ''; };
 

package/server.json

@@ -2,7 +2,7 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.phaedo-labs/phaedo-mcp",
   "description": "Make AI apps answer your way, check with you before acting, and get approvals on your phone.",
-  "version": "0.3.13",
+  "version": "0.3.15",
   "repository": {
     "url": "https://github.com/phaedo-labs/phaedo-mcp",
     "source": "github",
@@ -13,7 +13,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "phaedo-mcp",
-      "version": "0.3.13",
+      "version": "0.3.15",
       "transport": {
         "type": "stdio"
       }

package/vendor/trait-phrases.js

@@ -297,6 +297,8 @@
         ask: 'When things are unclear, ask me before deciding.',
         delay: 'When things are unclear, wait rather than commit too early.',
       },
+      // The request-level words (ambiguity_response) for "guess and carry on" mean be decisive here.
+      aliases: { assume_state_proceed: 'default', assume_silent: 'default', assume_state: 'default' },
     },
     evidence_threshold: {
       topic: 'how sure you need to be before committing',