chainlesschain 0.162.148 → 0.162.150

package/src/lib/settings-hook-events.cjs

@@ -19,6 +19,24 @@
 const { collectHooks } = require("./settings-hooks.cjs");
 const { runHooks } = require("./hook-runner.cjs");
 
+/**
+ * Split collected hooks into the blocking (sync) set and the fire-and-forget
+ * (`async: true`) set. Only NON-decision events should dispatch async hooks —
+ * an async hook can't gate a turn it no longer blocks, so a UserPromptSubmit
+ * hook that must be able to `block` should stay sync. The caller decides which
+ * events are eligible; this is just the partition.
+ * @returns {{ sync: Array, async: Array }}
+ */
+function partitionAsyncHooks(hooks) {
+  const sync = [];
+  const asyncHooks = [];
+  for (const h of hooks || []) {
+    if (h && h.async === true) asyncHooks.push(h);
+    else sync.push(h);
+  }
+  return { sync, async: asyncHooks };
+}
+
 /** Join the context emitted by the hooks that ran (additionalContext / plain stdout). */
 function aggregateContext(results) {
   const parts = [];
@@ -36,19 +54,32 @@ function aggregateContext(results) {
 /**
  * UserPromptSubmit settings hooks. A `block`/`ask` decision aborts the turn;
  * otherwise any emitted context is returned for the caller to inject.
+ *
+ * `async: true` hooks are EXCLUDED from this blocking run — they can't gate a
+ * turn they no longer block, so a fire-and-forget hook is dispatched separately
+ * (see dispatchAsyncHooks). This keeps the sync/decision path unchanged while a
+ * long-running check runs alongside the turn.
  * @returns {{ blocked:boolean, reason?:string, hook?:string, additionalContext:string|null }}
  */
-function runUserPromptSubmitHooks(settingsHooks, { prompt, cwd, sessionId } = {}) {
+function runUserPromptSubmitHooks(
+  settingsHooks,
+  { prompt, cwd, sessionId } = {},
+) {
   if (!settingsHooks) return { blocked: false, additionalContext: null };
   const matched = collectHooks(settingsHooks, "UserPromptSubmit", "");
   if (matched.length === 0) return { blocked: false, additionalContext: null };
+  const { sync } = partitionAsyncHooks(matched);
+  if (sync.length === 0) return { blocked: false, additionalContext: null };
   const payload = {
     hook_event_name: "UserPromptSubmit",
     prompt: String(prompt || ""),
     cwd,
     session_id: sessionId || null,
   };
-  const outcome = runHooks(matched, payload, { cwd, event: "UserPromptSubmit" });
+  const outcome = runHooks(sync, payload, {
+    cwd,
+    event: "UserPromptSubmit",
+  });
   if (outcome.decision === "block" || outcome.decision === "ask") {
     return {
       blocked: true,
@@ -57,7 +88,36 @@ function runUserPromptSubmitHooks(settingsHooks, { prompt, cwd, sessionId } = {}
       additionalContext: null,
     };
   }
-  return { blocked: false, additionalContext: aggregateContext(outcome.results) };
+  return {
+    blocked: false,
+    additionalContext: aggregateContext(outcome.results),
+  };
+}
+
+/**
+ * Dispatch the `async: true` hooks for an event fire-and-forget onto the given
+ * supervisor (see async-hook-supervisor). Sync hooks are ignored here — they run
+ * on the blocking path. No-op (returns []) without a supervisor or async hooks,
+ * so callers can wire it unconditionally.
+ *
+ * @param {object} settingsHooks   merged hooks block
+ * @param {string} event           UserPromptSubmit / PostToolUse / Stop / …
+ * @param {object} payload         extra fields merged into the hook stdin JSON
+ * @param {object} opts            { cwd, matchTarget, supervisor }
+ * @returns {Array<{command:string, dispatched:boolean, reason?:string}>}
+ */
+function dispatchAsyncHooks(settingsHooks, event, payload = {}, opts = {}) {
+  const supervisor = opts.supervisor;
+  if (!settingsHooks || !supervisor) return [];
+  const matched = collectHooks(settingsHooks, event, opts.matchTarget || "");
+  if (matched.length === 0) return [];
+  const { async: asyncHooks } = partitionAsyncHooks(matched);
+  if (asyncHooks.length === 0) return [];
+  return supervisor.dispatch(
+    asyncHooks,
+    { hook_event_name: event, cwd: opts.cwd, ...payload },
+    { cwd: opts.cwd },
+  );
 }
 
 /**
@@ -82,13 +142,23 @@ function runSessionStartHooks(settingsHooks, { source, cwd, sessionId } = {}) {
 /**
  * Generic observe-only fire (SessionEnd / Stop / PreCompact). Returns the raw
  * runHooks outcome so callers can read a block reason; never gates flow here.
+ *
+ * `async: true` hooks are EXCLUDED from this synchronous run — they are always
+ * fire-and-forget and are dispatched separately (dispatchAsyncHooks), so running
+ * them here too would double-execute them.
  */
-function runObserveHooks(settingsHooks, event, payload = {}, { cwd, matchTarget } = {}) {
+function runObserveHooks(
+  settingsHooks,
+  event,
+  payload = {},
+  { cwd, matchTarget } = {},
+) {
   if (!settingsHooks) return { decision: "continue", results: [] };
   const matched = collectHooks(settingsHooks, event, matchTarget || "");
-  if (matched.length === 0) return { decision: "continue", results: [] };
+  const { sync } = partitionAsyncHooks(matched);
+  if (sync.length === 0) return { decision: "continue", results: [] };
   return runHooks(
-    matched,
+    sync,
     { hook_event_name: event, cwd, ...payload },
     { cwd, event },
   );
@@ -99,4 +169,6 @@ module.exports = {
   runSessionStartHooks,
   runObserveHooks,
   aggregateContext,
+  partitionAsyncHooks,
+  dispatchAsyncHooks,
 };

package/src/lib/settings-hooks.cjs

@@ -39,11 +39,16 @@ const HOOK_EVENTS = Object.freeze([
   "PostToolUse",
   "UserPromptSubmit",
   "Stop",
+  "SubagentStart",
   "SubagentStop",
   "SessionStart",
+  "SessionResume",
+  "SessionPause",
   "SessionEnd",
+  "ConfigChange",
   "PreCompact",
   "Notification",
+  "PermissionRequest",
 ]);
 
 /**
@@ -210,18 +215,40 @@ function umbrellaFor(tool) {
  * matcher is tested against BOTH the CC umbrella (`Bash`) and the raw tool
  * name (`run_shell`), so settings written either way fire.
  *
- * @returns {Array<{command:string, timeout?:number}>}
+ * `async`/`asyncRewake` are carried through (default false) so the caller can
+ * split fire-and-forget hooks off the blocking path (see async-hook-supervisor).
+ * `event` is stamped on each hook so a supervisor can key runs by (event+cmd).
+ *
+ * @returns {Array<{command:string, timeout?:number, event:string,
+ *                  async:boolean, asyncRewake:boolean}>}
  */
 function collectHooks(hooksBlock, event, toolName) {
   const groups = (hooksBlock && hooksBlock[event]) || [];
   const umbrella = umbrellaFor(toolName);
   const raw = String(toolName || "");
+  // Claude-Code MCP parity: a bare server-prefix matcher (`mcp__github`) fires
+  // for EVERY tool from that server (`mcp__github__create_issue`, …). Our
+  // matcher is anchored (`^…$`), so the server prefix alone would never match a
+  // full `mcp__server__tool` name without also testing the prefix explicitly.
+  // (Users can still target one tool with the full name, or all of a server's
+  // tools with a `mcp__server*` wildcard / `/mcp__server__/` regex.)
+  let mcpServer = null;
+  if (raw.startsWith("mcp__")) {
+    const parts = raw.split("__");
+    if (parts.length >= 3) mcpServer = `${parts[0]}__${parts[1]}`;
+  }
   const out = [];
   for (const g of groups) {
     const fn = compileMatcher(g.matcher);
-    if (fn(umbrella) || (raw && fn(raw))) {
+    if (fn(umbrella) || (raw && fn(raw)) || (mcpServer && fn(mcpServer))) {
       for (const h of g.hooks)
-        out.push({ command: h.command, timeout: h.timeout });
+        out.push({
+          command: h.command,
+          timeout: h.timeout,
+          event,
+          async: h.async === true,
+          asyncRewake: h.asyncRewake === true,
+        });
     }
   }
   return out;

package/src/lib/settings-loader.cjs

@@ -300,6 +300,7 @@ function loadSettingsConfig(opts = {}) {
   const cwd = opts.cwd || process.cwd();
   let model = null;
   const env = {};
+  let sandbox = null;
   const files = [];
   for (const file of settingsPaths(cwd, opts.settingsFile)) {
     const data = readSettingsFile(file, { onWarn: opts.onWarn });
@@ -317,6 +318,14 @@ function loadSettingsConfig(opts = {}) {
         }
       }
     }
+    if (
+      data.sandbox &&
+      typeof data.sandbox === "object" &&
+      !Array.isArray(data.sandbox)
+    ) {
+      sandbox = mergeSandboxSettings(sandbox, data.sandbox);
+      contributed = true;
+    }
     if (contributed) files.push(file);
   }
   const managed = loadManagedSettings(opts);
@@ -335,9 +344,33 @@ function loadSettingsConfig(opts = {}) {
         }
       }
     }
+    if (
+      data.sandbox &&
+      typeof data.sandbox === "object" &&
+      !Array.isArray(data.sandbox)
+    ) {
+      sandbox = mergeSandboxSettings(sandbox, data.sandbox);
+      contributed = true;
+    }
     if (contributed) files.push(managed.file);
   }
-  return { model, env, files };
+  return { model, env, sandbox, files };
+}
+
+function mergeSandboxSettings(base, overlay) {
+  const out =
+    base && typeof base === "object" ? JSON.parse(JSON.stringify(base)) : {};
+  for (const [key, value] of Object.entries(overlay || {})) {
+    if (Array.isArray(value)) {
+      const previous = Array.isArray(out[key]) ? out[key] : [];
+      out[key] = [...new Set([...previous, ...value].map(String))];
+    } else if (value && typeof value === "object") {
+      out[key] = mergeSandboxSettings(out[key], value);
+    } else if (["string", "boolean", "number"].includes(typeof value)) {
+      out[key] = value;
+    }
+  }
+  return out;
 }
 
 /**
@@ -393,6 +426,7 @@ module.exports = {
   applyManagedPermissionPolicy,
   assertManagedPermissionMode,
   parseEnvList,
+  mergeSandboxSettings,
   ruleSource,
   addRule,
   scopeFile,

package/src/lib/siem-exporter.js

@@ -136,6 +136,51 @@ export function _resetState() {
   _exports.length = 0;
 }
 
+/**
+ * Rehydrate the in-memory _targets Map from the persisted siem_exports table.
+ * The CLI runs each `cc siem` subcommand in a fresh node process, so _targets
+ * starts empty every invocation. addTarget dual-writes (Map + INSERT INTO
+ * siem_exports) but every read (listTargets/exportLogs/getSIEMStats/
+ * removeTarget/setTargetStatus/listTargetsByStatus) is Map-only and nothing
+ * SELECTed the table back — so a target added in one invocation was invisible in
+ * the next (`No SIEM targets configured.`) and `siem export <id>` hard-crashed
+ * with `Target not found` for a target that genuinely exists on disk. Call after
+ * ensureSIEMTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureSIEMTables(db);
+  _targets.clear();
+  for (const r of db
+    .prepare(
+      `SELECT id, target_type, target_url, format, last_exported_log_id,
+              exported_count, last_export_at, status, config, created_at
+         FROM siem_exports ORDER BY created_at ASC`,
+    )
+    .all()) {
+    // One corrupt config cell must not sink the whole target load.
+    let config = {};
+    try {
+      config = r.config ? JSON.parse(r.config) : {};
+    } catch {
+      config = {};
+    }
+    _targets.set(r.id, {
+      id: r.id,
+      type: r.target_type,
+      url: r.target_url,
+      format: r.format,
+      exportedCount: Number(r.exported_count) || 0,
+      lastExportAt: r.last_export_at ?? null,
+      lastExportedLogId: r.last_exported_log_id ?? null,
+      status: r.status,
+      config,
+      createdAt: r.created_at,
+    });
+  }
+  return _targets.size;
+}
+
 // ═══════════════════════════════════════════════════════════════
 // V2 Canonical Surface (Phase 51)
 // ═══════════════════════════════════════════════════════════════

package/src/lib/skill-loader.js

@@ -28,6 +28,7 @@ import { getElectronUserDataDir } from "./paths.js";
 import { findProjectRoot } from "./project-detector.js";
 import { findProjectRoot as findGitRoot } from "./project-instructions.js";
 import { parseSkillMcpServers } from "./skill-mcp.js";
+import { discoverPluginSkillLayers } from "./plugin-runtime/skills.js";
 import settingsLoader from "./settings-loader.cjs";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -72,6 +73,7 @@ export const LAYER_NAMES = [
   "bundled",
   "cli-bundled",
   "marketplace",
+  "plugin",
   "managed",
   "claude-user",
   "claude-project",
@@ -82,6 +84,17 @@ export const LAYER_NAMES = [
  *  `<group>/<skill>/SKILL.md` layouts (infinite-recursion / deep-tree guard). */
 export const MAX_SKILL_NEST_DEPTH = 5;
 
+// Frontmatter keys (camelCased) that are semantically strings and are consumed
+// with string methods; they must never be number/boolean-coerced. `version` is
+// deliberately excluded — it is only string-interpolated and existing behavior
+// coerces it to a number.
+const STRING_SCALAR_FIELDS = new Set([
+  "name",
+  "displayName",
+  "description",
+  "category",
+]);
+
 /**
  * Simple YAML frontmatter parser (no dependencies)
  * Shared utility extracted from skill.js
@@ -163,8 +176,15 @@ export function parseSkillMd(content) {
         continue;
       }
 
-      // Handle booleans and numbers
-      if (value === "true") value = true;
+      // Handle booleans and numbers. These fields are string-semantic and get
+      // used with string methods downstream (skill.id.includes(),
+      // description.substring(), category/displayName.toLowerCase()); coercing a
+      // bare numeric ("2024") or boolean value to Number/Boolean makes those
+      // throw and aborts the whole `cc skill list/search/run` command on a
+      // single such skill — so never coerce them. (version stays coercible.)
+      if (STRING_SCALAR_FIELDS.has(camelKey))
+        value = value.replace(/^['"]|['"]$/g, "");
+      else if (value === "true") value = true;
       else if (value === "false") value = false;
       else if (value === "null") value = null;
       else if (/^\d+(\.\d+)?$/.test(value)) value = parseFloat(value);
@@ -312,6 +332,22 @@ export class CLISkillLoader {
       exists: fs.existsSync(marketplacePath),
     });
 
+    // Layer 1b: plugin — each installed plugin's skills/ dir (Phase 3). Sits
+    // just above marketplace so a user's managed/workspace/project skills still
+    // override a plugin's on a name collision. One entry per plugin.
+    try {
+      for (const p of discoverPluginSkillLayers({ cwd: process.cwd() })) {
+        layers.push({
+          layer: "plugin",
+          path: p.path,
+          exists: fs.existsSync(p.path),
+          plugin: p.name,
+        });
+      }
+    } catch {
+      /* plugin skill discovery is best-effort — never break skill loading */
+    }
+
     // Layer 2: managed — <userData>/skills/
     const managedPath = path.join(userData, "skills");
     layers.push({

package/src/lib/skill-marketplace.js

@@ -109,6 +109,89 @@ export function ensureMarketplaceTables(db) {
   );
 }
 
+/**
+ * Hydrate the in-memory _services/_invocations Maps from the DB. The CLI is
+ * one-shot: both start empty each process. Writes dual-write (Map + INSERT) but
+ * every read (getService/listServices/listInvocations/getInvocationStats/
+ * getMarketplaceStatsV2) and _mustGetService (record/status/invoke) is Map-only
+ * and nothing SELECTed the tables back — so a published service was invisible on
+ * the next invocation, and record/show/status threw "Service not found". Call
+ * after ensureMarketplaceTables(db).
+ *
+ * V2 timing fields (startedAt/completedAt) are not persisted → default null.
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureMarketplaceTables(db);
+  _services.clear();
+  _invocations.clear();
+
+  for (const r of db
+    .prepare(
+      `SELECT id, name, version, description, endpoint, pricing, status, owner, invocation_count, created_at, updated_at
+         FROM skill_services ORDER BY created_at ASC`,
+    )
+    .all()) {
+    // One corrupt pricing cell must not crash the whole service load.
+    let pricing = null;
+    try {
+      pricing = r.pricing ? JSON.parse(r.pricing) : null;
+    } catch {
+      pricing = null;
+    }
+    _services.set(r.id, {
+      id: r.id,
+      name: r.name,
+      version: r.version,
+      description: r.description || "",
+      endpoint: r.endpoint,
+      pricing,
+      status: r.status,
+      owner: r.owner,
+      invocationCount: Number(r.invocation_count) || 0,
+      createdAt: Number(r.created_at),
+      updatedAt: Number(r.updated_at),
+      _seq: ++_seq,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, service_id, caller_id, input, output, status, duration_ms, error, created_at
+         FROM skill_invocations ORDER BY created_at ASC`,
+    )
+    .all()) {
+    let input = null;
+    let output = null;
+    try {
+      input = r.input == null ? null : JSON.parse(r.input);
+    } catch {
+      input = r.input;
+    }
+    try {
+      output = r.output == null ? null : JSON.parse(r.output);
+    } catch {
+      output = r.output;
+    }
+    _invocations.set(r.id, {
+      id: r.id,
+      serviceId: r.service_id,
+      callerId: r.caller_id,
+      input,
+      output,
+      status: r.status,
+      durationMs: r.duration_ms == null ? null : Number(r.duration_ms),
+      error: r.error,
+      createdAt: Number(r.created_at),
+      startedAt: null,
+      completedAt: null,
+      _seq: ++_seq,
+    });
+  }
+
+  return _services.size + _invocations.size;
+}
+
 /* ── Catalogs ──────────────────────────────────────────────── */
 
 export function listServiceStatus() {

package/src/lib/sla-manager.js

@@ -484,6 +484,94 @@ export function _resetState() {
   _maxActiveSlasPerOrg = DEFAULT_MAX_ACTIVE_SLAS_PER_ORG;
 }
 
+/**
+ * Rehydrate the in-memory Maps from the persisted sla_* tables. The CLI runs
+ * each `cc sla` subcommand in a fresh node process, so _contracts/_metrics/
+ * _violations start empty every invocation. Every write dual-writes (Map +
+ * INSERT into sla_contracts/sla_metrics/sla_violations) but every read (listSLAs/
+ * getSLA/getSLAMetrics/checkViolations/listViolations/calculateCompensation/
+ * generateReport) is Map-only and nothing SELECTed the tables back — so `sla
+ * list` reported none, and `show`/`record`/`metrics`/`report` threw "SLA not
+ * found" for a contract that genuinely exists on disk. Call after
+ * ensureSlaTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureSlaTables(db);
+  _contracts.clear();
+  _metrics.clear();
+  _violations.clear();
+
+  for (const r of db
+    .prepare(
+      `SELECT sla_id, org_id, tier, terms, monthly_fee, start_date, end_date, status, created_at, updated_at
+         FROM sla_contracts ORDER BY created_at ASC`,
+    )
+    .all()) {
+    // One corrupt terms cell must not sink the whole contract list.
+    let terms = {};
+    try {
+      terms = r.terms ? JSON.parse(r.terms) : {};
+    } catch {
+      terms = {};
+    }
+    _contracts.set(r.sla_id, {
+      slaId: r.sla_id,
+      orgId: r.org_id,
+      tier: r.tier,
+      terms,
+      monthlyFee: Number(r.monthly_fee) || 0,
+      startDate: Number(r.start_date),
+      endDate: Number(r.end_date),
+      status: r.status,
+      createdAt: Number(r.created_at),
+      updatedAt: Number(r.updated_at),
+      _seq: ++_seq,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT metric_id, sla_id, term, value, recorded_at
+         FROM sla_metrics ORDER BY recorded_at ASC`,
+    )
+    .all()) {
+    if (!_metrics.has(r.sla_id)) _metrics.set(r.sla_id, []);
+    _metrics.get(r.sla_id).push({
+      metricId: r.metric_id,
+      slaId: r.sla_id,
+      term: r.term,
+      value: Number(r.value),
+      recordedAt: Number(r.recorded_at),
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT violation_id, sla_id, term, severity, expected_value, actual_value,
+              deviation_percent, compensation_amount, occurred_at, resolved_at
+         FROM sla_violations ORDER BY occurred_at ASC`,
+    )
+    .all()) {
+    _violations.set(r.violation_id, {
+      violationId: r.violation_id,
+      slaId: r.sla_id,
+      term: r.term,
+      severity: r.severity,
+      expectedValue: Number(r.expected_value),
+      actualValue: Number(r.actual_value),
+      deviationPercent:
+        r.deviation_percent == null ? null : Number(r.deviation_percent),
+      compensationAmount:
+        r.compensation_amount == null ? null : Number(r.compensation_amount),
+      occurredAt: Number(r.occurred_at),
+      resolvedAt: r.resolved_at == null ? null : Number(r.resolved_at),
+    });
+  }
+
+  return _contracts.size + _metrics.size + _violations.size;
+}
+
 /* ═══════════════════════════════════════════════════════════════
  * V2 (Phase 61) — Frozen enums + contract/violation state
  * machines + active-per-org cap + auto-expire + stats-v2.

package/src/lib/social-manager.js

@@ -54,6 +54,80 @@ export function ensureSocialTables(db) {
   `);
 }
 
+/**
+ * Hydrate the in-memory stores from the DB. The CLI is one-shot: every command
+ * runs in a fresh process, so the module-level Maps start empty. Write paths
+ * dual-write (Map + DB), but the read paths (listContacts/listFriends/listPosts/
+ * getChatMessages/getChatThreads/getSocialStats) read the Maps ONLY — so without
+ * this, a user's persisted contacts/friends/posts/messages are invisible on the
+ * next invocation. Mirrors social-graph.loadFromDb (the asymmetry tell: graph
+ * commands hydrate, social commands didn't). Call after ensureSocialTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _contacts.clear();
+  _friends.clear();
+  _posts.clear();
+  _messages.clear();
+
+  for (const r of db
+    .prepare(
+      `SELECT id, name, did, email, notes, created_at FROM social_contacts`,
+    )
+    .all()) {
+    _contacts.set(r.id, {
+      id: r.id,
+      name: r.name,
+      did: r.did || null,
+      email: r.email || null,
+      notes: r.notes || "",
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(`SELECT id, contact_id, status, created_at FROM social_friends`)
+    .all()) {
+    // Keyed by contact_id to match addFriend's _friends.set(contactId, ...).
+    _friends.set(r.contact_id, {
+      id: r.id,
+      contactId: r.contact_id,
+      status: r.status,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(`SELECT id, author, content, likes, created_at FROM social_posts`)
+    .all()) {
+    _posts.set(r.id, {
+      id: r.id,
+      author: r.author,
+      content: r.content,
+      likes: r.likes,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, thread_id, sender, recipient, content, read, created_at FROM social_messages`,
+    )
+    .all()) {
+    _messages.set(r.id, {
+      id: r.id,
+      threadId: r.thread_id,
+      sender: r.sender,
+      recipient: r.recipient,
+      content: r.content,
+      read: !!r.read,
+      createdAt: r.created_at,
+    });
+  }
+
+  return _contacts.size + _friends.size + _posts.size + _messages.size;
+}
+
 /* ── Contacts ──────────────────────────────────────────────── */
 
 export function addContact(db, name, did, email, notes) {