rd-band

1// Release-probe mod for the TUI scenario (spec §16.5 UI and queue order items):
2// - two AbovePrompt cards whose Buttons share the bare digit hotkey 2 (research/you-should-know.md:135);
3// - the prompt typed during a reply: its prompt.submit fields, and one context line (smoke-aside-nudge.md:398);
4// - `/rdprobe fork`: the /cost ledger around one $.model.fork, the route You should know uses, and around one
5//   $.model.complete (research/you-should-know.md:61,136; research/model-calls.md:20);
6// - `/rdprobe note`: one $.ui.log row in the watchdog's row format (§13.2), for the ctrl+o view
7//   (issues/11-ui-prototype.md:37).
8const FILE = '__LOG__/rd-band.jsonl';
9const QUEUED_MARK = 'QUEUED=PAPA';
10const QUEUED_CONTEXT = 'RDCTX-QUEUED: a probe marker line; ignore it.';
11const NOTE_ROW = '[concern] rdprobe: RDNOTE-CTRLO a row in the watchdog row format (steered)';
12const FORK_PROMPT = 'Reply with exactly FORKED.';
13const COMPLETE_PROMPT = 'Reply with exactly COMPLETED.';
14const COMMAND = { name: 'rdprobe', description: 'watchdog live probe', argumentHint: 'fork|note', immediate: true };
15const CALL_TIMEOUT_MS = 60_000;
16const SETTLE_MS = 300;
17// §13.2: a row from a command.run hook waits 300 ms, so it lands below the command echo.
18const ROW_DELAY_MS = 300;
19const lines = [];
20let writing = null;
21let isDirty = false;
22
23// Rewrites the whole log file; a write asked while one runs is folded into one more pass (as the observer does).
24const flush = ($) => {
25  if (writing) {
26    isDirty = true;
27    return writing;
28  }
29  writing = (async () => {
30    do {
31      isDirty = false;
32      await $.fs.write(FILE, `${lines.join('\n')}\n`);
33    } while (isDirty);
34  })()
35    .catch(() => undefined)
36    .finally(() => {
37      writing = null;
38    });
39  return writing;
40};
41
42const record = ($, data) => {
43  lines.push(JSON.stringify({ t: Date.now(), ...data }));
44  return flush($);
45};
46
47const errorText = (error) => String(error?.message ?? error).slice(0, 180);
48
49// §16.5 UI: which card's Button the digit pressed; the press runs the closure of the render that drew it.
50const press = ($, which) => {
51  void record($, { kind: 'press', which });
52  void Promise.resolve($.ui.log(`RDCARD press ${which}`)).catch(() => undefined);
53};
54
55// What /cost totals: `$.session.usage()` `cost.usd`, "what the session has cost so far, as /cost totals it" (d.ts).
56const ledger = async ($) => {
57  try {
58    return (await $.session.usage())?.cost?.usd ?? null;
59  } catch {
60    return null;
61  }
62};
63
64// One model call, bounded by the clock (a fork takes no timeout of its own), as plain data.
65const settle = async (call) => {
66  let timer;
67  try {
68    const timeout = new Promise((resolve) => {
69      timer = setTimeout(() => resolve({ isAnswered: false, reason: 'probe timeout' }), CALL_TIMEOUT_MS);
70    });
71    const result = await Promise.race([call(), timeout]);
72    return {
73      isAnswered: result?.isAnswered ?? false,
74      reason: result?.reason ?? null,
75      text: String(result?.text ?? '').slice(0, 80),
76      usage: result?.usage ?? null,
77    };
78  } catch (error) {
79    return { isAnswered: false, reason: `throw ${errorText(error)}`, text: '', usage: null };
80  } finally {
81    clearTimeout(timer);
82  }
83};
84
85// §16.5 UI: the ledger before and after one fork, then after one completion, with no model turn between them.
86const measure = async ($) => {
87  const before = await ledger($);
88  const fork = await settle(() => $.model.fork({ prompt: FORK_PROMPT }));
89  await $.clock.sleep(SETTLE_MS);
90  const afterFork = await ledger($);
91  const complete = await settle(() =>
92    $.model.complete({ model: 'haiku', prompt: COMPLETE_PROMPT, maxTokens: 16, timeoutMs: CALL_TIMEOUT_MS })
93  );
94  await $.clock.sleep(SETTLE_MS);
95  const afterComplete = await ledger($);
96  return { before, afterFork, afterComplete, fork, complete };
97};
98
99export const register = (on) => {
100  on('session.start', async ($, e, next) => {
101    try {
102      await $.command.register(COMMAND);
103      await record($, { kind: 'command', outcome: 'ok' });
104    } catch (error) {
105      await record($, { kind: 'command', outcome: `throw ${errorText(error)}` });
106    }
107    return next(e);
108  });
109  on('command.run', { command: 'rdprobe' }, async ($, e) => {
110    const args = String(e.args ?? '').trim();
111    if (args === 'fork') {
112      const result = await measure($);
113      await record($, { kind: 'fork', ...result });
114      return { text: `RDFORK ledger ${result.before} -> ${result.afterFork} -> ${result.afterComplete}` };
115    }
116    if (args === 'note') {
117      $.clock.after(ROW_DELAY_MS, () => {
118        $.ui.log(NOTE_ROW);
119      });
120      await record($, { kind: 'note' });
121      return { text: 'RDNOTE row sent' };
122    }
123    return { text: 'usage: /rdprobe fork|note' };
124  });
125  // research/you-should-know.md:135: two cards, each with a plain Button on hotkey 2; the later one in the tree is
126  // the second card.
127  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
128    if (e.props?.hasSurvey) {
129      return next(e);
130    }
131    const base = await next(e);
132    const E = $.ui.resolve(e);
133    const card = (key, title, which) =>
134      E.Box({
135        key,
136        flexDirection: 'column',
137        children: [
138          E.Text({ children: title }),
139          E.Button({ key: `${key}-btn`, label: which, hotkey: '2', plain: true, onPress: () => press($, which) }),
140        ],
141      });
142    return E.Box({
143      key: 'rd-band',
144      flexDirection: 'column',
145      children: [base, card('rd-card-1', 'RDCARD-A', 'first'), card('rd-card-2', 'RDCARD-B', 'second')],
146    });
147  });
148  // smoke-aside-nudge.md:398: the prompt typed during the last reply; the plugin's aside rides on such a prompt as
149  // a context line (§10.2), so this one carries one too.
150  on('prompt.submit', async ($, e, next) => {
151    if (!String(e.text ?? '').includes(QUEUED_MARK)) {
152      return next(e);
153    }
154    await record($, { kind: 'submit', turnId: e.turnId ?? null, wait: e.wait ?? null, origin: e.origin?.kind ?? null });
155    return next({ ...e, context: [...(e.context ?? []), QUEUED_CONTEXT] });
156  });
157};
158