freddie 0.0.119 → 0.0.121

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freddie",
-  "version": "0.0.119",
+  "version": "0.0.121",
   "type": "module",
   "description": "Open JS agent harness built on pi-mono, floosie, xstate, and anentrypoint-design",
   "bin": {
@@ -27,8 +27,8 @@
     "@mariozechner/pi-ai": "^0.70.6",
     "@mariozechner/pi-coding-agent": "^0.70.6",
     "@mariozechner/pi-tui": "^0.70.6",
-    "acptoapi": "^1.0.114",
-    "anentrypoint-design": "^0.0.140",
+    "acptoapi": "^1.0.115",
+    "anentrypoint-design": "^0.0.144",
     "commander": "^14.0.0",
     "express": "^5.0.0",
     "flatspace": "^1.0.18",

package/plugins/gui-machines/plugin.js

@@ -41,6 +41,10 @@ export default {
             try { res.json({ machines: await snapshotRows(req.params.kind) }) }
             catch (e) { res.status(500).json({ error: String(e.message || e) }) }
         })
+        gui.route('GET', '/api/machines/steps/:key', async (req, res) => {
+            try { const { listSteps } = await import('../../src/machines/step-journal.js'); res.json({ key: req.params.key, steps: await listSteps(req.params.key) }) }
+            catch (e) { res.status(500).json({ error: String(e.message || e) }) }
+        })
         gui.route('POST', '/api/machines/resume', async (_req, res) => {
             try { const { resumeAll } = await import('../../src/machines/resume.js'); res.json({ ok: true, summary: await resumeAll() }) }
             catch (e) { res.status(500).json({ error: String(e.message || e) }) }

package/src/acp/server.js

@@ -8,6 +8,7 @@ import { checkPermission, rememberAllow, rememberDeny } from './permissions.js'
 import { AcpSessionManager } from './session.js'
 import { createMachine, createActor } from 'xstate'
 import { persist, load, clear } from '../machines/snapshot-store.js'
+import { runStep, clearSteps } from '../machines/step-journal.js'
 
 const log = logger('acp')
 
@@ -102,9 +103,15 @@ const METHODS = {
         // refresh mid-turn is observable + resumable (the agent snapshot for the
         // turn itself lives under kind=agent via runTurn sessionKey).
         await persist('acp-prompt', sessionId, { status: 'active', value: 'running', context: { sessionId, prompt } })
-        const out = await runTurn({ prompt, callLLM: srv.callLLM, sessionKey: 'acp:' + sessionId })
+        const sk = 'acp:' + sessionId
+        // The agent turn itself is step-journaled under sessionKey=sk (at-most-once
+        // LLM + tool effects). The post-turn persistence (session append) is its
+        // own journaled step so a crash between runTurn return and appendAssistant
+        // does not double-append on resume.
+        const out = await runTurn({ prompt, callLLM: srv.callLLM, sessionKey: sk })
+        await runStep(sk, 'acp-persist', async () => { await srv.sessions.appendAssistant(sessionId, out.result || ''); return { ok: true } })
         await clear('acp-prompt', sessionId)
-        srv.sessions.appendAssistant(sessionId, out.result || '')
+        await clearSteps(sk)
         Events.messageComplete((o) => srv.send(o), { sessionId, role: 'assistant', content: out.result || '' })
         return { result: out.result, error: out.error, iterations: out.iterations }
     },

package/src/agent/machine.js

@@ -4,11 +4,12 @@ import { getEnabledToolSchemas } from '../toolsets.js'
 import { logger } from '../observability/log.js'
 import { resolveCallLLM } from './llm_resolver.js'
 import { createPersistentActor } from '../machines/persistent-actor.js'
+import { runStep, clearSteps } from '../machines/step-journal.js'
 import { randomUUID } from 'node:crypto'
 
 const log = logger('agent')
 
-export function createAgentMachine({ provider, model, maxIterations = 90, callLLM, enabledToolsets = ['core'], disabledToolsets = [], events } = {}) {
+export function createAgentMachine({ provider, model, maxIterations = 90, callLLM, enabledToolsets = ['core'], disabledToolsets = [], events, sessionKey } = {}) {
     const baseLLM = callLLM || resolveCallLLM({ provider, model })
     const llm = events ? async (input) => {
         const t0 = Date.now()
@@ -34,6 +35,7 @@ export function createAgentMachine({ provider, model, maxIterations = 90, callLL
             error: null,
             provider, model,
             enabledToolsets, disabledToolsets,
+            sessionKey,
         }),
         states: {
             idle: {
@@ -52,9 +54,9 @@ export function createAgentMachine({ provider, model, maxIterations = 90, callLL
                 invoke: {
                     src: fromPromise(async ({ input }) => {
                         const schemas = await getEnabledToolSchemas(input.enabledToolsets, input.disabledToolsets)
-                        return llm({ messages: input.messages, tools: schemas, model: input.model, provider: input.provider })
+                        return await runStep(input.sessionKey, 'llm:' + input.iterations, () => llm({ messages: input.messages, tools: schemas, model: input.model, provider: input.provider }))
                     }),
-                    input: ({ context }) => ({ messages: context.messages, model: context.model, provider: context.provider, enabledToolsets: context.enabledToolsets, disabledToolsets: context.disabledToolsets }),
+                    input: ({ context }) => ({ messages: context.messages, model: context.model, provider: context.provider, enabledToolsets: context.enabledToolsets, disabledToolsets: context.disabledToolsets, sessionKey: context.sessionKey, iterations: context.iterations }),
                     onDone: [
                         { guard: ({ event }) => Array.isArray(event.output?.tool_calls) && event.output.tool_calls.length > 0, target: 'tool_calls', actions: assign({ messages: ({ context, event }) => [...context.messages, { role: 'assistant', content: event.output.content || '', tool_calls: event.output.tool_calls }] }) },
                         { target: 'done', actions: assign({ messages: ({ context, event }) => [...context.messages, { role: 'assistant', content: event.output.content || '' }], lastResult: ({ context, event }) => {
@@ -92,16 +94,21 @@ export function createAgentMachine({ provider, model, maxIterations = 90, callLL
                             const tname = call.name || call.function?.name
                             const targs = call.arguments || call.function?.arguments || {}
                             const tcid = call.id || call.tool_call_id
-                            const pushExtras = r => { if (r?.systemMessage) extras.push({ role: 'system', content: '[hook] ' + r.systemMessage }); if (r?.additionalContext) extras.push({ role: 'system', content: r.additionalContext }) }
-                            const pre = await h.hooks.invoke('preToolCall', { name: tname, args: targs }); pushExtras(pre)
-                            if (pre?.behavior === 'block') { results.push({ tool_call_id: tcid, content: JSON.stringify({ error: 'tool call denied by plugsdk hook', tool: tname, reason: pre.reason || 'denied' }) }); continue }
-                            const res = await h.pi.dispatchTool(tname, (pre && pre.args) || targs)
-                            pushExtras(await h.hooks.invoke('postToolCall', { name: tname, args: targs, result: res }))
-                            results.push({ tool_call_id: tcid, content: res })
+                            const ret = await runStep(input.sessionKey, 'tool:' + input.iterations + ':' + tcid, async () => {
+                                const callExtras = []
+                                const pushExtras = r => { if (r?.systemMessage) callExtras.push({ role: 'system', content: '[hook] ' + r.systemMessage }); if (r?.additionalContext) callExtras.push({ role: 'system', content: r.additionalContext }) }
+                                const pre = await h.hooks.invoke('preToolCall', { name: tname, args: targs }); pushExtras(pre)
+                                if (pre?.behavior === 'block') { return { content: JSON.stringify({ error: 'tool call denied by plugsdk hook', tool: tname, reason: pre.reason || 'denied' }), extras: callExtras } }
+                                const res = await h.pi.dispatchTool(tname, (pre && pre.args) || targs)
+                                pushExtras(await h.hooks.invoke('postToolCall', { name: tname, args: targs, result: res }))
+                                return { content: res, extras: callExtras }
+                            })
+                            results.push({ tool_call_id: tcid, content: ret.content })
+                            extras.push(...ret.extras)
                         }
                         return { results, extras }
                     }),
-                    input: ({ context }) => ({ messages: context.messages }),
+                    input: ({ context }) => ({ messages: context.messages, sessionKey: context.sessionKey, iterations: context.iterations }),
                     onDone: { target: 'prompting', actions: assign({
                         messages: ({ context, event }) => [...context.messages, ...event.output.results.map(r => ({ role: 'tool', tool_call_id: r.tool_call_id, content: r.content })), ...event.output.extras],
                         iterations: ({ context }) => context.iterations + 1,
@@ -175,13 +182,17 @@ function mergeHookExtras(messages, r, tag) {
 // Drive a started persistent agent actor to its final state, wiring timeout +
 // session-end hooks + trajectory. Shared by runTurn (fresh) and resumeTurn
 // (rehydrated from a persisted snapshot after a refresh/restart).
-async function driveAgentActor({ pa, h, events, prompt, provider, model, skill, cwd, witnessPath, timeoutMs }) {
+async function driveAgentActor({ pa, h, events, prompt, provider, model, skill, cwd, witnessPath, timeoutMs, sessionKey }) {
     const { actor } = pa
     return await new Promise((resolve, reject) => {
         let sub
         const cleanup = () => { try { sub?.unsubscribe() } catch {} ; pa.flush().catch(() => {}).finally(() => { try { actor.stop() } catch {} }) }
-        const t = setTimeout(() => { cleanup(); reject(new Error('agent turn timeout')) }, timeoutMs)
-        sub = actor.subscribe(snap => { if (snap.status !== 'done') return; clearTimeout(t)
+        let settled = false
+        const t = setTimeout(() => { if (settled) return; settled = true; cleanup(); reject(new Error('agent turn timeout')) }, timeoutMs)
+        // Do not let a pending turn-timeout timer keep the event loop alive or fire
+        // during process teardown after the awaiting caller has already moved on.
+        if (typeof t?.unref === 'function') t.unref()
+        sub = actor.subscribe(snap => { if (snap.status !== 'done') return; if (settled) return; settled = true; clearTimeout(t)
             ;(async () => {
                 const out = snap.output
                 const outbound = await h.hooks.invoke('onMessageOutbound', { content: out?.result || '' })
@@ -189,6 +200,8 @@ async function driveAgentActor({ pa, h, events, prompt, provider, model, skill,
                 await h.hooks.invoke('onSessionEnd', { reason: out?.error ? 'error' : 'ok', iterations: out?.iterations })
                 const errorStack = out?.error ? (events.find(e => e.type === 'llm_call' && !e.ok)?.stack || null) : null
                 await writeTrajectory(out, { prompt, provider, model, skill, cwd, events, errorStack, witnessPath })
+                // Completed turn leaves no step-journal residue.
+                await clearSteps(sessionKey)
                 // Unsubscribe, flush the final snapshot (persistent-actor clears it on
                 // the done state) + stop the actor — a finished actor should not be
                 // left running with live subscriptions/handles.
@@ -209,13 +222,13 @@ export async function runTurn({ prompt, messages = [], model, provider, callLLM,
     const inbound = await h.hooks.invoke('onMessageInbound', { content: prompt })
     if (inbound?.behavior === 'block') { await h.hooks.invoke('onSessionEnd', { reason: 'prompt_blocked' }); return { messages: initMessages, result: null, error: 'prompt blocked by plugsdk hook: ' + (inbound.reason || 'denied'), iterations: 0 } }
     initMessages = mergeHookExtras(initMessages, inbound, 'onMessageInbound')
-    const machine = createAgentMachine({ model, provider, callLLM, enabledToolsets, disabledToolsets, maxIterations, events })
     // Persist the turn snapshot under kind=agent so an interrupted turn (process
     // refresh mid-tool-call) resumes exactly where it stopped via resumeTurn.
     const key = sessionKey || randomUUID()
+    const machine = createAgentMachine({ model, provider, callLLM, enabledToolsets, disabledToolsets, maxIterations, events, sessionKey: key })
     const pa = await createPersistentActor(machine, { kind: 'agent', key, input: { messages: initMessages } })
     pa.actor.send({ type: 'SUBMIT', prompt })
-    return await driveAgentActor({ pa, h, events, prompt, provider, model, skill, cwd, witnessPath, timeoutMs })
+    return await driveAgentActor({ pa, h, events, prompt, provider, model, skill, cwd, witnessPath, timeoutMs, sessionKey: key })
 }
 
 // Rehydrate an interrupted turn from its persisted snapshot and drive it to
@@ -226,10 +239,10 @@ export async function resumeTurn({ sessionKey, model, provider, callLLM, enabled
     const { load } = await import('../machines/snapshot-store.js')
     if (!(await load('agent', sessionKey))) return null
     const events = []; const h = await bootHost()
-    const machine = createAgentMachine({ model, provider, callLLM, enabledToolsets, disabledToolsets, maxIterations, events })
+    const machine = createAgentMachine({ model, provider, callLLM, enabledToolsets, disabledToolsets, maxIterations, events, sessionKey })
     const pa = await createPersistentActor(machine, { kind: 'agent', key: sessionKey, input: { messages: [] } })
     if (!pa.resumed) { await pa.forget(); return null }
-    return await driveAgentActor({ pa, h, events, prompt: '', provider, model, skill, cwd, witnessPath, timeoutMs })
+    return await driveAgentActor({ pa, h, events, prompt: '', provider, model, skill, cwd, witnessPath, timeoutMs, sessionKey })
 }
 
 export async function invokeCompactHooks({ trigger = 'auto', messages = [] } = {}) {

package/src/batch.js

@@ -6,6 +6,7 @@ import { randomUUID } from 'node:crypto'
 import { createMachine, assign, fromPromise } from 'xstate'
 import { createPersistentActor } from './machines/persistent-actor.js'
 import { load } from './machines/snapshot-store.js'
+import { runStep, clearSteps } from './machines/step-journal.js'
 
 // Run one prompt and append its result to the batch jsonl file.
 async function runOne({ job, model, callLLM, file }) {
@@ -43,7 +44,7 @@ export function createBatchMachine({ prompts, concurrency, model, callLLM, file
                             .map((p, i) => ({ i, p }))
                             .filter(({ i }) => !context.done.includes(i))
                             .slice(0, context.concurrency)
-                        return await Promise.all(pending.map(job => runOne({ job, model: context.model, callLLM, file: context.file })))
+                        return await Promise.all(pending.map(job => runStep(context.id, 'prompt:' + job.i, () => runOne({ job, model: context.model, callLLM, file: context.file }))))
                     }),
                     input: ({ context }) => ({ context }),
                     onDone: {
@@ -89,7 +90,7 @@ function driveBatch(pa) {
         const sub = actor.subscribe(snap => {
             if (snap.status !== 'done') return
             const out = snap.output
-            pa.flush().catch(() => {}).finally(() => { try { sub.unsubscribe() } catch {}; try { actor.stop() } catch {}; resolve(out) })
+            pa.flush().catch(() => {}).then(() => clearSteps(out.id)).catch(() => {}).finally(() => { try { sub.unsubscribe() } catch {}; try { actor.stop() } catch {}; resolve(out) })
         })
         actor.subscribe({ error: (e) => { try { sub.unsubscribe() } catch {}; reject(e) } })
     })

package/src/cron/scheduler.js

@@ -4,6 +4,7 @@ import { runTurn } from '../agent/machine.js'
 import { logger } from '../observability/log.js'
 import { createMachine, assign, fromPromise } from 'xstate'
 import { createPersistentActor } from '../machines/persistent-actor.js'
+import { runStep } from '../machines/step-journal.js'
 
 const log = logger('cron')
 
@@ -46,7 +47,10 @@ export async function tick(now = new Date(), { callLLM = null } = {}) {
             if (j.last_run && Math.floor(j.last_run / 60000) === minuteKey) continue
             await d.prepare(`UPDATE cron_jobs SET last_run = ? WHERE id = ?`).run(now.getTime(), j.id)
             fired.push(j)
-            runTurn({ prompt: j.prompt, callLLM }).catch(e => log.error('cron run failed', { id: j.id, err: String(e) }))
+            // runStep makes the fire idempotent within the minute as a second layer
+            // atop the last_run guard. Cron step rows accumulate (one per fired
+            // minute-key) but are tiny; minute-keys rotate so they don't collide.
+            runStep('cron:' + j.id, 'fire:' + minuteKey, () => runTurn({ prompt: j.prompt, callLLM })).catch(e => log.error('cron run failed', { id: j.id, err: String(e) }))
         } catch (e) { log.error('cron tick failed', { id: j.id, err: String(e) }) }
     }
     return fired

package/src/gateway/run.js

@@ -2,6 +2,7 @@ import { logger } from '../observability/log.js'
 import { runTurn } from '../agent/machine.js'
 import { createMachine, assign, fromPromise, createActor } from 'xstate'
 import { persist, load, clear } from '../machines/snapshot-store.js'
+import { runStep, clearSteps } from '../machines/step-journal.js'
 import { randomUUID } from 'node:crypto'
 
 const log = logger('gateway')
@@ -65,12 +66,13 @@ export class Gateway {
         await persist('gateway-msg', msgKey, { status: 'active', value: 'processing', context: { platform, from: msg.from, text: msg.text } })
         let cur = { ...msg, platform }
         for (const h of this.hooks.inbound) cur = (await h(cur)) || cur
-        const result = await runTurn({ prompt: cur.text || '', callLLM: this.callLLM })
+        const result = await runStep(msgKey, 'run', () => runTurn({ prompt: cur.text || '', callLLM: this.callLLM }))
         let reply = { to: msg.from, text: result.result || result.error || '', platform, result }
         for (const h of this.hooks.outbound) reply = (await h(reply)) || reply
         const adapter = this.platforms.get(platform)
         await adapter.send?.(reply)
         await clear('gateway-msg', msgKey)
+        await clearSteps(msgKey)
         return reply
     }
 }