airaknit 1.1.2-rc.9

package/src/server/workspace-agent.test.ts

@@ -0,0 +1,103 @@
+// src/server/project-agent.test.ts
+import { describe, expect, test, afterEach } from "bun:test"
+import { WorkspaceAgent } from "./workspace-agent"
+import { SessionIndex } from "./session-index"
+import { EventStore } from "./event-store"
+import { TranscriptSearchIndex } from "./transcript-search"
+import { mkdtemp, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+
+let tempDirs: string[] = []
+
+async function createAgent() {
+  const dir = await mkdtemp(path.join(tmpdir(), "pa-test-"))
+  tempDirs.push(dir)
+  const store = new EventStore(dir)
+  await store.initialize()
+  const sessions = new SessionIndex()
+  const search = new TranscriptSearchIndex()
+
+  const project = await store.openProject("/tmp/test", "Test Project")
+  const workspaceId = project.id
+
+  const agent = new WorkspaceAgent({ sessions, store, search, workspaceId })
+  return { agent, sessions, store, search, workspaceId }
+}
+
+afterEach(async () => {
+  for (const d of tempDirs) await rm(d, { recursive: true, force: true })
+  tempDirs = []
+})
+
+describe("WorkspaceAgent", () => {
+  describe("querySessions", () => {
+    test("returns sessions for project", async () => {
+      const { agent, workspaceId } = await createAgent()
+      const result = agent.querySessions(workspaceId)
+      expect(result).toEqual([])
+    })
+  })
+
+  describe("searchWork", () => {
+    test("delegates to transcript search", async () => {
+      const { agent, search } = await createAgent()
+      search.addEntry("chat-1", {
+        _id: "1",
+        createdAt: Date.now(),
+        kind: "user_prompt",
+        content: "implement auth middleware",
+      } as never)
+
+      const results = agent.searchWork("auth middleware", 10)
+      expect(results.length).toBe(1)
+    })
+  })
+
+  describe("claimTask", () => {
+    test("creates and claims task in event store", async () => {
+      const { agent } = await createAgent()
+      const task = await agent.claimTask("implement auth", "chat-1", "feat/auth")
+      expect(task.status).toBe("claimed")
+      expect(task.description).toBe("implement auth")
+      expect(task.claimedBy).toBe("chat-1")
+    })
+  })
+
+  describe("completeTask", () => {
+    test("completes task", async () => {
+      const { agent } = await createAgent()
+      const task = await agent.claimTask("task", "chat-1", null)
+      const completed = await agent.completeTask(task.id, ["file.ts"])
+      expect(completed).not.toBeNull()
+      expect(completed!.status).toBe("complete")
+      expect(completed!.outputs).toEqual(["file.ts"])
+    })
+  })
+
+  describe("listTasks", () => {
+    test("returns all tasks", async () => {
+      const { agent } = await createAgent()
+      await agent.claimTask("a", "c1", null)
+      await agent.claimTask("b", "c2", null)
+      expect(agent.listTasks().length).toBe(2)
+    })
+  })
+
+  describe("delegate", () => {
+    test("returns task info for task query", async () => {
+      const { agent } = await createAgent()
+      await agent.claimTask("implement auth", "chat-1", "feat/auth")
+
+      const result = await agent.delegate("who is working on auth?")
+      expect(result.status).toBe("ok")
+      expect(result.message).toContain("auth")
+    })
+
+    test("returns ok with summary when no data found", async () => {
+      const { agent } = await createAgent()
+      const result = await agent.delegate("what is going on?")
+      expect(result.status).toBe("ok")
+    })
+  })
+})

package/src/server/workspace-agent.ts

@@ -0,0 +1,102 @@
+// src/server/project-agent.ts
+import { randomUUID } from "node:crypto"
+import type { WorkspaceTodo, SessionRecord, SearchResult, DelegationResult } from "../shared/workspace-types"
+import type { SessionIndex } from "./session-index"
+import type { EventStore } from "./event-store"
+import type { TranscriptSearchIndex } from "./transcript-search"
+
+const TASK_KEYWORDS = ["task", "working on", "who", "claimed"]
+const SEARCH_KEYWORDS = ["search", "find", "implemented", "where"]
+
+interface WorkspaceAgentArgs {
+  sessions: SessionIndex
+  store: EventStore
+  search: TranscriptSearchIndex
+  workspaceId: string
+}
+
+export class WorkspaceAgent {
+  private readonly sessions: SessionIndex
+  private readonly store: EventStore
+  private readonly search: TranscriptSearchIndex
+  private readonly workspaceId: string
+
+  constructor(args: WorkspaceAgentArgs) {
+    this.sessions = args.sessions
+    this.store = args.store
+    this.search = args.search
+    this.workspaceId = args.workspaceId
+  }
+
+  querySessions(workspaceId: string): SessionRecord[] {
+    return this.sessions.getSessionsByProject(workspaceId)
+  }
+
+  getSessionSummary(chatId: string): SessionRecord | null {
+    return this.sessions.getSession(chatId)
+  }
+
+  searchWork(query: string, limit: number): SearchResult[] {
+    return this.search.search(query, limit)
+  }
+
+  listTasks(): WorkspaceTodo[] {
+    const coord = this.store.state.coordinationByWorkspace.get(this.workspaceId)
+    if (!coord) return []
+    return Array.from(coord.todos.values())
+  }
+
+  getTask(taskId: string): WorkspaceTodo | null {
+    const coord = this.store.state.coordinationByWorkspace.get(this.workspaceId)
+    if (!coord) return null
+    return coord.todos.get(taskId) ?? null
+  }
+
+  async claimTask(description: string, claimedBy: string, _branch: string | null): Promise<WorkspaceTodo> {
+    const todoId = randomUUID()
+    await this.store.addTodo(this.workspaceId, todoId, description, "normal", claimedBy)
+    await this.store.claimTodo(this.workspaceId, todoId, claimedBy)
+    const todo = this.getTask(todoId)
+    if (!todo) throw new Error(`Todo ${todoId} not found after creation`)
+    return todo
+  }
+
+  async completeTask(taskId: string, outputs: string[]): Promise<WorkspaceTodo | null> {
+    await this.store.completeTodo(this.workspaceId, taskId, outputs)
+    return this.getTask(taskId)
+  }
+
+  async abandonTask(taskId: string): Promise<WorkspaceTodo | null> {
+    await this.store.abandonTodo(this.workspaceId, taskId)
+    return this.getTask(taskId)
+  }
+
+  async delegate(request: string): Promise<DelegationResult> {
+    const sessions = this.querySessions(this.workspaceId)
+    const tasks = this.listTasks()
+    const lower = request.toLowerCase()
+
+    if (TASK_KEYWORDS.some((kw) => lower.includes(kw))) {
+      if (tasks.length === 0) {
+        return { status: "ok", message: "No tasks claimed." }
+      }
+      const summary = tasks.map((t) => `[${t.status}] "${t.description}" owned by ${t.claimedBy ?? t.createdBy}`).join("; ")
+      return { status: "ok", message: summary, data: { tasks } }
+    }
+
+    if (SEARCH_KEYWORDS.some((kw) => lower.includes(kw))) {
+      const searchResults = this.search.search(request, 5)
+      if (searchResults.length === 0) {
+        return { status: "ok", message: "No matching transcript entries found." }
+      }
+      const summary = searchResults.map((r) => `[${r.chatId}] ${r.fragment.slice(0, 100)}`).join("\n")
+      return { status: "ok", message: summary, data: { searchResults } }
+    }
+
+    // General — summarize known state
+    const parts: string[] = []
+    if (sessions.length > 0) parts.push(`${sessions.length} session(s) active`)
+    if (tasks.length > 0) parts.push(`${tasks.length} task(s) tracked`)
+    return { status: "ok", message: parts.length > 0 ? parts.join(", ") + "." : "No project activity recorded yet." }
+  }
+}

package/src/server/workspace-cli.test.ts

@@ -0,0 +1,79 @@
+// src/server/project-cli.test.ts
+import { describe, expect, test } from "bun:test"
+import { parseProjectCliArgs, formatOutput } from "./project-cli"
+
+describe("parseProjectCliArgs", () => {
+  test("parses 'sessions' command", () => {
+    const result = parseProjectCliArgs(["sessions"])
+    expect(result).toEqual({ command: "sessions", args: {} })
+  })
+
+  test("parses 'sessions <id>' command", () => {
+    const result = parseProjectCliArgs(["sessions", "chat-1"])
+    expect(result).toEqual({ command: "session-detail", args: { chatId: "chat-1" } })
+  })
+
+  test("parses 'search <query>' command", () => {
+    const result = parseProjectCliArgs(["search", "auth", "middleware"])
+    expect(result).toEqual({ command: "search", args: { query: "auth middleware" } })
+  })
+
+  test("parses 'tasks' command", () => {
+    const result = parseProjectCliArgs(["tasks"])
+    expect(result).toEqual({ command: "tasks", args: {} })
+  })
+
+  test("parses 'tasks <id>' command", () => {
+    const result = parseProjectCliArgs(["tasks", "t-1"])
+    expect(result).toEqual({ command: "task-detail", args: { taskId: "t-1" } })
+  })
+
+  test("parses 'claim <description>' with flags", () => {
+    const result = parseProjectCliArgs(["claim", "implement auth", "--session", "c1", "--branch", "feat/auth"])
+    expect(result).toEqual({
+      command: "claim",
+      args: { description: "implement auth", session: "c1", branch: "feat/auth" },
+    })
+  })
+
+  test("parses 'complete <id>'", () => {
+    const result = parseProjectCliArgs(["complete", "t-1"])
+    expect(result).toEqual({ command: "complete", args: { taskId: "t-1" } })
+  })
+
+  test("parses 'delegate <request>'", () => {
+    const result = parseProjectCliArgs(["delegate", "ensure", "postgres", "running"])
+    expect(result).toEqual({ command: "delegate", args: { request: "ensure postgres running" } })
+  })
+
+  test("parses --project flag", () => {
+    const result = parseProjectCliArgs(["sessions", "--project", "p1"])
+    expect(result).toEqual({ command: "sessions", args: { workspaceId: "p1" } })
+  })
+
+  test("returns help for no args", () => {
+    const result = parseProjectCliArgs([])
+    expect(result.command).toBe("help")
+  })
+
+  test("returns help for --help", () => {
+    const result = parseProjectCliArgs(["--help"])
+    expect(result.command).toBe("help")
+  })
+})
+
+describe("formatOutput", () => {
+  test("formats sessions as table when not --json", () => {
+    const output = formatOutput("sessions", [
+      { chatId: "c1", intent: "auth work", status: "active", provider: "claude", branch: null, filesTouched: [], commandsRun: [], lastActivity: "2026-04-04T10:00:00Z" },
+    ], false)
+    expect(output).toContain("c1")
+    expect(output).toContain("auth work")
+  })
+
+  test("formats as JSON when json=true", () => {
+    const data = [{ chatId: "c1" }]
+    const output = formatOutput("sessions", data, true)
+    expect(JSON.parse(output)).toEqual(data)
+  })
+})

package/src/server/workspace-config-manager.test.ts

@@ -0,0 +1,109 @@
+import { describe, test, expect, afterEach } from "bun:test"
+import { mkdtemp, rm, stat, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { WorkspaceConfigManager } from "./workspace-config-manager"
+import type { AgentConfig } from "../shared/agent-config-types"
+
+const makeConfig = (id: string): AgentConfig => ({
+  id,
+  name: `Agent ${id}`,
+  description: `Test agent ${id}`,
+  provider: "claude",
+  model: "opus-4",
+  systemPrompt: "You are helpful.",
+  tools: ["bash", "read"],
+  temperature: 0.7,
+})
+
+describe("WorkspaceConfigManager", () => {
+  let tmpDir: string
+  let mgr: WorkspaceConfigManager
+
+  const setup = async () => {
+    tmpDir = await mkdtemp(path.join(os.tmpdir(), "wcm-test-"))
+    mgr = new WorkspaceConfigManager(tmpDir)
+  }
+
+  afterEach(async () => {
+    if (tmpDir) {
+      await rm(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  test("initWorkspaceDir creates .git, agents/, workflows/", async () => {
+    await setup()
+    const wsPath = await mgr.initWorkspaceDir("ws-1")
+    expect(wsPath).toBe(path.join(tmpDir, "ws-1"))
+    const gitStat = await stat(path.join(wsPath, ".git"))
+    expect(gitStat.isDirectory()).toBe(true)
+    const agentsStat = await stat(path.join(wsPath, "agents"))
+    expect(agentsStat.isDirectory()).toBe(true)
+    const workflowsStat = await stat(path.join(wsPath, "workflows"))
+    expect(workflowsStat.isDirectory()).toBe(true)
+  })
+
+  test("initWorkspaceDir is idempotent", async () => {
+    await setup()
+    await mgr.initWorkspaceDir("ws-2")
+    const wsPath = await mgr.initWorkspaceDir("ws-2")
+    expect(wsPath).toBe(path.join(tmpDir, "ws-2"))
+  })
+
+  test("saveAgentConfig writes agents/<id>.yaml", async () => {
+    await setup()
+    await mgr.initWorkspaceDir("ws-3")
+    const config = makeConfig("agent-a")
+    await mgr.saveAgentConfig("ws-3", config)
+    const filePath = path.join(tmpDir, "ws-3", "agents", "agent-a.yaml")
+    const fileStat = await stat(filePath)
+    expect(fileStat.isFile()).toBe(true)
+  })
+
+  test("readAgentConfig roundtrips saved config", async () => {
+    await setup()
+    await mgr.initWorkspaceDir("ws-4")
+    const config = makeConfig("agent-b")
+    await mgr.saveAgentConfig("ws-4", config)
+    const read = await mgr.readAgentConfig("ws-4", "agent-b")
+    expect(read).toEqual(config)
+  })
+
+  test("readAgentConfig returns null for missing agent", async () => {
+    await setup()
+    await mgr.initWorkspaceDir("ws-5")
+    const read = await mgr.readAgentConfig("ws-5", "nope")
+    expect(read).toBeNull()
+  })
+
+  test("listAgentConfigs returns all saved, skips non-yaml", async () => {
+    await setup()
+    await mgr.initWorkspaceDir("ws-6")
+    await mgr.saveAgentConfig("ws-6", makeConfig("x"))
+    await mgr.saveAgentConfig("ws-6", makeConfig("y"))
+    // write a non-yaml file that should be skipped
+    await writeFile(path.join(tmpDir, "ws-6", "agents", "readme.txt"), "ignore me")
+    const configs = await mgr.listAgentConfigs("ws-6")
+    expect(configs).toHaveLength(2)
+    const ids = configs.map((c: AgentConfig) => c.id).sort()
+    expect(ids).toEqual(["x", "y"])
+  })
+
+  test("removeAgentConfig deletes the file", async () => {
+    await setup()
+    await mgr.initWorkspaceDir("ws-7")
+    await mgr.saveAgentConfig("ws-7", makeConfig("del-me"))
+    await mgr.removeAgentConfig("ws-7", "del-me")
+    const configs = await mgr.listAgentConfigs("ws-7")
+    expect(configs).toHaveLength(0)
+  })
+
+  test("commitConfig returns a non-empty hash", async () => {
+    await setup()
+    await mgr.initWorkspaceDir("ws-8")
+    await mgr.saveAgentConfig("ws-8", makeConfig("committed"))
+    const hash = await mgr.commitConfig("ws-8", "initial config")
+    expect(typeof hash).toBe("string")
+    expect(hash.length).toBeGreaterThanOrEqual(7)
+  })
+})

package/src/server/workspace-config-manager.ts

@@ -0,0 +1,83 @@
+import { mkdir, rm, readdir, readFile, writeFile } from "node:fs/promises"
+import path from "node:path"
+import { $ } from "bun"
+import yaml from "js-yaml"
+import type { AgentConfig } from "../shared/agent-config-types"
+
+const LOG_PREFIX = "[WorkspaceConfigManager]"
+
+export class WorkspaceConfigManager {
+  constructor(private basePath: string) {}
+
+  async initWorkspaceDir(workspaceId: string): Promise<string> {
+    const wsPath = this.getWorkspacePath(workspaceId)
+    await mkdir(path.join(wsPath, "agents"), { recursive: true })
+    await mkdir(path.join(wsPath, "workflows"), { recursive: true })
+    await $`git -C ${wsPath} init`.quiet()
+    await $`git -C ${wsPath} config user.email "workspace@tinkaria.local"`.quiet()
+    await $`git -C ${wsPath} config user.name "Tinkaria Workspace"`.quiet()
+    return wsPath
+  }
+
+  async saveAgentConfig(workspaceId: string, config: AgentConfig): Promise<void> {
+    const agentDir = path.join(this.getWorkspacePath(workspaceId), "agents")
+    await mkdir(agentDir, { recursive: true })
+    const filePath = this.getAgentConfigPath(workspaceId, config.id)
+    const content = yaml.dump(config, { sortKeys: true })
+    await writeFile(filePath, content, "utf-8")
+  }
+
+  async readAgentConfig(workspaceId: string, agentId: string): Promise<AgentConfig | null> {
+    const filePath = this.getAgentConfigPath(workspaceId, agentId)
+    try {
+      const content = await readFile(filePath, "utf-8")
+      return yaml.load(content) as AgentConfig
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error)
+      if (msg.includes("ENOENT") || error instanceof SyntaxError) {
+        return null
+      }
+      console.warn(`${LOG_PREFIX} readAgentConfig failed: ${msg}`)
+      return null
+    }
+  }
+
+  async listAgentConfigs(workspaceId: string): Promise<AgentConfig[]> {
+    const agentsDir = path.join(this.getWorkspacePath(workspaceId), "agents")
+    const entries = await readdir(agentsDir)
+    const configs: AgentConfig[] = []
+    for (const entry of entries) {
+      if (!entry.endsWith(".yaml")) continue
+      try {
+        const content = await readFile(path.join(agentsDir, entry), "utf-8")
+        const parsed = yaml.load(content) as AgentConfig
+        configs.push(parsed)
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error)
+        console.warn(`${LOG_PREFIX} skipping unparseable ${entry}: ${msg}`)
+      }
+    }
+    return configs
+  }
+
+  async removeAgentConfig(workspaceId: string, agentId: string): Promise<void> {
+    const filePath = this.getAgentConfigPath(workspaceId, agentId)
+    await rm(filePath, { force: true })
+  }
+
+  async commitConfig(workspaceId: string, message: string): Promise<string> {
+    const wsPath = this.getWorkspacePath(workspaceId)
+    await $`git -C ${wsPath} add -A`.quiet()
+    await $`git -C ${wsPath} commit -m ${message} --allow-empty`.quiet()
+    const result = await $`git -C ${wsPath} rev-parse HEAD`.quiet()
+    return result.text().trim()
+  }
+
+  private getWorkspacePath(workspaceId: string): string {
+    return path.join(this.basePath, workspaceId)
+  }
+
+  private getAgentConfigPath(workspaceId: string, agentId: string): string {
+    return path.join(this.getWorkspacePath(workspaceId), "agents", `${agentId}.yaml`)
+  }
+}

package/src/server/workspace-directory-policy.test.ts

@@ -0,0 +1,109 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtemp, rm, stat } from "node:fs/promises"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { EventStore } from "./event-store"
+import { WorkspaceConfigManager } from "./workspace-config-manager"
+import { WorkspaceDirectoryPolicy } from "./workspace-directory-policy"
+import type { AgentConfig } from "../shared/agent-config-types"
+
+const tempDirs: string[] = []
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
+})
+
+async function createTempDir(prefix: string) {
+  const dir = await mkdtemp(join(tmpdir(), prefix))
+  tempDirs.push(dir)
+  return dir
+}
+
+const makeConfig = (id: string): AgentConfig => ({
+  id,
+  name: `Agent ${id}`,
+  description: `Test agent ${id}`,
+  provider: "claude",
+  model: "opus-4",
+})
+
+describe("WorkspaceDirectoryPolicy", () => {
+  test("onWorkspaceOpened creates workspace dir", async () => {
+    const storeDir = await createTempDir("wdp-store-")
+    const wsBase = await createTempDir("wdp-ws-")
+    const store = new EventStore(storeDir)
+    await store.initialize()
+    const mgr = new WorkspaceConfigManager(wsBase)
+    const policy = new WorkspaceDirectoryPolicy(store, mgr)
+
+    await policy.onWorkspaceOpened("ws-test")
+
+    const gitStat = await stat(join(wsBase, "ws-test", ".git"))
+    expect(gitStat.isDirectory()).toBe(true)
+    const agentsStat = await stat(join(wsBase, "ws-test", "agents"))
+    expect(agentsStat.isDirectory()).toBe(true)
+  })
+
+  test("onAgentConfigSaved writes YAML and records commit hash", async () => {
+    const storeDir = await createTempDir("wdp-store-")
+    const wsBase = await createTempDir("wdp-ws-")
+    const store = new EventStore(storeDir)
+    await store.initialize()
+    const workspace = await store.openProject("/tmp/wdp-project")
+    const mgr = new WorkspaceConfigManager(wsBase)
+    const policy = new WorkspaceDirectoryPolicy(store, mgr)
+
+    // Init the workspace dir first
+    await mgr.initWorkspaceDir(workspace.id)
+
+    // Save a config via EventStore so the record exists for commitAgentConfig
+    await store.saveAgentConfig(workspace.id, "agent-1", makeConfig("agent-1"))
+
+    // Now run the policy
+    await policy.onAgentConfigSaved(workspace.id, "agent-1", makeConfig("agent-1"))
+
+    // YAML file should exist
+    const yamlStat = await stat(join(wsBase, workspace.id, "agents", "agent-1.yaml"))
+    expect(yamlStat.isFile()).toBe(true)
+
+    // Commit hash should be recorded in EventStore
+    const record = store.state.agentConfigsByWorkspace.get(workspace.id)?.get("agent-1")
+    expect(record).toBeDefined()
+    expect(record!.lastCommitHash).toBeDefined()
+    expect(typeof record!.lastCommitHash).toBe("string")
+    expect(record!.lastCommitHash!.length).toBeGreaterThanOrEqual(7)
+  })
+
+  test("onAgentConfigRemoved deletes YAML from disk", async () => {
+    const storeDir = await createTempDir("wdp-store-")
+    const wsBase = await createTempDir("wdp-ws-")
+    const store = new EventStore(storeDir)
+    await store.initialize()
+    const mgr = new WorkspaceConfigManager(wsBase)
+    const policy = new WorkspaceDirectoryPolicy(store, mgr)
+
+    // Setup: init dir, write a config
+    await mgr.initWorkspaceDir("ws-rm")
+    await mgr.saveAgentConfig("ws-rm", makeConfig("agent-del"))
+    await mgr.commitConfig("ws-rm", "setup")
+
+    // Verify file exists
+    const yamlPath = join(wsBase, "ws-rm", "agents", "agent-del.yaml")
+    const before = await stat(yamlPath)
+    expect(before.isFile()).toBe(true)
+
+    // Remove via policy
+    await policy.onAgentConfigRemoved("ws-rm", "agent-del")
+
+    // File should be gone
+    let exists = true
+    try {
+      await stat(yamlPath)
+    } catch (err) {
+      if (err instanceof Error && "code" in err && (err as NodeJS.ErrnoException).code === "ENOENT") {
+        exists = false
+      }
+    }
+    expect(exists).toBe(false)
+  })
+})

package/src/server/workspace-directory-policy.ts

@@ -0,0 +1,56 @@
+import type { WorkspaceConfigManager } from "./workspace-config-manager"
+import type { EventStore } from "./event-store"
+import type { AgentConfig } from "../shared/agent-config-types"
+
+const LOG_PREFIX = "[WorkspaceDirectoryPolicy]"
+
+export class WorkspaceDirectoryPolicy {
+  constructor(
+    private store: EventStore,
+    private configManager: WorkspaceConfigManager,
+    private onStateChange?: () => void,
+  ) {}
+
+  /** Called after workspace_opened — creates physical workspace directory + git init */
+  async onWorkspaceOpened(workspaceId: string): Promise<void> {
+    try {
+      await this.configManager.initWorkspaceDir(workspaceId)
+    } catch (err) {
+      console.warn(
+        `${LOG_PREFIX} Failed to init workspace dir:`,
+        err instanceof Error ? err.message : String(err),
+      )
+    }
+  }
+
+  /** Called after agent_config_saved — writes YAML to disk + git commit, then records commit hash */
+  async onAgentConfigSaved(workspaceId: string, agentId: string, config: AgentConfig): Promise<void> {
+    try {
+      await this.configManager.saveAgentConfig(workspaceId, config)
+      const commitHash = await this.configManager.commitConfig(
+        workspaceId,
+        `Save agent config: ${config.name}`,
+      )
+      await this.store.commitAgentConfig(workspaceId, agentId, commitHash)
+      this.onStateChange?.()
+    } catch (err) {
+      console.warn(
+        `${LOG_PREFIX} Failed to commit agent config:`,
+        err instanceof Error ? err.message : String(err),
+      )
+    }
+  }
+
+  /** Called after agent_config_removed — deletes YAML from disk + git commit */
+  async onAgentConfigRemoved(workspaceId: string, agentId: string): Promise<void> {
+    try {
+      await this.configManager.removeAgentConfig(workspaceId, agentId)
+      await this.configManager.commitConfig(workspaceId, `Remove agent config: ${agentId}`)
+    } catch (err) {
+      console.warn(
+        `${LOG_PREFIX} Failed to remove agent config from disk:`,
+        err instanceof Error ? err.message : String(err),
+      )
+    }
+  }
+}

package/src/shared/agent-config-types.ts

@@ -0,0 +1,25 @@
+export interface AgentConfig {
+  id: string
+  name: string
+  description: string
+  provider: "claude" | "codex"
+  model: string
+  systemPrompt?: string
+  tools?: string[]
+  temperature?: number
+}
+
+export interface AgentConfigRecord {
+  id: string
+  workspaceId: string
+  config: AgentConfig
+  createdAt: number
+  updatedAt: number
+  lastCommitHash?: string
+}
+
+export interface AgentConfigSnapshot {
+  workspaceId: string
+  configs: AgentConfigRecord[]
+  lastUpdated: string
+}