pantheon-opencode 1.0.1 → 1.0.6

package/src/agents/themis.md

@@ -1,45 +1,20 @@
 ---
 name: themis
-description: Quality & security gate — heuristic scan (Layer 1, zero LLM) + deep
-  review (Layer 2, LLM leve) + verification planning (Layer 3). Ruff/Biome, anti-pattern
-  slop detection, hash-anchored edits, OWASP Top 10, coverage >80%. Called by implementers;
-  escalates blockers to zeus.
-mode: primary
+description: "Quality & security gate — Ruff/Biome linting, dead/legacy code detection, OWASP Top 10, coverage >80%, correctness, deprecation audit. Called by implementers; escalates blockers to zeus."
+mode: subagent
 reasoning_effort: high
 permission:
+  read: allow
+  grep: allow
+  bash: allow
   edit: ask
-  bash:
-    pytest *: allow
-    ruff *: allow
-    grep *: allow
-    npx vitest *: allow
-    pip-audit *: allow
-    dep-audit *: allow
-  "pantheon-resources_*": allow
-  "pantheon-memory_*": allow
-  "pantheon-persistence_*": allow
-
-tools:
-  agent: true
-  vscode/askQuestions: true
-  search/codebase: true
-  search/usages: true
-  read/readFile: true
-  read/problems: true
-  execute/runInTerminal: true
-  execute/testFailure: true
-  edit/editFiles: true
-  browser/openBrowserPage: true
-  browser/navigatePage: true
-  browser/readPage: true
-  browser/clickElement: true
-  browser/screenshotPage: true
 temperature: 0.1
-steps: 20
+steps: 30
 skills:
-- code-review-checklist
-- security-hardening
-- tdd-with-agents
+  - code-review-checklist
+  - security-hardening
+  - tdd-with-agents
+  - context-compression
 mcp_tools:
   pantheon-resources: all
   pantheon-memory: [memory_search]

package/src/agents/zeus.md

@@ -7,12 +7,9 @@ permission:
   bash: allow
   task:
     "*": allow
-  pantheon-resources_*: allow
-  pantheon-memory_*: allow
   pantheon-code-mode_*: ask
-  pantheon-persistence_*: allow
 temperature: 0.2
-steps: 25
+steps: 45
 mcp_tools:
   pantheon-resources: all
   pantheon-memory:
@@ -27,12 +24,13 @@ mcp_tools:
     - kv_search
 skills:
   - agent-coordination
+  - session-goal
   - artifact-management
-  - auto-continue
   - context-compression
-  - memory-bank
+  - auto-continue
   - orchestration-workflow
-  - session-goal
+  - incremental-implementation
+
 ---
 
 ## Memory Protocol

package/src/mcp/mcp_resources_server.py

@@ -111,6 +111,8 @@ async def list_skills() -> str:
 async def get_routing() -> str:
     """Return the full content of routing.yml."""
     routing_file = _PANTHEON_HOME / "routing.yml"
+    if not routing_file.exists() and _PANTHEON_PROJECT:
+        routing_file = _PANTHEON_PROJECT / "src" / "routing.yml"
     if not routing_file.exists():
         return "routing.yml not found."
     return routing_file.read_text(encoding="utf-8")

package/src/plugins/tui/dist/tui.tsx

@@ -1,144 +1,254 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: necessary for TuiPluginApi dynamic state access
+// biome-ignore-all lint/a11y/noStaticElementInteractions: TUI elements, not DOM
 /** @jsxImportSource @opentui/solid */
-import type { TuiPlugin, TuiPluginApi, TuiPluginModule, TuiSlotContext, TuiSlotPlugin } from '@opencode-ai/plugin/tui'
-import type { JSX } from '@opentui/solid'
-import { createMemo, createSignal, Show, For } from 'solid-js'
 
