tulingcode 0.1.0

package/src/acp/session.ts

@@ -0,0 +1,116 @@
+import { RequestError, type McpServer } from "@agentclientprotocol/sdk"
+import type { ACPSessionState } from "./types"
+import { Log } from "@/util"
+import type { OpencodeClient } from "@tuling-ai/sdk/v2"
+
+const log = Log.create({ service: "acp-session-manager" })
+
+export class ACPSessionManager {
+  private sessions = new Map<string, ACPSessionState>()
+  private sdk: OpencodeClient
+
+  constructor(sdk: OpencodeClient) {
+    this.sdk = sdk
+  }
+
+  tryGet(sessionId: string): ACPSessionState | undefined {
+    return this.sessions.get(sessionId)
+  }
+
+  async create(cwd: string, mcpServers: McpServer[], model?: ACPSessionState["model"]): Promise<ACPSessionState> {
+    const session = await this.sdk.session
+      .create(
+        {
+          directory: cwd,
+        },
+        { throwOnError: true },
+      )
+      .then((x) => x.data!)
+
+    const sessionId = session.id
+    const resolvedModel = model
+
+    const state: ACPSessionState = {
+      id: sessionId,
+      cwd,
+      mcpServers,
+      createdAt: new Date(),
+      model: resolvedModel,
+    }
+    log.info("creating_session", { state })
+
+    this.sessions.set(sessionId, state)
+    return state
+  }
+
+  async load(
+    sessionId: string,
+    cwd: string,
+    mcpServers: McpServer[],
+    model?: ACPSessionState["model"],
+  ): Promise<ACPSessionState> {
+    const session = await this.sdk.session
+      .get(
+        {
+          sessionID: sessionId,
+          directory: cwd,
+        },
+        { throwOnError: true },
+      )
+      .then((x) => x.data!)
+
+    const resolvedModel = model
+
+    const state: ACPSessionState = {
+      id: sessionId,
+      cwd,
+      mcpServers,
+      createdAt: new Date(session.time.created),
+      model: resolvedModel,
+    }
+    log.info("loading_session", { state })
+
+    this.sessions.set(sessionId, state)
+    return state
+  }
+
+  get(sessionId: string): ACPSessionState {
+    const session = this.sessions.get(sessionId)
+    if (!session) {
+      log.error("session not found", { sessionId })
+      throw RequestError.invalidParams(JSON.stringify({ error: `Session not found: ${sessionId}` }))
+    }
+    return session
+  }
+
+  getModel(sessionId: string) {
+    const session = this.get(sessionId)
+    return session.model
+  }
+
+  setModel(sessionId: string, model: ACPSessionState["model"]) {
+    const session = this.get(sessionId)
+    session.model = model
+    this.sessions.set(sessionId, session)
+    return session
+  }
+
+  getVariant(sessionId: string) {
+    const session = this.get(sessionId)
+    return session.variant
+  }
+
+  setVariant(sessionId: string, variant?: string) {
+    const session = this.get(sessionId)
+    session.variant = variant
+    this.sessions.set(sessionId, session)
+    return session
+  }
+
+  setMode(sessionId: string, modeId: string) {
+    const session = this.get(sessionId)
+    session.modeId = modeId
+    this.sessions.set(sessionId, session)
+    return session
+  }
+}

package/src/acp/types.ts

@@ -0,0 +1,24 @@
+import type { McpServer } from "@agentclientprotocol/sdk"
+import type { OpencodeClient } from "@tuling-ai/sdk/v2"
+import type { ProviderID, ModelID } from "../provider/schema"
+
+export interface ACPSessionState {
+  id: string
+  cwd: string
+  mcpServers: McpServer[]
+  createdAt: Date
+  model?: {
+    providerID: ProviderID
+    modelID: ModelID
+  }
+  variant?: string
+  modeId?: string
+}
+
+export interface ACPConfig {
+  sdk: OpencodeClient
+  defaultModel?: {
+    providerID: ProviderID
+    modelID: ModelID
+  }
+}

package/src/actor/actor.sql.ts

