arkaos 4.13.2 → 4.14.0

package/VERSION

@@ -1 +1 @@
-4.13.2
+4.14.0

package/arka/SKILL.md

@@ -220,6 +220,22 @@ Users don't need to memorize commands. Just describe what you need:
    English prompt, then dispatches back through `/do`. A request that is
    already specific skips refinement.
 
+### Skill Not Installed (curated default, F2-7c)
+
+When /do resolves to a skill that is not installed (curated default;
+the long tail lives in the department plugins), the Skill tool fails.
+NEVER answer as a generic assistant or improvise the skill: look the
+slug up in `knowledge/skills-manifest.json` and reply — in the user's
+language — with the actionable install hint:
+
+```
+The <slug> skill is not in the installed curated set.
+Install the department pack: /plugin install arkaos-<dept>@arkaos
+Or restore the full set: npx arkaos update --skills full
+```
+
+Fail loud and actionable, never silently.
+
 ### Squad Routing (MUST)
 
 EVERY request routes through the appropriate department squad. ArkaOS never responds

package/bin/arka-doctor

@@ -2,7 +2,7 @@
 # ============================================================================
 # ARKA OS — Doctor (Health Check System)
 # Usage: arka doctor [--fix] [--json]
-# 17 modular checks: fail = critical, warn = advisory
+# 18 modular checks: fail = critical, warn = advisory
 # ============================================================================
 set -euo pipefail
 
@@ -376,6 +376,25 @@ for hf_name in hyperframes hyperframes-core; do
 done
 run_check "hyperframes-skills" "warn" "$HF_DESC" "$HF_OK" "Run /content video-setup in Claude Code"
 
+# ─── Check 18: SQLite corrupt-store backups (self-heal F1-D1) ──────────────
+# Parity with installer/doctor.js `sqlite-corrupt-backups`: same name,
+# same pattern, warn-only. A <db>.corrupt-<ts>.bak means a store healed
+# itself — the operator should inspect, then delete the backup.
+BAK_OK=true
+BAK_DESC="No self-healed SQLite stores awaiting inspection"
+BAK_LIST=""
+if [ -d "$HOME/.arkaos" ]; then
+  # `|| true`: set -euo pipefail must not kill the doctor when find
+  # errors or head closes the pipe early — absence of backups is fine.
+  BAK_LIST=$(find "$HOME/.arkaos" -name "*.corrupt-*.bak" -type f 2>/dev/null | head -3 || true)
+fi
+if [ -n "$BAK_LIST" ]; then
+  BAK_OK=false
+  BAK_FIRST=$(echo "$BAK_LIST" | head -1)
+  BAK_DESC="Self-healed store backup(s) found (e.g. ${BAK_FIRST##*/})"
+fi
+run_check "sqlite-corrupt-backups" "warn" "$BAK_DESC" "$BAK_OK" "Inspect then delete ~/.arkaos/**/*.corrupt-*.bak"
+
 # ─── Output ────────────────────────────────────────────────────────────────
 TOTAL=$((PASS_COUNT + WARN_COUNT + FAIL_COUNT))
 

package/config/cognition/schedules.yaml

@@ -20,6 +20,22 @@ schedules:
     max_retries: 2
     timeout_minutes: 60
 
+  session-memory-maintenance:
+    command: session-memory-maintenance
+    # F1-A4 (memory/learning reform): full embedding backfill, retention
+    # prune and VACUUM for ~/.arkaos/session-memory.db. The per-turn
+    # Stop-hook worker only amortises a small slice of this; the nightly
+    # job finishes the backlog. Cheap and idempotent; respects
+    # memory.sessionMemory + ARKA_SESSION_MEMORY=0.
+    python_module: "core.memory.turn_capture"
+    module_args: ["maintenance"]
+    time: "03:30"
+    timezone: auto
+    enabled: true
+    retry_on_fail: false
+    max_retries: 0
+    timeout_minutes: 20
+
   research:
     command: research
     prompt_file: "~/.arkaos/cognition/prompts/research.md"

package/config/hooks/_lib/fastpath/engine.cjs

