pantheon-opencode 1.5.1 → 1.6.0-beta.1

package/scripts/validate-routing.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+
 /**
  * validate-routing.mjs — Validate routing.yml consistency
  *
@@ -14,6 +15,7 @@
  *   node scripts/validate-routing.mjs --verbose   # show all entries checked
  */
 
+import { createHash } from 'node:crypto'
 import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -106,6 +108,44 @@ for (const [name, info] of Object.entries(routing.agents || {})) {
   }
 }
 
+// B2. skills-lock.json must match src/skills/*/SKILL.md exactly — content
+// digests stay in sync, and the set of locked paths equals the set on disk
+// (so adding/removing a skill without updating the lock fails the gate).
+console.log('\n  skills-lock.json integrity:')
+const lockPath = join(ROOT, 'skills-lock.json')
+let skillLock = null
+try {
+  skillLock = JSON.parse(readFileSync(lockPath, 'utf8'))
+} catch (err) {
+  check(false, `skills-lock.json missing or malformed: ${err.message}`)
+}
+if (skillLock && typeof skillLock === 'object' && !Array.isArray(skillLock)) {
+  const lockedFiles = Object.keys(skillLock).sort()
+  const skillFiles = existsSync(srcSkillsDir)
+    ? readdirSync(srcSkillsDir)
+        .filter((d) => existsSync(join(srcSkillsDir, d, 'SKILL.md')))
+        .map((d) => `src/skills/${d}/SKILL.md`)
+        .sort()
+    : []
+  console.log(`  Locked skills: ${lockedFiles.length} (on disk: ${skillFiles.length})`)
+
+  for (const rel of skillFiles) {
+    const actual = createHash('sha256')
+      .update(readFileSync(join(ROOT, rel)))
+      .digest('hex')
+    check(
+      skillLock[rel] === actual,
+      `skills-lock.json stale for "${rel}": expected ${actual}, got ${skillLock[rel] ?? 'no entry'}`,
+    )
+  }
+  for (const rel of lockedFiles) {
+    check(
+      skillFiles.includes(rel),
+      `skills-lock.json lists "${rel}" but that SKILL.md does not exist`,
+    )
+  }
+}
+
 // C. Handoff validation
 console.log(
   `\n  Handoff definitions: ${Object.keys(routing.handoffs || {}).length} agents with handoffs`,

package/skills-lock.json

@@ -1,23 +1,22 @@
 {
   "src/skills/agent-coordination/SKILL.md": "cfd040ef29e3dd0fd5e0e67773874facf7c06e3284898afe1fddba4456c3f1aa",
   "src/skills/artifact-management/SKILL.md": "c60e493666bedf46e9113d0dd20106489d5c5a73905e1370fcfc1c0d71c59185",
-  "src/skills/auto-continue/SKILL.md": "791b7f8d981bca571a6350cfd0f7f623ab8d9c2190b015dc63c15f8663b25e53",
+  "src/skills/auto-continue/SKILL.md": "f6ff530b5537af9c8a0224a52eb0da6da7f9cf4ab4958ce2908c5c3a911b8879",
+  "src/skills/clonedeps/SKILL.md": "3e0b43cf96da98c83699dc48db3fd58fbfda84b9022bb70d3747875c81c3e124",
   "src/skills/code-review-checklist/SKILL.md": "0e59367c65ef4608db80a0674279f32cfc3f67dca7236f233b61a47fe506579f",
-  "src/skills/context-compression/SKILL.md": "07cfddfedeb8087794ae49ef8e60d8adca3ec2342d592cc30d0407d1b8ab1b90",
+  "src/skills/codemap/SKILL.md": "87af5271e1576e154cadff313eab16264b726e43d094520736b7a5b03b409a4a",
+  "src/skills/context-compression/SKILL.md": "ebc721c715c1fa20e4ebf5177007fde94e001540b16cef4316393a665633c16f",
   "src/skills/git-workflow-and-versioning/SKILL.md": "685a94041f1b4ce2a430301f517b89102055696267c369a7e8fb191606659276",
   "src/skills/incremental-implementation/SKILL.md": "7065ddb45da3c6b6751de07f290e92e6cb072e949a2e3aaae13ee7762f0a70fc",
+  "src/skills/loop-engineering/SKILL.md": "f804e545821b9cca8fe0ec517307ed902446f28c2ca8ff9194c0f987cf7229e3",
   "src/skills/memory-bank/SKILL.md": "4717cf18b43550c9f02cfab810968b97a5b2584f00a15516ecba643c80cdc110",
-  "src/skills/orchestration-workflow/SKILL.md": "0eeabaf71a802d1f673f79996548cda2d394bbcc7c62eaca03482d3fa99be688",
+  "src/skills/reflect/SKILL.md": "4c7608c2a55cb8a50ac90fc0e2446bdf25e7914b1748cb7731c311d13c29dfdd",
   "src/skills/security-hardening/SKILL.md": "6d637e122421f7bc3b751f04854ad343a5a5d35249458bc8939233138fd3f20d",
   "src/skills/session-goal/SKILL.md": "793498265f70253c20524f6adc88bcc86db11d7160fe8232a26aedc6b1c5489f",
+  "src/skills/simplify/SKILL.md": "aa739e9f75962a77d6574557d674ea01b5aea95e580b721d66c058753161b053",
   "src/skills/spec-driven-development/SKILL.md": "e93b9103d6cd1848ab01328efde82c1daf564d1cabbdc2278254b346fcf55d02",
   "src/skills/tdd-with-agents/SKILL.md": "9880919a46b74f549f948147d8b086b008635de94fa259f76261d067772bb8e3",
+  "src/skills/verification-planning/SKILL.md": "14186446ef51e1ba2c87b337e8d5f86e566d805156ab21fba2a75f8c4a99df3f",
   "src/skills/visual-review-pipeline/SKILL.md": "f6e65ff75a9325c38e0e9dde8e87f09b873e14e490936ef48aa80201bb68fe10",
-  "src/skills/codemap/SKILL.md": "src/skills/codemap/SKILL.md",
-  "src/skills/simplify/SKILL.md": "src/skills/simplify/SKILL.md",
-  "src/skills/reflect/SKILL.md": "src/skills/reflect/SKILL.md",
-  "src/skills/worktrees/SKILL.md": "src/skills/worktrees/SKILL.md",
-  "src/skills/verification-planning/SKILL.md": "src/skills/verification-planning/SKILL.md",
-  "src/skills/loop-engineering/SKILL.md": "src/skills/loop-engineering/SKILL.md",
-  "src/skills/clonedeps/SKILL.md": "src/skills/clonedeps/SKILL.md"
+  "src/skills/worktrees/SKILL.md": "0033c5f8a50f210f31f0256ba8cc0fd99c65674a2aabedb05d8e69447b5ec218"
 }

package/src/agents/mnemosyne.md

@@ -114,7 +114,7 @@ Mnemosyne executes the expanded compression pipeline. When Zeus delegates compre
    - Append new entries to `_xref/index.md`
    - Increment `_xref/_next_id.json`
 
-7. **Auto-index vector memory**: Run `scripts/vector_memory/index.index_all()` to index new entries into the Level 3 Vector Memory system. If sentence-transformers is not installed, indexes FTS5 only.
+7. **Auto-index memory**: Store the new entries with the `memory_store` MCP tool (namespace `memory-bank`) so `memory_search` can find them. Search is FTS5 (BM25) keyword retrieval — there is no embedding step to run or report on.
 
 8. **Report**: Return summary: "Compressed. 2 CRITICAL, 1 HIGH, 3 STANDARD. Budget: 15/20 lines. Cross-refs: +2 entities, +1 decision. Indexed X new, skipped Y duplicates."
 
@@ -127,16 +127,16 @@ Mnemosyne executes the expanded compression pipeline. When Zeus delegates compre
 - NEVER write over existing entries (idempotency by date+phase+agent hash)
 - NEVER delete _xref/ entries (append-only)
 
-##  Semantic Recall Handler (Level 3)
+##  Recall Handler (Level 3)
 
-Mnemosyne provides semantic recall via the Level 3 Vector Memory system:
+Mnemosyne recalls stored entries with the `memory_search` MCP tool:
 
 **Command:** `@mnemosyne Recall "<query>" [--top-k 5] [--type adr|subtask|wisdom|impl|decision] [--agent hermes] [--since 2026-01-01] [--tags auth,jwt]`
 
 **How it works:**
-1. Calls `scripts/vector_memory/query.recall()` with the provided parameters
-2. Returns ranked, structured results with scores and source paths
-3. Uses fallback chain: vector KNN → FTS5 BM25 → flat grep
+1. Calls `memory_search` with the query, namespace, and `top_k`
+2. Returns ranked, structured results with BM25 scores and source keys
+3. Retrieval is lexical: stopwords are dropped and terms of 4+ characters are prefix-matched, so queries should use words that actually appear in the stored text. Filter by type/agent/tags in the caller — `memory_search` filters on `namespace` only.
 
 **Usage examples:**
 ```
@@ -146,14 +146,13 @@ Mnemosyne provides semantic recall via the Level 3 Vector Memory system:
 ```
 
 **Integration with compress_context:**
-After each `compress_context` run, automatically index new entries:
-1. Run `scripts/vector_memory/index.index_all()`
+After each `compress_context` run, store the new entries with `memory_store`:
+1. Store each new entry with namespace `memory-bank` and a `memory-bank/<id>` key
 2. Report: "Indexed X new memories, skipped Y duplicates"
-3. If sentence-transformers is not installed, skip vector indexing but still index FTS5
 
 **Integration with Close sprint:**
 When `Close sprint` is called, before wiping .tmp/:
-1. Run final batch: `index_all()`
+1. Store the final batch of entries
 2. Report final index stats
 
 ## Invocation Rules
@@ -164,8 +163,8 @@ When `Close sprint` is called, before wiping .tmp/:
 ##  Quick-Index Handler (Tier 1 — Background Agent Results)
 
 Called automatically by Zeus when any agent returns a subtask_summary
-(background or foreground). Persists results into Vector Memory immediately,
-no Themis needed.
+(background or foreground). Persists results via the `memory_store` MCP tool
+immediately, no Themis needed.
 
 **Trigger patterns:**
 - Background agent completes → Zeus calls Mnemosyne Quick-index
@@ -175,9 +174,9 @@ no Themis needed.
 **Command:** `@mnemosyne Quick-index <subtask_summary_json>`
 
 **What it does:**
-1. Calls `scripts/vector_memory/index.quick_index()` with the summary dict
-2. Auto-generates tags from keywords (no manual specification needed)
-3. Reports: "Indexed: {type} from @{agent} ({memory_id})"
+1. Calls `memory_store` with the summary fields
+2. Stores under a `type/agent` namespace and a `<type>:<agent>:<date>` key
+3. Reports: "Indexed: {type} from @{agent} (namespace {namespace})"
 
 **Parameters (from subtask_summary):**
 | Field | Source | Required |
@@ -194,7 +193,7 @@ no Themis needed.
 **Safety:**
 - [OK] Safe to call on partial results (indexes what's available)
 - [OK] Safe to call multiple times (idempotent)
-- [OK] Works without sentence-transformers (FTS5 only)
+- [OK] Works with no embedding backend (FTS5 keyword search only)
 - [FAIL] Does NOT generate ZZ artifact (that's Tier 2)
 - [FAIL] Does NOT update 01-active-context.md (that's Tier 2)
 

package/src/agents/zeus.md

@@ -26,7 +26,6 @@ skills:
   - artifact-management
   - context-compression
   - auto-continue
-  - orchestration-workflow
   - incremental-implementation
 
 ---
@@ -202,7 +201,7 @@ Zeus (nivel 0) -> Apollo/Hermes (nivel 1) -> sub-subagente (nivel 2 max).
 
 | Tier | Trigger | Action |
 |------|---------|--------|
-| Tier 1 — Auto-index | Any agent returns subtask_summary | `memory_store()` direto -> Vector Memory |
+| Tier 1 — Auto-index | Any agent returns subtask_summary | `memory_store()` direto -> FTS5 memory |
 | Tier 2 — Compression | Themis APPROVED | compress_context -> ZZ -> memory-bank |
 
 ## MCP Tools

package/src/mcp/code_mode_server.py

@@ -20,6 +20,11 @@ import hashlib
 import json
 import logging
 import os
+
+try:
+    import resource
+except (ImportError, OSError, ValueError):  # pragma: no cover - platform-specific
+    resource = None  # type: ignore[assignment]
 import shutil
 import signal
 import stat
@@ -125,6 +130,88 @@ def _build_script_env(
     return env
 
 
+# Additional tasks a sandboxed script may create beyond the UID's current
+# count. RLIMIT_NPROC is a per-real-UID limit on the *total* number of
+# processes AND threads, so the sandbox floor must clear everything the host
+# already owns before a script can fork at all. This headroom is the actual
+# anti-fork-bomb budget: the script still cannot exceed current + headroom.
+NPROC_HEADROOM: int = 64
+
+
+def _uid_task_count() -> int | None:
+    """Count the tasks (processes + threads) this real UID already owns.
+
+    The kernel compares the post-fork total against RLIMIT_NPROC, so this is
+    the number the sandbox limit has to exceed. Returns *None* when the count
+    cannot be established (no readable ``/proc``), which makes the caller
+    fail open on ``--nproc`` rather than pin a value that may be too low and
+    break every script.
+
+    The tally is one too high per process: ``/proc/<pid>/task`` already lists
+    the thread-group leader, so the extra ``1`` counts it twice. That bias
+    only widens the derived limit (the fail-open direction), so it is left in
+    place deliberately.
+    """
+    uid = os.getuid()
+    count = 0
+    try:
+        pids = os.listdir("/proc")
+    except OSError:
+        return None
+    for pid in pids:
+        if not pid.isdigit():
+            continue
+        proc_dir = f"/proc/{pid}"
+        try:
+            if os.stat(proc_dir).st_uid != uid:
+                continue
+            # ``/proc/<pid>/task`` already includes the thread-group leader,
+            # so the extra 1 counts it twice (over-count by one per process).
+            count += 1 + len(os.listdir(f"{proc_dir}/task"))
+        except OSError:
+            # Process exited between listdir and stat, or is not ours to read.
+            continue
+    return count
+
+
+def _sandbox_nproc() -> str | None:
+    """Return the ``--nproc`` value for a sandboxed script, or *None*.
+
+    Derived from the host rather than hardcoded: the value is the UID's
+    current task count plus ``NPROC_HEADROOM``, clamped to the hard limit
+    (``prlimit`` fails with EPERM above it, and an unprivileged process cannot
+    raise its soft limit past the hard one).
+
+    Returns *None* when the count or the limit cannot be read, in which case
+    the caller omits ``--nproc``. ``--as`` and ``--cpu`` still apply, so the
+    sandbox keeps its memory and CPU boundaries.
+    """
+    current = _uid_task_count()
+    if current is None:
+        _log.warning(
+            "code-mode: cannot count this UID's tasks; omitting --nproc, so "
+            "the sandboxed script's fork budget is unbounded"
+        )
+        return None
+    if resource is None:
+        _log.warning(
+            "code-mode: cannot read RLIMIT_NPROC; omitting --nproc, so the "
+            "sandboxed script's fork budget is unbounded"
+        )
+        return None
+    try:
+        _soft, hard = resource.getrlimit(resource.RLIMIT_NPROC)
+    except (OSError, ValueError):
+        _log.warning(
+            "code-mode: cannot read RLIMIT_NPROC; omitting --nproc, so the "
+            "sandboxed script's fork budget is unbounded"
+        )
+        return None
+    if hard == getattr(resource, "RLIM_INFINITY", -1):
+        return str(current + NPROC_HEADROOM)
+    return str(max(1, min(current + NPROC_HEADROOM, hard)))
+
+
 def _prlimit_prefix(
     prlimit_path: str | None,
     timeout_s: int = SCRIPT_TIMEOUT,
@@ -132,21 +219,34 @@ def _prlimit_prefix(
     """Return a ``prlimit`` command prefix to wrap a subprocess, or *None*.
 
     On Linux with ``prlimit`` available the prefix adds:
-      --nproc=512  --as=1073741824  --cpu=<timeout_s + 5>
-
-    On non-Linux or when *prlimit_path* is falsy, returns *None* (fail-open).
+      --nproc=<uid task count + NPROC_HEADROOM>  --as=1073741824
+      --cpu=<timeout_s + 5>
+
+    ``--nproc`` is derived per invocation by :func:`_sandbox_nproc` rather
+    than hardcoded. RLIMIT_NPROC is a per-real-UID total across processes AND
+    threads, so a fixed value below the host's current usage makes the very
+    first ``fork()`` inside the sandbox fail with EAGAIN — which is exactly
+    what a hardcoded ``--nproc=512`` did on a host already running more than
+    512 tasks. The isolation property is unchanged: a script still cannot
+    create more than ``NPROC_HEADROOM`` additional tasks.
+
+    On non-Linux, when *prlimit_path* is falsy, or when the nproc limit cannot
+    be derived, the flag is omitted (fail-open); ``--as``/``--cpu`` remain.
     """
     if not prlimit_path:
         return None
 
     cpu_limit = timeout_s + 5
-    return [
-        prlimit_path,
-        "--nproc=512",
+    prefix = [prlimit_path]
+    nproc = _sandbox_nproc()
+    if nproc is not None:
+        prefix.append(f"--nproc={nproc}")
+    prefix += [
         "--as=1073741824",  # 1 GiB in bytes
         f"--cpu={cpu_limit}",
         "--",
     ]
+    return prefix
 
 
 def _detect_prlimit() -> str | None:
@@ -226,7 +326,9 @@ def _packaged_scripts_dir() -> Path | None:
     return None
 
 
-def _resolve_scripts_dir(candidates: list[Path], *, allow_packaged: bool = True) -> Path | None:
+def _resolve_scripts_dir(
+    candidates: list[Path], *, allow_packaged: bool = True
+) -> Path | None:
     """Select the first usable candidate, optionally trying the package copy."""
     for candidate in candidates:
         if _has_usable_scripts(candidate):
@@ -377,9 +479,7 @@ def _load_manifest(scripts_dir: Path | None = None) -> dict[str, str]:
         ) from None
 
     if not isinstance(data, dict):
-        raise ManifestError(
-            "CORRUPT_DATA", "Code-mode manifest must be a JSON object."
-        )
+        raise ManifestError("CORRUPT_DATA", "Code-mode manifest must be a JSON object.")
 
     if data.get("version") != 1:
         raise ManifestError(
@@ -527,7 +627,6 @@ def _contract_result(
     return f"[{status}] {message}"
 
 
-
 def _format_output(
     stdout: str,
     stderr: str,
@@ -818,22 +917,15 @@ async def execute_code_script(
                 timeout_s=timeout_s,
                 status="TIMEOUT",
             )
-    except FileNotFoundError:
-        return _build_result(
-            "",
-            f"Script '{script_name}' not found or interpreter missing.",
-            -1,
-            timed_out=False,
-            duration_ms=0,
-            metadata=metadata,
-            json_output=json_output,
-            timeout_s=timeout_s,
-            status="UNAVAILABLE",
-        )
     except OSError as e:
+        error = (
+            f"Script '{script_name}' not found or interpreter missing."
+            if isinstance(e, FileNotFoundError)
+            else f"Failed to execute script: {e}"
+        )
         return _build_result(
             "",
-            f"Failed to execute script: {e}",
+            error,
             -1,
             timed_out=False,
             duration_ms=0,