arkaos 2.61.0 → 2.63.0

package/VERSION

@@ -1 +1 @@
-2.61.0
+2.63.0

package/config/constitution.yaml

@@ -66,6 +66,10 @@ enforcement_levels:
         rule: "Forge plans must pass critic validation and governance check before approval"
         enforcement: "Plan Critic validates constitution compliance; PostToolUse monitors execution"
 
+      - id: mandatory-skill-evaluation
+        rule: "After every completed substantive task (Phase 13 marker fires), the system MUST evaluate whether the work just done represents a repeatable capability that should be captured as a permanent skill. Proposals are written to ~/.arkaos/skill-proposals/<date>-<slug>.md for operator review. Bypass via [arka:trivial] or [arka:skill-skip]."
+        enforcement: "Stop hook calls core.governance.skill_proposer.evaluate on the closing transcript tail. When the classifier returns should_propose=True a SKILL.md draft is written. Operator promotes via /arka skill-promote (PR45) or manual scaffold under departments/<dept>/skills/<slug>/."
+
       - id: mandatory-flow
         rule: "Every non-trivial request executes the 13-phase canonical flow defined in arka/skills/flow/SKILL.md. No task type, no context, no runtime setting can opt out. The only bypass is [arka:trivial] for single-file edits under 10 lines."
         enforcement: "UserPromptSubmit hook classifies the turn; SessionStart systemMessage embeds the flow at system-prompt priority; arka/SKILL.md references it as default; violation is a constitution breach, not a style issue."

package/config/hooks/stop.sh

@@ -162,6 +162,17 @@ try:
 except Exception:
     pass
 
+# PR44 v2.63.0 — Mandatory post-task skill evaluation
+# (NON-NEGOTIABLE constitution rule mandatory-skill-evaluation).
+# Classifier decides whether closing message represents a repeatable
+# capability worth capturing as a permanent skill. Proposals written
+# to ~/.arkaos/skill-proposals/<date>-<slug>.md. Never raises.
+try:
+    from core.governance.skill_proposer import evaluate as _eval_skill
+    _eval_skill(last)
+except Exception:
+    pass
+
 # PR30 v2.49.0 — Meta-tag soft block. Mirrors the KB cite-check
 # pipeline. Records whether the closing message carried the required
 # [arka:meta] one-liner; persists result to /tmp/arkaos-meta/<session>.json

package/core/governance/skill_proposer.py