@@ -0,0 +1,337 @@
+"use strict";
+/**
+ * ArkaOS hook fast-path engine (F2-6) — pure decision logic, no I/O
+ * beyond what the caller injects. Consumed by pre-tool-use.cjs and
+ * post-tool-use.cjs; exercised directly by
+ * tests/installer/gate-manifest.test.js against the SAME corpora the
+ * pytest side runs against the real Python functions.
+ *
+ * Security invariant #0: this engine has NO deny path. Every decision
+ * is either {action:"fast-allow"} on a closed, corpus-proven set, or
+ * {action:"delegate"} to the bash->Python chain. A bug here degrades
+ * to latency, never to a skipped deny.
+ *
+ * Every constant comes from the injected manifest
+ * (config/gate-manifest.json, generated by core/hooks/gate_manifest.py
+ * from the real Python gate constants). No constant may be declared in
+ * this file — that is exactly the drift the manifest exists to kill.
+ */
+
+const SCHEMA_VERSION = 1;
+
+/** Python truthiness — NOT JS Boolean(): [] and {} are falsy in Python,
+ *  "false" (non-empty string) is truthy in both. flow_enforcer coerces
+ *  hooks.hardEnforcement with bool(), so the shim must match. */
+function pythonTruthy(value) {
+  if (Array.isArray(value)) return value.length > 0;
+  if (value !== null && typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return Boolean(value);
+}
+
+/** datetime.now(timezone.utc).isoformat() shape: microseconds + +00:00.
+ *  JS has ms precision; pad to 6 digits — still fromisoformat-parseable. */
+function pyIsoNow(now) {
+  const d = now || new Date();
+  const pad = (n, w) => String(n).padStart(w, "0");
+  const micros = pad(d.getUTCMilliseconds(), 3) + "000";
+  return (
+    `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1, 2)}-` +
+    `${pad(d.getUTCDate(), 2)}T${pad(d.getUTCHours(), 2)}:` +
+    `${pad(d.getUTCMinutes(), 2)}:${pad(d.getUTCSeconds(), 2)}.` +
+    `${micros}+00:00`
+  );
+}
+
+function validateManifest(manifest) {
+  return Boolean(
+    manifest &&
+    manifest.schema_version === SCHEMA_VERSION &&
+    manifest.tools && manifest.bash && manifest.post &&
+    manifest.telemetry && manifest.io_contract
+  );
+}
+
+function compileRegex(entry) {
+  return new RegExp(entry.js, entry.flags || "");
+}
+
+/** Mirror of flow_enforcer.bash_is_effect: blacklist anywhere first,
+ *  strip VAR=val prefixes, whitelist first token, unknown → effect. */
+function bashIsEffect(command, manifest) {
+  if (!command || !command.trim()) return false;
+  const stripped = command.trim();
+  // QG B1 (redo 1): JS \s / trim / split treat U+FEFF (and other
+  // non-ASCII whitespace) as separators; Python's re \s and str.split
+  // do NOT for U+FEFF — a token like "FOO=1<U+FEFF>grep" is ONE unknown
+  // token (EFFECT) to Python but splits to a whitelisted "grep" here,
+  // a skipped deny under hard enforcement. Any whitespace-class char
+  // outside the ASCII set forces EFFECT → the shim delegates and
+  // Python classifies with its own semantics (safe: no deny path).
+  if (/[^\S \t\n\r\f\v]/.test(stripped)) return true;
+  for (const entry of manifest.bash.effect_patterns) {
+    if (compileRegex(entry).test(stripped)) return true;
+  }
+  let rest = stripped;
+  let first = rest.split(/\s+/, 1)[0] || "";
+  while (first.includes("=")) {
+    const idx = rest.search(/\s/);
+    if (idx < 0) return false;
+    rest = rest.slice(idx).trim();
+    first = rest.split(/\s+/, 1)[0] || "";
+    if (!rest) return false;
+  }
+  if (!first) return false;
+  if (manifest.bash.discovery_first_tokens.includes(first)) return false;
+  return true;
+}
+
+/** Strict session-id allowlist (core/shared/safe_session_id.py):
+ *  charset pattern + dot-only rejection. null means "never build a
+ *  filesystem path from this id". */
+function safeSessionId(sid, manifest) {
+  if (!sid || typeof sid !== "string") return null;
+  if (!compileRegex(manifest.session_id).test(sid)) return null;
+  if (manifest.session_id.reject_dot_only && /^\.+$/.test(sid)) return null;
+  return sid;
+}
+
+function readJsonFile(fs, filePath) {
+  // {state: "missing" | "corrupt" | "ok", data}
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return { state: "missing", data: null };
+  }
+  try {
+    const data = JSON.parse(raw);
+    return { state: "ok", data };
+  } catch {
+    return { state: "corrupt", data: null };
+  }
+}
+
+/** cost_governor semantics: budget active iff the section is a dict and
+ *  any cap key parses as float > 0. Missing/corrupt config → {} → no cap
+ *  (cost_governor.py:68-86). */
+function budgetActive(configResult, manifest) {
+  if (configResult.state !== "ok") return false;
+  const data = configResult.data;
+  const section =
+    data && typeof data === "object" && !Array.isArray(data)
+      ? data[manifest.flags.budget.section]
+      : null;
+  if (!section || typeof section !== "object" || Array.isArray(section)) {
+    return false;
+  }
+  for (const key of manifest.flags.budget.cap_keys) {
+    const value = Number(section[key]);
+    if (Number.isFinite(value) && value > 0) return true;
+  }
+  return false;
+}
+
+/** flow_enforcer._feature_flag_on: missing file → false, corrupt →
+ *  false, else python-truthy of hooks.hardEnforcement. */
+function hardEnforcementOn(configResult, manifest) {
+  if (configResult.state !== "ok") return false;
+  const [section, key] = manifest.flags.hardEnforcement.path;
+  const data = configResult.data;
+  const hooks =
+    data && typeof data === "object" && !Array.isArray(data)
+      ? data[section]
+      : null;
+  if (!hooks || typeof hooks !== "object" || Array.isArray(hooks)) {
+    return false;
+  }
+  return pythonTruthy(hooks[key]);
+}
+
+function telemetryLine(prefix, template, now) {
+  return JSON.stringify({ ...prefix, ...template }) + "\n";
+}
+
+/**
+ * PreToolUse decision. Returns
+ *   {action:"fast-allow", writes:[{path, line}]} — exit 0, empty stdout
+ *   {action:"delegate", reason} — spawn the sibling .sh
+ * ctx: {homeDir, config: readJsonFile result for ~/.arkaos/config.json,
+ *       now?: Date}
+ */
+function decidePre(payload, manifest, ctx) {
+  if (!validateManifest(manifest)) {
+    return { action: "delegate", reason: "manifest-invalid" };
+  }
+  const toolName = String(payload.tool_name || "");
+  const tools = manifest.tools;
+
+  // P3 — research tools can deny (2nd violation) + vault rglob nudge.
+  if (tools.research_external.includes(toolName)) {
+    return { action: "delegate", reason: "research-gated" };
+  }
+
+  // P4 — not flow-gated: no Python gate ever denies these; the only
+  // parity duty is the kb_first telemetry append (research_gate
+  // record_telemetry runs for every tool).
+  if (!tools.flow_gated.includes(toolName)) {
+    return {
+      action: "fast-allow",
+      writes: [kbFirstWrite(payload, manifest, ctx, toolName)],
+    };
+  }
+
+  // P5/P6/P7 — Bash: discovery commands are allow-with-telemetry before
+  // any flag/bypass check (flow_enforcer.py:456-463); budget must be
+  // provably inactive because cost_governor runs first for flow-gated
+  // tools and can warn/deny.
+  if (toolName === "Bash") {
+    const command = String(
+      (payload.tool_input && payload.tool_input.command) || ""
+    );
+    if (!bashIsEffect(command, manifest) && !budgetActive(ctx.config, manifest)) {
+      return {
+        action: "fast-allow",
+        writes: [
+          kbFirstWrite(payload, manifest, ctx, toolName),
+          enforcementWrite(payload, manifest, ctx, toolName),
+        ],
+      };
+    }
+    return { action: "delegate", reason: "bash-effect-or-budget" };
+  }
+
+  // P7/P8 — Write/Edit/MultiEdit/NotebookEdit/Task/Skill: specialist +
+  // frontend + flow chains with decision-bearing state writes.
+  return { action: "delegate", reason: "flow-gated" };
+}
+
+function kbFirstWrite(payload, manifest, ctx, toolName) {
+  const t = manifest.telemetry;
+  return {
+    path: `${ctx.homeDir}/${manifest.home_paths.telemetry_kb_first}`,
+    line: telemetryLine(
+      {
+        ts: pyIsoNow(ctx.now),
+        session_id: String(payload.session_id || ""),
+        tool: toolName,
+      },
+      t.kb_first_template
+    ),
+  };
+}
+
+function enforcementWrite(payload, manifest, ctx, toolName) {
+  const t = manifest.telemetry;
+  return {
+    path: `${ctx.homeDir}/${manifest.home_paths.telemetry_enforcement}`,
+    line: telemetryLine(
+      {
+        ts: pyIsoNow(ctx.now),
+        session_id: String(payload.session_id || ""),
+        tool: toolName,
+        cwd: String(payload.cwd || ""),
+      },
+      t.enforcement_template
+    ),
+  };
+}
+
+/** Flow-auth freshness (Q6): auth file exists, valid JSON, numeric
+ *  confirmed_ts within TTL. Anything else → not fresh → delegate. */
+function flowAuthFresh(sid, manifest, ctx) {
+  const safe = safeSessionId(sid, manifest);
+  if (!safe) return false;
+  const dirs = manifest.state_dirs;
+  const override = (ctx.env[dirs.flow_auth_env_override] || "").trim();
+  const base = override ||
+    `${dirs.tmp_base_posix}/${dirs.flow_auth_dirname}`;
+  const result = readJsonFile(ctx.fs, `${base}/${safe}.json`);
+  if (result.state !== "ok" || !result.data) return false;
+  const ts = result.data.confirmed_ts;
+  if (typeof ts !== "number" || !Number.isFinite(ts)) return false;
+  const nowSeconds = (ctx.now ? ctx.now.getTime() : Date.now()) / 1000;
+  return nowSeconds - ts <= manifest.numbers.auth_ttl_seconds;
+}
+
+/**
+ * PostToolUse decision. Returns
+ *   {action:"fast-exit", stdout:"{}", writes:[...]} — mcp telemetry only
+ *   {action:"delegate", reason}
+ * ctx: {homeDir, config, env, fs, now?: Date}
+ */
+function decidePost(payload, manifest, ctx) {
+  if (!validateManifest(manifest)) {
+    return { action: "delegate", reason: "manifest-invalid" };
+  }
+  const toolName = String(payload.tool_name || "");
+
+  // Q3/Q4 — plan approval (G2) + subagent tracking live in Python.
+  if (manifest.tools.post_delegate_always.includes(toolName)) {
+    return { action: "delegate", reason: "post-stateful-tool" };
+  }
+
+  // Q5 — error path: gotchas, violations, cognition capture, metrics.
+  const exitCode = String(payload.exit_code ?? "") || "0";
+  if (!manifest.post.success_exit_codes.includes(exitCode)) {
+    return { action: "delegate", reason: "error-exit-code" };
+  }
+  const toolOutput = String(payload.tool_output ?? "");
+  if (compileRegex(manifest.post.error_trigger).test(toolOutput)) {
+    return { action: "delegate", reason: "error-trigger" };
+  }
+
+  // Q6/Q7 — the only remaining Python work on this path is the flow-auth
+  // confirm rescan. Redundant when enforcement is off (the pre-side flag
+  // check short-circuits before ever reading auth) or when a confirmed
+  // auth is fresh; load-bearing otherwise (GRACE_CAP exhaustion) →
+  // delegate.
+  const sid = String(payload.session_id || "");
+  const enforcementOff =
+    ctx.config.state !== "missing"
+      ? !hardEnforcementOn(ctx.config, manifest)
+      : true; // missing config file → flag definitively false
+  if (!enforcementOff && !flowAuthFresh(sid, manifest, ctx)) {
+    return { action: "delegate", reason: "flow-auth-not-fresh" };
+  }
+
+  const writes = [];
+  const prefix = manifest.telemetry.mcp_prefix;
+  if (toolName.startsWith(prefix)) {
+    const rest = toolName.slice(prefix.length);
+    const sep = rest.indexOf("__");
+    const server = sep > 0 ? rest.slice(0, sep) : "";
+    const tool = sep > 0 ? rest.slice(sep + 2) : "";
+    if (server && tool) {
+      writes.push({
+        path: `${ctx.homeDir}/${manifest.home_paths.telemetry_mcp}`,
+        line: JSON.stringify({
+          ts: pyIsoNow(ctx.now),
+          server,
+          tool,
+          session: sid,
+        }) + "\n",
+      });
+    }
+  }
+  return {
+    action: "fast-exit",
+    stdout: manifest.io_contract.post.success_stdout,
+    writes,
+  };
+}
+
+module.exports = {
+  bashIsEffect,
+  budgetActive,
+  decidePost,
+  decidePre,
+  flowAuthFresh,
+  hardEnforcementOn,
+  pyIsoNow,
+  pythonTruthy,
+  readJsonFile,
+  safeSessionId,
+  validateManifest,
+};