-const AGENTS = [
-  'zeus', 'athena', 'apollo', 'hermes', 'aphrodite',
-  'demeter', 'themis', 'prometheus', 'hephaestus',
-  'nyx', 'gaia', 'iris', 'mnemosyne', 'talos',
+import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from '@opencode-ai/plugin/tui'
+import { createMemo, createSignal, createResource, For, Show } from 'solid-js'
+
+async function readPantheonVersion(api: TuiPluginApi): Promise<string> {
+  try {
+    const worktree = ((api.state as any).path?.worktree ?? '') as string
+    const filePath = worktree ? `${worktree}/package.json` : 'package.json'
+    const result = await api.client.file.read({ query: { path: filePath } })
+    const content = typeof result.content === 'string' ? result.content : String(result.content ?? '')
+    const match = content.match(/"version":\s*"([^"]+)"/)
+    if (match?.[1]) return match[1]
+  } catch { /* fall through */ }
+
+  try {
+    const proc = (api as any).client?.process
+    if (typeof proc?.exec === 'function') {
+      const result = await proc.exec({ command: 'git', args: ['describe', '--tags', '--always'] })
+      const stdout = (result.stdout ?? result.output ?? '') as string
+      const tag = stdout.trim().replace(/^v/, '')
+      if (tag) return tag
+    }
+  } catch { /* fall through */ }
+
+  return '1.0.1'
+}
+
+const COMMANDS = [
+  { name: '/pantheon', desc: 'Council synthesis' },
+  { name: '/pantheon-status', desc: 'System status' },
+  { name: '/pantheon-audit', desc: 'Full audit' },
+  { name: '/pantheon-bg', desc: 'List background tasks' },
+  { name: '/pantheon-cancel', desc: 'Cancel task' },
+  { name: '/pantheon-deepwork', desc: 'Deep work mode' },
+  { name: '/pantheon-focus', desc: 'Focus on scope' },
+  { name: '/pantheon-remember', desc: 'Memory store/recall' },
+  { name: '/pantheon-search', desc: 'Memory search' },
+  { name: '/pantheon-consolidate', desc: 'Merge memories' },
+  { name: '/pantheon-forget', desc: 'Compress memories' },
 ] as const
 
