shraga 0.1.77 → 0.1.79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shraga",
-  "version": "0.1.77",
+  "version": "0.1.79",
   "description": "The teammate you delegate coding to — a self-hostable, multi-user AI coding agent web UI (Claude Code, with a pluggable engine seam).",
   "type": "module",
   "main": "./src/index.ts",

package/src/server/claude-usage.ts

@@ -2,11 +2,12 @@
 // the Claude Code CLI maintains on this box. Fails CLOSED: every error path returns null, and the
 // caller renders nothing — a broken or zeroed gauge is worse than no gauge.
 import { execFile } from 'node:child_process';
-import { readdir, readFile } from 'node:fs/promises';
+import { readdir, readFile, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 import { promisify } from 'node:util';
+import { dataPath } from './paths.ts';
 
 const execFileAsync = promisify(execFile);
 
@@ -71,6 +72,10 @@ export class ClaudeUsageOptions {
   keychainService = 'Claude Code-credentials';
   /** A locked keychain can block (or prompt) indefinitely — never let that stall a client poll. */
   keychainTimeoutMs = 3_000;
+  /** Where the last known-good reading is mirrored, so a restart (deploy, self-upgrade) does not
+   *  blank the gauge on a box whose upstream is rate-limited for the next hour. Identity + percentages
+   *  only — never a token. */
+  cachePath = dataPath('claude-usage-last.json');
   /** Seam: hands back the raw secret string, or null on ANY failure. Tests inject here so the suite
    *  never shells out to the real `security` binary. */
   readKeychain: (options: ClaudeUsageOptions) => Promise<string | null> = readKeychainSecret;
@@ -144,6 +149,8 @@ export class ClaudeUsageReader {
    *  a widget that flickers in and out reads as a bug. We keep serving this, flagged `stale`, and the
    *  client shows how old it is. Only a box that never had a good reading answers null. */
   private lastGood: { at: number; value: ClaudeUsage } | null = null;
+  /** One-shot rehydrate of `lastGood` from disk, awaited by the first get(). */
+  private restored: Promise<void> | null = null;
 
   public constructor(options?: Partial<ClaudeUsageOptions>) {
     this.options = { ...new ClaudeUsageOptions(), ...options };
@@ -151,6 +158,7 @@ export class ClaudeUsageReader {
 
   /** null => this box is not on a Claude subscription, or we could not prove that it ever was. */
   async get(): Promise<ClaudeUsage | null> {
+    await (this.restored ??= this.restore());
     const now = Date.now();
     if (now < this.cooldownUntil) return this.stale();
     if (this.cache && now - this.cache.at < this.options.ttlMs) return this.cache.value ?? this.stale();
@@ -162,13 +170,36 @@ export class ClaudeUsageReader {
         const at = Date.now();
         const stamped = value ? { ...value, fetchedAt: new Date(at).toISOString() } : null;
         this.cache = { at, value: stamped };
-        if (stamped) this.lastGood = { at, value: stamped };
+        if (stamped) { this.lastGood = { at, value: stamped }; void this.persist(this.lastGood); }
         return stamped ?? this.stale();
       })
       .finally(() => { this.inflight = null; });
     return this.inflight;
   }
 
+  /** Rehydrate the last reading a previous process wrote. Never throws: a missing or corrupt file
+   *  just means we start with nothing, exactly as before. */
+  private async restore(): Promise<void> {
+    try {
+      const saved = JSON.parse(await readFile(this.options.cachePath, 'utf8'));
+      if (Array.isArray(saved?.value?.limits) && saved.value.limits.length && typeof saved.at === 'number') {
+        this.lastGood = { at: saved.at, value: saved.value };
+      }
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code !== 'ENOENT') console.debug(`${TAG} could not restore the last reading: ${(err as Error).message}`);
+    }
+  }
+
+  /** Mirror a fresh reading to disk. Best-effort — a write failure must never break the response. */
+  private async persist(entry: { at: number; value: ClaudeUsage }) {
+    try {
+      await writeFile(this.options.cachePath, JSON.stringify(entry));
+    } catch (err) {
+      console.debug(`${TAG} could not persist the last reading: ${(err as Error).message}`);
+    }
+  }
+
   /** Last known-good reading, marked stale. Never invents numbers — null when we never had any. */
   private stale(): ClaudeUsage | null {
     return this.lastGood ? { ...this.lastGood.value, stale: true } : null;

package/src/server/skills.ts

@@ -323,6 +323,83 @@ export function buildSkillIndexBlock(): string {
   return `<available-skills>\nSkills available in data/skills/. Use Read to load full skill content when needed.\n${lines.join('\n')}\n</available-skills>`;
 }
 
+/* ── Trigger matching ─────────────────────────────────────────────────────────
+ * Triggers are authored as natural phrases ("make a video ad"), but real briefs
+ * insert words into them ("make a NEW video ad variant"). A plain substring test
+ * missed those, and a missed trigger silently costs more than the skill text —
+ * it also drops the skill's `turns` budget (see resolveSkillTurns).
+ *
+ * So: match on WORD TOKENS, not raw characters.
+ *  - Short triggers (< MIN_TOKENS_FOR_GAPS) must still match as a contiguous run.
+ *    This is strictly NARROWER than `includes` — "cost per" no longer fires on
+ *    "cost performance", "ad" no longer fires on "adding".
+ *  - Longer triggers (3+ tokens) tolerate a few inserted words, bounded hard so
+ *    the phrase cannot smear across a whole message.
+ * A trailing plural on either side is tolerated at every position ("video ads").
+ */
+
+/** Words, keeping decimal numbers whole so "wan 2.2" is [wan, 2.2] and not [wan, 2, 2]. */
+const TRIGGER_TOKEN_RE = /[a-z0-9]+(?:\.[0-9]+)*/g;
+/** Triggers with fewer tokens than this must match contiguously — too short to be safely loosened. */
+const MIN_TOKENS_FOR_GAPS = 3;
+/** Words that may be inserted across the WHOLE trigger phrase. This one bound is what stops a
+ * phrase smearing over a long message: "make a video ad" reaches "make a NEW video ad" and
+ * "make me a new video ad", but not "make something. later, a video. then an ad.". */
+const MAX_INSERTED = 3;
+/** Articles the trigger's AUTHOR typed that the asker may not ("make SOME video ads"). Skipping
+ * one costs an insertion, so it is not free. */
+const TRIGGER_FILLER = new Set(['a', 'an', 'the']);
+
+function tokenizeTrigger(s: string): string[] {
+  return s.toLowerCase().match(TRIGGER_TOKEN_RE) ?? [];
+}
+
+/** Token equality with a tolerated trailing plural on either side ("ad" ~ "ads", "match" ~ "matches"). */
+function tokenEq(a: string, b: string): boolean {
+  if (a === b) return true;
+  const [long, short] = a.length > b.length ? [a, b] : [b, a];
+  return long === `${short}s` || long === `${short}es`;
+}
+
+function matchTokens(hay: string[], needle: string[]): boolean {
+  if (!needle.length || needle.length > hay.length) return false;
+  for (let start = 0; start + needle.length <= hay.length; start++) {
+    if (!tokenEq(hay[start], needle[0])) continue;
+    if (needle.length < MIN_TOKENS_FOR_GAPS) {
+      // Too short to loosen. Contiguous whole words only — strictly NARROWER than `includes`,
+      // which fired "ad set" on "ad settings" and "cost per" on "cost performance".
+      if (needle.every((t, k) => tokenEq(hay[start + k], t))) return true;
+      continue;
+    }
+    // Leftmost-greedy subsequence, then bound the SPAN it consumed.
+    let i = start + 1, n = 1, inserted = 0;
+    while (n < needle.length && i < hay.length && inserted <= MAX_INSERTED) {
+      if (tokenEq(hay[i], needle[n])) { n++; i++; continue; }
+      i++; inserted++;
+    }
+    if (n === needle.length && inserted <= MAX_INSERTED) return true;
+  }
+  return false;
+}
+
+/**
+ * True when `trigger` occurs in `text` as an in-order run of whole words spanning at most
+ * MAX_INSERTED extra words. Exported for tests — a trigger layer is easy to widen by accident.
+ *
+ * Two passes rather than one clever one: the trigger as authored, then the trigger with its
+ * articles dropped ("make a video ad" -> make/video/ad, so "make SOME video ads" lands). A single
+ * pass that skipped articles inline had to guess, greedily and wrongly, whether the article ahead
+ * in the message was the one the trigger meant.
+ */
+export function triggerMatches(text: string, trigger: string): boolean {
+  const hay = tokenizeTrigger(text);
+  const needle = tokenizeTrigger(trigger);
+  if (matchTokens(hay, needle)) return true;
+  const stripped = needle.filter(t => !TRIGGER_FILLER.has(t));
+  return stripped.length !== needle.length && stripped.length >= MIN_TOKENS_FOR_GAPS
+    && matchTokens(hay, stripped);
+}
+
 /**
  * Match message text against skill triggers. Returns matched skill names.
  * Skips skills already in the defaults list (they're already injected).
@@ -343,7 +420,7 @@ export function matchTriggeredSkillNames(message: string, context?: Record<strin
     if (isExpired(meta)) continue;
     if (!meta.triggers?.length) continue;
     if (meta.origin === 'auto' && meta.reviewed === false) continue;
-    const hit = meta.triggers.some(t => lower.includes(t.toLowerCase()));
+    const hit = meta.triggers.some(t => triggerMatches(lower, t));
     if (hit) {
       console.log(`[skills] Trigger matched: ${name}${ctxPrefix ? ` (context: ${ctxPrefix})` : ''}`);
       matched.push(name);