cc-sticky-probe

1// M0 probe. Every line it logs starts with "PROBE " so the stream-json output can be grepped.
2// Driven by the prompt prefix: "probe-<name> <rest>". Unknown prompts pass through.
3import type { Register } from 'claude-code'
4
5export const register: Register = on => {
6
7  on('session.start', async ($, e, next) => {
8    const out = (s: string) => $.ui.log(`PROBE ${s}`)
9    out(`session.start e=${JSON.stringify(e)}`)
10    out(`version=${JSON.stringify(await $.session.version())}`)
11    out(`id=${await $.session.id()} root=${await $.session.root()} cwd=${await $.session.cwd()}`)
12    out(`surfaces=${JSON.stringify(await $.session.surfaces())} plugin.root=${$.plugin.root}`)
13    out(`env TYPESAFE_API_KEY set=${(await $.env.get('TYPESAFE_API_KEY')) !== undefined}`)
14    out(`env OPENAI_API_KEY set=${(await $.env.get('OPENAI_API_KEY')) !== undefined}`)
15    // store: who was here before (cross-session persistence)
16    const id = await $.session.id()
17    const visits = ((await $.store.get('visits')) as string[] | undefined) ?? []
18    out(`store visits(before)=${JSON.stringify(visits)}`)
19    await $.store.set('visits', [...visits, id].slice(-10))
20    await $.store.set(`mark:${id}`, await $.clock.now())
21    out(`store keys=${JSON.stringify(await $.store.keys())}`)
22    return next(e)
23  })
24
25  on('turn.start', async ($, e, next) => {
26    $.ui.log(`PROBE turn.start turnId=${e.turnId} text=${JSON.stringify(e.text.slice(0, 60))}`)
27    return next(e)
28  })
29
30  on('turn.complete', async ($, e, next) => {
31    $.ui.log(`PROBE turn.complete keys=${Object.keys(e).join(',')}`)
32    // second look at the store: did a concurrent session write meanwhile?
33    $.ui.log(`PROBE store keys at turn.complete=${JSON.stringify(await $.store.keys())}`)
34    return next(e)
35  })
36
37  on('prompt.submit', async ($, e, next) => {
38    const out = (s: string) => $.ui.log(`PROBE ${s}`)
39    out(`prompt.submit keys=${Object.keys(e).join(',')} turnId=${e.turnId} wait=${e.wait} origin=${JSON.stringify(e.origin)}`)
40    const m = /^probe-([a-z-]+)\s*([\s\S]*)$/.exec(e.text)
41    if (!m) return next(e)
42    const [, name, rest] = m
43    const t0 = await $.clock.now()
44    const ms = async () => (await $.clock.now()) - t0
45
46    switch (name) {
47      case 'drop':
48        return { drop: 'cc-sticky-probe: dropped on purpose' }
49
50      case 'fork': {
51        const r = await $.model.fork({ prompt: rest || 'In one sentence: what is TCP backpressure?' })
52        out(`fork ms=${await ms()} result=${JSON.stringify(r).slice(0, 600)}`)
53        return { drop: 'cc-sticky-probe: fork answered off the transcript' }
54      }
55
56      case 'fork-history': {
57        // Can a fork carry side-thread history? Only via the prompt text (ModelForkRequest is { prompt }).
58        const history = 'Q1: What is TCP backpressure?\nA1: When a receiver is slower than a sender, buffers fill and the sender is told to slow down.\n'
59        const r = await $.model.fork({ prompt: `[side thread so far]\n${history}\n[follow-up]\n${rest || 'How does that relate to Node streams? One sentence.'}` })
60        out(`fork-history ms=${await ms()} result=${JSON.stringify(r).slice(0, 600)}`)
61        return { drop: 'cc-sticky-probe: fork-history done' }
62      }
63
64      case 'fork-bg': {
65        // Drop first, answer in the background.
66        $.clock.after(0, async () => {
67          const r = await $.model.fork({ prompt: rest || 'One sentence: what is a hash map?' })
68          $.ui.log(`PROBE fork-bg ms=${(await $.clock.now()) - t0} result=${JSON.stringify(r).slice(0, 400)}`)
69        })
70        return { drop: 'cc-sticky-probe: fork-bg scheduled' }
71      }
72
73      case 'complete': {
74        const r = await $.model.complete({
75          model: 'haiku',
76          effort: 'low',
77          system: 'Reply with a JSON object {"title": string (<=12 chars), "summary": string (3 sentences)}.',
78          prompt: rest || 'Q: What is TCP backpressure? A: Receiver slower than sender, sender slows down.',
79          maxTokens: 300,
80          timeoutMs: 20000,
81        })
82        out(`complete ms=${await ms()} result=${JSON.stringify(r).slice(0, 600)}`)
83        return { drop: 'cc-sticky-probe: complete done' }
84      }
85
86      case 'model': {
87        // Does $.model.complete honour an alias and a full id? (claudeModel userConfig)
88        for (const model of (rest || 'sonnet claude-haiku-4-5-20251001 opus').split(/\s+/)) {
89          try {
90            const r = await $.model.complete({ model, prompt: 'Reply with only the name of the model you are.', maxTokens: 40, effort: 'low', timeoutMs: 30000 })
91            out(`model ${model} ms=${await ms()} result=${JSON.stringify(r).slice(0, 300)}`)
92          } catch (err) {
93            out(`model ${model} threw ${String(err).slice(0, 200)}`)
94          }
95        }
96        return { drop: 'cc-sticky-probe: model done' }
97      }
98
99      case 'classify': {
100        try {
101          const label = await $.model.classify(rest || 'why does TCP need a three-way handshake?', [
102            'main_task', 'sidebar_knowledge', 'project_question',
103          ])
104          out(`classify ms=${await ms()} label=${JSON.stringify(label)}`)
105        } catch (err) {
106          out(`classify threw ${String(err)}`)
107        }
108        return { drop: 'cc-sticky-probe: classify done' }
109      }
110
111      case 'messages': {
112        const msgs = await $.session.messages()
113        if (Array.isArray(msgs)) {
114          out(`messages n=${msgs.length}`)
115          for (const one of msgs.slice(-4)) {
116            out(`  msg role=${one.role} keys=${Object.keys(one).join(',')} text=${JSON.stringify(one.text.slice(0, 80))} toolUses=${one.toolUses.length}`)
117          }
118        } else out(`messages deny=${JSON.stringify(msgs)}`)
119        out(`turns=${await $.session.turns()} usage=${JSON.stringify(await $.session.usage()).slice(0, 400)}`)
120        return { drop: 'cc-sticky-probe: messages done' }
121      }
122
123      case 'http': {
124        for (const url of ['https://api.openai.com/v1/models', 'https://api.typesafe.ai/v1/systemone']) {
125          try {
126            const r = await $.http.fetch(url, { method: url.includes('typesafe') ? 'POST' : 'GET', headers: { 'content-type': 'application/json' }, body: url.includes('typesafe') ? '{}' : undefined })
127            out(`http ${url} status=${r.status} ok=${r.ok} headerKeys=${Object.keys(r.headers).slice(0, 8).join(',')} text=${JSON.stringify(r.text.slice(0, 200))}`)
128          } catch (err) {
129            out(`http ${url} threw ${String(err)}`)
130          }
131        }
132        return { drop: 'cc-sticky-probe: http done' }
133      }
134
135      case 'jev': {
136        // Real Jev call with the four PLAN.md questions; logs the raw response.
137        const key = await $.env.get('TYPESAFE_API_KEY')
138        if (!key) {
139          out('jev: no TYPESAFE_API_KEY')
140          return { drop: 'cc-sticky-probe: jev skipped' }
141        }
142        const prompt = rest || 'TCP 的 backpressure 是什麼原理？'
143        const body = {
144          model: 'jev-latest',
145          state: `[recent main-line context]\nuser: 把 auth 改成 session cookie\nassistant: 已改好，剩 token 輪替。\n\n[sidebar state]\nactive_thread_title: none\nactive_thread_last_question: none\nmain_turns_since_last_sidebar: 2\n\n[new prompt]\n${prompt}`,
146          questions: {
147            route: {
148              type: 'choice',
149              instructions: 'Where should the new prompt go?',
150              criteria: {
151                main_task: 'Advances the project: an instruction, a code change, or a decision about what Claude just did',
152                sidebar_knowledge: 'Asks about a principle, concept or background knowledge; does not ask Claude to change anything',
153                project_question: 'A question about this project itself whose answer belongs in the main conversation',
154              },
155            },
156            is_followup: { type: 'noul', instructions: 'Does the new prompt continue the topic of active_thread?' },
157            needs_project_ctx: { type: 'noul', instructions: "Does answering the new prompt require seeing the project's code or conversation?" },
158            tag: { type: 'choice', instructions: 'Which topic tag fits the new prompt?', criteria: { network: 'About network', db: 'About db', __new__: 'None of the existing tags fits' } },
159          },
160        }
161        const r = await $.http.fetch('https://api.typesafe.ai/v1/systemone', {
162          method: 'POST',
163          headers: { 'content-type': 'application/json', authorization: `Bearer ${key}` },
164          body: JSON.stringify(body),
165        })
166        out(`jev ms=${await ms()} status=${r.status} text=${r.text.slice(0, 1500)}`)
167        return { drop: 'cc-sticky-probe: jev done' }
168      }
169
170      case 'openai': {
171        const key = await $.env.get('OPENAI_API_KEY')
172        if (!key) {
173          out('openai: no OPENAI_API_KEY')
174          return { drop: 'cc-sticky-probe: openai skipped' }
175        }
176        const r = await $.http.fetch('https://api.openai.com/v1/chat/completions', {
177          method: 'POST',
178          headers: { 'content-type': 'application/json', authorization: `Bearer ${key}` },
179          body: JSON.stringify({
180            model: rest || 'gpt-5-mini',
181            max_completion_tokens: 400,
182            reasoning_effort: 'minimal',
183            messages: [
184              { role: 'system', content: 'Reply with JSON only: {"title": "<=12 chars", "summary": "three sentences"}' },
185              { role: 'user', content: 'Q: What is TCP backpressure? A: When the receiver is slower, buffers fill and the sender slows down.' },
186            ],
187          }),
188        })
189        out(`openai ms=${await ms()} status=${r.status} text=${r.text.slice(0, 1500)}`)
190        return { drop: 'cc-sticky-probe: openai done' }
191      }
192
193      case 'agents': {
194        try {
195          const r = await $.tool.call({ tool: 'ListAgents' })
196          out(`ListAgents result=${JSON.stringify(r).slice(0, 800)}`)
197        } catch (err) {
198          out(`ListAgents threw ${String(err)}`)
199        }
200        return { drop: 'cc-sticky-probe: agents done' }
201      }
202
203      case 'suggest': {
204        const r = await $.prompt.suggest({ text: '正在追問：probe' })
205        out(`suggest result=${JSON.stringify(r)}`)
206        return { drop: 'cc-sticky-probe: suggest done' }
207      }
208
209      case 'store-race': {
210        // Two processes run this at once. Separate keys + one shared read-modify-write key.
211        const id = await $.session.id()
212        await $.store.set(`race:${id}`, t0)
213        const before = ((await $.store.get('race-list')) as string[] | undefined) ?? []
214        await $.clock.sleep(3000)
215        await $.store.set('race-list', [...before, id])
216        out(`store-race id=${id} keysAfter=${JSON.stringify((await $.store.keys()).filter(k => k.startsWith('race')))} list=${JSON.stringify(await $.store.get('race-list'))}`)
217        return { drop: 'cc-sticky-probe: store-race done' }
218      }
219
220      case 'store-read': {
221        out(`store-read keys=${JSON.stringify((await $.store.keys()).filter(k => k.startsWith('race')))} list=${JSON.stringify(await $.store.get('race-list'))}`)
222        return { drop: 'cc-sticky-probe: store-read done' }
223      }
224
225      case 'budget': {
226        // Does a long $ call count against the 10 s budget? $.clock.sleep does; http does not.
227        try {
228          await $.http.fetch('https://httpbin.org/delay/12')
229          out(`budget http 12s ok ms=${await ms()}`)
230        } catch (err) {
231          out(`budget http threw ${String(err)} ms=${await ms()}`)
232        }
233        return { drop: 'cc-sticky-probe: budget done' }
234      }
235
236      case 'context': {
237        // project_question path: pass through with extra context
238        return next({ ...e, text: rest ?? '', context: [...(e.context ?? []), '[sticky-notes] project question; answer briefly'] })
239      }
240
241      default:
242        return next(e)
243    }
244  })
245
246  // UI probe: a badge beside the original user row, and a hotkey the type says is refused.
247  on('ui.render', { component: 'UserMessage' }, async ($, e, next) => {
248    if (!e.props.text.includes('badge-me')) return next(e)
249    const { Box, Button } = $.ui.resolve(e)
250    const original = await next(e)
251    return (
252      <Box flexDirection="row">
253        {original}
254        <Button key="badge" plain label="📌 1" onPress={() => $.ui.toast('badge pressed')} />
255      </Box>
256    )
257  })
258
259  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
260    const { Box, Button } = $.ui.resolve(e)
261    return (
262      <Box>
263        <Button key="alt" label="open" hotkey="⌥s" onPress={() => {}} />
264      </Box>
265    )
266  })
267}
268