@cmodjs/core 1.6.0 → 2.0.1

package/src/runtime/state.ts

@@ -84,14 +84,19 @@ export function createState<State extends object>({ name, initial, session, root
 
   const forgetEndedSessions = async (current: string) => {
     const stored = await claude.store.keys()
-    for (const recorded of stored.filter((key) => key.startsWith(transcriptsKey))) {
-      const owner = recorded.slice(transcriptsKey.length)
-      if (owner === current) continue
+    const ended = async (recorded: string) => {
       const transcript = await claude.store.get(recorded)
-      if (typeof transcript === 'string' && (await claude.fs.exists(transcript))) continue
-      for (const value of stored.filter((key) => key.startsWith(`${name}.`) && key.endsWith(`.sessions.${owner}`))) await claude.store.delete(value)
-      await claude.store.delete(recorded)
+      return typeof transcript !== 'string' || !(await claude.fs.exists(transcript))
     }
+    const owners = stored.filter((key) => key.startsWith(transcriptsKey) && key !== `${transcriptsKey}${current}`)
+    await Promise.all(
+      owners.map(async (recorded) => {
+        if (!(await ended(recorded))) return
+        const owner = recorded.slice(transcriptsKey.length)
+        await Promise.all(stored.filter((key) => key.startsWith(`${name}.`) && key.endsWith(`.sessions.${owner}`)).map((value) => claude.store.delete(value)))
+        await claude.store.delete(recorded)
+      }),
+    )
   }
 
   const loadGroups = async (only: readonly Lifetime[], next: { readonly root: string; readonly session: string }) => {
@@ -151,8 +156,10 @@ export function createState<State extends object>({ name, initial, session, root
     moveTo: (nextRoot) => inTurn(async () => (nextRoot === projectRoot ? undefined : loadGroups(['project'], { root: nextRoot, session: sessionId }))),
     switchSession: (nextSession, source, transcript) =>
       inTurn(async () => {
-        await claude.store.set(`${transcriptsKey}${nextSession}`, transcript)
-        await forgetEndedSessions(nextSession)
+        if (Object.keys(declared.session).length > 0) {
+          await claude.store.set(`${transcriptsKey}${nextSession}`, transcript)
+          void forgetEndedSessions(nextSession).catch((error: unknown) => report({ id: 'state:sessions', message: 'Could not forget the session values of ended sessions', error }))
+        }
         if (nextSession === sessionId) return
         if (source === 'fork') await copySession(sessionId, nextSession)
         return loadGroups(['memory', 'session'], { root: projectRoot, session: nextSession })

package/src/runtime/tool-calls.ts

@@ -5,7 +5,6 @@ export type Agent = { agentId?: string; agentType?: string }
 
 export type ToolCalls = {
   agentOf(toolUseId: string | undefined): Promise<Agent>
-  cwdOf(toolUseId: string): string | undefined
 }
 
 export const reservedKeys: readonly string[] = ['tool', 'tool_use_id', 'consent', 'agentId']
@@ -16,12 +15,9 @@ export function toolInputOf(envelope: object): Record<string, unknown> {
 
 type AgentFields = { readonly agent_id?: string; readonly agent_type?: string }
 
-const keptCalls = 100
-
 export function toolCalls(claude: Claude, router: Router): ToolCalls {
   let mainAgentType: string | undefined
   const agentIds = new Map<string, string>()
-  const cwds = new Map<string, string>()
   const noteAgent = (e: AgentFields) => {
     if (e.agent_id === undefined) mainAgentType = e.agent_type
   }
@@ -34,11 +30,6 @@ export function toolCalls(claude: Claude, router: Router): ToolCalls {
     return next(e)
   })
   router.add('tool.call', async (e, next) => {
-    cwds.set(e.tool_use_id, await claude.session.cwd())
-    for (const oldest of cwds.keys()) {
-      if (cwds.size <= keptCalls) break
-      cwds.delete(oldest)
-    }
     if (e.agentId === undefined) return next(e)
     agentIds.set(e.tool_use_id, e.agentId)
     try {
@@ -47,21 +38,11 @@ export function toolCalls(claude: Claude, router: Router): ToolCalls {
       agentIds.delete(e.tool_use_id)
     }
   })
-  for (const event of ['classic.PostToolUse', 'classic.PostToolUseFailure'] as const) {
-    router.add(event, async (e, next) => {
-      try {
-        return await next(e)
-      } finally {
-        cwds.delete(e.tool_use_id)
-      }
-    })
-  }
   return {
     async agentOf(toolUseId) {
       const agentId = toolUseId === undefined ? undefined : agentIds.get(toolUseId)
       const agentType = agentId === undefined ? mainAgentType : (await claude.agent.list()).find((agent) => agent.id === agentId)?.type
       return { ...(agentId === undefined ? {} : { agentId }), ...(agentType === undefined ? {} : { agentType }) }
     },
-    cwdOf: (toolUseId) => cwds.get(toolUseId),
   }
 }

package/src/session/context/turn/message/instruction-file.ts

@@ -0,0 +1,13 @@
+import type { MessageOf } from './message.js'
+
+export const InstructionFile = 'instructionFile'
+
+export type InstructionFile = MessageOf<typeof InstructionFile> & {
+  readonly path: string
+  readonly text: string
+  readonly isRule: boolean
+}
+
+export function isRulePath(path: string): boolean {
+  return /(^|\/)\.claude[^/]*\/rules\//.test(path)
+}

package/src/session/context/turn/message/message.ts

@@ -1,18 +1,18 @@
 import { isObject } from '../../../../records.js'
 import { Task } from '../../../goal/task.js'
-import { Document } from './document.js'
+import { InstructionFile, isRulePath } from './instruction-file.js'
 import { Note } from './note.js'
 import { Notice } from './notice.js'
 import { Prompt } from './prompt.js'
 import { Reply } from './reply.js'
 import { senderOf } from './sender.js'
 import { Skill } from './skill.js'
-import { ToolCall } from './tool-call.js'
+import { ToolCall, type CallFiles } from './tool-call.js'
 import { ToolResult } from './tool-result.js'
 
 export const Message = 'message'
 
-export type MessageType = typeof Prompt | typeof Note | typeof Reply | typeof ToolCall | typeof ToolResult | typeof Skill | typeof Document | typeof Notice
+export type MessageType = typeof Prompt | typeof Note | typeof Reply | typeof ToolCall | typeof ToolResult | typeof Skill | typeof InstructionFile | typeof Notice
 
 export type MessageOf<Type extends MessageType> = {
   readonly id: string
@@ -24,7 +24,7 @@ export type MessageOf<Type extends MessageType> = {
   readonly task?: string
 }
 
-export type Message = Prompt | Note | Reply | ToolCall | ToolResult | Skill | Document | Notice
+export type Message = Prompt | Note | Reply | ToolCall | ToolResult | Skill | InstructionFile | Notice
 
 export type Placed = 'session' | 'context' | 'turn' | 'task'
 
@@ -44,13 +44,17 @@ export type Row = {
   readonly model?: string
 }
 
-export const messageTypes: readonly MessageType[] = [Prompt, Note, Reply, ToolCall, ToolResult, Skill, Document, Notice]
+export const messageTypes: readonly MessageType[] = [Prompt, Note, Reply, ToolCall, ToolResult, Skill, InstructionFile, Notice]
 
 export const skillPrefix = 'Base directory for this skill:'
 
 const rowTypes: readonly string[] = ['user', 'assistant', 'attachment', 'system']
 
-const memoryPath = /^Contents of (.+?) \(/
+const memoryPath = /^Contents of (.+?)(?: \([^)\n]*\))?:\r?$/m
+
+export function instructionPathOf(text: string): string {
+  return memoryPath.exec(text)?.[1] ?? ''
+}
 
 export function rowOfLine(row: Readonly<Record<string, unknown>>): Row | undefined {
   const { uuid, timestamp, type } = row
@@ -77,7 +81,7 @@ export function rowOfLine(row: Readonly<Record<string, unknown>>): Row | undefin
 export function rowOfAppend(append: { readonly uuid: string; readonly door: string; readonly origin: unknown; readonly message: { readonly type: Row['type']; readonly name?: string; readonly isMeta?: true; readonly content: readonly unknown[] } }, at: string, cwd: string): Row {
   const { message, origin } = append
   const text = textOf(message.content)
-  const path = message.type === 'attachment' ? memoryPath.exec(text)?.[1] : undefined
+  const path = message.type === 'attachment' ? instructionPathOf(text) || undefined : undefined
   const model = isObject(origin) && origin['kind'] === 'model' && typeof origin['model'] === 'string' ? origin['model'] : undefined
   return {
     id: append.uuid,
@@ -94,6 +98,8 @@ export function rowOfAppend(append: { readonly uuid: string; readonly door: stri
   }
 }
 
+export const noFiles: CallFiles = { read: [], changed: [] }
+
 export function messagesOf(row: Row, isInTask: boolean): Unplaced[] {
   const found = unplacedOf(row, isInTask)
   return found.length === 1 ? found : found.map((message, index) => ({ ...message, id: `${row.id}:${index}` }))
@@ -103,17 +109,17 @@ function unplacedOf(row: Row, isInTask: boolean): Unplaced[] {
   const base = { id: row.id, at: row.at }
   const text = textOf(row.content).trim()
   if (row.type === 'system') return row.name === 'turn_duration' || row.name === 'compact_boundary' || text === '' ? [] : [{ ...base, type: Notice, text }]
-  if (row.type === 'attachment') return row.name === 'nested_memory' ? [{ ...base, type: Document, path: row.path ?? '', text }] : []
+  if (row.type === 'attachment') return row.name === 'nested_memory' ? [{ ...base, type: InstructionFile, path: row.path ?? '', text, isRule: isRulePath(row.path ?? '') }] : []
   if (row.type === 'assistant') {
     return row.content.filter(isObject).flatMap((block): Unplaced[] => {
       if (block['type'] === 'text' && typeof block['text'] === 'string' && block['text'].trim() !== '') return [{ ...base, type: Reply, text: block['text'].trim() }]
       if (block['type'] !== 'tool_use' || typeof block['id'] !== 'string' || typeof block['name'] !== 'string') return []
-      return [{ ...base, type: ToolCall, callId: block['id'], name: block['name'], input: isObject(block['input']) ? block['input'] : {}, cwd: row.cwd ?? '' }]
+      return [{ ...base, type: ToolCall, callId: block['id'], name: block['name'], input: isObject(block['input']) ? block['input'] : {}, cwd: row.cwd ?? '', files: noFiles }]
     })
   }
   if (row.isSummary) return []
   const results = row.content.filter(isToolResultBlock)
-  if (results.length > 0) return results.map((block) => ({ ...base, type: ToolResult, callId: block['tool_use_id'] as string, text: textOf(block['content']), isError: block['is_error'] === true }))
+  if (results.length > 0) return results.map((block) => ({ ...base, type: ToolResult, callId: block['tool_use_id'] as string, name: '', input: {}, cwd: row.cwd ?? '', files: noFiles, output: textOf(block['content']), isError: block['is_error'] === true }))
   if (text === '') return []
   if (text.startsWith(skillPrefix)) return [{ ...base, type: Skill, name: basename(text.slice(skillPrefix.length).split('\n')[0]?.trim() ?? ''), text }]
   if (text.startsWith('<task-notification')) return [{ ...base, type: Note, text: tagOf(text, 'summary') ?? text, from: { type: Task } }]
@@ -175,7 +181,7 @@ const toolValueChars = 1024
 export function searchText(message: Unplaced): string {
   if (message.type === ToolCall) return [message.name, ...stringsIn(message.input).map((value) => value.slice(0, toolValueChars))].join('\n')
   if (message.type === ToolResult) return ''
-  if (message.type === Document) return `${message.path}\n${message.text}`
+  if (message.type === InstructionFile) return `${message.path}\n${message.text}`
   return message.text
 }
 

package/src/session/context/turn/message/sender.ts

@@ -11,7 +11,9 @@ export const Channel = 'channel'
 
 export const Sdk = 'sdk'
 
-export type SenderType = typeof Person | typeof Mod | 'session' | typeof Task | typeof Schedule | typeof Channel | typeof Sdk
+export const Engine = 'engine'
+
+export type SenderType = typeof Person | typeof Mod | 'session' | typeof Task | typeof Schedule | typeof Channel | typeof Sdk | typeof Engine
 
 export type Sender = {
   readonly type: SenderType
@@ -19,7 +21,7 @@ export type Sender = {
   readonly as?: typeof Person
 }
 
-const personOrigins: readonly string[] = ['human', 'composer', 'bridge', 'slack-ping', 'auto-continuation']
+const personOrigins: readonly string[] = ['human', 'composer', 'bridge', 'slack-ping']
 
 const sessionOrigins: readonly string[] = ['peer', 'peer-send-message', 'coordinator', 'projects-relay', 'observer', 'observer-activity']
 
@@ -29,6 +31,7 @@ export function senderOf(origin: unknown, isInTask: boolean): Sender {
   if (kind === undefined) return { type: isInTask ? Task : Person }
   if (personOrigins.includes(kind)) return { type: Person }
   if (sessionOrigins.includes(kind)) return { type: 'session' }
+  if (kind === 'auto-continuation') return { type: Engine }
   if (kind === 'plugin' && typeof fields['name'] === 'string') return { type: Mod, name: fields['name'], ...(fields['asUser'] === true ? { as: Person } : {}) }
   if (kind === 'scheduled-trigger') return { type: Schedule }
   if (kind === 'channel' && typeof fields['server'] === 'string') return { type: Channel, name: fields['server'] }

package/src/session/context/turn/message/tool-call.ts

@@ -2,9 +2,12 @@ import type { MessageOf } from './message.js'
 
 export const ToolCall = 'toolCall'
 
+export type CallFiles = { readonly read: readonly string[]; readonly changed: readonly string[] }
+
 export type ToolCall = MessageOf<typeof ToolCall> & {
   readonly callId: string
   readonly name: string
   readonly input: Readonly<Record<string, unknown>>
   readonly cwd: string
+  readonly files: CallFiles
 }

package/src/session/context/turn/message/tool-result.ts

@@ -1,9 +1,14 @@
 import type { MessageOf } from './message.js'
+import type { CallFiles } from './tool-call.js'
 
 export const ToolResult = 'toolResult'
 
 export type ToolResult = MessageOf<typeof ToolResult> & {
   readonly callId: string
-  readonly text: string
+  readonly name: string
+  readonly input: Readonly<Record<string, unknown>>
+  readonly cwd: string
+  readonly files: CallFiles
+  readonly output: unknown
   readonly isError: boolean
 }

package/src/session/context/turn/turn.ts

@@ -11,5 +11,9 @@ export type Turn = RecordPart & {
   readonly context: number
   readonly openedAt: string
   readonly closedAt?: string
+  readonly answer?: string
+  readonly reason?: 'answer' | 'error'
+  readonly failure?: { readonly type: string; readonly text: string }
   messages(): Promise<Message[]>
+  abort(): Promise<void>
 }

package/src/session/conversation.ts

@@ -5,7 +5,7 @@ import { Prompt } from './context/turn/message/prompt.js'
 import { ToolCall } from './context/turn/message/tool-call.js'
 import { ToolResult } from './context/turn/message/tool-result.js'
 import { TurnEnd, TurnStart, type Turn } from './context/turn/turn.js'
-import { GoalChange, type Goal } from './goal/goal.js'
+import { GoalChange } from './goal/goal.js'
 import { Task, TaskEnd, TaskStart } from './goal/task.js'
 import type { UsageChange, Usage } from './session.js'
 
@@ -24,13 +24,15 @@ export type SessionData = {
 
 export type ContextData = Pick<Context, 'number' | 'openedAt' | 'closedAt' | 'task'>
 
-export type TurnData = Pick<Turn, 'prompt' | 'context' | 'openedAt' | 'closedAt'>
+export type TurnData = Pick<Turn, 'prompt' | 'context' | 'openedAt' | 'closedAt' | 'answer' | 'reason' | 'failure'>
+
+export type TurnEnding = Pick<Turn, 'answer' | 'reason' | 'failure'>
 
 export type TaskData = Pick<Task, 'id' | 'title' | 'openedBy' | 'openedAt' | 'closedAt'> & { readonly agentType: string; readonly model?: string; readonly parent?: string }
 
 export type RunningTask = TaskData & { readonly context: number; readonly contextOpenedAt?: string }
 
-export type GoalData = Pick<Goal, 'text'> & { readonly task?: string }
+export type GoalData = { readonly text: string; readonly task?: string }
 
 export type SessionChange =
   | { readonly type: typeof Message; readonly message: Message }
@@ -50,12 +52,16 @@ export type ConversationState = {
   readonly endedCalls: Readonly<Record<string, string>>
   readonly tasks: Readonly<Record<string, RunningTask>>
   readonly taskTurns: Readonly<Record<string, TurnData>>
+  readonly openCalls?: Readonly<Record<string, OpenCall>>
 }
 
+type OpenCall = Pick<ToolCall, 'name' | 'input' | 'cwd'>
+
 export type Conversation = {
   add(row: Row, task?: string): SessionChange[]
   startTask(task: TaskData): SessionChange[]
   startContext(at: string): SessionChange[]
+  endTurn(at: string, ending: TurnEnding, task?: string): SessionChange[]
   changeGoal(text: string): SessionChange[]
   readonly state: ConversationState
 }
@@ -76,12 +82,13 @@ export function createConversation(start: ConversationState): Conversation {
   const endedCalls = new Map(Object.entries(start.endedCalls))
   const tasks = new Map(Object.entries(start.tasks))
   const taskTurns = new Map(Object.entries(start.taskTurns))
+  const openCalls = new Map(Object.entries(start.openCalls ?? {}))
 
-  const endTaskTurn = (task: string, at: string): SessionChange[] => {
+  const endTaskTurn = (task: string, at: string, ending: TurnEnding = {}): SessionChange[] => {
     const open = taskTurns.get(task)
     if (open === undefined) return []
     taskTurns.delete(task)
-    return open.closedAt === undefined ? [{ type: TurnEnd, turn: { ...open, closedAt: at } }] : []
+    return open.closedAt === undefined ? [{ type: TurnEnd, turn: { ...open, ...ending, closedAt: at } }] : []
   }
 
   const startContext = (at: string): SessionChange[] => {
@@ -103,9 +110,9 @@ export function createConversation(start: ConversationState): Conversation {
     ]
   }
 
-  const endTurn = (at: string): SessionChange[] => {
+  const endTurn = (at: string, ending: TurnEnding = {}): SessionChange[] => {
     if (turn === undefined) return []
-    const ended = { ...turn, closedAt: at }
+    const ended = { ...turn, ...ending, closedAt: at }
     turn = undefined
     return [{ type: TurnEnd, turn: ended }]
   }
@@ -148,8 +155,12 @@ export function createConversation(start: ConversationState): Conversation {
           if (task === undefined && goal === undefined) changes.push(...changeGoal(unplaced.text))
         }
         const open = task === undefined ? turn : taskTurns.get(task)
+        const call = unplaced.type === ToolResult ? openCalls.get(unplaced.callId) : undefined
+        if (unplaced.type === ToolCall) openCalls.set(unplaced.callId, { name: unplaced.name, input: unplaced.input, cwd: unplaced.cwd })
+        if (unplaced.type === ToolResult) openCalls.delete(unplaced.callId)
         const placed = {
           ...unplaced,
+          ...call,
           session: start.session,
           context: placedIn,
           ...(open === undefined ? {} : { turn: open.prompt.id }),
@@ -157,7 +168,7 @@ export function createConversation(start: ConversationState): Conversation {
         } as Message
         changes.push({ type: Message, message: placed })
         if (placed.type === ToolCall && agentTools.includes(placed.name)) agentCalls.add(placed.callId)
-        if (placed.type === ToolResult && agentCalls.has(placed.callId) && !placed.text.startsWith(asyncLaunch)) changes.push(...endTask(placed.callId, row.at))
+        if (placed.type === ToolResult && agentCalls.has(placed.callId) && !String(placed.output).startsWith(asyncLaunch)) changes.push(...endTask(placed.callId, row.at))
         if (placed.type === Note && placed.from.type === Task) {
           const call = tagOf(textOf(row.content), 'tool-use-id')
           if (call !== undefined && agentCalls.has(call)) changes.push(...endTask(call, row.at, tagOf(textOf(row.content), 'task-id')))
@@ -176,6 +187,7 @@ export function createConversation(start: ConversationState): Conversation {
       return changes
     },
     startContext,
+    endTurn: (at, ending, task) => (task === undefined ? endTurn(at, ending) : endTaskTurn(task, at, ending)),
     changeGoal,
     get state() {
       return {
@@ -188,6 +200,7 @@ export function createConversation(start: ConversationState): Conversation {
         endedCalls: Object.fromEntries(endedCalls),
         tasks: Object.fromEntries(tasks),
         taskTurns: Object.fromEntries(taskTurns),
+        openCalls: Object.fromEntries(openCalls),
       }
     },
   }

package/src/session/goal/goal.ts

@@ -4,7 +4,7 @@ import type { Task } from './task.js'
 export const GoalChange = 'goalChange'
 
 export type Goal = RecordPart & {
-  readonly text: string
+  text(): Promise<string>
   tasks(): Promise<Task[]>
   update(change: { readonly text: string }): Promise<void>
 }

package/src/session/goal/task.ts

@@ -1,5 +1,5 @@
 import type { Message } from '../context/turn/message/message.js'
-import type { RecordPart, Session } from '../session.js'
+import type { RecordPart, TaskOwner } from '../session.js'
 
 export const Task = 'task'
 
@@ -10,7 +10,7 @@ export const TaskEnd = 'taskEnd'
 export type Task = RecordPart & {
   readonly id: string
   readonly title: string
-  readonly owner: Session
+  readonly owner: TaskOwner
   readonly openedBy: string
   readonly openedAt: string
   readonly closedAt?: string