@@ -0,0 +1,133 @@
+"""Post-task skill proposer (PR44 v2.63.0).
+
+Constitution rule (NON-NEGOTIABLE): after every completed substantive
+task, the system MUST evaluate whether the work just done represents a
+repeatable capability that should be promoted to a permanent skill.
+
+Mirror of the PR20 reorganizer pattern but focused on capability-capture.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+_COMPLETION_PATTERNS: tuple[re.Pattern[str], ...] = (
+    re.compile(r"\[arka:phase:13\]", re.IGNORECASE),
+    re.compile(r"\barc complete\b", re.IGNORECASE),
+)
+
+_BYPASS_PATTERNS: tuple[re.Pattern[str], ...] = (
+    re.compile(r"\[arka:trivial\]", re.IGNORECASE),
+    re.compile(r"\[arka:skill-skip\]", re.IGNORECASE),
+)
+
+_SKILL_WORTHY_HINTS: tuple[re.Pattern[str], ...] = (
+    re.compile(r"\b\d+-phase\b", re.IGNORECASE),
+    re.compile(r"\bworkflow\b", re.IGNORECASE),
+    re.compile(r"\bskill\b", re.IGNORECASE),
+    re.compile(r"\btemplate\b", re.IGNORECASE),
+    re.compile(r"\bprocedure\b", re.IGNORECASE),
+    re.compile(r"\bplaybook\b", re.IGNORECASE),
+    re.compile(r"\bchecklist\b", re.IGNORECASE),
+)
+
+_TRIVIAL_WORD_THRESHOLD: int = 15
+_DEFAULT_OUTPUT_DIR: Path = Path.home() / ".arkaos" / "skill-proposals"
+
+
+@dataclass(frozen=True)
+class SkillProposal:
+    """Outcome of a skill-evaluation pass."""
+    should_propose: bool
+    reason: str
+    suggested_slug: str | None
+    proposal_path: Path | None
+    proposal_markdown: str | None
+
+
+def evaluate(
+    transcript_tail: str,
+    *,
+    output_dir: Path | None = None,
+    today: str | None = None,
+) -> SkillProposal:
+    """Classify the closing transcript tail; propose a skill if warranted."""
+    text = transcript_tail or ""
+
+    if _has_bypass(text):
+        return SkillProposal(False, "bypass-marker", None, None, None)
+
+    if not _has_completion_signal(text):
+        return SkillProposal(False, "no-completion-signal", None, None, None)
+
+    if _is_trivial_length(text):
+        return SkillProposal(False, "trivial-length", None, None, None)
+
+    hint_count = sum(1 for pat in _SKILL_WORTHY_HINTS if pat.search(text))
+    if hint_count < 2:
+        return SkillProposal(False, "below-skill-hint-floor", None, None, None)
+
+    slug = _suggest_slug(text)
+    markdown = _render_proposal(text, slug, today=today)
+    out_dir = output_dir or _DEFAULT_OUTPUT_DIR
+    out_dir.mkdir(parents=True, exist_ok=True)
+    iso_today = today or datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    path = out_dir / f"{iso_today}-{slug}.md"
+    path.write_text(markdown, encoding="utf-8")
+    return SkillProposal(True, "proposed", slug, path, markdown)
+
+
+def _has_completion_signal(text: str) -> bool:
+    return any(p.search(text) for p in _COMPLETION_PATTERNS)
+
+
+def _has_bypass(text: str) -> bool:
+    return any(p.search(text) for p in _BYPASS_PATTERNS)
+
+
+def _is_trivial_length(text: str) -> bool:
+    return len(text.split()) < _TRIVIAL_WORD_THRESHOLD
+
+
+def _suggest_slug(text: str) -> str:
+    for pat in _SKILL_WORTHY_HINTS:
+        m = pat.search(text)
+        if m:
+            anchor = m.group(0).lower()
+            return _slugify(f"capability-{anchor}")
+    return "capability-task"
+
+
+def _slugify(value: str) -> str:
+    out = re.sub(r"[^a-z0-9-]+", "-", value.lower()).strip("-")
+    return out[:60] if out else "capability"
+
+
+def _render_proposal(text: str, slug: str, *, today: str | None) -> str:
+    iso = today or datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    excerpt = text.strip()
+    if len(excerpt) > 1000:
+        excerpt = excerpt[:1000].rstrip() + "..."
+    return (
+        f"# Skill Proposal — {slug}\n\n"
+        f"> Auto-generated by skill_proposer.evaluate on {iso}. "
+        "Review before promoting.\n\n"
+        "## Why this proposal exists\n\n"
+        "The constitution rule mandatory-skill-evaluation (NON-NEGOTIABLE) "
+        "fires after every completed substantive task. This proposal "
+        "represents a candidate capability the system thinks could be "
+        "captured as a permanent skill in a department.\n\n"
+        "## Transcript excerpt (last 1000 chars)\n\n"
+        f"```\n{excerpt}\n```\n\n"
+        "## Suggested next steps\n\n"
+        "1. Decide if this capability deserves its own skill.\n"
+        "2. Pick the target department (/dev, /brand, /saas, ...).\n"
+        "3. Manually scaffold departments/<dept>/skills/<slug>/SKILL.md.\n"
+        "4. Delete this proposal file once acted on.\n\n"
+        "## Status\n\n"
+        "- Reviewed by operator: NO\n"
+        "- Promoted to skill: NO\n"
+    )

package/installer/claude-plugins.js

@@ -0,0 +1,86 @@
+// Auto-install official Claude Code plugins on `npx arkaos install` and
+// `npx arkaos@latest update` (PR43 v2.62.0).
+//
+// Behaviour:
+//   - No-op when runtime is not Claude Code
+//   - Idempotent: skips plugins already in
+//     ~/.claude/plugins/installed_plugins.json
+//   - Surfaces a one-line status per plugin (installed | already-present | failed)
+//   - Never raises — install failures are logged but don't break the installer
+//
+// Plugin list is intentionally short. Add new defaults here when the
+// operator decides a plugin should ship as a standard ArkaOS dependency.
+
+import { existsSync, readFileSync } from "node:fs";
+import { execSync, spawnSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// Each entry is "name@marketplace" matching the `claude plugin install`
+// CLI argument format.
+export const DEFAULT_CLAUDE_PLUGINS = [
+  "frontend-design@claude-plugins-official",
+];
+
+const _INSTALLED_REGISTRY = join(
+  homedir(), ".claude", "plugins", "installed_plugins.json",
+);
+
+export function installDefaultClaudePlugins({
+  runtime = "claude-code",
+  plugins = DEFAULT_CLAUDE_PLUGINS,
+  home = homedir(),
+} = {}) {
+  if (runtime !== "claude-code") {
+    return { skipped: "runtime-not-claude-code", results: [] };
+  }
+  if (!isClaudeCliAvailable()) {
+    return { skipped: "claude-cli-not-found", results: [] };
+  }
+  const alreadyInstalled = readInstalledRegistry(home);
+  const results = plugins.map((p) =>
+    installOne(p, alreadyInstalled),
+  );
+  return { skipped: null, results };
+}
+
+function isClaudeCliAvailable() {
+  try {
+    execSync("claude --version", { stdio: "pipe", timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readInstalledRegistry(home) {
+  const path = join(home, ".claude", "plugins", "installed_plugins.json");
+  if (!existsSync(path)) {
+    return new Set();
+  }
+  try {
+    const data = JSON.parse(readFileSync(path, "utf-8"));
+    return new Set(Object.keys(data.plugins || {}));
+  } catch {
+    return new Set();
+  }
+}
+
+function installOne(plugin, alreadyInstalled) {
+  if (alreadyInstalled.has(plugin)) {
+    return { plugin, action: "already-present" };
+  }
+  // Use spawnSync so we can capture exit code without throwing on non-zero.
+  // Pass --silent equivalents if available; otherwise default verbosity is OK
+  // — the installer is interactive at install time.
+  const out = spawnSync("claude", ["plugin", "install", plugin], {
+    timeout: 60_000,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  });
+  if (out.error || out.status !== 0) {
+    const msg = (out.stderr || out.error?.message || "unknown").trim().slice(0, 200);
+    return { plugin, action: "failed", reason: msg };
+  }
+  return { plugin, action: "installed" };
+}

package/installer/index.js

@@ -311,6 +311,27 @@ export async function install({ runtime, path, force, skipSystem, withOllama })
     console.log(`         Warning: could not scaffold user-data (${err.message})`);
   }
 
+  // PR43 v2.62.0 — auto-install default Claude Code plugins. Only runs
+  // when runtime is Claude Code AND the `claude` CLI is available.
+  // Idempotent: skips plugins already in installed_plugins.json.
+  try {
+    const { installDefaultClaudePlugins } = await import("./claude-plugins.js");
+    const pluginResult = installDefaultClaudePlugins({ runtime });
+    if (!pluginResult.skipped) {
+      for (const r of pluginResult.results) {
+        if (r.action === "installed") {
+          console.log(`         ${r.plugin} installed.`);
+        } else if (r.action === "already-present") {
+          console.log(`         ${r.plugin} already installed (skipped).`);
+        } else if (r.action === "failed") {
+          console.log(`         ${r.plugin} install failed (${r.reason}).`);
+        }
+      }
+    }
+  } catch (err) {
+    console.log(`         Warning: could not install default Claude plugins (${err.message})`);
+  }
+
   const manifest = {
     version: VERSION,
     runtime,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arkaos",
-  "version": "2.61.0",
+  "version": "2.63.0",
   "description": "The Operating System for AI Agent Teams",
   "type": "module",
   "bin": {

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arkaos-core"
-version = "2.61.0"
+version = "2.63.0"
 description = "Core engine for ArkaOS — The Operating System for AI Agent Teams"
 readme = "README.md"
 license = {text = "MIT"}