-const CMDS = [
-  '/pantheon', '/pantheon-status', '/pantheon-audit',
-  '/pantheon-bg', '/pantheon-deepwork', '/pantheon-focus',
-  '/pantheon-optimize', '/pantheon-doc',
-  '/pantheon-remember', '/pantheon-search', '/pantheon-forget',
-  '/pantheon-consolidate', '/pantheon-todo', '/pantheon-hash',
+const AGENTS = [
+  { name: 'zeus', tier: 'default' as const, role: 'Orchestrator' },
+  { name: 'athena', tier: 'premium' as const, role: 'Strategic planner' },
+  { name: 'apollo', tier: 'fast' as const, role: 'Codebase discovery' },
+  { name: 'hermes', tier: 'default' as const, role: 'Backend' },
+  { name: 'aphrodite', tier: 'default' as const, role: 'Frontend' },
+  { name: 'demeter', tier: 'default' as const, role: 'Database' },
+  { name: 'themis', tier: 'premium' as const, role: 'Quality & security' },
+  { name: 'prometheus', tier: 'default' as const, role: 'Infrastructure' },
+  { name: 'hephaestus', tier: 'default' as const, role: 'AI pipelines' },
+  { name: 'nyx', tier: 'fast' as const, role: 'Observability' },
+  { name: 'gaia', tier: 'fast' as const, role: 'Remote sensing' },
+  { name: 'iris', tier: 'fast' as const, role: 'GitHub operations' },
+  { name: 'mnemosyne', tier: 'fast' as const, role: 'Memory bank' },
+  { name: 'talos', tier: 'fast' as const, role: 'Hotfixes' },
 ] as const
 
-function PantheonPanel(props: { api: TuiPluginApi; version: string }): JSX.Element {
-  const [showSub, setShowSub] = createSignal(false)
-  const [showCmd, setShowCmd] = createSignal(false)
-  const [showAg, setShowAg] = createSignal(false)
-  const [showCfg, setShowCfg] = createSignal(false)
-  const [showMem, setShowMem] = createSignal(false)
+function safeNum(v: unknown): number {
+  return typeof v === 'number' && Number.isFinite(v) ? v : 0
+}
+
+function View(props: { api: TuiPluginApi; sessionID: string; version: string }) {
+  const [showCommands, setShowCommands] = createSignal(false)
+  const [showAgents, setShowAgents] = createSignal(false)
+  const [showConfig, setShowConfig] = createSignal(false)
+  const [showMemory, setShowMemory] = createSignal(false)
+  const [showSubagents, setShowSubagents] = createSignal(false)
+
+  const theme = () => props.api.theme.current
+
+  const branch = createMemo(() =>
+    props.api.state.vcs?.branch ? `\u2387 ${props.api.state.vcs.branch}` : null,
+  )
+
+  const configInfo = createMemo(() => {
+    const cfg = (props.api.state as any).config
+    if (!cfg) return null
+    return {
+      plugins: Array.isArray(cfg.plugin) ? cfg.plugin : [],
+      mcpCount: cfg.mcp ? Object.keys(cfg.mcp).length : 0,
+      autoCompaction: cfg.compaction?.auto === true,
+    }
+  })
 
-  const branch = createMemo(() => {
-    const b = props.api.state.vcs?.branch
-    return b ? `\u2387 ${b}` : null
+  const memoryInfo = createMemo(() => {
+    const mem = (props.api.state as any).memory
+    if (mem) {
+      const entries = safeNum(mem?.entries) || safeNum(mem?.count)
+      return entries > 0 ? { entries } : null
+    }
+    return null
   })
 
-  const mem = (props.api.state as any).memory
-  const cfg = props.api.state.config
+  const [subagents] = createResource(
+    () => showSubagents(),
+    async () => {
+      try {
+        const proc = (props.api as any).client?.process
+        if (typeof proc?.exec !== 'function') return null
+        const result = await proc.exec({
+          command: 'opencode',
+          args: ['session', 'list', '--format', 'json'],
+          timeoutMs: 5000,
+        })
+        const stdout = (result.stdout ?? result.output ?? '') as string
+        const sessions = JSON.parse(stdout)
+        if (!Array.isArray(sessions)) return null
+        return sessions
+          .filter((s: any) => s.id !== props.sessionID)
+          .sort((a: any, b: any) => (b.updated ?? 0) - (a.updated ?? 0))
+          .slice(0, 10)
+      } catch { return null }
+    },
+  )
 
   return (
     <box flexDirection="column" width="100%">
-      <text fg={props.api.theme.current.accent} attributes={{ bold: true }}>
-        Pantheon v{props.version}
+      {/* Header */}
+      <text fg={theme().accent} attributes={{ bold: true }}>
+        {`Pantheon v${props.version}`}
       </text>
 
       <Show when={branch()}>
-        {(b) => <box marginTop={1}><text fg={props.api.theme.current.textMuted}>{b()}</text></box>}
+        {(b) => (<box marginTop={1}><text fg={theme().textMuted}>{b()}</text></box>)}
       </Show>
 
-      {/* Sessions — total historico (API nao distingue ativas) */}
-      <box marginTop={0} onMouseDown={() => setShowSub((x) => !x)}>
-        <text fg={props.api.theme.current.text} attributes={{ bold: true }}>
-          {showSub() ? '\u25bc ' : '\u25b6 '}Sessions
-        </text>
-        <text fg={props.api.theme.current.textMuted}>
-          ({(props.api.state as any).session?.count?.() ?? '?'} total)
+      {/* Subagents */}
+      <box marginTop={0} onMouseDown={() => setShowSubagents((x) => !x)}>
+        <text fg={theme().text} attributes={{ bold: true }}>
+          {`${showSubagents() ? '\u25bc' : '\u25b6'} Subagents`}
         </text>
+        <text fg={theme().textMuted}>{` (${String(props.api.state.session.count())})`}</text>
       </box>
 
+      <Show when={showSubagents()}>
+        <Show when={subagents()} fallback={<box marginLeft={1}><text fg={theme().textMuted}>{`sessions: ${String(props.api.state.session.count())}`}</text></box>}>
+          {(sessions) => (
+            <Show when={sessions().length > 0} fallback={<box marginLeft={1}><text fg={theme().textMuted}>(idle)</text></box>}>
+              <box marginLeft={1} flexDirection="column">
+                <For each={sessions().slice(0, 5)}>
+                  {(s: any) => (
+                    <text fg={theme().textMuted}>{`${s.id.slice(0, 8)}... ${s.title?.slice(0, 30) ?? ''}`}</text>
+                  )}
+                </For>
+              </box>
+            </Show>
+          )}
+        </Show>
+      </Show>
+
       {/* Commands */}
-      <box marginTop={0} onMouseDown={() => setShowCmd((x) => !x)}>
-        <text fg={props.api.theme.current.text} attributes={{ bold: true }}>
-          {showCmd() ? '\u25bc ' : '\u25b6 '}Commands
+      <box marginTop={0} onMouseDown={() => setShowCommands((x) => !x)}>
+        <text fg={theme().text} attributes={{ bold: true }}>
+          {`${showCommands() ? '\u25bc' : '\u25b6'} Commands`}
         </text>
-        <text fg={props.api.theme.current.textMuted}> ({CMDS.length})</text>
+        <text fg={theme().textMuted}>{` (${String(COMMANDS.length)})`}</text>
       </box>
-      <Show when={showCmd()}>
-        <box marginLeft={1} flexDirection="column">
-          <For each={CMDS}>
-            {(cmd) => <text fg={props.api.theme.current.textMuted}>{'\u00b7'} {cmd}</text>}
-          </For>
-        </box>
+
+      <Show when={showCommands()}>
+        <For each={COMMANDS}>
+          {(cmd) => (
+            <box marginLeft={1} onMouseDown={(e) => {
+              e.stopPropagation()
+              try {
+                const cmdApi = (props.api as any).command
+                const cmdName = cmd.name.replace('/', '')
+                if (cmdApi?.trigger?.(cmdName)) return
+              } catch {}
+              props.api.ui?.toast?.({ title: 'Command', message: `Type ${cmd.name} in chat` })
+            }}>
+              <text fg={cmd.name === '/pantheon' ? theme().accent : theme().textMuted}>{cmd.name}</text>
+              <text fg={theme().textMuted}>{` — ${cmd.desc}`}</text>
+            </box>
+          )}
+        </For>
       </Show>
 
       {/* Agents */}
-      <box marginTop={0} onMouseDown={() => setShowAg((x) => !x)}>
-        <text fg={props.api.theme.current.text} attributes={{ bold: true }}>
-          {showAg() ? '\u25bc ' : '\u25b6 '}Agents
+      <box marginTop={0} onMouseDown={() => setShowAgents((x) => !x)}>
+        <text fg={theme().text} attributes={{ bold: true }}>
+          {`${showAgents() ? '\u25bc' : '\u25b6'} Agents`}
         </text>
-        <text fg={props.api.theme.current.textMuted}> ({AGENTS.length})</text>
+        <text fg={theme().textMuted}>{` (${String(AGENTS.length)})`}</text>
       </box>
-      <Show when={showAg()}>
-        <box marginLeft={1} flexDirection="column">
-          <For each={AGENTS}>
-            {(a) => <text fg={props.api.theme.current.textMuted}>{'\u00b7'} {a}</text>}
-          </For>
-        </box>
+
+      <Show when={showAgents()}>
+        <For each={AGENTS}>
+          {(agent) => (
+            <box marginLeft={1}>
+              <text fg={agent.tier === 'premium' ? theme().accent : theme().textMuted}>
+                {`${agent.tier === 'premium' ? '\u2726 ' : '\u00b7 '}${agent.name}`}
+              </text>
+              <text fg={theme().textMuted}>{` — ${agent.role}`}</text>
+            </box>
+          )}
+        </For>
       </Show>
 
       {/* Config */}
-      <box marginTop={0} onMouseDown={() => setShowCfg((x) => !x)}>
-        <text fg={props.api.theme.current.text} attributes={{ bold: true }}>
-          {showCfg() ? '\u25bc ' : '\u25b6 '}Config
+      <box marginTop={0} onMouseDown={() => setShowConfig((x) => !x)}>
+        <text fg={theme().text} attributes={{ bold: true }}>
+          {`${showConfig() ? '\u25bc' : '\u25b6'} Config`}
         </text>
       </box>
-      <Show when={showCfg()}>
-        <box marginLeft={1} flexDirection="column">
-          <text fg={props.api.theme.current.textMuted}>
-            MCPs: {cfg?.mcp ? Object.keys(cfg.mcp).length : 0}
-          </text>
-          <text fg={props.api.theme.current.textMuted}>
-            Compaction: {cfg?.compaction?.auto ? 'ON' : 'OFF'}
-          </text>
-        </box>
+
+      <Show when={showConfig()}>
+        <Show when={configInfo()} fallback={<box marginLeft={1}><text fg={theme().textMuted}>(no config data)</text></box>}>
+          {(cfg) => (
+            <box marginLeft={1} flexDirection="column">
+              <text fg={theme().textMuted}>{`MCP servers: ${String(cfg().mcpCount)}`}</text>
+              <text fg={theme().textMuted}>{`Auto-compaction: ${cfg().autoCompaction ? 'ON' : 'OFF'}`}</text>
+            </box>
+          )}
+        </Show>
       </Show>
 
       {/* Memory */}
-      <box marginTop={0} onMouseDown={() => setShowMem((x) => !x)}>
-        <text fg={props.api.theme.current.text} attributes={{ bold: true }}>
-          {showMem() ? '\u25bc ' : '\u25b6 '}Memory
+      <box marginTop={0} onMouseDown={() => setShowMemory((x) => !x)}>
+        <text fg={theme().text} attributes={{ bold: true }}>
+          {`${showMemory() ? '\u25bc' : '\u25b6'} Memory`}
         </text>
       </box>
-      <Show when={showMem()}>
-        <box marginLeft={1}>
-          <text fg={props.api.theme.current.textMuted}>
-            {mem?.entries > 0 ? `Entries: ${mem.entries}` : '(no data)'}
-          </text>
-        </box>
+
+      <Show when={showMemory()}>
+        <Show when={memoryInfo()} fallback={<box marginLeft={1}><text fg={theme().textMuted}>(no data)</text></box>}>
+          {(mem) => (<box marginLeft={1}><text fg={theme().textMuted}>{`Entries: ${String(mem().entries)}`}</text></box>)}
+        </Show>
       </Show>
     </box>
   )
 }
 
-function createSlot(api: TuiPluginApi, version: string): TuiSlotPlugin {
-  return {
+const tui: TuiPlugin = async (api, _options, _meta) => {
+  const version = await readPantheonVersion(api)
+  api.slots.register({
     order: 900,
     slots: {
-      sidebar_content(_ctx: TuiSlotContext, _input: { session_id: string }): JSX.Element {
-        return <PantheonPanel api={api} version={version} />
+      sidebar_content(_ctx, props) {
+        return <View api={api} sessionID={props.session_id} version={version} />
       },
     },
-  }
+  })
 }
 
-const tui: TuiPlugin = async (api: TuiPluginApi) => {
-  // Read version ONCE at startup (sincrono, evitando Promise)
-  let version = '5.0.0'
-  try {
-    const wt = api.state.path?.worktree ?? ''
-    const fp = wt ? `${wt}/package.json` : 'package.json'
-    const r = await api.client.file.read({ query: { path: fp } })
-    const m = String(r?.content ?? '').match(/"version":\s*"([^"]+)"/)
-    if (m?.[1]) version = m[1]
-  } catch { /* fallback */ }
-
-  api.slots.register(createSlot(api, version))
+const plugin: TuiPluginModule & { id: string } = {
+  id: 'pantheon.tui',
+  tui,
 }
 
-export default { id: 'pantheon.tui', tui } as TuiPluginModule & { id: string }
+export default plugin