@@ -0,0 +1,38 @@
+import { sqliteTable, text, integer, index, primaryKey } from "drizzle-orm/sqlite-core"
+import { SessionTable } from "../session/session.sql"
+import type { SessionID, MessageID } from "../session/schema"
+import { Timestamps } from "../storage/schema.sql"
+
+export const ActorRegistryTable = sqliteTable(
+  "actor_registry",
+  {
+    session_id: text()
+      .$type<SessionID>()
+      .notNull()
+      .references(() => SessionTable.id, { onDelete: "cascade" }),
+    actor_id: text().notNull(),
+    mode: text().$type<"peer" | "subagent" | "main">().notNull(),
+    parent_actor_id: text(),
+    status: text().$type<"pending" | "running" | "idle">().notNull(),
+    last_outcome: text().$type<"success" | "failure" | "cancelled">(),
+    lifecycle: text().$type<"ephemeral" | "persistent">().notNull(),
+    agent: text().notNull(),
+    description: text().notNull(),
+    context_mode: text().$type<"none" | "state" | "full">().notNull(),
+    context_watermark: text().$type<MessageID>(),
+    background: integer({ mode: "boolean" }).notNull(),
+    tools: text({ mode: "json" }).$type<readonly string[] | "INHERIT">(),
+    last_turn_time: integer().notNull(),
+    turn_count: integer().notNull().default(0),
+    last_error: text(),
+    time_completed: integer(),
+    ...Timestamps,
+  },
+  (table) => [
+    primaryKey({ columns: [table.session_id, table.actor_id] }),
+    index("actor_registry_session_agent_idx").on(table.session_id, table.agent),
+    index("actor_registry_session_parent_idx").on(table.session_id, table.parent_actor_id),
+    index("actor_registry_status_idx").on(table.status),
+    index("actor_registry_status_last_turn_idx").on(table.status, table.last_turn_time),
+  ],
+)

package/src/actor/events.ts

@@ -0,0 +1,67 @@
+import { BusEvent } from "@/bus/bus-event"
+import { SessionID } from "@/session/schema"
+import { ActorStatus, ActorOutcome, SpawnMode } from "./schema"
+import z from "zod"
+
+export const ActorRegistered = BusEvent.define(
+  "actor.registered",
+  z.object({
+    sessionID: SessionID.zod,
+    actorID: z.string(),
+    mode: SpawnMode,
+    parentActorID: z.string().optional(),
+    description: z.string(),
+    agent: z.string(),
+    background: z.boolean(),
+  }),
+)
+
+export const ActorStatusChanged = BusEvent.define(
+  "actor.status",
+  z.object({
+    sessionID: SessionID.zod,
+    actorID: z.string(),
+    status: ActorStatus,
+    lastOutcome: ActorOutcome.optional(),
+    turnCount: z.number(),
+    lastTurnTime: z.number(),
+    error: z.string().optional(),
+  }),
+)
+
+export const ActorStuck = BusEvent.define(
+  "actor.stuck",
+  z.object({
+    sessionID: SessionID.zod,
+    actorID: z.string(),
+    description: z.string(),
+    lastTurnTime: z.number(),
+    stuckDuration: z.number(),
+  }),
+)
+
+export const WriterCachePerf = BusEvent.define(
+  "writer.cache_perf",
+  z.object({
+    sessionID: SessionID.zod,
+    writerActorID: z.string(),
+    status: z.enum(["completed", "failed"]),
+    total_input_tokens: z.number(),
+    cache_read_tokens: z.number(),
+    cache_write_tokens: z.number(),
+    cache_hit_rate: z.number(),
+    num_llm_calls: z.number(),
+  }),
+)
+
+export const InboxArrived = BusEvent.define(
+  "inbox.arrived",
+  z.object({
+    receiverSessionID: SessionID.zod,
+    receiverActorID: z.string(),
+    senderSessionID: SessionID.zod.optional(),
+    senderActorID: z.string().optional(),
+    inboxID: z.string(),
+    type: z.string(),
+  }),
+)

