opencastle 0.8.2 → 0.9.0

package/src/cli/run/schema.test.ts

@@ -0,0 +1,343 @@
+import { describe, it, expect } from 'vitest'
+import { parseYaml, parseTimeout, validateSpec, applyDefaults } from './schema.js'
+
+// ── parseYaml ──────────────────────────────────────────────────
+
+describe('parseYaml', () => {
+  it('parses valid YAML mapping', () => {
+    const result = parseYaml('name: test\nvalue: 42')
+    expect(result).toEqual({ name: 'test', value: 42 })
+  })
+
+  it('throws on scalar top-level value', () => {
+    expect(() => parseYaml('hello')).toThrow('YAML must be a mapping')
+  })
+
+  it('throws on array top-level value', () => {
+    expect(() => parseYaml('- a\n- b')).toThrow('YAML must be a mapping')
+  })
+
+  it('throws on empty input', () => {
+    expect(() => parseYaml('')).toThrow('YAML must be a mapping')
+  })
+
+  it('handles nested objects', () => {
+    const result = parseYaml('parent:\n  child: value')
+    expect(result).toEqual({ parent: { child: 'value' } })
+  })
+
+  it('handles multiline strings', () => {
+    const result = parseYaml('text: |\n  line one\n  line two')
+    expect(result.text).toContain('line one')
+    expect(result.text).toContain('line two')
+  })
+
+  it('rejects YAML with dangerous __proto__ key gracefully', () => {
+    // yaml npm package handles __proto__ safely by default
+    const result = parseYaml('__proto__:\n  polluted: true')
+    expect(result).toBeDefined()
+    // Verify prototype pollution didn't work
+    expect(({} as Record<string, unknown>).polluted).toBeUndefined()
+  })
+})
+
+// ── parseTimeout ───────────────────────────────────────────────
+
+describe('parseTimeout', () => {
+  it('parses seconds', () => {
+    expect(parseTimeout('30s')).toBe(30_000)
+  })
+
+  it('parses minutes', () => {
+    expect(parseTimeout('10m')).toBe(600_000)
+  })
+
+  it('parses hours', () => {
+    expect(parseTimeout('2h')).toBe(7_200_000)
+  })
+
+  it('returns NaN for invalid format', () => {
+    expect(parseTimeout('abc')).toBeNaN()
+  })
+
+  it('returns NaN for missing unit', () => {
+    expect(parseTimeout('10')).toBeNaN()
+  })
+
+  it('returns NaN for empty string', () => {
+    expect(parseTimeout('')).toBeNaN()
+  })
+
+  it('handles single digit', () => {
+    expect(parseTimeout('1s')).toBe(1_000)
+  })
+
+  it('handles large values', () => {
+    expect(parseTimeout('999m')).toBe(999 * 60 * 1000)
+  })
+})
+
+// ── validateSpec ───────────────────────────────────────────────
+
+describe('validateSpec', () => {
+  const validSpec = {
+    name: 'test-run',
+    tasks: [
+      { id: 'task-1', prompt: 'Do something' },
+      { id: 'task-2', prompt: 'Do another thing', depends_on: ['task-1'] },
+    ],
+  }
+
+  it('accepts a valid minimal spec', () => {
+    const result = validateSpec(validSpec)
+    expect(result.valid).toBe(true)
+    expect(result.errors).toHaveLength(0)
+  })
+
+  it('rejects null input', () => {
+    const result = validateSpec(null)
+    expect(result.valid).toBe(false)
+    expect(result.errors[0]).toMatch(/must be a YAML object/)
+  })
+
+  it('rejects non-object input', () => {
+    const result = validateSpec('string')
+    expect(result.valid).toBe(false)
+  })
+
+  it('requires name field', () => {
+    const result = validateSpec({ tasks: [{ id: 'a', prompt: 'b' }] })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('name'))
+  })
+
+  it('requires tasks array', () => {
+    const result = validateSpec({ name: 'test' })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('tasks'))
+  })
+
+  it('rejects empty tasks array', () => {
+    const result = validateSpec({ name: 'test', tasks: [] })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('non-empty'))
+  })
+
+  it('rejects tasks without id', () => {
+    const result = validateSpec({ name: 'test', tasks: [{ prompt: 'x' }] })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('id'))
+  })
+
+  it('rejects tasks without prompt', () => {
+    const result = validateSpec({ name: 'test', tasks: [{ id: 'a' }] })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('prompt'))
+  })
+
+  it('rejects duplicate task ids', () => {
+    const result = validateSpec({
+      name: 'test',
+      tasks: [
+        { id: 'same', prompt: 'a' },
+        { id: 'same', prompt: 'b' },
+      ],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('duplicate'))
+  })
+
+  it('validates concurrency is a positive integer', () => {
+    const result = validateSpec({ ...validSpec, concurrency: -1 })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('concurrency'))
+  })
+
+  it('validates concurrency rejects zero', () => {
+    const result = validateSpec({ ...validSpec, concurrency: 0 })
+    expect(result.valid).toBe(false)
+  })
+
+  it('accepts valid concurrency', () => {
+    const result = validateSpec({ ...validSpec, concurrency: 3 })
+    expect(result.valid).toBe(true)
+  })
+
+  it('validates on_failure values', () => {
+    const result = validateSpec({ ...validSpec, on_failure: 'invalid' })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('on_failure'))
+  })
+
+  it('accepts valid on_failure values', () => {
+    expect(validateSpec({ ...validSpec, on_failure: 'continue' }).valid).toBe(true)
+    expect(validateSpec({ ...validSpec, on_failure: 'stop' }).valid).toBe(true)
+  })
+
+  it('validates adapter is a string', () => {
+    const result = validateSpec({ ...validSpec, adapter: 123 })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('adapter'))
+  })
+
+  it('validates invalid timeout format', () => {
+    const result = validateSpec({
+      name: 'test',
+      tasks: [{ id: 'a', prompt: 'x', timeout: 'bad' }],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('timeout'))
+  })
+
+  it('validates depends_on must be an array', () => {
+    const result = validateSpec({
+      name: 'test',
+      tasks: [{ id: 'a', prompt: 'x', depends_on: 'task-1' }],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('depends_on'))
+  })
+
+  it('validates depends_on references exist', () => {
+    const result = validateSpec({
+      name: 'test',
+      tasks: [{ id: 'a', prompt: 'x', depends_on: ['nonexistent'] }],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('unknown task'))
+  })
+
+  it('validates files must be an array', () => {
+    const result = validateSpec({
+      name: 'test',
+      tasks: [{ id: 'a', prompt: 'x', files: 'not-array' }],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('files'))
+  })
+
+  it('detects simple circular dependency (A→B→A)', () => {
+    const result = validateSpec({
+      name: 'test',
+      tasks: [
+        { id: 'a', prompt: 'x', depends_on: ['b'] },
+        { id: 'b', prompt: 'y', depends_on: ['a'] },
+      ],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('Circular'))
+  })
+
+  it('detects 3-node cycle (A→B→C→A)', () => {
+    const result = validateSpec({
+      name: 'test',
+      tasks: [
+        { id: 'a', prompt: 'x', depends_on: ['c'] },
+        { id: 'b', prompt: 'y', depends_on: ['a'] },
+        { id: 'c', prompt: 'z', depends_on: ['b'] },
+      ],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('Circular'))
+  })
+
+  it('accepts a valid DAG without cycles', () => {
+    const result = validateSpec({
+      name: 'test',
+      tasks: [
+        { id: 'a', prompt: 'x' },
+        { id: 'b', prompt: 'y', depends_on: ['a'] },
+        { id: 'c', prompt: 'z', depends_on: ['a', 'b'] },
+      ],
+    })
+    expect(result.valid).toBe(true)
+  })
+
+  it('accepts a self-contained task (no depends_on)', () => {
+    const result = validateSpec({
+      name: 'test',
+      tasks: [{ id: 'solo', prompt: 'do it' }],
+    })
+    expect(result.valid).toBe(true)
+  })
+
+  it('collects multiple errors at once', () => {
+    const result = validateSpec({
+      tasks: [{ id: 123, timeout: 'bad' }],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors.length).toBeGreaterThan(1)
+  })
+})
+
+// ── applyDefaults ──────────────────────────────────────────────
+
+describe('applyDefaults', () => {
+  it('applies default concurrency', () => {
+    const spec = applyDefaults({
+      name: 'test',
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    expect(spec.concurrency).toBe(1)
+  })
+
+  it('applies default on_failure', () => {
+    const spec = applyDefaults({
+      name: 'test',
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    expect(spec.on_failure).toBe('continue')
+  })
+
+  it('applies default adapter', () => {
+    const spec = applyDefaults({
+      name: 'test',
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    expect(spec.adapter).toBe('claude-code')
+  })
+
+  it('preserves user-specified values', () => {
+    const spec = applyDefaults({
+      name: 'test',
+      concurrency: 3,
+      on_failure: 'stop',
+      adapter: 'copilot',
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    expect(spec.concurrency).toBe(3)
+    expect(spec.on_failure).toBe('stop')
+    expect(spec.adapter).toBe('copilot')
+  })
+
+  it('applies task-level defaults', () => {
+    const spec = applyDefaults({
+      name: 'test',
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    const task = spec.tasks[0]
+    expect(task.agent).toBe('developer')
+    expect(task.timeout).toBe('30m')
+    expect(task.depends_on).toEqual([])
+    expect(task.files).toEqual([])
+  })
+
+  it('preserves user-specified task values', () => {
+    const spec = applyDefaults({
+      name: 'test',
+      tasks: [{
+        id: 'a',
+        prompt: 'x',
+        agent: 'ui-ux-expert',
+        timeout: '15m',
+        depends_on: ['b'],
+        files: ['src/'],
+      }],
+    })
+    const task = spec.tasks[0]
+    expect(task.agent).toBe('ui-ux-expert')
+    expect(task.timeout).toBe('15m')
+    expect(task.depends_on).toEqual(['b'])
+    expect(task.files).toEqual(['src/'])
+  })
+})

package/src/cli/run/schema.ts

@@ -8,7 +8,7 @@ import type { TaskSpec, ValidationResult } from '../types.js'
  */
 export function parseYaml(text: string): Record<string, unknown> {
   const result = yamlParse(text)
-  if (!result || typeof result !== 'object') {
+  if (!result || typeof result !== 'object' || Array.isArray(result)) {
     throw new Error('YAML must be a mapping at the top level')
   }
   return result as Record<string, unknown>

package/src/dashboard/node_modules/.vite/deps/_metadata.json

@@ -1,25 +1,25 @@
 {
-  "hash": "69236408",
+  "hash": "d4030ca8",
   "configHash": "30f8ea04",
-  "lockfileHash": "9a76027c",
-  "browserHash": "31f52ba6",
+  "lockfileHash": "30f69af6",
+  "browserHash": "5c8328e9",
   "optimized": {
     "astro > cssesc": {
       "src": "../../../../../node_modules/cssesc/cssesc.js",
       "file": "astro___cssesc.js",
-      "fileHash": "1714fa2c",
+      "fileHash": "5802e199",
       "needsInterop": true
     },
     "astro > aria-query": {
       "src": "../../../../../node_modules/aria-query/lib/index.js",
       "file": "astro___aria-query.js",
-      "fileHash": "24f1b1e8",
+      "fileHash": "3b8b6441",
       "needsInterop": true
     },
     "astro > axobject-query": {
       "src": "../../../../../node_modules/axobject-query/lib/index.js",
       "file": "astro___axobject-query.js",
-      "fileHash": "415129f4",
+      "fileHash": "12a97af5",
       "needsInterop": true
     }
   },

package/src/orchestrator/agents/session-guard.agent.md

@@ -0,0 +1,113 @@
+---
+description: 'Lightweight compliance agent called by Team Lead as its final action. Verifies observability logs, lessons, and quality gates — then provides ready-to-run fix commands for any gaps.'
+name: 'Session Guard'
+model: Claude Opus 4.6
+tools: [read/readFile, search/textSearch, search/fileSearch, execute/runInTerminal, execute/getTerminalOutput, read/terminalLastCommand]
+---
+
+# Session Guard
+
+You are a **compliance verification agent**. The Team Lead calls you as its **last action before responding to the user**. Your sole job: verify that all quality gates are satisfied and provide fix commands for any gaps.
+
+You do NOT create or modify log entries yourself. You verify and report.
+
+## Input
+
+The Team Lead provides a **session summary** with:
+
+- **Task description** — what was accomplished
+- **Delegations** — list of `(agent, task, mechanism)` for each delegation made
+- **Reviews** — whether fast reviews or panel reviews were run (and for which delegations)
+- **Retries** — whether any agent retried with a different approach
+- **Discovered issues** — any pre-existing bugs found during work
+- **Files changed** — count and key paths
+- **Commits/branch** — whether changes were committed and to which branch
+
+## Checks
+
+Run ALL checks. Report each as ✅ or ❌.
+
+### 1. Delegation Records
+
+For each delegation in the session summary, verify a matching record exists in `.github/customizations/logs/delegations.ndjson`.
+
+**How:** `tail -20 .github/customizations/logs/delegations.ndjson` and match agent + task against the summary.
+
+**Fix command template:**
+```bash
+echo '{"timestamp":"<ISO>","session_id":"<branch>","agent":"<name>","model":"<model>","tier":"<tier>","mechanism":"<sub-agent|background>","outcome":"<success|failure>","retries":0,"phase":N,"file_partition":["<paths>"]}' >> .github/customizations/logs/delegations.ndjson
+```
+
+Also verify each delegation record includes `session_id` (branch name). Records missing `session_id` should be flagged.
+
+### 2. Session Record
+
+Verify a session record exists in `.github/customizations/logs/sessions.ndjson` for the current task.
+
+**How:** `tail -5 .github/customizations/logs/sessions.ndjson` and match task description.
+
+**Fix command template:**
+```bash
+echo '{"timestamp":"<ISO>","agent":"Team Lead","model":"<model>","task":"<description>","outcome":"success","duration_min":<N>,"files_changed":<N>,"retries":0,"lessons_added":[],"discoveries":[]}' >> .github/customizations/logs/sessions.ndjson
+```
+
+### 3. Lessons Captured
+
+If the session summary indicates retries occurred, verify new entries exist in `.github/customizations/LESSONS-LEARNED.md`.
+
+**How:** `grep -c "^### LES-" .github/customizations/LESSONS-LEARNED.md` — compare count with expected.
+
+### 4. Discovered Issues Tracked
+
+If the session summary lists discovered issues, verify they appear in:
+- `.github/customizations/KNOWN-ISSUES.md`, OR
+- A task tracker ticket referenced in the summary
+
+### 5. Review & Panel Records
+
+If the session summary mentions fast reviews or panel reviews, verify matching records exist in `.github/customizations/logs/reviews.ndjson` and/or `.github/customizations/logs/panels.ndjson`.
+
+**How:** `tail -10 .github/customizations/logs/reviews.ndjson` and/or `tail -5 .github/customizations/logs/panels.ndjson`.
+
+**Fix command templates:**
+```bash
+# Fast review
+echo '{"timestamp":"<ISO>","agent":"<reviewed-agent>","reviewer_model":"<model>","verdict":"<pass|fail>","attempt":1,"issues_critical":0,"issues_major":0,"issues_minor":0,"confidence":"high","escalated":false,"duration_sec":N}' >> .github/customizations/logs/reviews.ndjson
+# Panel review
+echo '{"timestamp":"<ISO>","panel_key":"<key>","verdict":"<pass|block>","pass_count":N,"block_count":N,"must_fix":0,"should_fix":0,"reviewer_model":"<model>","weighted":false,"attempt":1,"artifacts_count":N}' >> .github/customizations/logs/panels.ndjson
+```
+
+### 6. Uncommitted Changes
+
+**How:** `git status --short`
+
+Only flag if the session produced code changes that should have been committed. Research-only or analysis sessions may not produce commits.
+
+## Output
+
+Return a structured report:
+
+```
+## Session Guard Report
+
+**Verdict:** PASS | FAIL
+
+### Checks
+1. Delegation records: ✅ N/N found | ❌ M/N missing
+2. Session record: ✅ found | ❌ missing
+3. Lessons captured: ✅ N/A (no retries) | ❌ retries occurred, no lesson added
+4. Discovered issues: ✅ all tracked | ❌ untracked issues
+5. Review/panel records: ✅ N/A | ❌ M/N missing
+6. Uncommitted changes: ✅ clean | ⚠️ N files uncommitted
+
+### Fix Commands (only if FAIL)
+<ready-to-run echo commands with filled-in values from the session summary>
+```
+
+## Rules
+
+- **Complete in under 2 minutes** — this is fast verification, not an audit
+- **Never modify files** — only read and report
+- **Fill in fix commands completely** — use real values from the session summary, not placeholders
+- **When in doubt, flag it** — false positives are better than missed gaps
+- **No delegation records needed for research-only sub-agents** that produced no code changes