@wrongstack/core 0.297.0 → 0.298.0

package/dist/plugin/index.js

@@ -179,6 +179,15 @@ var init_errors = __esm({
   }
 });
 
+// src/security/file-permissions.ts
+var SECRET_FILE_MODE;
+var init_file_permissions = __esm({
+  "src/security/file-permissions.ts"() {
+    "use strict";
+    SECRET_FILE_MODE = 384;
+  }
+});
+
 // src/utils/atomic-write.ts
 import {
   createPersistencePrimitives
@@ -278,6 +287,7 @@ var FINDING_RESOLVED_RETENTION_MS, FINDING_IGNORED_RETENTION_MS, FINDING_DEFAULT
 var init_review_finding_store = __esm({
   "src/plugins/review-finding-store.ts"() {
     "use strict";
+    init_file_permissions();
     init_atomic_write();
     init_review_finding_types();
     FINDING_RESOLVED_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
@@ -298,33 +308,49 @@ var init_review_finding_store = __esm({
       async upsert(newFindings, context) {
         if (newFindings.length === 0) return { created: 0, relinked: 0, reopened: 0 };
         const result = { created: 0, relinked: 0, reopened: 0 };
-        const existing = await this._readAll();
         return withFileLock(this.filePath, async () => {
+          const existing = await this._readAll();
           for (const finding of newFindings) {
             const match = existing.find((e) => e.finding.fingerprint === finding.fingerprint);
             if (match) {
               const materialized = this._materialize(match);
               if (materialized.status === "resolved" || materialized.status === "ignored") {
-                const reopenEvent = this._makeEvent(match.finding.id, "reopened", materialized.status, "active", context);
+                const reopenEvent = this._makeEvent(
+                  match.finding.id,
+                  "reopened",
+                  materialized.status,
+                  "active",
+                  context
+                );
                 match.finding.status = "active";
                 match.finding.resolution = void 0;
                 const updatedRecord = { __finding: 1, data: match.finding };
                 await fsp2.appendFile(
                   this.filePath,
                   JSON.stringify(updatedRecord) + LINE_SEPARATOR + JSON.stringify({ __findingEvent: 1, data: reopenEvent }) + LINE_SEPARATOR,
-                  "utf8"
+                  { encoding: "utf8", mode: SECRET_FILE_MODE }
                 );
                 result.reopened++;
               } else {
-                const relinkEvent = this._makeEvent(match.finding.id, "relinked", match.finding.status, match.finding.status, context);
-                await fsp2.appendFile(this.filePath, JSON.stringify({ __findingEvent: 1, data: relinkEvent }) + LINE_SEPARATOR, "utf8");
+                const relinkEvent = this._makeEvent(
+                  match.finding.id,
+                  "relinked",
+                  match.finding.status,
+                  match.finding.status,
+                  context
+                );
+                await fsp2.appendFile(
+                  this.filePath,
+                  JSON.stringify({ __findingEvent: 1, data: relinkEvent }) + LINE_SEPARATOR,
+                  { encoding: "utf8", mode: SECRET_FILE_MODE }
+                );
                 result.relinked++;
               }
             } else {
               const record = { __finding: 1, data: finding };
               const createdEvent = this._makeEvent(finding.id, "created", null, "active", context);
               const lines = JSON.stringify(record) + LINE_SEPARATOR + JSON.stringify({ __findingEvent: 1, data: createdEvent }) + LINE_SEPARATOR;
-              await fsp2.appendFile(this.filePath, lines, "utf8");
+              await fsp2.appendFile(this.filePath, lines, { encoding: "utf8", mode: SECRET_FILE_MODE });
               result.created++;
             }
           }
@@ -332,39 +358,41 @@ var init_review_finding_store = __esm({
         });
       }
       async transition(findingId, to, actor, opts) {
-        const all = await this._readAll();
-        const entry = all.find((e) => e.finding.id === findingId);
-        if (!entry) throw new Error(`Finding not found: ${findingId}`);
-        const from = entry.finding.status;
-        validateTransition(from, to);
-        validateResolution(to, opts?.outcome);
-        const event = {
-          id: randomUUID3(),
-          findingId,
-          eventType: to === "resolved" ? "resolved" : to === "ignored" ? "ignored" : this._eventTypeFor(to),
-          fromStatus: from,
-          toStatus: to,
-          actorId: actor.id,
-          actorKind: actor.kind,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          reason: opts?.reason
-        };
-        entry.finding.status = to;
-        if (to === "resolved" && opts?.outcome) {
-          entry.finding.resolution = {
-            outcome: opts.outcome,
-            resolvedAt: event.timestamp,
-            resolvedBy: actor.id,
-            notes: opts.reason
+        return withFileLock(this.filePath, async () => {
+          const all = await this._readAll();
+          const entry = all.find((e) => e.finding.id === findingId);
+          if (!entry) throw new Error(`Finding not found: ${findingId}`);
+          const from = this._materialize(entry).status;
+          validateTransition(from, to);
+          validateResolution(to, opts?.outcome);
+          const event = {
+            id: randomUUID3(),
+            findingId,
+            eventType: to === "resolved" ? "resolved" : to === "ignored" ? "ignored" : this._eventTypeFor(to),
+            fromStatus: from,
+            toStatus: to,
+            actorId: actor.id,
+            actorKind: actor.kind,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            reason: opts?.reason
           };
-        }
-        const updatedRecord = { __finding: 1, data: entry.finding };
-        await fsp2.appendFile(
-          this.filePath,
-          JSON.stringify(updatedRecord) + LINE_SEPARATOR + JSON.stringify({ __findingEvent: 1, data: event }) + LINE_SEPARATOR,
-          "utf8"
-        );
-        return { ...entry.finding };
+          entry.finding.status = to;
+          if (to === "resolved" && opts?.outcome) {
+            entry.finding.resolution = {
+              outcome: opts.outcome,
+              resolvedAt: event.timestamp,
+              resolvedBy: actor.id,
+              notes: opts.reason
+            };
+          }
+          const updatedRecord = { __finding: 1, data: entry.finding };
+          await fsp2.appendFile(
+            this.filePath,
+            JSON.stringify(updatedRecord) + LINE_SEPARATOR + JSON.stringify({ __findingEvent: 1, data: event }) + LINE_SEPARATOR,
+            { encoding: "utf8", mode: SECRET_FILE_MODE }
+          );
+          return { ...entry.finding };
+        });
       }
       async list(opts) {
         const all = await this._readAll();
@@ -384,7 +412,12 @@ var init_review_finding_store = __esm({
         if (opts?.reportId) {
           findings = findings.filter((f) => f.originReport.reportId === opts.reportId);
         }
-        const severityRank = { critical: 0, high: 1, medium: 2, low: 3 };
+        const severityRank = {
+          critical: 0,
+          high: 1,
+          medium: 2,
+          low: 3
+        };
         findings.sort((a, b) => {
           const sa = severityRank[a.severity] - severityRank[b.severity];
           if (sa !== 0) return sa;
@@ -415,46 +448,57 @@ var init_review_finding_store = __esm({
         return events.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
       }
       async compact(opts) {
-        const resolvedMaxAge = opts?.resolvedMaxAgeMs ?? FINDING_RESOLVED_RETENTION_MS;
-        const ignoredMaxAge = opts?.ignoredMaxAgeMs ?? FINDING_IGNORED_RETENTION_MS;
-        const now = Date.now();
-        const all = await this._readAll();
-        const kept = [];
-        let removed = 0;
-        let eventsFolded = 0;
-        for (const entry of all) {
-          const age = now - new Date(entry.finding.createdAt).getTime();
-          const isResolved = entry.finding.status === "resolved";
-          const isIgnored = entry.finding.status === "ignored";
-          const maxAge = isResolved ? resolvedMaxAge : isIgnored ? ignoredMaxAge : Infinity;
-          if (age > maxAge && (isResolved || isIgnored)) {
-            removed++;
-            eventsFolded += entry.events.length;
-            continue;
-          }
-          const oldEvents = entry.events.filter((ev) => now - new Date(ev.timestamp).getTime() > maxAge);
-          if (oldEvents.length > 1) {
-            eventsFolded += oldEvents.length - 1;
-            const newestOld = oldEvents.sort((a, b) => b.timestamp.localeCompare(a.timestamp))[0];
-            entry.events = [newestOld, ...entry.events.filter((ev) => now - new Date(ev.timestamp).getTime() <= maxAge)];
+        return withFileLock(this.filePath, async () => {
+          const resolvedMaxAge = opts?.resolvedMaxAgeMs ?? FINDING_RESOLVED_RETENTION_MS;
+          const ignoredMaxAge = opts?.ignoredMaxAgeMs ?? FINDING_IGNORED_RETENTION_MS;
+          const now = Date.now();
+          const all = await this._readAll();
+          const kept = [];
+          let removed = 0;
+          let eventsFolded = 0;
+          for (const entry of all) {
+            const age = now - new Date(entry.finding.createdAt).getTime();
+            const isResolved = entry.finding.status === "resolved";
+            const isIgnored = entry.finding.status === "ignored";
+            const maxAge = isResolved ? resolvedMaxAge : isIgnored ? ignoredMaxAge : Infinity;
+            if (age > maxAge && (isResolved || isIgnored)) {
+              removed++;
+              eventsFolded += entry.events.length;
+              continue;
+            }
+            const oldEvents = entry.events.filter(
+              (ev) => now - new Date(ev.timestamp).getTime() > maxAge
+            );
+            if (oldEvents.length > 1) {
+              eventsFolded += oldEvents.length - 1;
+              const newestOld = oldEvents.sort((a, b) => b.timestamp.localeCompare(a.timestamp))[0];
+              entry.events = [
+                newestOld,
+                ...entry.events.filter((ev) => now - new Date(ev.timestamp).getTime() <= maxAge)
+              ];
+            }
+            kept.push({ record: { __finding: 1, data: entry.finding }, events: entry.events });
           }
-          kept.push({ record: { __finding: 1, data: entry.finding }, events: entry.events });
-        }
-        const lines = [];
-        for (const { record, events } of kept) {
-          if (record) lines.push(JSON.stringify(record));
-          for (const ev of events) {
-            lines.push(JSON.stringify({ __findingEvent: 1, data: ev }));
+          const lines = [];
+          for (const { record, events } of kept) {
+            if (record) lines.push(JSON.stringify(record));
+            for (const ev of events) {
+              lines.push(JSON.stringify({ __findingEvent: 1, data: ev }));
+            }
           }
-        }
-        lines.push(JSON.stringify({
-          __findingCompact: 1,
-          compactedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          removedFindings: removed,
-          foldedEvents: eventsFolded
-        }));
-        await atomicWrite(this.filePath, lines.join(LINE_SEPARATOR) + LINE_SEPARATOR, { mode: 384 });
-        return { removed, eventsFolded };
+          lines.push(
+            JSON.stringify({
+              __findingCompact: 1,
+              compactedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              removedFindings: removed,
+              foldedEvents: eventsFolded
+            })
+          );
+          await atomicWrite(this.filePath, lines.join(LINE_SEPARATOR) + LINE_SEPARATOR, {
+            mode: 384
+          });
+          return { removed, eventsFolded };
+        });
       }
       // ── Private helpers ──────────────────────────────────────────────
       async _readAllLines() {
@@ -600,6 +644,7 @@ var REPORT_RETENTION_MS, REPORT_DEFAULT_PAGE_SIZE, NL2, REPORT_STORE_FILE, Jsonl
 var init_review_report_store = __esm({
   "src/plugins/review-report-store.ts"() {
     "use strict";
+    init_file_permissions();
     init_atomic_write();
     init_review_report_types();
     REPORT_RETENTION_MS = 90 * 24 * 60 * 60 * 1e3;
@@ -628,11 +673,10 @@ var init_review_report_store = __esm({
               rawText: input.rawText || existing.rawText,
               files: input.files.length > 0 ? input.files : existing.files
             };
-            await fsp3.appendFile(
-              this.filePath,
-              JSON.stringify({ __report: 1, data: updated }) + NL2,
-              "utf8"
-            );
+            await fsp3.appendFile(this.filePath, JSON.stringify({ __report: 1, data: updated }) + NL2, {
+              encoding: "utf8",
+              mode: SECRET_FILE_MODE
+            });
             return updated;
           }
           const report = {
@@ -663,57 +707,60 @@ var init_review_report_store = __esm({
             timestamp: report.reviewedAt
           };
           const lines = JSON.stringify({ __report: 1, data: report }) + NL2 + JSON.stringify({ __reportEvent: 1, data: createdEvent }) + NL2;
-          await fsp3.appendFile(this.filePath, lines, "utf8");
+          await fsp3.appendFile(this.filePath, lines, { encoding: "utf8", mode: SECRET_FILE_MODE });
           return report;
         });
       }
       // ── Lifecycle transitions ────────────────────────────────────────
       async transition(reportId, to, actor, opts) {
-        const all = await this._readAll();
-        const entry = all.find((e) => e.report.id === reportId);
-        if (!entry) throw new Error(`Review report not found: ${reportId}`);
-        const from = this._materialize(entry).lifecycle;
-        validateReportTransition(from, to);
-        const event = {
-          id: randomUUID5(),
-          reportId,
-          eventType: reportEventTypeFor(to),
-          fromLifecycle: from,
-          toLifecycle: to,
-          actorId: actor.id,
-          actorKind: actor.kind,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          reason: opts?.reason
-        };
-        entry.report.lifecycle = to;
-        await fsp3.appendFile(
-          this.filePath,
-          JSON.stringify({ __reportEvent: 1, data: event }) + NL2,
-          "utf8"
-        );
-        return { ...entry.report };
+        return withFileLock(this.filePath, async () => {
+          const all = await this._readAll();
+          const entry = all.find((e) => e.report.id === reportId);
+          if (!entry) throw new Error(`Review report not found: ${reportId}`);
+          const from = this._materialize(entry).lifecycle;
+          validateReportTransition(from, to);
+          const event = {
+            id: randomUUID5(),
+            reportId,
+            eventType: reportEventTypeFor(to),
+            fromLifecycle: from,
+            toLifecycle: to,
+            actorId: actor.id,
+            actorKind: actor.kind,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            reason: opts?.reason
+          };
+          entry.report.lifecycle = to;
+          await fsp3.appendFile(this.filePath, JSON.stringify({ __reportEvent: 1, data: event }) + NL2, {
+            encoding: "utf8",
+            mode: SECRET_FILE_MODE
+          });
+          return { ...entry.report };
+        });
       }
       async addNote(reportId, actor, note) {
-        const all = await this._readAll();
-        const entry = all.find((e) => e.report.id === reportId);
-        if (!entry) throw new Error(`Review report not found: ${reportId}`);
-        const event = {
-          id: randomUUID5(),
-          reportId,
-          eventType: "note_added",
-          fromLifecycle: entry.report.lifecycle,
-          toLifecycle: entry.report.lifecycle,
-          actorId: actor.id,
-          actorKind: actor.kind,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          reason: note
-        };
-        await fsp3.appendFile(
-          this.filePath,
-          JSON.stringify({ __reportEvent: 1, data: event }) + NL2,
-          "utf8"
-        );
-        return { ...entry.report };
+        return withFileLock(this.filePath, async () => {
+          const all = await this._readAll();
+          const entry = all.find((e) => e.report.id === reportId);
+          if (!entry) throw new Error(`Review report not found: ${reportId}`);
+          const materialized = this._materialize(entry);
+          const event = {
+            id: randomUUID5(),
+            reportId,
+            eventType: "note_added",
+            fromLifecycle: materialized.lifecycle,
+            toLifecycle: materialized.lifecycle,
+            actorId: actor.id,
+            actorKind: actor.kind,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            reason: note
+          };
+          await fsp3.appendFile(this.filePath, JSON.stringify({ __reportEvent: 1, data: event }) + NL2, {
+            encoding: "utf8",
+            mode: SECRET_FILE_MODE
+          });
+          return materialized;
+        });
       }
       // ── Query ────────────────────────────────────────────────────────
       async list(opts) {
@@ -752,44 +799,53 @@ var init_review_report_store = __esm({
       }
       // ── Compaction ───────────────────────────────────────────────────
       async compact(opts) {
-        const maxAge = opts?.maxAgeMs ?? REPORT_RETENTION_MS;
-        const now = Date.now();
-        const all = await this._readAll();
-        const kept = [];
-        let removed = 0;
-        let eventsFolded = 0;
-        for (const entry of all) {
-          const age = now - new Date(entry.report.reviewedAt).getTime();
-          const materialized = this._materialize(entry);
-          const isTerminal = materialized.lifecycle === "completed" || materialized.lifecycle === "skipped";
-          if (isTerminal && age > maxAge) {
-            removed++;
-            eventsFolded += entry.events.length;
-            continue;
-          }
-          const oldEvents = entry.events.filter((ev) => now - new Date(ev.timestamp).getTime() > maxAge);
-          if (oldEvents.length > 1) {
-            eventsFolded += oldEvents.length - 1;
-            const newestOld = oldEvents.sort((a, b) => b.timestamp.localeCompare(a.timestamp))[0];
-            entry.events = [newestOld, ...entry.events.filter((ev) => now - new Date(ev.timestamp).getTime() <= maxAge)];
+        return withFileLock(this.filePath, async () => {
+          const maxAge = opts?.maxAgeMs ?? REPORT_RETENTION_MS;
+          const now = Date.now();
+          const all = await this._readAll();
+          const kept = [];
+          let removed = 0;
+          let eventsFolded = 0;
+          for (const entry of all) {
+            const age = now - new Date(entry.report.reviewedAt).getTime();
+            const materialized = this._materialize(entry);
+            const isTerminal = materialized.lifecycle === "completed" || materialized.lifecycle === "skipped";
+            if (isTerminal && age > maxAge) {
+              removed++;
+              eventsFolded += entry.events.length;
+              continue;
+            }
+            const oldEvents = entry.events.filter(
+              (ev) => now - new Date(ev.timestamp).getTime() > maxAge
+            );
+            if (oldEvents.length > 1) {
+              eventsFolded += oldEvents.length - 1;
+              const newestOld = oldEvents.sort((a, b) => b.timestamp.localeCompare(a.timestamp))[0];
+              entry.events = [
+                newestOld,
+                ...entry.events.filter((ev) => now - new Date(ev.timestamp).getTime() <= maxAge)
+              ];
+            }
+            kept.push({ record: { __report: 1, data: entry.report }, events: entry.events });
           }
-          kept.push({ record: { __report: 1, data: entry.report }, events: entry.events });
-        }
-        const lines = [];
-        for (const { record, events } of kept) {
-          if (record) lines.push(JSON.stringify(record));
-          for (const ev of events) {
-            lines.push(JSON.stringify({ __reportEvent: 1, data: ev }));
+          const lines = [];
+          for (const { record, events } of kept) {
+            if (record) lines.push(JSON.stringify(record));
+            for (const ev of events) {
+              lines.push(JSON.stringify({ __reportEvent: 1, data: ev }));
+            }
           }
-        }
-        lines.push(JSON.stringify({
-          __reportCompact: 1,
-          compactedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          removedReports: removed,
-          foldedEvents: eventsFolded
-        }));
-        await atomicWrite(this.filePath, lines.join(NL2) + NL2, { mode: 384 });
-        return { removed, eventsFolded };
+          lines.push(
+            JSON.stringify({
+              __reportCompact: 1,
+              compactedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              removedReports: removed,
+              foldedEvents: eventsFolded
+            })
+          );
+          await atomicWrite(this.filePath, lines.join(NL2) + NL2, { mode: 384 });
+          return { removed, eventsFolded };
+        });
       }
       // ── Private helpers ──────────────────────────────────────────────
       async _readAllLines() {
@@ -1079,10 +1135,10 @@ function validateAgainstSchema(value, schema) {
   return { ok: errors.length === 0, errors };
 }
 var MAX_SCHEMA_DEPTH = 64;
-function walk(value, schema, path28, errors, depth) {
+function walk(value, schema, path29, errors, depth) {
   if (depth > MAX_SCHEMA_DEPTH) {
     errors.push({
-      path: path28 || "<root>",
+      path: path29 || "<root>",
       message: `schema nesting exceeds maximum depth (${MAX_SCHEMA_DEPTH})`
     });
     return;
@@ -1090,7 +1146,7 @@ function walk(value, schema, path28, errors, depth) {
   if (schema.enum !== void 0) {
     if (!enumIncludes(schema.enum, value)) {
       errors.push({
-        path: path28 || "<root>",
+        path: path29 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -1099,7 +1155,7 @@ function walk(value, schema, path28, errors, depth) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path28 || "<root>",
+        path: path29 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)} (${previewValue(value)})`
       });
       return;
@@ -1111,7 +1167,7 @@ function walk(value, schema, path28, errors, depth) {
       if (!(req in obj)) {
         const expected = schema.properties?.[req]?.type;
         errors.push({
-          path: joinPath(path28, req),
+          path: joinPath(path29, req),
           message: `required property missing${typeof expected === "string" ? ` (expected ${expected})` : ""}`
         });
       }
@@ -1119,14 +1175,14 @@ function walk(value, schema, path28, errors, depth) {
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path28, key), errors, depth + 1);
+          walk(obj[key], subSchema, joinPath(path29, key), errors, depth + 1);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
     for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path28}[${i}]`, errors, depth + 1);
+      walk(value[i], schema.items, `${path29}[${i}]`, errors, depth + 1);
     }
   }
 }
@@ -2054,23 +2110,6 @@ import { createHash as createHash7 } from "node:crypto";
 import * as fsp from "node:fs/promises";
 import * as path14 from "node:path";
 
-// src/core/model-ref.ts
-function parseModelRef(ref) {
-  const trimmed = ref.trim();
-  const slash = trimmed.indexOf("/");
-  if (slash !== -1) {
-    return {
-      provider: trimmed.slice(0, slash) || void 0,
-      model: trimmed.slice(slash + 1).trim()
-    };
-  }
-  const parts = trimmed.split(/\s+/);
-  if (parts.length >= 2) {
-    return { provider: parts[0], model: parts.slice(1).join(" ") };
-  }
-  return { model: trimmed };
-}
-
 // src/core/model-availability-calendar.ts
 function logicalCalendarTarget(providerId, model) {
   if (providerId !== "omniroute") return { providerId, model };
@@ -2149,6 +2188,23 @@ function evaluateModelCalendar(rules, providerId, model, at = /* @__PURE__ */ ne
   return { allowed: true };
 }
 
+// src/core/model-ref.ts
+function parseModelRef(ref) {
+  const trimmed = ref.trim();
+  const slash = trimmed.indexOf("/");
+  if (slash !== -1) {
+    return {
+      provider: trimmed.slice(0, slash) || void 0,
+      model: trimmed.slice(slash + 1).trim()
+    };
+  }
+  const parts = trimmed.split(/\s+/);
+  if (parts.length >= 2) {
+    return { provider: parts[0], model: parts.slice(1).join(" ") };
+  }
+  return { model: trimmed };
+}
+
 // src/core/fallback-profile-manager.ts
 function hasText(value) {
   return typeof value === "string" && value.trim().length > 0;
@@ -2249,18 +2305,42 @@ var FallbackProfileManager = class {
    * Mirrors the previous `effectiveFallbackChain()` logic but centralized.
    */
   resolveEffective(opts = {}) {
+    const bridge = this.resolveBridge(opts.exclude);
+    let selected = FREEZER_EMPTY;
     if (opts.fallbackModels && opts.fallbackModels.length > 0) {
       const resolved = this.resolveRefs(opts.fallbackModels, opts.exclude);
-      if (resolved.length > 0) return resolved;
+      if (resolved.length > 0) selected = resolved;
     }
-    if (opts.fallbackProfile) {
+    if (selected.length === 0 && opts.fallbackProfile) {
       const resolved = this.resolve(opts.fallbackProfile, { exclude: opts.exclude });
-      if (resolved.length > 0) return resolved;
+      if (resolved.length > 0) selected = resolved;
     }
-    if (opts.fallbackAuto !== false) {
-      return this.smartDefault(opts.exclude);
+    if (selected.length === 0 && opts.fallbackAuto !== false) {
+      selected = this.smartDefault(opts.exclude);
     }
-    return FREEZER_EMPTY;
+    if (bridge.length === 0) return selected;
+    if (selected.length === 0) return bridge;
+    const seen = new Set(bridge.map((entry) => `${entry.providerId}/${entry.model}`));
+    return Object.freeze([
+      ...bridge,
+      ...selected.filter((entry) => !seen.has(`${entry.providerId}/${entry.model}`))
+    ]);
+  }
+  /** Resolve the optional, fully-qualified emergency continuity route. */
+  resolveBridge(exclude) {
+    const ref = this.config.fallbackBridge?.trim();
+    if (!ref) return FREEZER_EMPTY;
+    const parsed = parseModelRef(ref);
+    if (!parsed.provider || !parsed.model) return FREEZER_EMPTY;
+    return this.resolveRefs([ref], exclude);
+  }
+  /**
+   * Resolve every usable configured target as an uncapped last-resort chain.
+   * Normal smart defaults stay bounded; callers append this only after the
+   * preferred chain and only when automatic fallback is enabled.
+   */
+  resolveAllConfigured(exclude) {
+    return this.smartDefault(exclude, Number.POSITIVE_INFINITY);
   }
   // ── Provider availability (read-only) ──────────────────────────────────
   checkProvider(providerId) {
@@ -2319,7 +2399,7 @@ var FallbackProfileManager = class {
    * explicit is set. Same-provider alternatives first, then cross-provider.
    * Limited to 4 entries to avoid burning through models on a transient blip.
    */
-  smartDefault(exclude) {
+  smartDefault(exclude, maxCandidates = 4) {
     const leaderProvider = this.config.provider;
     const leaderModel = this.config.model;
     const providers = this.config.providers ?? {};
@@ -2360,8 +2440,18 @@ var FallbackProfileManager = class {
         (id === leaderProvider ? sameProvider : crossProvider).push(ref);
       }
     }
-    const MAX = 4;
-    const all = [...favorites, ...sameProvider, ...crossProvider].slice(0, MAX);
+    const ordered = [...favorites, ...sameProvider, ...crossProvider];
+    const all = Number.isFinite(maxCandidates) ? ordered.slice(0, Math.max(0, maxCandidates)) : [...ordered];
+    const firstCrossProvider = ordered.find((ref) => {
+      const parsed = parseModelRef(ref);
+      return (parsed.provider ?? leaderProvider) !== leaderProvider;
+    });
+    if (all.length > 0 && firstCrossProvider && !all.some((ref) => {
+      const parsed = parseModelRef(ref);
+      return (parsed.provider ?? leaderProvider) !== leaderProvider;
+    })) {
+      all[all.length - 1] = firstCrossProvider;
+    }
     return Object.freeze(
       all.map((ref) => {
         const p = parseModelRef(ref);
@@ -2618,6 +2708,7 @@ function stableId(prefix, value) {
 }
 
 // src/chronicle/journal.ts
+init_file_permissions();
 init_atomic_write();
 import { randomUUID } from "node:crypto";
 import { createReadStream } from "node:fs";
@@ -2682,7 +2773,16 @@ var ChronicleJournal = class {
   drainPromise;
   drainScheduled = false;
   drainTimer;
-  counters = { acceptedEvents: 0, persistedEvents: 0, rejectedEvents: 0, failedEvents: 0, batches: 0, maxObservedPending: 0, largestBatch: 0, partitionRolls: 0 };
+  counters = {
+    acceptedEvents: 0,
+    persistedEvents: 0,
+    rejectedEvents: 0,
+    failedEvents: 0,
+    batches: 0,
+    maxObservedPending: 0,
+    largestBatch: 0,
+    partitionRolls: 0
+  };
   lastBatchDurationMs;
   partitionIndex = 0;
   partitionStartedAt;
@@ -2708,18 +2808,27 @@ var ChronicleJournal = class {
     return this.partitionIndex === 0 ? this.basePath : rotatedPath(this.basePath, this.partitionIndex);
   }
   stats() {
-    return { ...this.counters, pendingEvents: this.pending.length, ...this.lastBatchDurationMs !== void 0 ? { lastBatchDurationMs: this.lastBatchDurationMs } : {} };
+    return {
+      ...this.counters,
+      pendingEvents: this.pending.length,
+      ...this.lastBatchDurationMs !== void 0 ? { lastBatchDurationMs: this.lastBatchDurationMs } : {}
+    };
   }
   append(input) {
     if (this.pending.length >= this.maxPending) {
       this.counters.rejectedEvents++;
-      return Promise.reject(new Error(`Chronicle backpressure limit reached (${this.maxPending} pending events)`));
+      return Promise.reject(
+        new Error(`Chronicle backpressure limit reached (${this.maxPending} pending events)`)
+      );
     }
     const promise = new Promise((resolve16, reject) => {
       this.pending.push({ input, resolve: resolve16, reject });
     });
     this.counters.acceptedEvents++;
-    this.counters.maxObservedPending = Math.max(this.counters.maxObservedPending, this.pending.length);
+    this.counters.maxObservedPending = Math.max(
+      this.counters.maxObservedPending,
+      this.pending.length
+    );
     this.scheduleDrain();
     return promise;
   }
@@ -2745,7 +2854,8 @@ var ChronicleJournal = class {
     await this.flush();
     const files = await collectPartitions(this.basePath);
     const checkpointResult = await readRetentionCheckpoint(this.basePath);
-    if (checkpointResult.error) return { ok: false, entries: 0, brokenAt: 0, reason: checkpointResult.error };
+    if (checkpointResult.error)
+      return { ok: false, entries: 0, brokenAt: 0, reason: checkpointResult.error };
     return verifyPartitionFiles(files, checkpointResult.checkpoint);
   }
   async purge(options) {
@@ -2763,7 +2873,10 @@ var ChronicleJournal = class {
     for (const suppliedPath of new Set(suppliedFiles)) {
       const file = path4.resolve(suppliedPath);
       if (!isJournalPartition(file, path4.dirname(this.basePath), this.basePath)) {
-        errors.push({ file: suppliedPath, reason: "not a Chronicle journal partition in this journal directory" });
+        errors.push({
+          file: suppliedPath,
+          reason: "not a Chronicle journal partition in this journal directory"
+        });
         sc++;
         continue;
       }
@@ -2812,8 +2925,12 @@ var ChronicleJournal = class {
             const checkpointResult = await readRetentionCheckpoint(familyBase);
             if (checkpointResult.error) throw new Error(checkpointResult.error);
             const checkpoint = checkpointResult.checkpoint;
-            const nextCheckpoint = await verifyRetainedPrefix(streamEntriesStrict(file), checkpoint);
-            if (!nextCheckpoint) throw new Error("partition does not extend the trusted Chronicle chain");
+            const nextCheckpoint = await verifyRetainedPrefix(
+              streamEntriesStrict(file),
+              checkpoint
+            );
+            if (!nextCheckpoint)
+              throw new Error("partition does not extend the trusted Chronicle chain");
             if (nextCheckpoint.sequence > (checkpoint?.sequence ?? 0)) {
               await writeRetentionCheckpoint(familyBase, nextCheckpoint);
             }
@@ -2833,7 +2950,13 @@ var ChronicleJournal = class {
         }
       }
     }
-    return { deletedCount: dc, deletedBytes: db, skippedCount: sc, errors, ...options.dryRun ? { candidates } : {} };
+    return {
+      deletedCount: dc,
+      deletedBytes: db,
+      skippedCount: sc,
+      errors,
+      ...options.dryRun ? { candidates } : {}
+    };
   }
   async maybeAutoPurge() {
     if (this.retentionDays <= 0) return;
@@ -2909,7 +3032,8 @@ var ChronicleJournal = class {
       this.rotate();
       return;
     }
-    if (Number.isFinite(this.maxPartitionSizeBytes) && this.partitionSizeBytes >= this.maxPartitionSizeBytes) this.rotate();
+    if (Number.isFinite(this.maxPartitionSizeBytes) && this.partitionSizeBytes >= this.maxPartitionSizeBytes)
+      this.rotate();
   }
   rotate() {
     this.partitionIndex++;
@@ -2930,13 +3054,23 @@ var ChronicleJournal = class {
         let prev = this.lastSequence > 0 ? { sequence: this.lastSequence, hash: this.lastHash } : void 0;
         recorded = batch.map(({ input }) => {
           const instant = this.now().toISOString();
-          const uh = { ...input, occurredAt: input.occurredAt ?? instant, monotonicNs: input.monotonicNs ?? this.monotonicNow().toString(), schemaVersion: CHRONICLE_SCHEMA_VERSION, eventId: this.idFactory(), observedAt: instant, persistedAt: instant, sequence: (prev?.sequence ?? 0) + 1, previousHash: prev?.hash ?? GENESIS_HASH };
+          const uh = {
+            ...input,
+            occurredAt: input.occurredAt ?? instant,
+            monotonicNs: input.monotonicNs ?? this.monotonicNow().toString(),
+            schemaVersion: CHRONICLE_SCHEMA_VERSION,
+            eventId: this.idFactory(),
+            observedAt: instant,
+            persistedAt: instant,
+            sequence: (prev?.sequence ?? 0) + 1,
+            previousHash: prev?.hash ?? GENESIS_HASH
+          };
           const event = { ...uh, hash: hashValue(uh) };
           prev = event;
           return event;
         });
         const serialized = recorded.map((e) => JSON.stringify(e)).join("\n") + "\n";
-        await fs2.appendFile(cp, serialized, "utf8");
+        await fs2.appendFile(cp, serialized, { encoding: "utf8", mode: SECRET_FILE_MODE });
         this.partitionSizeBytes += Buffer.byteLength(serialized);
       });
       const last = recorded[recorded.length - 1];
@@ -2972,7 +3106,8 @@ async function collectPartitions(basePath) {
   const result = [];
   try {
     const entries = await fs2.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) if (entry.isFile() && pattern.test(entry.name)) result.push(path4.join(dir, entry.name));
+    for (const entry of entries)
+      if (entry.isFile() && pattern.test(entry.name)) result.push(path4.join(dir, entry.name));
   } catch {
   }
   const baseFile = path4.join(dir, base + ext);
@@ -3047,23 +3182,42 @@ async function verifyPartitionFiles(files, checkpoint) {
       for await (const entry of streamEntriesStrict(file)) {
         const { hash: recordedHash, ...content } = entry;
         if (entry.sequence <= checkpointSequence) {
-          if (hashValue(content) !== recordedHash) return { ok: false, entries, brokenAt: entries, reason: "entry hash mismatch" };
+          if (hashValue(content) !== recordedHash)
+            return { ok: false, entries, brokenAt: entries, reason: "entry hash mismatch" };
           if (coveredPrevious && entry.sequence !== coveredPrevious.sequence + 1) {
-            return { ok: false, entries, brokenAt: entries, reason: `sequence ${entry.sequence} is not ${coveredPrevious.sequence + 1}` };
+            return {
+              ok: false,
+              entries,
+              brokenAt: entries,
+              reason: `sequence ${entry.sequence} is not ${coveredPrevious.sequence + 1}`
+            };
           }
           if (coveredPrevious && entry.previousHash !== coveredPrevious.hash) {
             return { ok: false, entries, brokenAt: entries, reason: "previous hash mismatch" };
           }
           if (entry.sequence === checkpointSequence && recordedHash !== checkpoint?.hash) {
-            return { ok: false, entries, brokenAt: entries, reason: "retention checkpoint hash mismatch" };
+            return {
+              ok: false,
+              entries,
+              brokenAt: entries,
+              reason: "retention checkpoint hash mismatch"
+            };
           }
           coveredPrevious = entry;
           continue;
         }
         const index = entries++;
-        if (entry.sequence !== lastSequence + 1) return { ok: false, entries, brokenAt: index, reason: `sequence ${entry.sequence} is not ${lastSequence + 1}` };
-        if (entry.previousHash !== previousHash) return { ok: false, entries, brokenAt: index, reason: "previous hash mismatch" };
-        if (hashValue(content) !== recordedHash) return { ok: false, entries, brokenAt: index, reason: "entry hash mismatch" };
+        if (entry.sequence !== lastSequence + 1)
+          return {
+            ok: false,
+            entries,
+            brokenAt: index,
+            reason: `sequence ${entry.sequence} is not ${lastSequence + 1}`
+          };
+        if (entry.previousHash !== previousHash)
+          return { ok: false, entries, brokenAt: index, reason: "previous hash mismatch" };
+        if (hashValue(content) !== recordedHash)
+          return { ok: false, entries, brokenAt: index, reason: "entry hash mismatch" };
         previousHash = recordedHash;
         lastSequence = entry.sequence;
       }
@@ -3096,7 +3250,9 @@ async function readRetentionCheckpoint(basePath) {
 }
 async function writeRetentionCheckpoint(basePath, checkpoint) {
   await atomicWrite(retentionCheckpointPath(basePath), `${JSON.stringify(checkpoint)}
-`, { mode: 384 });
+`, {
+    mode: 384
+  });
 }
 function isHash(value) {
   return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
@@ -3121,8 +3277,8 @@ async function readLastEntryState(filePath) {
     throw error;
   }
   try {
-    const stat6 = await handle.stat();
-    const size = stat6.size;
+    const stat7 = await handle.stat();
+    const size = stat7.size;
     let position = size, suffix = "";
     while (position > 0) {
       const length = Math.min(65536, position);
@@ -3136,13 +3292,17 @@ async function readLastEntryState(filePath) {
         const trimmed = lines[i].trim();
         if (!trimmed) continue;
         try {
-          return { entry: JSON.parse(trimmed), size, birthtimeMs: stat6.birthtimeMs };
+          return {
+            entry: JSON.parse(trimmed),
+            size,
+            birthtimeMs: stat7.birthtimeMs
+          };
         } catch {
         }
       }
       suffix = lines[0] ?? "";
     }
-    return { size, birthtimeMs: stat6.birthtimeMs };
+    return { size, birthtimeMs: stat7.birthtimeMs };
   } finally {
     await handle.close();
   }
@@ -3561,8 +3721,8 @@ async function* reverseLines(filePath, maxBytes) {
     return;
   }
   try {
-    const fileSize = (await handle.stat()).size;
-    const size = Math.min(fileSize, maxBytes ?? fileSize);
+    const fileSize2 = (await handle.stat()).size;
+    const size = Math.min(fileSize2, maxBytes ?? fileSize2);
     let position = size;
     let suffix = Buffer.alloc(0);
     while (position > 0) {
@@ -4925,6 +5085,14 @@ var SKILL_LIMITS = {
    * Consumer: `downloadGitHubTarball`.
    */
   MAX_TARBALL_SIZE: 50 * 1024 * 1024,
+  /**
+   * Maximum size of a GitHub skill tarball after gzip decompression. The
+   * compressed download limit alone does not protect against highly
+   * compressible archives expanding until the process runs out of memory.
+   *
+   * Consumer: `downloadGitHubTarball`.
+   */
+  MAX_UNCOMPRESSED_TARBALL_SIZE: 64 * 1024 * 1024,
   /**
    * Default total char budget for skill bodies injected in eager mode when
    * `config.skills.eagerMaxChars` is unset. ~6k tokens. Skills are injected
@@ -4936,6 +5104,17 @@ var SKILL_LIMITS = {
    * `skillEagerMaxChars`).
    */
   EAGER_DEFAULT_MAX_CHARS: 24e3,
+  /**
+   * Default total char budget for compact (token-saving) skill bodies injected
+   * by `buildCompactSkillBodiesText`. Mirrors the eager ceiling so compact mode
+   * can never inject more total skill text than eager mode. Before this bound
+   * existed, compact mode injected EVERY skill's compact body with no cap, so
+   * the section grew linearly with the number of installed skills. Skills past
+   * the budget overflow to a name list the agent loads via the `skill` tool.
+   *
+   * Consumer: `buildCompactSkillBodiesText` (default for its `budget` param).
+   */
+  COMPACT_DEFAULT_MAX_CHARS: 24e3,
   /**
    * Auto-compact body limits (the token-saving fallback used when a skill has
    * no hand-crafted `SKILL.save.md`). The Overview and Rules sections are
@@ -4964,34 +5143,148 @@ var SKILL_LIMITS = {
   SKILL_BODY_LINE_LIMIT: 500
 };
 
-// src/utils/instruction-file.ts
-import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
-import * as path9 from "node:path";
-import { fileURLToPath } from "node:url";
-var textCache = /* @__PURE__ */ new Map();
-var rootCandidates;
-function readBundledInstructionText(relativePath) {
-  const cached = textCache.get(relativePath);
-  if (cached !== void 0) return cached;
-  let resolved = "";
-  for (const root of instructionRootCandidates()) {
-    try {
-      resolved = readFileSync2(path9.join(root, relativePath), "utf8").trimEnd();
-      break;
-    } catch {
+// src/skills/frontmatter.ts
+var SCALAR_KEYS = /* @__PURE__ */ new Set(["name", "description", "trigger", "version", "license", "compatibility"]);
+function parseSkillFrontmatter(raw) {
+  const text = normalizeLineEndings(raw);
+  if (!text.startsWith("---")) return {};
+  const end = text.indexOf("\n---", 4);
+  if (end === -1) return {};
+  return parseFrontmatterBlock(text.slice(4, end));
+}
+function stripFrontmatter(raw) {
+  const text = normalizeLineEndings(raw);
+  if (!text.startsWith("---")) return text;
+  const end = text.indexOf("\n---", 4);
+  if (end === -1) return text;
+  let body = text.slice(end + 4);
+  if (body.startsWith("\n")) body = body.slice(1);
+  return body;
+}
+function normalizeLineEndings(s) {
+  return s.replace(/\r\n?/g, "\n");
+}
+function parseFrontmatterBlock(block) {
+  const out = {};
+  const lines = block.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const m = /^([a-zA-Z][a-zA-Z0-9_-]*):\s*(.*)$/.exec(line);
+    if (!m) {
+      i++;
+      continue;
+    }
+    const key = m[1] ?? "";
+    const rest = (m[2] ?? "").trim();
+    if (key === "metadata") {
+      const map = {};
+      i++;
+      while (i < lines.length) {
+        const sub = lines[i] ?? "";
+        const sm = /^\s+([a-zA-Z0-9_.-]+):\s*(.*)$/.exec(sub);
+        if (!sm) break;
+        map[sm[1] ?? ""] = unquote((sm[2] ?? "").trim());
+        i++;
+      }
+      if (Object.keys(map).length > 0) out.metadata = map;
+      continue;
+    }
+    if (rest === "|" || rest === ">") {
+      const collected = [];
+      i++;
+      while (i < lines.length) {
+        const sub = lines[i] ?? "";
+        if (sub === "" || sub.startsWith(" ") || sub.startsWith("	")) {
+          collected.push(sub.replace(/^\s+/, ""));
+          i++;
+        } else break;
+      }
+      out[normalizeKey2(key)] = collected.join("\n").trim();
+      continue;
+    }
+    if (key === "allowed-tools" || key === "allowedTools") {
+      out.allowedTools = rest.split(/[\s,]+/).filter(Boolean);
+      i++;
+      continue;
+    }
+    if (SCALAR_KEYS.has(key)) {
+      out[key] = unquote(rest);
+      i++;
+      continue;
     }
+    i++;
   }
-  textCache.set(relativePath, resolved);
-  return resolved;
+  return out;
 }
-function renderInstructionTemplate(template, values) {
-  return template.replace(
-    /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g,
-    (match, key) => Object.hasOwn(values, key) ? values[key] ?? "" : match
-  );
+function normalizeKey2(key) {
+  return key === "allowed-tools" ? "allowedTools" : key;
 }
-function instructionRootCandidates() {
-  if (rootCandidates !== void 0) return rootCandidates;
+function unquote(s) {
+  if (s.length >= 2 && (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function isValidSkillNameFormat(name) {
+  return name.length >= 1 && name.length <= 64 && /^[a-z0-9]+(-[a-z0-9]+)*$/.test(name);
+}
+function validateSkillName(name, parentDirName) {
+  const errors = [];
+  if (!name || name.trim().length === 0) {
+    errors.push("name is empty");
+    return errors;
+  }
+  if (name.length > 64) errors.push(`name is ${name.length} characters (max 64)`);
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(name)) {
+    errors.push(
+      "name must be lowercase letters, digits, and single hyphens only (no leading/trailing/consecutive hyphens)"
+    );
+  }
+  if (parentDirName !== void 0 && name !== parentDirName) {
+    errors.push(`name "${name}" must match its parent directory "${parentDirName}"`);
+  }
+  return errors;
+}
+
+// src/core/system-prompt-skill-text.ts
+function capSkillBody(body) {
+  const max = SKILL_LIMITS.MAX_SKILL_BODY_CHARS;
+  if (body.length <= max) return body;
+  const budget = max - 1;
+  const cut = body.lastIndexOf("\n\n", budget);
+  const truncated = cut > budget / 2 ? body.slice(0, cut) : body.slice(0, budget);
+  return truncated + "\u2026";
+}
+
+// src/utils/instruction-file.ts
+import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import * as path9 from "node:path";
+import { fileURLToPath } from "node:url";
+var textCache = /* @__PURE__ */ new Map();
+var rootCandidates;
+function readBundledInstructionText(relativePath) {
+  const cached = textCache.get(relativePath);
+  if (cached !== void 0) return cached;
+  let resolved = "";
+  for (const root of instructionRootCandidates()) {
+    try {
+      resolved = readFileSync2(path9.join(root, relativePath), "utf8").trimEnd();
+      break;
+    } catch {
+    }
+  }
+  textCache.set(relativePath, resolved);
+  return resolved;
+}
+function renderInstructionTemplate(template, values) {
+  return template.replace(
+    /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g,
+    (match, key) => Object.hasOwn(values, key) ? values[key] ?? "" : match
+  );
+}
+function instructionRootCandidates() {
+  if (rootCandidates !== void 0) return rootCandidates;
   const here = path9.dirname(fileURLToPath(import.meta.url));
   const candidates = [
     path9.resolve(here, "../../instructions"),
@@ -5786,6 +6079,7 @@ function encodeChronicleProjectServerMessage(message) {
 }
 
 // src/chronicle/project-server-endpoint.ts
+var CHRONICLE_PROJECT_SERVER_METADATA_FILE = "server.json";
 function normalizedPath(value) {
   const resolved = path11.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
@@ -5804,6 +6098,9 @@ function chronicleProjectServerEndpoint(projectDir) {
     `${key}.sock`
   );
 }
+function chronicleProjectServerMetadataPath(projectDir) {
+  return path11.join(projectDir, "chronicle", CHRONICLE_PROJECT_SERVER_METADATA_FILE);
+}
 
 // src/chronicle/project-server-client.ts
 var CONNECT_ATTEMPT_TIMEOUT_MS = 750;
@@ -5858,6 +6155,8 @@ var ChronicleProjectServerClient = class {
   connectResolve = null;
   connectReject = null;
   nextId = 1;
+  /** WS-027: read from the owner-only metadata file — see currentAuthToken. */
+  authToken;
   pending = /* @__PURE__ */ new Map();
   async call(op, args, options = {}) {
     await this.ensureConnected(true);
@@ -5940,6 +6239,7 @@ var ChronicleProjectServerClient = class {
   connectOnce() {
     this.socket?.destroy();
     this.socket = null;
+    this.authToken = void 0;
     this.info = null;
     this.buffer = "";
     return new Promise((resolve16, reject) => {
@@ -5970,13 +6270,42 @@ var ChronicleProjectServerClient = class {
       socket.on("close", () => this.onClose(socket));
     });
   }
+  /**
+   * WS-027: the per-process token, read from the daemon's owner-only metadata
+   * file — never from the `hello` frame, which the daemon sends to every
+   * socket that connects (the mistake WS-028 found in the SAGE daemon).
+   *
+   * Read lazily and re-read while unknown: the daemon starts listening before
+   * it writes metadata (endpoint ownership has to be won first), and a
+   * respawned daemon mints a new token, so a cached wrong one would be sticky.
+   */
+  currentAuthToken() {
+    if (this.authToken === void 0) {
+      try {
+        const raw = fs7.readFileSync(
+          chronicleProjectServerMetadataPath(this.options.projectDir),
+          "utf8"
+        );
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.authToken === "string" && parsed.authToken.length > 0) {
+          this.authToken = parsed.authToken;
+        }
+      } catch {
+      }
+    }
+    return this.authToken;
+  }
   request(message, timeoutMs) {
     const socket = this.socket;
     if (!socket || socket.destroyed) {
       return Promise.reject(new Error("Chronicle project server connection is unavailable"));
     }
     const id = this.nextId++;
-    const encoded = encodeChronicleProjectServerMessage({ ...message, id });
+    const encoded = encodeChronicleProjectServerMessage({
+      ...message,
+      id,
+      authToken: this.currentAuthToken()
+    });
     if (encoded.length > CHRONICLE_PROJECT_SERVER_MAX_FRAME_CHARS) {
       return Promise.reject(new Error("Chronicle project server request exceeded frame limit"));
     }
@@ -6554,7 +6883,12 @@ function selectRoundRobinReviewerAssignment(pool, cursor, fallbackProvider = "",
 }
 function resolveAutoReviewConfig(cfg, sessionConfig) {
   const mgr = new FallbackProfileManager(sessionConfig);
-  const chain = cfg.fallbackProfile ? mgr.resolve(cfg.fallbackProfile) : mgr.resolveEffective({ fallbackAuto: true });
+  const chain = mgr.resolveEffective({
+    ...cfg.fallbackProfile ? { fallbackProfile: cfg.fallbackProfile, fallbackAuto: false } : {
+      fallbackModels: sessionConfig.fallbackModels,
+      fallbackAuto: sessionConfig.fallbackAuto
+    }
+  });
   const rawProvider = cfg.provider?.trim();
   const rawModel = cfg.model?.trim();
   const resolvedProvider = rawProvider || (chain.length > 0 ? chain[0].providerId : sessionConfig.provider);
@@ -6698,8 +7032,8 @@ async function snapshotChangedFiles(cwd) {
     if (file.path.startsWith(".wrongstack/")) continue;
     if (budget <= 0) break;
     try {
-      const stat6 = await fsp.stat(path14.join(cwd, file.path));
-      if (!stat6.isFile() || stat6.size > MAX_SNAPSHOT_FILE_BYTES) continue;
+      const stat7 = await fsp.stat(path14.join(cwd, file.path));
+      if (!stat7.isFile() || stat7.size > MAX_SNAPSHOT_FILE_BYTES) continue;
       const content = await fsp.readFile(path14.join(cwd, file.path), "utf8");
       budget -= content.length;
       snapshots.push({
@@ -7157,7 +7491,6 @@ function createAutoReviewPlugin() {
 
 // src/plugins/chimera-plugin.ts
 init_error();
-import { randomUUID as randomUUID6 } from "node:crypto";
 import { spawn as spawn4 } from "node:child_process";
 import * as fsp4 from "node:fs/promises";
 import * as os5 from "node:os";
@@ -7233,10 +7566,20 @@ function parseFindingSegment(segment, severity, context) {
   if (tagMatch) {
     remaining = content.slice(tagMatch[0].length).trim();
   }
+  const citationMatch = remaining.match(
+    /^(`+)([a-zA-Z_./\\:][^`]*[a-zA-Z0-9_./\\:])\1(?=\s*[—–-]|\s*$)/
+  );
+  if (citationMatch) {
+    const inner = citationMatch[2];
+    const afterCitation = remaining.slice(citationMatch[0].length);
+    remaining = `${inner}${afterCitation}`;
+  }
   let file;
   let line;
   let desc = remaining;
-  const refMatch = remaining.match(/^(.+?)(?::(\d+))?\s*[—–-]\s*(.+)$/);
+  const refMatch = remaining.match(
+    /^([a-zA-Z_./\\][a-zA-Z0-9_./\\-]*\.\w+)(?::(\d+))?\s+(?:[—–]|-)\s+(.+)$/
+  );
   if (refMatch) {
     file = refMatch[1].trim();
     if (refMatch[2] !== void 0) {
@@ -7334,12 +7677,26 @@ async function persistReviewReport(payload, reportId, projectDir) {
     ...cascadeDepth !== void 0 ? { cascadeDepth } : {}
   };
   await store.persist(input);
+  if (reviewStatus === "success" && parsed.findings.length === 0 && parsed.unparseableCount === 0 && isExplicitAllClearReview(payload.reviewText)) {
+    await store.transition(
+      reportId,
+      "completed",
+      { id: "chimera", kind: "system" },
+      {
+        reason: "Successful Chimera review produced no actionable findings"
+      }
+    );
+  }
   return {
     reportId,
     created: !existed,
     totalFindings: parsed.findings.length
   };
 }
+function isExplicitAllClearReview(text) {
+  const normalized = text.trim().toLowerCase();
+  return normalized.startsWith("## \u{1F982} chimera review \u2014 all clear") || normalized.includes("chimera review: all clear");
+}
 async function syncReportCompletion(reportId, projectDir, actor) {
   const reportStore = new JsonlReportStore(projectDir);
   const findingStore = new JsonlFindingStore(projectDir);
@@ -7812,49 +8169,6 @@ async function showStatus(ctx) {
   ].join("\n");
 }
 
-// src/plugins/review-finding-integration.ts
-init_review_finding_store();
-async function integrateFindings(payload, projectDir, reportId) {
-  if (!payload.reviewText || payload.reviewText.trim().length === 0) {
-    return { created: 0, relinked: 0, reopened: 0, totalFindings: 0, unparseableCount: 0 };
-  }
-  const store = new JsonlFindingStore(projectDir);
-  const source = (payload.bundle.cascadeDepth ?? 0) > 0 ? "cascade" : payload.bundle.cascadeOn !== void 0 && payload.bundle.cascadeOn !== "off" ? "auto" : "chimera";
-  const agentId = payload.bundle.fileProvenance?.find((entry) => entry.agentId)?.agentId ?? "chimera-review";
-  const sessionId = payload.sessionId ?? payload.cwd;
-  const model = payload.bundle.config.model;
-  const parsed = parseChimeraReviewReport(payload.reviewText, {
-    sessionId,
-    agentId,
-    reviewerModel: model,
-    reviewType: source,
-    reportId
-  });
-  if (parsed.findings.length === 0) {
-    return {
-      created: 0,
-      relinked: 0,
-      reopened: 0,
-      totalFindings: 0,
-      unparseableCount: parsed.unparseableCount
-    };
-  }
-  const result = await store.upsert(parsed.findings, {
-    sessionId,
-    reportId,
-    agentId,
-    model
-  });
-  return {
-    created: result.created,
-    relinked: result.relinked,
-    reopened: result.reopened,
-    reportId,
-    totalFindings: parsed.findings.length,
-    unparseableCount: parsed.unparseableCount
-  };
-}
-
 // src/plugins/chimera-plugin.ts
 var DEFAULT_MAX_FILES = 15;
 var DEFAULT_CASCADE_ON = "off";
@@ -8010,18 +8324,6 @@ function buildReviewCommand(_getConfig) {
     }
   };
 }
-async function tryPersistFindings(payload) {
-  if (!payload || typeof payload !== "object") return;
-  const p = payload;
-  const cwd = p.cwd ?? p.bundle?.cwd;
-  if (!cwd) return;
-  const slug = projectSlug(cwd);
-  const globalRoot = path17.join(os5.homedir(), ".wrongstack");
-  const projectDir = path17.join(globalRoot, "projects", slug);
-  const reportId = randomUUID6();
-  await persistReviewReport(payload, reportId, projectDir);
-  await integrateFindings(payload, projectDir, reportId);
-}
 function createChimeraPlugin() {
   return {
     name: "wstack-chimera",
@@ -8050,9 +8352,6 @@ function createChimeraPlugin() {
       });
       api.onPattern("chimera.review_complete", (_event, payload) => {
         recordCompletedReview(api.events, payload);
-        tryPersistFindings(payload).catch((err) => {
-          api.log.warn(`[review-finding] failed to persist findings: ${toErrorMessage(err)}`);
-        });
       });
       if (!resolved.enabled) {
         api.log.info("[chimera] disabled by config");
@@ -8634,8 +8933,8 @@ var PromptUsageStore = class {
   }
   async fileSignature() {
     try {
-      const stat6 = await fs10.stat(this.file);
-      return { size: stat6.size, mtimeMs: stat6.mtimeMs, ctimeMs: stat6.ctimeMs };
+      const stat7 = await fs10.stat(this.file);
+      return { size: stat7.size, mtimeMs: stat7.mtimeMs, ctimeMs: stat7.ctimeMs };
     } catch {
       return null;
     }
@@ -9045,12 +9344,12 @@ function parseFlags(input) {
   while (s.startsWith("--") && (m = flagRe.exec(s))) {
     const name = expectDefined(m[1]);
     const rawVal = m[2] ?? m[3] ?? "true";
-    flags[name] = unquote(rawVal);
+    flags[name] = unquote2(rawVal);
     s = s.slice(m[0].length);
   }
   return { flags, positional: s.trim() };
 }
-function unquote(v) {
+function unquote2(v) {
   if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
     return v.slice(1, -1);
   }
@@ -9089,7 +9388,7 @@ function parseKeyValues(kvs) {
   const out = {};
   for (const kv of kvs) {
     const eq = kv.indexOf("=");
-    if (eq > 0) out[kv.slice(0, eq)] = unquote(kv.slice(eq + 1));
+    if (eq > 0) out[kv.slice(0, eq)] = unquote2(kv.slice(eq + 1));
   }
   return out;
 }
@@ -9109,9 +9408,123 @@ function dim(s) {
   return `\x1B[2m${s}\x1B[0m`;
 }
 
+// src/plugins/review-finding-integration.ts
+init_review_finding_store();
+async function integrateFindings(payload, projectDir, reportId) {
+  if (!payload.reviewText || payload.reviewText.trim().length === 0) {
+    return { created: 0, relinked: 0, reopened: 0, totalFindings: 0, unparseableCount: 0 };
+  }
+  const store = new JsonlFindingStore(projectDir);
+  const source = (payload.bundle.cascadeDepth ?? 0) > 0 ? "cascade" : payload.bundle.cascadeOn !== void 0 && payload.bundle.cascadeOn !== "off" ? "auto" : "chimera";
+  const agentId = payload.bundle.fileProvenance?.find((entry) => entry.agentId)?.agentId ?? "chimera-review";
+  const sessionId = payload.sessionId ?? payload.cwd;
+  const model = payload.bundle.config.model;
+  const parsed = parseChimeraReviewReport(payload.reviewText, {
+    sessionId,
+    agentId,
+    reviewerModel: model,
+    reviewType: source,
+    reportId
+  });
+  if (parsed.findings.length === 0) {
+    return {
+      created: 0,
+      relinked: 0,
+      reopened: 0,
+      totalFindings: 0,
+      unparseableCount: parsed.unparseableCount
+    };
+  }
+  const result = await store.upsert(parsed.findings, {
+    sessionId,
+    reportId,
+    agentId,
+    model
+  });
+  return {
+    created: result.created,
+    relinked: result.relinked,
+    reopened: result.reopened,
+    reportId,
+    totalFindings: parsed.findings.length,
+    unparseableCount: parsed.unparseableCount
+  };
+}
+
+// src/plugins/review-store-maintenance.ts
+init_atomic_write();
+init_review_finding_store();
+init_review_report_store();
+import * as fsp5 from "node:fs/promises";
+import * as path21 from "node:path";
+var REVIEW_STORE_COMPACTION_THRESHOLD_BYTES = 8 * 1024 * 1024;
+var REVIEW_STORE_COMPACTION_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var REVIEW_STORE_MAINTENANCE_FILE = ".review-store-maintenance.json";
+async function maybeCompactReviewStores(projectDir, opts = {}) {
+  const thresholdBytes = opts.thresholdBytes ?? REVIEW_STORE_COMPACTION_THRESHOLD_BYTES;
+  const intervalMs = opts.intervalMs ?? REVIEW_STORE_COMPACTION_INTERVAL_MS;
+  const now = opts.now ?? Date.now();
+  const maintenancePath = path21.join(projectDir, REVIEW_STORE_MAINTENANCE_FILE);
+  return withFileLock(maintenancePath, async () => {
+    const totalBytes = await fileSize(resolveReportStorePath(projectDir)) + await fileSize(resolveFindingStorePath(projectDir));
+    if (totalBytes < thresholdBytes) {
+      return emptyResult("below_threshold", totalBytes);
+    }
+    const state = await readMaintenanceState(maintenancePath);
+    if (state && now - new Date(state.compactedAt).getTime() < intervalMs) {
+      return emptyResult("interval", totalBytes);
+    }
+    const reportResult = await new JsonlReportStore(projectDir).compact();
+    const findingResult = await new JsonlFindingStore(projectDir).compact();
+    const nextState = {
+      compactedAt: new Date(now).toISOString(),
+      totalBytesBefore: totalBytes
+    };
+    await atomicWrite(maintenancePath, `${JSON.stringify(nextState)}
+`, { mode: 384 });
+    return {
+      compacted: true,
+      totalBytes,
+      reason: "compacted",
+      removedReports: reportResult.removed,
+      removedFindings: findingResult.removed,
+      eventsFolded: reportResult.eventsFolded + findingResult.eventsFolded
+    };
+  });
+}
+function emptyResult(reason, totalBytes) {
+  return {
+    compacted: false,
+    totalBytes,
+    reason,
+    removedReports: 0,
+    removedFindings: 0,
+    eventsFolded: 0
+  };
+}
+async function fileSize(filePath) {
+  try {
+    return (await fsp5.stat(filePath)).size;
+  } catch (error) {
+    if (error.code === "ENOENT") return 0;
+    throw error;
+  }
+}
+async function readMaintenanceState(filePath) {
+  try {
+    const parsed = JSON.parse(await fsp5.readFile(filePath, "utf8"));
+    return typeof parsed.compactedAt === "string" && Number.isFinite(parsed.totalBytesBefore) ? parsed : null;
+  } catch (error) {
+    if (error.code === "ENOENT" || error instanceof SyntaxError) {
+      return null;
+    }
+    throw error;
+  }
+}
+
 // src/plugins/skills-plugin.ts
 import * as os7 from "node:os";
-import * as path25 from "node:path";
+import * as path26 from "node:path";
 
 // src/skills/foreign-sources.ts
 var FOREIGN_SKILL_TOOLS = [
@@ -9294,104 +9707,7 @@ function numField(rec, key) {
 init_errors();
 import { spawn as spawn5 } from "node:child_process";
 import * as fs12 from "node:fs/promises";
-import * as path21 from "node:path";
-
-// src/skills/frontmatter.ts
-var SCALAR_KEYS = /* @__PURE__ */ new Set(["name", "description", "version", "license", "compatibility"]);
-function parseSkillFrontmatter(raw) {
-  const text = normalizeLineEndings(raw);
-  if (!text.startsWith("---")) return {};
-  const end = text.indexOf("\n---", 4);
-  if (end === -1) return {};
-  return parseFrontmatterBlock(text.slice(4, end));
-}
-function normalizeLineEndings(s) {
-  return s.replace(/\r\n?/g, "\n");
-}
-function parseFrontmatterBlock(block) {
-  const out = {};
-  const lines = block.split("\n");
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i] ?? "";
-    const m = /^([a-zA-Z][a-zA-Z0-9_-]*):\s*(.*)$/.exec(line);
-    if (!m) {
-      i++;
-      continue;
-    }
-    const key = m[1] ?? "";
-    const rest = (m[2] ?? "").trim();
-    if (key === "metadata") {
-      const map = {};
-      i++;
-      while (i < lines.length) {
-        const sub = lines[i] ?? "";
-        const sm = /^\s+([a-zA-Z0-9_.-]+):\s*(.*)$/.exec(sub);
-        if (!sm) break;
-        map[sm[1] ?? ""] = unquote2((sm[2] ?? "").trim());
-        i++;
-      }
-      if (Object.keys(map).length > 0) out.metadata = map;
-      continue;
-    }
-    if (rest === "|" || rest === ">") {
-      const collected = [];
-      i++;
-      while (i < lines.length) {
-        const sub = lines[i] ?? "";
-        if (sub === "" || sub.startsWith(" ") || sub.startsWith("	")) {
-          collected.push(sub.replace(/^\s+/, ""));
-          i++;
-        } else break;
-      }
-      out[normalizeKey2(key)] = collected.join("\n").trim();
-      continue;
-    }
-    if (key === "allowed-tools" || key === "allowedTools") {
-      out.allowedTools = rest.split(/[\s,]+/).filter(Boolean);
-      i++;
-      continue;
-    }
-    if (SCALAR_KEYS.has(key)) {
-      out[key] = unquote2(rest);
-      i++;
-      continue;
-    }
-    i++;
-  }
-  return out;
-}
-function normalizeKey2(key) {
-  return key === "allowed-tools" ? "allowedTools" : key;
-}
-function unquote2(s) {
-  if (s.length >= 2 && (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'"))) {
-    return s.slice(1, -1);
-  }
-  return s;
-}
-function isValidSkillNameFormat(name) {
-  return name.length >= 1 && name.length <= 64 && /^[a-z0-9]+(-[a-z0-9]+)*$/.test(name);
-}
-function validateSkillName(name, parentDirName) {
-  const errors = [];
-  if (!name || name.trim().length === 0) {
-    errors.push("name is empty");
-    return errors;
-  }
-  if (name.length > 64) errors.push(`name is ${name.length} characters (max 64)`);
-  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(name)) {
-    errors.push(
-      "name must be lowercase letters, digits, and single hyphens only (no leading/trailing/consecutive hyphens)"
-    );
-  }
-  if (parentDirName !== void 0 && name !== parentDirName) {
-    errors.push(`name "${name}" must match its parent directory "${parentDirName}"`);
-  }
-  return errors;
-}
-
-// src/skills/skill-generator.ts
+import * as path22 from "node:path";
 async function validateSkillNameAvailable(name, loader) {
   const formatViolations = validateSkillName(name);
   const conflicts = loader ? (await loader.listEntries()).filter((e) => e.name === name) : [];
@@ -9510,8 +9826,8 @@ async function writeSkeletonSkill(skillsDir, body, opts = {}) {
       subsystem: "general"
     });
   }
-  const skillDir = path21.join(skillsDir, name);
-  const skillFile = path21.join(skillDir, "SKILL.md");
+  const skillDir = path22.join(skillsDir, name);
+  const skillFile = path22.join(skillDir, "SKILL.md");
   if (!opts.overwrite) {
     try {
       await fs12.access(skillFile);
@@ -9570,13 +9886,14 @@ function defaultEditor() {
 init_errors();
 init_error();
 import * as fs15 from "node:fs/promises";
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 
 // src/skills/github-fetcher.ts
 init_errors();
+import { createWriteStream } from "node:fs";
 import * as fs13 from "node:fs/promises";
 import * as os6 from "node:os";
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGunzip } from "node:zlib";
@@ -9603,6 +9920,46 @@ function parseSkillRef(input) {
   }
   return { owner: expectDefined(parts[0]), repo: expectDefined(parts[1]), ref };
 }
+async function writeBoundedGzipStream(source, outputPath, maxBytes, maxCompressedBytes = SKILL_LIMITS.MAX_TARBALL_SIZE) {
+  let compressedBytes = 0;
+  let writtenBytes = 0;
+  await pipeline(
+    source,
+    async function* (chunks) {
+      for await (const chunk of chunks) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        compressedBytes += buffer.byteLength;
+        if (compressedBytes > maxCompressedBytes) {
+          throw new WrongStackError({
+            message: `Compressed tarball too large. Max: ${maxCompressedBytes / 1024 / 1024}MB`,
+            code: ERROR_CODES.UNKNOWN,
+            subsystem: "general",
+            context: { compressedBytes, maxBytes: maxCompressedBytes }
+          });
+        }
+        yield buffer;
+      }
+    },
+    createGunzip(),
+    async function* (chunks) {
+      for await (const chunk of chunks) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        writtenBytes += buffer.byteLength;
+        if (writtenBytes > maxBytes) {
+          throw new WrongStackError({
+            message: `Uncompressed tarball too large. Max: ${maxBytes / 1024 / 1024}MB`,
+            code: ERROR_CODES.UNKNOWN,
+            subsystem: "general",
+            context: { uncompressedBytes: writtenBytes, maxBytes }
+          });
+        }
+        yield buffer;
+      }
+    },
+    createWriteStream(outputPath, { flags: "wx" })
+  );
+  return writtenBytes;
+}
 function resolveGitHubToken(env = process.env) {
   const raw = env["WRONGSTACK_GITHUB_TOKEN"] ?? env["GITHUB_TOKEN"] ?? env["GH_TOKEN"];
   if (!raw) return void 0;
@@ -9678,7 +10035,7 @@ async function downloadGitHubTarball(parsed) {
       }
     });
   }
-  const tempDir = await fs13.mkdtemp(path22.join(os6.tmpdir(), "wskill-"));
+  const tempDir = await fs13.mkdtemp(path23.join(os6.tmpdir(), "wskill-"));
   try {
     if (!response.body) {
       throw new WrongStackError({
@@ -9689,15 +10046,14 @@ async function downloadGitHubTarball(parsed) {
       });
     }
     const nodeStream = Readable.fromWeb(response.body);
-    const gunzip = createGunzip();
-    const chunks = [];
-    await pipeline(nodeStream, gunzip, async (source) => {
-      for await (const chunk of source) {
-        chunks.push(Buffer.from(chunk));
-      }
-    });
-    const tarBuf = Buffer.concat(chunks);
-    await extractTar(tarBuf, tempDir);
+    const tarPath = path23.join(tempDir, ".wrongstack-download.tar");
+    await writeBoundedGzipStream(nodeStream, tarPath, SKILL_LIMITS.MAX_UNCOMPRESSED_TARBALL_SIZE);
+    const tarBuf = await fs13.readFile(tarPath);
+    try {
+      await extractTar(tarBuf, tempDir);
+    } finally {
+      await fs13.rm(tarPath, { force: true });
+    }
     return { tempDir };
   } catch (err) {
     await fs13.rm(tempDir, { recursive: true, force: true }).catch(() => {
@@ -9705,6 +10061,44 @@ async function downloadGitHubTarball(parsed) {
     throw err;
   }
 }
+function readTarSize(buf, start) {
+  const first = buf[start] ?? 0;
+  if ((first & 128) !== 0) {
+    if (first === 255) {
+      throw new Error("tar: negative base-256 size field");
+    }
+    let value = first & 127;
+    for (let i = start + 1; i < start + 12; i++) {
+      value = value * 256 + (buf[i] ?? 0);
+      if (!Number.isSafeInteger(value)) {
+        throw new Error("tar: base-256 size exceeds the safe integer range");
+      }
+    }
+    return value;
+  }
+  const text = readTarString(buf, start, 12).trim();
+  if (text === "") return 0;
+  if (!/^[0-7]+$/.test(text)) {
+    throw new Error(`tar: unparseable size field ${JSON.stringify(text)}`);
+  }
+  const parsed = Number.parseInt(text, 8);
+  if (!Number.isSafeInteger(parsed) || parsed < 0) {
+    throw new Error("tar: size field out of range");
+  }
+  return parsed;
+}
+function readTarString(buf, start, maxLen) {
+  let end = start;
+  while (end < start + maxLen && end < buf.length && buf[end] !== 0) {
+    end++;
+  }
+  return buf.subarray(start, end).toString("utf8");
+}
+function stripTopDir(p) {
+  const idx = p.indexOf("/");
+  if (idx === -1) return "";
+  return p.slice(idx + 1);
+}
 async function extractTar(buf, destDir) {
   let offset = 0;
   while (offset + 512 <= buf.length) {
@@ -9712,15 +10106,15 @@ async function extractTar(buf, destDir) {
     if (header.every((b) => b === 0)) break;
     const name = readTarString(buf, offset, 100);
     const prefix = readTarString(buf, offset + 345, 155);
-    const size = Number.parseInt(readTarString(buf, offset + 124, 12).trim(), 8) || 0;
+    const size = readTarSize(buf, offset + 124);
     const typeflag = buf[offset + 156] ?? 0;
     const fullPath = prefix ? `${prefix}/${name}` : name;
     const relPath = stripTopDir(fullPath);
     if (relPath && relPath !== "." && relPath !== "..") {
-      const destPath = path22.join(destDir, relPath);
-      const resolvedDest = path22.resolve(destPath);
-      const resolvedRoot = path22.resolve(destDir);
-      if (resolvedDest !== resolvedRoot && !resolvedDest.startsWith(resolvedRoot + path22.sep)) {
+      const destPath = path23.join(destDir, relPath);
+      const resolvedDest = path23.resolve(destPath);
+      const resolvedRoot = path23.resolve(destDir);
+      if (resolvedDest !== resolvedRoot && !resolvedDest.startsWith(resolvedRoot + path23.sep)) {
         offset += 512 + Math.ceil(size / 512) * 512;
         continue;
       }
@@ -9730,7 +10124,7 @@ async function extractTar(buf, destDir) {
         }
       }
       if ((typeflag === 48 || typeflag === 0 || typeflag === 0) && size > 0) {
-        const dir = path22.dirname(destPath);
+        const dir = path23.dirname(destPath);
         await fs13.mkdir(dir, { recursive: true });
         const dataStart = offset + 512;
         const dataEnd = dataStart + size;
@@ -9741,23 +10135,11 @@ async function extractTar(buf, destDir) {
     offset += 512 + Math.ceil(size / 512) * 512;
   }
 }
-function readTarString(buf, start, maxLen) {
-  let end = start;
-  while (end < start + maxLen && end < buf.length && buf[end] !== 0) {
-    end++;
-  }
-  return buf.subarray(start, end).toString("utf8");
-}
-function stripTopDir(p) {
-  const idx = p.indexOf("/");
-  if (idx === -1) return "";
-  return p.slice(idx + 1);
-}
 
 // src/skills/manifest-store.ts
 init_atomic_write();
 import * as fs14 from "node:fs/promises";
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 var SkillManifestStore = class {
   manifestPath;
   cache;
@@ -9780,7 +10162,7 @@ var SkillManifestStore = class {
     return this.cache;
   }
   async write(data) {
-    const dir = path23.dirname(this.manifestPath);
+    const dir = path24.dirname(this.manifestPath);
     await fs14.mkdir(dir, { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(data, null, 2) + "\n");
     this.cache = data;
@@ -9818,6 +10200,10 @@ var SkillManifestStore = class {
 };
 
 // src/skills/skill-installer.ts
+function isInside(resolved, destDir) {
+  const root = path25.resolve(destDir);
+  return resolved === root || resolved.startsWith(root + path25.sep);
+}
 var MAX_SKILL_FILE_SIZE = SKILL_LIMITS.MAX_SKILL_FILE_SIZE;
 var SkillInstaller = class {
   opts;
@@ -9871,14 +10257,14 @@ var SkillInstaller = class {
           this.opts.log?.(`Overwriting existing skill "${skill.name}" (${scope})...`);
           await this.removeSkillFiles(skill.name, scope);
         }
-        const destDir = path24.join(targetDir, skill.name);
+        const destDir = path25.join(targetDir, skill.name);
         await fs15.mkdir(destDir, { recursive: true });
         const copiedFiles = [];
         for (const file of skill.files) {
-          const srcPath = path24.join(skill.baseDir, file);
-          const destPath = path24.join(destDir, file);
-          const resolved2 = path24.resolve(destPath);
-          if (!resolved2.startsWith(path24.resolve(destDir))) {
+          const srcPath = path25.join(skill.baseDir, file);
+          const destPath = path25.join(destDir, file);
+          const resolved2 = path25.resolve(destPath);
+          if (!isInside(resolved2, destDir)) {
             throw new FsError({
               message: `Path traversal detected in skill file: ${file}`,
               code: ERROR_CODES.FS_DELETE_FAILED,
@@ -9886,16 +10272,16 @@ var SkillInstaller = class {
               context: { reason: "path_traversal", skillName: skill.name }
             });
           }
-          const stat6 = await fs15.stat(srcPath);
-          if (stat6.size > MAX_SKILL_FILE_SIZE) {
+          const stat7 = await fs15.stat(srcPath);
+          if (stat7.size > MAX_SKILL_FILE_SIZE) {
             throw new FsError({
-              message: `Skill file "${file}" is too large (${(stat6.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`,
+              message: `Skill file "${file}" is too large (${(stat7.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`,
               code: ERROR_CODES.FS_WRITE_FAILED,
               path: srcPath,
-              context: { skillName: skill.name, fileSize: stat6.size, maxSize: MAX_SKILL_FILE_SIZE }
+              context: { skillName: skill.name, fileSize: stat7.size, maxSize: MAX_SKILL_FILE_SIZE }
             });
           }
-          await fs15.mkdir(path24.dirname(destPath), { recursive: true });
+          await fs15.mkdir(path25.dirname(destPath), { recursive: true });
           await fs15.copyFile(srcPath, destPath);
           copiedFiles.push(file);
         }
@@ -9953,7 +10339,7 @@ var SkillInstaller = class {
     const results = [];
     for (const e of entries) {
       if (!await entryIsDirectory(srcDir, e)) continue;
-      const skillMdPath = path24.join(srcDir, e.name, "SKILL.md");
+      const skillMdPath = path25.join(srcDir, e.name, "SKILL.md");
       let content;
       try {
         content = await fs15.readFile(skillMdPath, "utf8");
@@ -9966,16 +10352,16 @@ var SkillInstaller = class {
       if (existing.find((x) => x.scope === scope)) {
         await this.removeSkillFiles(fm.name, scope);
       }
-      const destDir = path24.join(targetDir, fm.name);
+      const destDir = path25.join(targetDir, fm.name);
       await fs15.mkdir(destDir, { recursive: true });
-      const srcSkillDir = path24.join(srcDir, e.name);
+      const srcSkillDir = path25.join(srcDir, e.name);
       const files = await collectFiles(srcSkillDir, srcSkillDir);
       const copiedFiles = [];
       for (const file of files) {
-        const srcPath = path24.join(srcSkillDir, file);
-        const destPath = path24.join(destDir, file);
-        const resolved = path24.resolve(destPath);
-        if (!resolved.startsWith(path24.resolve(destDir))) {
+        const srcPath = path25.join(srcSkillDir, file);
+        const destPath = path25.join(destDir, file);
+        const resolved = path25.resolve(destPath);
+        if (!isInside(resolved, destDir)) {
           throw new FsError({
             message: `Path traversal detected in skill file: ${file}`,
             code: ERROR_CODES.FS_DELETE_FAILED,
@@ -9983,7 +10369,7 @@ var SkillInstaller = class {
             context: { reason: "path_traversal", skillName: fm.name }
           });
         }
-        await fs15.mkdir(path24.dirname(destPath), { recursive: true });
+        await fs15.mkdir(path25.dirname(destPath), { recursive: true });
         if (opts?.link) {
           try {
             await fs15.symlink(srcPath, destPath);
@@ -10146,7 +10532,7 @@ var SkillInstaller = class {
    */
   async detectSkills(baseDir) {
     const results = [];
-    const rootSkillMd = path24.join(baseDir, "SKILL.md");
+    const rootSkillMd = path25.join(baseDir, "SKILL.md");
     try {
       await fs15.access(rootSkillMd);
       const content = await fs15.readFile(rootSkillMd, "utf8");
@@ -10161,17 +10547,17 @@ var SkillInstaller = class {
       }
     } catch {
     }
-    const skillsDir = path24.join(baseDir, "skills");
+    const skillsDir = path25.join(baseDir, "skills");
     try {
       const entries = await fs15.readdir(skillsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const skillFile = path24.join(skillsDir, entry.name, "SKILL.md");
+        const skillFile = path25.join(skillsDir, entry.name, "SKILL.md");
         try {
           const content = await fs15.readFile(skillFile, "utf8");
           const fm = parseSkillFrontmatter(content);
           if (fm.name && fm.description && isValidSkillNameFormat(fm.name)) {
-            const skillDir = path24.join(skillsDir, entry.name);
+            const skillDir = path25.join(skillsDir, entry.name);
             const files = await collectFiles(skillDir, skillDir);
             results.push({
               name: fm.name,
@@ -10189,9 +10575,31 @@ var SkillInstaller = class {
   /**
    * Remove all files for an installed skill.
    */
+  /**
+   * Delete an installed skill's directory.
+   *
+   * The containment check is not ceremonial: this is a `recursive: true,
+   * force: true` delete whose target is built from a skill NAME taken from
+   * manifest frontmatter. `path.join` normalises `..`, so a crafted name
+   * escapes `targetDir` and takes the recursive delete with it. This file
+   * already had `isInside` and applied it on the copy path but not here.
+   *
+   * The strict-subdirectory requirement matters separately: `isInside` allows
+   * equality by design, and an empty or `.` name resolves `skillDir` to
+   * `targetDir` itself — deleting every installed skill (WS-097).
+   */
   async removeSkillFiles(name, scope) {
     const targetDir = scope === "project" ? this.opts.projectSkillsDir : this.opts.globalSkillsDir;
-    const skillDir = path24.join(targetDir, name);
+    const root = path25.resolve(targetDir);
+    const skillDir = path25.resolve(path25.join(targetDir, name));
+    if (skillDir === root || !isInside(skillDir, root)) {
+      throw new FsError({
+        message: `Refusing to delete skill files outside the skills directory: ${name}`,
+        code: ERROR_CODES.FS_DELETE_FAILED,
+        path: skillDir,
+        context: { reason: "path_traversal", skillName: name, scope }
+      });
+    }
     await fs15.rm(skillDir, { recursive: true, force: true });
   }
   /**
@@ -10227,7 +10635,7 @@ async function entryIsDirectory(dir, entry) {
   if (entry.isDirectory()) return true;
   if (entry.isSymbolicLink()) {
     try {
-      return (await fs15.stat(path24.join(dir, entry.name))).isDirectory();
+      return (await fs15.stat(path25.join(dir, entry.name))).isDirectory();
     } catch {
       return false;
     }
@@ -10238,8 +10646,8 @@ async function collectFiles(dir, baseDir) {
   const results = [];
   const entries = await fs15.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path24.join(dir, entry.name);
-    const relPath = path24.relative(baseDir, fullPath);
+    const fullPath = path25.join(dir, entry.name);
+    const relPath = path25.relative(baseDir, fullPath);
     if (entry.isDirectory()) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
       results.push(...await collectFiles(fullPath, baseDir));
@@ -10318,7 +10726,7 @@ function createSkillsPlugin(opts) {
 function makeInstaller(skillLoader, projectRoot, registryAdapters) {
   const paths = resolveWstackPaths({ projectRoot });
   return new SkillInstaller({
-    manifestPath: path25.join(paths.configDir, "installed-skills.json"),
+    manifestPath: path26.join(paths.configDir, "installed-skills.json"),
     projectSkillsDir: paths.inProjectSkills,
     globalSkillsDir: paths.globalSkills,
     projectHash: paths.projectHash,
@@ -10346,7 +10754,8 @@ ${lines.join("\n\n")}
       }
       const skill = await skillLoader.find(args.trim());
       if (!skill) return { message: `Skill "${args.trim()}" not found.` };
-      return { message: await skillLoader.readBody(skill.name) };
+      const body = capSkillBody(stripFrontmatter(await skillLoader.readBody(skill.name)));
+      return { message: body };
     }
   };
 }
@@ -10385,9 +10794,32 @@ function buildSkillGeneratorCommand(skillLoader) {
           return `  ${src} ${e.name}
      ${e.trigger}`;
         });
-        return { message: `Available Skills:
+        let message = `Available Skills:
 ${lines.join("\n\n")}
-` };
+`;
+        const diag = skillLoader.diagnostics?.();
+        if (diag && (diag.shadowed.length > 0 || diag.skipped.length > 0)) {
+          const notes = [];
+          if (diag.shadowed.length > 0) {
+            notes.push(color.dim("Shadowed (hidden by a higher-priority layer):"));
+            for (const s of diag.shadowed) {
+              notes.push(
+                color.dim(`  \u26A0 ${s.name} (${s.source}) \u2190 overridden by ${s.shadowedBy}`)
+              );
+            }
+          }
+          if (diag.skipped.length > 0) {
+            notes.push(color.dim("Skipped (malformed SKILL.md):"));
+            for (const k of diag.skipped) {
+              const name = k.name ? ` "${k.name}"` : "";
+              notes.push(color.dim(`  \u2717 ${k.entry}${name} \u2014 ${k.reason}`));
+            }
+          }
+          message += `
+${notes.join("\n")}
+`;
+        }
+        return { message };
       }
       if (sub === "validate") {
         const name = rest[0];
@@ -10444,7 +10876,10 @@ ${lines.join("\n\n")}
         if (!skill) return { message: `Skill "${skillName}" not found.` };
         try {
           await openInEditor(skill.path);
-          return { message: `Opening ${skill.path} in your editor\u2026` };
+          skillLoader.invalidateCache();
+          return {
+            message: `Opening ${skill.path} in your editor\u2026 (skill cache cleared \u2014 changes load on next use)`
+          };
         } catch (err) {
           return { message: `\u2717 ${toErrorMessage(err)}` };
         }
@@ -10670,7 +11105,7 @@ function resolveImportSourceDir(tool, opts) {
   const entry = IMPORT_SOURCE_TOOLS.find((t) => t.id === tool);
   if (!entry) return void 0;
   const base = opts.global ? opts.homeDir ?? os7.homedir() : opts.projectRoot;
-  return path25.join(base, "." + entry.id, entry.subdir);
+  return path26.join(base, "." + entry.id, entry.subdir);
 }
 function buildSkillImportCommand(skillLoader) {
   return {
@@ -10711,7 +11146,7 @@ function buildSkillImportCommand(skillLoader) {
           };
         }
       } else if (positional) {
-        srcDir = path25.resolve(ctx.projectRoot, positional);
+        srcDir = path26.resolve(ctx.projectRoot, positional);
       } else {
         return {
           message: "Usage: /skill-import <src-dir> | --from <tool> | --from-claude [--global] [--link]"
@@ -10838,14 +11273,14 @@ function truncate(s, max) {
 }
 
 // src/plugins/sync-plugin.ts
-import * as path27 from "node:path";
+import * as path28 from "node:path";
 init_error();
 
 // src/storage/cloud-sync.ts
 init_atomic_write();
 init_errors();
 import * as fs16 from "node:fs/promises";
-import * as path26 from "node:path";
+import * as path27 from "node:path";
 import { createHash as createHash9 } from "node:crypto";
 var ALL_SYNC_CATEGORIES = ["settings", "skills", "prompts", "memory", "history"];
 var CloudSync = class {
@@ -10853,8 +11288,8 @@ var CloudSync = class {
     this.paths = paths;
     this.getConfig = getConfig;
     this.setConfig = setConfig;
-    this.statePath = path26.join(paths.configDir, "sync-state.json");
-    this.getSettingsConfigPath = getSettingsConfigPath ?? (() => path26.join(this.paths.configDir, "config.json"));
+    this.statePath = path27.join(paths.configDir, "sync-state.json");
+    this.getSettingsConfigPath = getSettingsConfigPath ?? (() => path27.join(this.paths.configDir, "config.json"));
   }
   paths;
   getConfig;
@@ -11134,13 +11569,13 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat6 = await fs16.lstat(localPath);
-        if (stat6.isSymbolicLink()) continue;
-        if (stat6.isDirectory()) {
+        const stat7 = await fs16.lstat(localPath);
+        if (stat7.isSymbolicLink()) continue;
+        if (stat7.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fs16.readFile(file, "utf8");
-            const rel = path26.relative(localPath, file).replace(/\\/g, "/");
+            const rel = path27.relative(localPath, file).replace(/\\/g, "/");
             entries.push({ path: `data/${cat}/${rel}`, content, mode: "100644" });
             hashes.push(`${cat}/${rel}\0${content}`);
           }
@@ -11161,13 +11596,13 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat6 = await fs16.lstat(localPath);
-        if (stat6.isSymbolicLink()) continue;
-        if (stat6.isDirectory()) {
+        const stat7 = await fs16.lstat(localPath);
+        if (stat7.isSymbolicLink()) continue;
+        if (stat7.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fs16.readFile(file, "utf8");
-            const rel = path26.relative(localPath, file).replace(/\\/g, "/");
+            const rel = path27.relative(localPath, file).replace(/\\/g, "/");
             hashes.push(`${cat}/${rel}\0${content}`);
           }
         } else {
@@ -11201,7 +11636,7 @@ var CloudSync = class {
     const entries = await fs16.readdir(dir, { withFileTypes: true });
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const full = path26.join(dir, entry.name);
+      const full = path27.join(dir, entry.name);
       if (entry.isSymbolicLink()) continue;
       if (entry.isDirectory()) {
         results.push(...await this.walkDir(full, base));
@@ -11214,25 +11649,25 @@ var CloudSync = class {
 };
 async function preparePulledDestination(cat, localPath, destPath, remotePath) {
   const directoryBacked = cat === "skills" || cat === "prompts";
-  const rootPath = directoryBacked ? localPath : path26.dirname(localPath);
+  const rootPath = directoryBacked ? localPath : path27.dirname(localPath);
   const rootStat = await lstatIfExists(rootPath);
   if (rootStat?.isSymbolicLink()) {
     throw unsafePulledSymlinkError(remotePath, rootPath);
   }
   if (directoryBacked) {
-    const relativeParent = path26.relative(rootPath, path26.dirname(destPath));
+    const relativeParent = path27.relative(rootPath, path27.dirname(destPath));
     let cursor = rootPath;
     if (relativeParent) {
-      for (const segment of relativeParent.split(path26.sep)) {
-        cursor = path26.join(cursor, segment);
-        const stat6 = await lstatIfExists(cursor);
-        if (stat6?.isSymbolicLink()) throw unsafePulledSymlinkError(remotePath, cursor);
+      for (const segment of relativeParent.split(path27.sep)) {
+        cursor = path27.join(cursor, segment);
+        const stat7 = await lstatIfExists(cursor);
+        if (stat7?.isSymbolicLink()) throw unsafePulledSymlinkError(remotePath, cursor);
       }
     }
   }
   const destStat = await lstatIfExists(destPath);
   if (destStat?.isSymbolicLink()) throw unsafePulledSymlinkError(remotePath, destPath);
-  await fs16.mkdir(path26.dirname(destPath), { recursive: true });
+  await fs16.mkdir(path27.dirname(destPath), { recursive: true });
 }
 async function lstatIfExists(filePath) {
   try {
@@ -11262,9 +11697,9 @@ function resolvePulledCategoryPath(cat, localPath, rel, remotePath) {
     return localPath;
   }
   if (!rel) return localPath;
-  const normalizedRel = path26.normalize(rel);
-  const traversesUp = normalizedRel === ".." || normalizedRel.startsWith(`..${path26.sep}`);
-  if (path26.isAbsolute(normalizedRel) || traversesUp) {
+  const normalizedRel = path27.normalize(rel);
+  const traversesUp = normalizedRel === ".." || normalizedRel.startsWith(`..${path27.sep}`);
+  if (path27.isAbsolute(normalizedRel) || traversesUp) {
     throw new FsError({
       message: `Refusing CloudSync path traversal: ${remotePath}`,
       code: ERROR_CODES.FS_DELETE_FAILED,
@@ -11272,10 +11707,10 @@ function resolvePulledCategoryPath(cat, localPath, rel, remotePath) {
       context: { reason: "path_traversal", normalizedRel }
     });
   }
-  const dest = path26.resolve(localPath, normalizedRel);
-  const root = path26.resolve(localPath);
-  const relative5 = path26.relative(root, dest);
-  if (relative5.startsWith("..") || path26.isAbsolute(relative5)) {
+  const dest = path27.resolve(localPath, normalizedRel);
+  const root = path27.resolve(localPath);
+  const relative5 = path27.relative(root, dest);
+  if (relative5.startsWith("..") || path27.isAbsolute(relative5)) {
     throw new FsError({
       message: `Refusing CloudSync path outside category root: ${remotePath}`,
       code: ERROR_CODES.FS_DELETE_FAILED,
@@ -11318,7 +11753,7 @@ function createSyncPlugin(opts) {
         api.log.warn("[sync] paths, configStore, or configDir not available \u2014 /sync disabled");
         return;
       }
-      const syncConfigPath = paths.syncConfig ?? path27.join(paths.configDir, "sync.json");
+      const syncConfigPath = paths.syncConfig ?? path28.join(paths.configDir, "sync.json");
       cloud = new CloudSync(
         paths,
         () => {
@@ -11329,7 +11764,7 @@ function createSyncPlugin(opts) {
           await persistSyncConfig(syncConfigPath, cfg, vault);
           configStore?.update({ sync: cfg });
         },
-        () => path27.join(paths.configDir, "config.json")
+        () => path28.join(paths.configDir, "config.json")
       );
       void cloud.loadState();
       api.slashCommands.register(buildSyncCommand(cloud, configStore, vault, syncConfigPath));
@@ -11532,8 +11967,14 @@ export {
   definePlugin,
   diffPluginConfig,
   emitReviewIfChanged,
+  integrateFindings,
   loadPlugins,
+  maybeCompactReviewStores,
+  parseChimeraReviewReport,
   parseReviewSeverity,
+  persistReviewReport,
+  recordCompletedReview,
+  recordStartedReview,
   redactPluginConfig,
   resolvePluginConfig,
   resolvePluginManifestConfig,