package/src/actor/index.ts

@@ -0,0 +1,2 @@
+export * as ActorRegistry from "./registry"
+export * as ActorWaiter from "./waiter"

package/src/actor/registry.ts

@@ -0,0 +1,412 @@
+import { Effect, Layer, Context, Schedule } from "effect"
+import { Database, inArray, eq, and, lte, sql } from "@/storage"
+import { Bus } from "@/bus"
+import type { SessionID, MessageID } from "@/session/schema"
+import { ActorRegistryTable } from "./actor.sql"
+import type { Actor, ActorStatus, ActorOutcome, ContextMode, Lifecycle, SpawnMode, ToolWhitelist } from "./schema"
+import * as Events from "./events"
+import { Log } from "@/util"
+import { SYSTEM_SPAWNED_AGENT_TYPES } from "@/agent/config"
+
+const log = Log.create({ service: "actor.registry" })
+
+const STUCK_THRESHOLD_MS = 5 * 60 * 1000 // 5 minutes
+const SCAN_INTERVAL_MS = 60 * 1000 // every 60s
+
+type ActorRow = typeof ActorRegistryTable.$inferSelect
+
+function fromRow(row: ActorRow): Actor {
+  return {
+    sessionID: row.session_id,
+    actorID: row.actor_id,
+    mode: row.mode,
+    parentActorID: row.parent_actor_id ?? undefined,
+    status: row.status,
+    lastOutcome: row.last_outcome ?? undefined,
+    lifecycle: row.lifecycle,
+    agent: row.agent,
+    description: row.description,
+    contextMode: row.context_mode,
+    contextWatermark: row.context_watermark ?? undefined,
+    background: Boolean(row.background),
+    tools: row.tools ?? undefined,
+    lastTurnTime: row.last_turn_time,
+    turnCount: row.turn_count,
+    lastError: row.last_error ?? undefined,
+    time: {
+      created: row.time_created,
+      updated: row.time_updated,
+      completed: row.time_completed ?? undefined,
+    },
+  }
+}
+
+export interface Interface {
+  readonly register: (input: {
+    sessionID: SessionID
+    actorID: string
+    mode: SpawnMode
+    parentActorID?: string
+    agent: string
+    description: string
+    contextMode: ContextMode
+    contextWatermark?: MessageID
+    background: boolean
+    lifecycle: Lifecycle
+    tools?: ToolWhitelist
+  }) => Effect.Effect<Actor>
+
+  readonly updateStatus: (
+    sessionID: SessionID,
+    actorID: string,
+    patch: {
+      status: ActorStatus
+      lastOutcome?: ActorOutcome | undefined
+      lastError?: string | undefined
+    },
+  ) => Effect.Effect<void>
+  readonly updateTurn: (sessionID: SessionID, actorID: string) => Effect.Effect<void>
+  readonly get: (sessionID: SessionID, actorID: string) => Effect.Effect<Actor | undefined>
+  readonly listBySession: (sessionID: SessionID) => Effect.Effect<Actor[]>
+  readonly listActive: () => Effect.Effect<Actor[]>
+  readonly listByParent: (sessionID: SessionID, parentActorID: string) => Effect.Effect<Actor[]>
+  readonly renderForAgent: (sessionID: SessionID) => Effect.Effect<string>
+  readonly agentTypeFor: (sessionID: SessionID, actorID: string) => Effect.Effect<string>
+  readonly isSystemSpawned: (sessionID: SessionID, actorID: string) => Effect.Effect<boolean>
+  readonly allocateActorID: (sessionID: SessionID, agentType: string) => Effect.Effect<string>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@tulingcode/ActorRegistry") {}
+
+export const layer: Layer.Layer<Service, never, Bus.Service> = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const bus = yield* Bus.Service
+
+    // --- CRUD methods ---
+
+    const register = Effect.fn("ActorRegistry.register")(function* (input: {
+      sessionID: SessionID
+      actorID: string
+      mode: SpawnMode
+      parentActorID?: string
+      agent: string
+      description: string
+      contextMode: ContextMode
+      contextWatermark?: MessageID
+      background: boolean
+      lifecycle: Lifecycle
+      tools?: ToolWhitelist
+    }) {
+      const now = Date.now()
+      const row = {
+        session_id: input.sessionID,
+        actor_id: input.actorID,
+        mode: input.mode,
+        parent_actor_id: input.parentActorID ?? null,
+        status: "pending" as const,
+        last_outcome: null,
+        lifecycle: input.lifecycle,
+        agent: input.agent,
+        description: input.description,
+        context_mode: input.contextMode,
+        context_watermark: input.contextWatermark ?? null,
+        background: input.background,
+        tools: input.tools ?? null,
+        last_turn_time: now,
+        turn_count: 0,
+        last_error: null,
+        time_completed: null,
+        time_created: now,
+        time_updated: now,
+      }
+      yield* Effect.sync(() => Database.use((db) => db.insert(ActorRegistryTable).values(row).run()))
+      yield* bus.publish(Events.ActorRegistered, {
+        sessionID: input.sessionID,
+        actorID: input.actorID,
+        mode: input.mode,
+        parentActorID: input.parentActorID,
+        description: input.description,
+        agent: input.agent,
+        background: input.background,
+      })
+      return fromRow(row)
+    })
+
+    const updateStatus = Effect.fn("ActorRegistry.updateStatus")(function* (
+      sessionID: SessionID,
+      actorID: string,
+      patch: {
+        status: ActorStatus
+        lastOutcome?: ActorOutcome | undefined
+        lastError?: string | undefined
+      },
+    ) {
+      const now = Date.now()
+      const isTerminal = patch.status === "idle" && patch.lastOutcome !== undefined
+      const set: Record<string, unknown> = {
+        status: patch.status,
+        time_updated: now,
+        ...(isTerminal ? { time_completed: now } : {}),
+      }
+      if (patch.lastOutcome !== undefined) set.last_outcome = patch.lastOutcome
+      if (patch.lastError !== undefined) set.last_error = patch.lastError
+      else if (patch.lastOutcome !== undefined && patch.lastOutcome !== "failure") set.last_error = null
+      yield* Effect.sync(() =>
+        Database.use((db) =>
+          db
+            .update(ActorRegistryTable)
+            .set(set)
+            .where(
+              and(eq(ActorRegistryTable.session_id, sessionID), eq(ActorRegistryTable.actor_id, actorID)),
+            )
+            .run(),
+        ),
+      )
+      // Re-read so the event payload reflects committed row values (not the
+      // sparse patch). Skip publish if the row vanished between UPDATE and
+      // SELECT — a dropped event beats a misleading one.
+      const row = yield* Effect.sync(() =>
+        Database.use((db) =>
+          db
+            .select()
+            .from(ActorRegistryTable)
+            .where(
+              and(eq(ActorRegistryTable.session_id, sessionID), eq(ActorRegistryTable.actor_id, actorID)),
+            )
+            .get(),
+        ),
+      )
+      if (!row) return
+      yield* bus.publish(Events.ActorStatusChanged, {
+        sessionID,
+        actorID,
+        status: row.status,
+        ...(row.last_outcome ? { lastOutcome: row.last_outcome } : {}),
+        turnCount: row.turn_count,
+        lastTurnTime: row.last_turn_time,
+        ...(row.last_error ? { error: row.last_error } : {}),
+      })
+    })
+
+    const updateTurn = Effect.fn("ActorRegistry.updateTurn")(function* (sessionID: SessionID, actorID: string) {
+      const now = Date.now()
+      yield* Effect.sync(() =>
+        Database.use((db) =>
+          db
+            .update(ActorRegistryTable)
+            .set({
+              last_turn_time: now,
+              turn_count: sql`${ActorRegistryTable.turn_count} + 1`,
+              time_updated: now,
+            })
+            .where(
+              and(eq(ActorRegistryTable.session_id, sessionID), eq(ActorRegistryTable.actor_id, actorID)),
+            )
+            .run(),
+        ),
+      )
+    })
+
+    const get = Effect.fn("ActorRegistry.get")(function* (sessionID: SessionID, actorID: string) {
+      const row = yield* Effect.sync(() =>
+        Database.use((db) =>
+          db
+            .select()
+            .from(ActorRegistryTable)
+            .where(
+              and(eq(ActorRegistryTable.session_id, sessionID), eq(ActorRegistryTable.actor_id, actorID)),
+            )
+            .get(),
+        ),
+      )
+      return row ? fromRow(row) : undefined
+    })
+
+    const listBySession = Effect.fn("ActorRegistry.listBySession")(function* (sessionID: SessionID) {
+      const rows = yield* Effect.sync(() =>
+        Database.use((db) =>
+          db.select().from(ActorRegistryTable).where(eq(ActorRegistryTable.session_id, sessionID)).all(),
+        ),
+      )
+      return rows.map(fromRow)
+    })
+
+    const listActive = Effect.fn("ActorRegistry.listActive")(function* () {
+      const rows = yield* Effect.sync(() =>
+        Database.use((db) =>
+          db
+            .select()
+            .from(ActorRegistryTable)
+            .where(
+              and(
+                inArray(ActorRegistryTable.status, ["pending", "running"]),
+                eq(ActorRegistryTable.background, true),
+              ),
+            )
+            .all(),
+        ),
+      )
+      return rows.map(fromRow)
+    })
+
+    const listByParent = Effect.fn("ActorRegistry.listByParent")(function* (
+      sessionID: SessionID,
+      parentActorID: string,
+    ) {
+      const rows = yield* Effect.sync(() =>
+        Database.use((db) =>
+          db
+            .select()
+            .from(ActorRegistryTable)
+            .where(
+              and(
+                eq(ActorRegistryTable.session_id, sessionID),
+                eq(ActorRegistryTable.parent_actor_id, parentActorID),
+              ),
+            )
+            .all(),
+        ),
+      )
+      return rows.map(fromRow)
+    })
+
+    const renderForAgent = Effect.fn("ActorRegistry.renderForAgent")(function* (sessionID: SessionID) {
+      const actors = yield* listBySession(sessionID)
+      const active = actors.filter((actor) => actor.background && (actor.status === "pending" || actor.status === "running"))
+      if (active.length === 0) return ""
+
+      const lines: string[] = []
+      lines.push("## Active Actors")
+      lines.push("")
+      lines.push(`You have ${active.length} background actor(s) registered. Interact via the \`actor\` tool.`)
+      lines.push("")
+      const now = Date.now()
+      for (const actor of active) {
+        const idleMs = now - actor.lastTurnTime
+        const idle = idleMs < 60_000 ? `${Math.floor(idleMs / 1000)}s` : `${Math.floor(idleMs / 60_000)}m`
+        lines.push(`- actor_id: ${actor.actorID} (${actor.status}, last activity ${idle} ago)`)
+        lines.push(`  description: ${actor.description}`)
+        lines.push(`  agent: ${actor.agent}`)
+      }
+      return lines.join("\n")
+    })
+
+    const agentTypeFor = Effect.fn("ActorRegistry.agentTypeFor")(function* (
+      sessionID: SessionID,
+      actorID: string,
+    ) {
+      if (actorID === "main") return "main"
+      const actor = yield* get(sessionID, actorID)
+      return actor?.agent ?? "main"
+    })
+
+    const isSystemSpawned = Effect.fn("ActorRegistry.isSystemSpawned")(function* (
+      sessionID: SessionID,
+      actorID: string,
+    ) {
+      if (actorID === "main") return false
+      const actor = yield* get(sessionID, actorID)
+      if (!actor) return false
+      return SYSTEM_SPAWNED_AGENT_TYPES.has(actor.agent)
+    })
+
+    const allocateActorID = Effect.fn("ActorRegistry.allocateActorID")(function* (
+      sessionID: SessionID,
+      agentType: string,
+    ) {
+      const existing = yield* Effect.sync(() =>
+        Database.use((db) =>
+          db
+            .select({ actor_id: ActorRegistryTable.actor_id })
+            .from(ActorRegistryTable)
+            .where(and(eq(ActorRegistryTable.session_id, sessionID), eq(ActorRegistryTable.agent, agentType)))
+            .all(),
+        ),
+      )
+      const prefix = `${agentType}-`
+      let max = 0
+      for (const row of existing) {
+        if (row.actor_id.startsWith(prefix)) {
+          const n = parseInt(row.actor_id.slice(prefix.length), 10)
+          if (Number.isFinite(n) && n > max) max = n
+        }
+      }
+      return `${agentType}-${max + 1}`
+    })
+
+    // --- Orphan Recovery ---
+    // On init, mark all pending/running actors as idle with failure outcome.
+    // Per spec B6: don't auto-revive — they wake on next sender's send.
+    yield* Effect.sync(() =>
+      Database.use((db) => {
+        const now = Date.now()
+        db.update(ActorRegistryTable)
+          .set({
+            status: "idle",
+            last_outcome: "failure",
+            last_error: "orphaned: process restarted",
+            time_updated: now,
+            time_completed: now,
+          })
+          .where(inArray(ActorRegistryTable.status, ["pending", "running"]))
+          .run()
+      }),
+    )
+    log.info("orphan recovery complete")
+
+    // --- Stuck Detection ---
+    const scanStuck = Effect.gen(function* () {
+      const cutoff = Date.now() - STUCK_THRESHOLD_MS
+      const stuck = yield* Effect.sync(() =>
+        Database.use((db) =>
+          db
+            .select()
+            .from(ActorRegistryTable)
+            .where(
+              and(
+                eq(ActorRegistryTable.status, "running"),
+                lte(ActorRegistryTable.last_turn_time, cutoff),
+              ),
+            )
+            .all(),
+        ),
+      )
+      for (const row of stuck) {
+        const entry = fromRow(row)
+        yield* bus.publish(Events.ActorStuck, {
+          sessionID: entry.sessionID,
+          actorID: entry.actorID,
+          description: entry.description,
+          lastTurnTime: entry.lastTurnTime,
+          stuckDuration: Date.now() - entry.lastTurnTime,
+        })
+      }
+    })
+
+    // Fork stuck detection fiber in the layer scope
+    yield* scanStuck.pipe(
+      Effect.repeat(Schedule.fixed(SCAN_INTERVAL_MS)),
+      Effect.ignore,
+      Effect.forkScoped,
+    )
+
+    return Service.of({
+      register,
+      updateStatus,
+      updateTurn,
+      get,
+      listBySession,
+      listActive,
+      listByParent,
+      renderForAgent,
+      agentTypeFor,
+      isSystemSpawned,
+      allocateActorID,
+    })
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
+
+export * as ActorRegistry from "./registry"

package/src/actor/return-header.ts

@@ -0,0 +1,24 @@
+export const RETURN_STATUSES = ["success", "partial", "failed", "blocked"] as const
+export type ReturnStatus = (typeof RETURN_STATUSES)[number]
+
+export interface ParsedReturnHeader {
+  status?: ReturnStatus
+  summary?: string
+}
+
+const STATUS_RE = /^\s*\*\*Status\*\*:\s*(success|partial|failed|blocked)\b/im
+const SUMMARY_RE = /\*\*Summary\*\*:\s*(.+)$/im
+
+// Parse the **Status**/**Summary** header a subagent is asked to emit
+// (see RETURN_FORMAT_INSTRUCTION in spawn.ts). Missing/malformed → {}.
+export function parseReturnHeader(finalText: string | undefined): ParsedReturnHeader {
+  if (!finalText) return {}
+  const status = finalText.match(STATUS_RE)?.[1]?.toLowerCase() as ReturnStatus | undefined
+  const summary = finalText.match(SUMMARY_RE)?.[1]?.trim()
+  return {
+    ...(status ? { status } : {}),
+    ...(summary ? { summary } : {}),
+  }
+}
+
+export * as ReturnHeader from "./return-header"