@zerwiz/ymir 0.1.33 → 0.1.35

package/apps/sessrumnir/src/web-server.ts

@@ -0,0 +1,315 @@
+/**
+ * Sessrúmnir web server — Bun.serve implementing the bridge over HTTP + WS.
+ *
+ * Reuses the main-process logic (WorkspaceManager, PiRpcManager, etc.)
+ * instead of reimplementing it. The transport differs:
+ *   - HTTP POST /api/<channel> for request/response
+ *   - WebSocket /ws/<channel> for event subscriptions
+ *   - Static files for the built renderer
+ *
+ * This file is the web shell's origin. It serves the built renderer
+ * and the bridge API on the same port.
+ *
+ * NOTE: This server runs in Bun (not Electron), so it cannot import
+ * Electron modules. It only imports pure logic modules from src/main/.
+ */
+
+import { WorkspaceManager } from './main/workspace-manager'
+import { SessionTagManager } from './main/session-tags'
+import { ArchivedSessionsManager } from './main/archived-sessions'
+import { TerminalService } from './main/terminal-service'
+import { NotesManager } from './main/notes-manager'
+import { loadAppSettings, saveAppSettings } from './main/settings-logic'
+import type { IpcContext } from './main/ipc/context'
+import type { PiRpcManager } from './main/pi-rpc-manager'
+import type { AppSettings } from './shared/ipc-contracts'
+
+// ─── WebSocket client registry ──────────────────────────────────────────────
+
+interface WsClient {
+  ws: WebSocket
+  id: string
+}
+
+const clients: WsClient[] = []
+
+// ─── Adapted IPC context for web ────────────────────────────────────────────
+
+function createWebIpcContext(workspaceManager: WorkspaceManager): IpcContext {
+  const tagManager = new SessionTagManager() as unknown as SessionTagManager
+  const archivedSessions = new ArchivedSessionsManager() as unknown as ArchivedSessionsManager
+  const terminalService = new TerminalService() as unknown as TerminalService
+  const notesManager = new NotesManager() as unknown as NotesManager
+
+  const approvedAttachmentPaths = new Set<string>()
+
+  function getActivePi(): PiRpcManager {
+    const pi = workspaceManager.getActivePiManager()
+    if (!pi) throw new Error('No active workspace or Pi not running')
+    return pi
+  }
+
+  // Broadcast to all connected WebSocket clients instead of Electron windows
+  function broadcast(channel: string, data: unknown): void {
+    for (const client of clients) {
+      if (client.ws.readyState === WebSocket.OPEN) {
+        client.ws.send(JSON.stringify({ channel, data }))
+      }
+    }
+  }
+
+  return {
+    workspaceManager,
+    broadcast,
+    getActivePi,
+    approvedAttachmentPaths,
+    tagManager,
+    archivedSessions,
+    notesManager,
+    terminalService,
+  }
+}
+
+// ─── Server state ───────────────────────────────────────────────────────────
+
+let workspaceManager: WorkspaceManager | null = null
+let ipcContext: IpcContext | null = null
+
+// ─── Static file serving ────────────────────────────────────────────────────
+
+const CONTENT_TYPES: Record<string, string> = {
+  '.html': 'text/html',
+  '.js': 'application/javascript',
+  '.css': 'text/css',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+}
+
+async function serveStaticFile(filepath: string): Promise<Response | null> {
+  try {
+    const ext = filepath.substring(filepath.lastIndexOf('.')).toLowerCase()
+    const contentType = CONTENT_TYPES[ext] || 'application/octet-stream'
+
+    // Read from out/renderer/ (the electron-vite build output)
+    const fullPath = `${process.cwd()}/out/renderer${filepath}`
+    const file = Bun.file(fullPath)
+    const bytes = await file.bytes()
+
+    return new Response(bytes, {
+      headers: { 'Content-Type': contentType },
+    })
+  } catch (err) {
+    console.error('[Sessrúmnir Web] Failed to serve static file:', filepath, err)
+    return null // file not found
+  }
+}
+
+// ─── HTTP handler ───────────────────────────────────────────────────────────
+
+async function handleRequest(req: Request): Promise<Response> {
+  const url = new URL(req.url)
+
+  // ── Serve static files (built renderer) ────────────────────────────────
+  if (req.method === 'GET') {
+    const pathname = url.pathname
+
+    // HTML entry point — serve index.html
+    if (pathname === '/' || pathname.endsWith('.html')) {
+      const filePath = pathname === '/' ? '/index.html' : pathname
+      const res = await serveStaticFile(filePath)
+      if (res) return res
+    }
+
+    // JS/CSS/assets — serve from out/renderer/
+    if (pathname.match(/\.(js|css|mjs|png|svg|woff|woff2|ttf)$/)) {
+      const res = await serveStaticFile(pathname)
+      if (res) return res
+    }
+
+    // For any other GET, try to serve as static file
+    const res = await serveStaticFile(pathname)
+    if (res) return res
+  }
+
+  // ── API endpoint (POST /api/<channel>) ─────────────────────────────────
+  if (req.method === 'POST' && url.pathname.startsWith('/api/')) {
+    const channel = url.pathname.replace(/^\/api\//, '')
+
+    if (!ipcContext) {
+      return new Response('Server not initialized', { status: 503 })
+    }
+
+    try {
+      const body = await req.json()
+      const args = Array.isArray(body) ? body : [body]
+
+      // Route to the appropriate handler
+      const result = await routeToHandler(channel, args)
+      return new Response(JSON.stringify(result), {
+        headers: { 'Content-Type': 'application/json' },
+      })
+    } catch (err) {
+      return new Response(JSON.stringify({ error: String(err) }), {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    }
+  }
+
+  // ── 404 ────────────────────────────────────────────────────────────────
+  return new Response('Not found', { status: 404 })
+}
+
+// ─── Handler routing ────────────────────────────────────────────────────────
+
+/**
+ * Route an API call to the appropriate handler function.
+ * This mirrors what the IPC handlers do, but calls them directly.
+ */
+async function routeToHandler(channel: string, args: unknown[]): Promise<unknown> {
+  if (!ipcContext || !workspaceManager) {
+    throw new Error('Server not initialized')
+  }
+
+  const { workspaceManager: wm } = ipcContext
+
+  // ── Pi process lifecycle ───────────────────────────────────────────────
+  if (channel === 'pi:start') {
+    const activeWs = wm.getActiveWorkspace()
+    if (!activeWs) throw new Error('No active workspace')
+    const pi = wm.getActivePiManager()
+    if (!pi) throw new Error('No Pi manager')
+    return pi.getStatus()
+  }
+
+  if (channel === 'pi:stop') {
+    const activeWs = wm.getActiveWorkspace()
+    if (activeWs) wm.stopPiForWorkspace(activeWs.id)
+    return { status: 'stopped', pid: null, error: null }
+  }
+
+  if (channel === 'pi:restart') {
+    const activeWs = wm.getActiveWorkspace()
+    if (!activeWs) throw new Error('No active workspace')
+    const pi = wm.getPiManager(activeWs.id)
+    if (!pi) throw new Error('No Pi manager')
+    pi.stop()
+    return { status: 'stopped', pid: null, error: null }
+  }
+
+  if (channel === 'pi:status') {
+    const activeWs = wm.getActiveWorkspace()
+    if (!activeWs) return { status: 'stopped', pid: null, error: null }
+    const pi = wm.getActivePiManager()
+    if (!pi) return { status: 'stopped', pid: null, error: null }
+    return pi.getStatus()
+  }
+
+  if (channel === 'pi:detect-installations') {
+    // Simplified: return empty
+    return { installations: [] }
+  }
+
+  // ── Session management ─────────────────────────────────────────────────
+  if (channel === 'session:list') {
+    const cwd = args[0] as string | undefined
+    return wm.listSessions(cwd)
+  }
+
+  if (channel === 'session:list-all') {
+    const cwd = args[0] as string | undefined
+    return wm.listSessions(cwd, true)
+  }
+
+  // ── Settings ───────────────────────────────────────────────────────────
+  if (channel === 'settings:get-all') {
+    return await loadAppSettings(wm)
+  }
+
+  if (channel === 'settings:save') {
+    const settings = args[0] as Partial<AppSettings>
+    await saveAppSettings(settings)
+    return await loadAppSettings(wm)
+  }
+
+  // ── Workspace management ───────────────────────────────────────────────
+  if (channel === 'workspace:list') {
+    return wm.getWorkspaces()
+  }
+
+  if (channel === 'workspace:get-active') {
+    return wm.getActiveWorkspace()
+  }
+
+  // ── File operations ────────────────────────────────────────────────────
+  if (channel === 'file:tree') {
+    const _maxDepth = (args[0] as number) || 2
+    // Simplified: return empty tree
+    return { name: '', path: '', type: 'directory' as const, children: [] }
+  }
+
+  // ── Default: unknown channel ───────────────────────────────────────────
+  return { error: `Unknown channel: ${channel}` }
+}
+
+// ─── WebSocket handler ──────────────────────────────────────────────────────
+
+function _handleWebSocket(_ws: WebSocket): void {
+  const id = crypto.randomUUID()
+  clients.push({ ws: _ws, id })
+
+  _ws.addEventListener('close', () => {
+    const idx = clients.findIndex((c) => c.id === id)
+    if (idx >= 0) clients.splice(idx, 1)
+  })
+
+  _ws.addEventListener('message', (_event) => {
+    const _msg = JSON.parse(_event.data.toString())
+    // Forward messages to the appropriate handler
+    // This is a simplified approach for now
+  })
+}
+
+// ─── Start the server ───────────────────────────────────────────────────────
+
+export async function startWebServer(port: number = 3890): Promise<void> {
+  try {
+    // Initialize workspace manager (same as main process)
+    workspaceManager = new WorkspaceManager()
+    await workspaceManager.initialize()
+    console.log('[Sessrúmnir Web] WorkspaceManager initialized')
+
+    // Create adapted IPC context
+    ipcContext = createWebIpcContext(workspaceManager)
+    console.log('[Sessrúmnir Web] IPC context created')
+
+    // Start Bun server
+    const server = Bun.serve({
+      port,
+      fetch: handleRequest,
+      websocket: {
+        message(_ws, _message) {
+          // Handle WebSocket messages
+        },
+      },
+    })
+
+    console.log(`[Sessrúmnir Web] Listening on http://127.0.0.1:${port}`)
+    
+    // Keep the process alive by preventing exit
+    const keepAlive = setInterval(() => {}, 60000)
+    keepAlive.unref()
+    
+    // Also prevent exit via stdin close
+    process.stdin.resume()
+    
+    return server
+  } catch (err) {
+    console.error('[Sessrúmnir Web] Failed to start:', err)
+    process.exit(1)
+  }
+}

package/apps/sessrumnir/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "composite": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "incremental": true
+  },
+  "files": [],
+  "references": [
+    { "path": "./src/shared/tsconfig.json" },
+    { "path": "./src/main/tsconfig.json" },
+    { "path": "./src/preload/tsconfig.json" },
+    { "path": "./src/renderer/tsconfig.json" }
+  ]
+}

package/apps/smidja/smidja_build.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env -S uv run
+# /// script
+# dependencies = ["pydantic", "python-dotenv", "pyyaml", "rich"]
+# ///
+"""smidja Build — one-shot implementation workflow.
+
+Usage:
+    uv run smidja/smidja_build.py "<prompt or path/to/prompt.md>" [--config smidja/smidja_smidja_config/smidja.config.yaml] [--smidja-id a1b2c3d4]
+
+Phases: engineer(request) -> builder
+"""
+
+import argparse
+import sys
+
+from smidja_modules import agents, gates, session, utils
+from smidja_modules.data_types import AgentCall, BuildOutput, PhaseParams
+
+REQUIRED_AGENTS = ["builder"]
+
+
+def main(prompt: str, config: str = "smidja/smidja_smidja_config/smidja.config.yaml", smidja_id: str | None = None) -> int:
+    cfg = agents.load_config(config)
+    agents.validate(cfg, REQUIRED_AGENTS)
+    run = session.ensure(cfg, smidja_id)
+
+    with run.phase(PhaseParams(name="request", kind="engineer", owner=run.engineer,
+                               description="Capture the incoming ask")) as ph:
+        ph.log(input=prompt)
+
+    with run.phase(PhaseParams(name="build", kind="agent", owner="builder", retries=1,
+                               description="Implement the request")) as ph:
+        ph.call(AgentCall(output_type=BuildOutput, prompt=prompt,
+                          gates=[gates.diff_matches_claims]))
+
+    return run.finish()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("prompt", help="inline text or a path to a prompt file")
+    parser.add_argument("--config", default="smidja/smidja_smidja_config/smidja.config.yaml")
+    parser.add_argument("--smidja-id", default=None, help="join or pin an existing session")
+    args = parser.parse_args()
+    sys.exit(main(utils.resolve_prompt(args.prompt), args.config, args.smidja_id))

package/apps/smidja/smidja_build_review.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env -S uv run
+# /// script
+# dependencies = ["pydantic", "python-dotenv", "pyyaml", "rich"]
+# ///
+"""smidja Build Review — implement, then confirm it is what was asked for.
+
+Usage:
+    uv run smidja/smidja_build_review.py "<prompt or path/to/prompt.md>" [--config smidja/smidja_smidja_config/smidja.config.yaml] [--smidja-id a1b2c3d4]
+
+Phases: engineer(request) -> builder -> reviewer [-> builder(revise) -> reviewer ... bounded]
+
+Review is not testing. Tests answer "does it run"; the reviewer answers "is this
+the thing that was asked for" — it reads the spec (`plan.md` from a prior plan
+phase if the session has one, else the prompt verbatim), reads the code that was
+written, and rules on each requirement.
+
+Like the tester, the reviewer's phase succeeds when it RUNS and REPORTS. A
+rejection does not fail the phase; it fails the run, checked at the end, after
+the bounded revise loop has had its chances.
+"""
+
+import argparse
+import sys
+
+from smidja_modules import agents, gates, session, utils
+from smidja_modules.data_types import (AgentCall, BuildOutput, PhaseParams,
+                                    ReviewOutput)
+
+REQUIRED_AGENTS = ["builder", "reviewer"]
+MAX_REVISION_LOOPS = 3
+
+
+def main(prompt: str, config: str = "smidja/smidja_smidja_config/smidja.config.yaml", smidja_id: str | None = None) -> int:
+    cfg = agents.load_config(config)
+    agents.validate(cfg, REQUIRED_AGENTS)
+    run = session.ensure(cfg, smidja_id)
+
+    with run.phase(PhaseParams(name="request", kind="engineer", owner=run.engineer,
+                               description="Capture the incoming ask")) as ph:
+        ph.log(input=prompt)
+
+    with run.phase(PhaseParams(name="build", kind="agent", owner="builder",
+                               description="Implement the request")) as ph:
+        previous = ph.call(AgentCall(output_type=BuildOutput, prompt=prompt,
+                                     gates=[gates.diff_matches_claims]))
+
+    review = None
+    for i in range(1, MAX_REVISION_LOOPS + 1):
+        with run.phase(PhaseParams(name=f"review_{i}", kind="agent", owner="reviewer",
+                                   description="Rule on every requirement in the spec, against the code on disk")) as ph:
+            review = ph.call(AgentCall(output_type=ReviewOutput, prompt=prompt,
+                                       previous=previous,
+                                       gates=[gates.artifacts_exist,
+                                              gates.verdict_consistent]))
+
+        if review.approved:
+            break
+        if i == MAX_REVISION_LOOPS:
+            break
+
+        with run.phase(PhaseParams(name=f"revise_{i}", kind="agent", owner="builder", retries=1,
+                                   description="Close every blocking finding the reviewer named")) as ph:
+            previous = ph.call(AgentCall(output_type=BuildOutput, prompt=prompt, previous=review,
+                                         gates=[gates.diff_matches_claims]))
+
+    return run.finish(accepted=review is not None and review.approved,
+                      reason=f"the reviewer never approved after {MAX_REVISION_LOOPS} revision(s)")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("prompt", help="inline text or a path to a prompt file")
+    parser.add_argument("--config", default="smidja/smidja_smidja_config/smidja.config.yaml")
+    parser.add_argument("--smidja-id", default=None, help="join or pin an existing session")
+    args = parser.parse_args()
+    sys.exit(main(utils.resolve_prompt(args.prompt), args.config, args.smidja_id))

package/apps/smidja/smidja_build_test.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env -S uv run
+# /// script
+# dependencies = ["pydantic", "python-dotenv", "pyyaml", "rich"]
+# ///
+"""smidja Build Test — implement, then verify; failures flow back into the builder.
+
+Usage:
+    uv run smidja/smidja_build_test.py "<prompt or path/to/prompt.md>" [--config smidja/smidja_smidja_config/smidja.config.yaml] [--smidja-id a1b2c3d4]
+
+Phases: engineer(request) -> builder -> code(test) [-> builder(fix) -> code(test) ... bounded]
+
+Testing is CODE. The suite's command is written down in smidja_modules/quality.py,
+so running it needs no judgement — only repairing it does. Failures reach the
+builder as an envelope through `quality.as_envelope`, which is the same door an
+agent's report came through, so the repair loop is unchanged.
+
+A failing suite does NOT fail its phase: the runner did its job, the code is
+what failed. It fails the run, checked at the end, after the bounded fix loop
+has had its chances.
+"""
+
+import argparse
+import sys
+
+from smidja_modules import agents, gates, quality, session, utils
+from smidja_modules.data_types import AgentCall, BuildOutput, PhaseParams
+
+REQUIRED_AGENTS = ["builder"]
+MAX_FIX_LOOPS = 3
+
+
+def main(prompt: str, config: str = "smidja/smidja_smidja_config/smidja.config.yaml", smidja_id: str | None = None) -> int:
+    cfg = agents.load_config(config)
+    agents.validate(cfg, REQUIRED_AGENTS)
+    run = session.ensure(cfg, smidja_id)
+
+    def record(ph, result) -> None:
+        passed = sum(1 for check in result.checks if check.passed)
+        ph.log(passed=result.passed, checks=f"{passed}/{len(result.checks)}",
+               artifacts=", ".join(result.artifacts))
+
+    with run.phase(PhaseParams(name="request", kind="engineer", owner=run.engineer,
+                               description="Capture the incoming ask")) as ph:
+        ph.log(input=prompt)
+
+    with run.phase(PhaseParams(name="build", kind="agent", owner="builder",
+                               description="Implement the request")) as ph:
+        previous = ph.call(AgentCall(output_type=BuildOutput, prompt=prompt,
+                                     gates=[gates.diff_matches_claims]))
+
+    test = None
+    for i in range(1, MAX_FIX_LOOPS + 1):
+        with run.phase(PhaseParams(name=f"test_{i}", kind="code", owner="quality",
+                                   description="Run the suite — a known command, so code runs "
+                                               "it and no agent has to rediscover it")) as ph:
+            test = quality.run_tests(run)
+            record(ph, test)
+
+        if test.passed:
+            break
+
+        with run.phase(PhaseParams(name=f"fix_{i}", kind="agent", owner="builder", retries=1,
+                                   description="Repair what the suite reported, from its "
+                                               "verbatim output")) as ph:
+            previous = ph.call(AgentCall(output_type=BuildOutput, prompt=prompt,
+                                         previous=quality.as_envelope(test, "tests"),
+                                         gates=[gates.diff_matches_claims]))
+
+    return run.finish(accepted=test is not None and test.passed,
+                      reason=f"the suite still failed after {MAX_FIX_LOOPS} fix attempt(s)")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("prompt", help="inline text or a path to a prompt file")
+    parser.add_argument("--config", default="smidja/smidja_smidja_config/smidja.config.yaml")
+    parser.add_argument("--smidja-id", default=None, help="join or pin an existing session")
+    args = parser.parse_args()
+    sys.exit(main(utils.resolve_prompt(args.prompt), args.config, args.smidja_id))

package/apps/smidja/smidja_document.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env -S uv run
+# /// script
+# dependencies = ["pydantic", "python-dotenv", "pyyaml", "rich"]
+# ///
+"""smidja Document — write up the work that was just done, from the diff.
+
+Usage:
+    uv run smidja/smidja_document.py "<prompt or path/to/prompt.md>" [--base main] [--config smidja/smidja_smidja_config/smidja.config.yaml] [--smidja-id a1b2c3d4]
+
+Phases: engineer(request) -> code(changes) -> documenter
+
+This runs AFTER a build, and the guard is structural rather than advisory: the
+change capture is a code phase, and an empty diff raises there — before the
+documenter is ever spawned. There is nothing to document until something was
+built, and the phase says so instead of paying an agent to discover it.
+
+`git diff` against `--base` (main by default) is what "the latest changes"
+means here; see smidja_modules/changes.py for how the base commit is resolved on a
+branch, on main, and on a clean tree right after a chain committed.
+"""
+
+import argparse
+import sys
+
+from smidja_modules import agents, changes, gates, session, utils
+from smidja_modules.data_types import (AgentCall, ChangeCapture, DocumentOutput,
+                                    PhaseParams)
+
+REQUIRED_AGENTS = ["documenter"]
+
+DOCUMENT_NOTES = ("Read diff_path in full before writing. Document only what the "
+                  "diff shows, then copy the write-up into app_docs/ as your task "
+                  "describes.")
+
+
+def main(prompt: str, base: str = "main",
+         config: str = "smidja/smidja_smidja_config/smidja.config.yaml", smidja_id: str | None = None) -> int:
+    cfg = agents.load_config(config)
+    agents.validate(cfg, REQUIRED_AGENTS)
+    run = session.ensure(cfg, smidja_id)
+
+    with run.phase(PhaseParams(name="request", kind="engineer", owner=run.engineer,
+                               description="Capture the incoming ask")) as ph:
+        ph.log(input=prompt)
+
+    with run.phase(PhaseParams(name="changes", kind="code", owner="git",
+                               description=f"Diff the working tree against {base} — the change to be written up")) as ph:
+        changeset = changes.capture(run, ChangeCapture(base=base))
+        ph.log(base=f"{changeset.base.label} @ {changeset.base.commit[:7]}",
+               reason=changeset.base.reason,
+               files=len(changeset.files) + len(changeset.untracked),
+               lines=f"+{changeset.insertions} -{changeset.deletions}",
+               diff=changeset.diff_path)
+        if changeset.empty:
+            raise RuntimeError(
+                f"nothing changed since {changeset.base.label} ({changeset.base.reason}) "
+                f"— documenting runs after a build. Build something first, or point "
+                f"--base at the ref the work should be measured from.")
+
+    with run.phase(PhaseParams(name="document", kind="agent", owner="documenter", retries=1,
+                               description="Turn the captured diff into a write-up an engineer can read")) as ph:
+        ph.call(AgentCall(output_type=DocumentOutput, prompt=prompt,
+                          previous=changes.as_envelope(changeset, DOCUMENT_NOTES),
+                          gates=[gates.artifacts_exist, gates.files_non_empty]))
+
+    return run.finish()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("prompt", help="inline text or a path to a prompt file")
+    parser.add_argument("--base", default="main", help="ref the change is measured against")
+    parser.add_argument("--config", default="smidja/smidja_smidja_config/smidja.config.yaml")
+    parser.add_argument("--smidja-id", default=None, help="join or pin an existing session")
+    args = parser.parse_args()
+    sys.exit(main(utils.resolve_prompt(args.prompt), args.base, args.config, args.smidja_id))

package/apps/smidja/smidja_modules/agent_cc.py

@@ -0,0 +1,15 @@
+"""Claude Code interface — STUB in v1. The smidja is Pi-only for now.
+
+The config schema accepts `coding_agent: claude_code` so nothing breaks at the
+schema level, but selecting it raises until v2 implements this interface
+(`claude -p --output-format stream-json --resume <session_id>`).
+"""
+
+from __future__ import annotations
+
+
+def run(*args, **kwargs):
+    raise NotImplementedError(
+        "coding_agent 'claude_code' is not implemented in v1 — smidja v1 runs the "
+        "Pi coding agent only. Set coding_agent: pi (or omit it) in smidja.config.yaml."
+    )