toga-ai 1.0.921 → 1.0.923

package/.claude/settings.json

@@ -90,6 +90,16 @@
             "timeout": 3000
           }
         ]
+      },
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/toga/platform-reuse-reminder.js\"",
+            "timeout": 3000
+          }
+        ]
       }
     ],
     "PostToolUse": [

package/knowledge/2.0/apps/worker2/features/clickup-webhook-health-monitor.md

@@ -6,7 +6,7 @@ project: Worker
 client: shared
 type: feature
 status: active
-updated: 2026-09-22
+updated: 2026-09-30
 owners: [jcardinal]
 files:
   - worker2/Worker/Monitor/Clickup.php
@@ -35,6 +35,7 @@ Distinct from the sibling email watchdog [`_Worker_Clickup_Health`](./clickup-co
   - `HIGH` (full failure / Offline) — **blind read**: the ClickUp call threw, OR a monitored `togahub.com` webhook has no readable `health.status`. "We don't know the status."
   - `DEGRADED` — a monitored `togahub.com` webhook has `health.status = "suspended"`, OR no `togahub.com` subscription exists at all. A known outage we can see.
   - `OK` — every monitored webhook is readable and not suspended (so `active`, `failing`, any other readable status → OK).
+  - **Coverage check** (`evaluateCoverage()`, added 2026-09-25) also → `DEGRADED`: a watched space/event has no covering webhook, a duplicate covering webhook, or a covering webhook with `health.status = "suspended"` (`self::SUSPENDED_STATUS`). `failing` is OK here too (ClickUp is still retrying). Unreadable status is not flagged by coverage — the main loop already makes it `HIGH`.
   - Precedence: `HIGH` > `DEGRADED` > `OK`. `probe` is `OK` on any successful read (even when `alarm=HIGH` from a blind webhook) and `DEGRADED` only when the ClickUp read itself failed.
 - **OneUptime criteria must match the tokens** (config lives outside the repo): Request Body Contains `"alarm":"HIGH"` → Offline + incident; Contains `"alarm":"DEGRADED"` → Degraded; received in 1 min AND Contains `"alarm":"OK"` → Online (OK-gated recovery).
 - **Push URL is an in-file `$ONEUPTIME_URL` local, not `[oneuptime]` config** — the established team convention for every `Worker/Monitor/*` file (Operations, Staples, Compass, Aig, Prudential, Nycdoe, Fleet). A cso review suggested reading it from config; the developer rejected that on purpose — the heartbeat URL is treated as low-sensitivity and stays inline, matching the siblings. See the credential note in [OneUptime push-metric monitors](./oneuptime-worker2-monitoring.md). The `$push` guard still soft-fails on a blank URL so the job can deploy inert.
@@ -47,6 +48,7 @@ Distinct from the sibling email watchdog [`_Worker_Clickup_Health`](./clickup-co
 - Keep the metric POST non-fatal — a monitoring outage must never break the worker job.
 
 ## Change history
+- 2026-09-30 — Coverage check flagged any covering webhook with status ≠ `active` as degraded, so `failing` (fail_count 1) made the monitor Degraded. Now flags only `suspended`; const `HEALTHY_STATUS` → `SUSPENDED_STATUS`, `CheckWebhook()` uses `self::SUSPENDED_STATUS` (duplicate local removed). `Worker/Clickup/Project.php` (EnsureWebhooks) only reads `degradedHealth` for a message — unaffected. Not yet committed/deployed at capture. (jcardinal)
 - 2026-09-22 — Reworked the alarm rule from "any status ≠ active → DEGRADED" to three levels: `HIGH` on a blind read (ClickUp call failed, or a webhook has no readable `health.status`), `DEGRADED` on `"suspended"` or no `togahub.com` subscription, `OK` for everything else (`active`/`failing`/other). Original was too sensitive. Also hardened: blind-path OneUptime push wrapped in try/catch (non-fatal), `health` guarded against a non-object, stale "Left BLANK" URL comment removed (URL is live). Payload fields changed: `activeCount` → `okCount`, added `suspendedCount`/`blindCount`. OneUptime monitor criteria must be set to match `"alarm":"HIGH"` and `"alarm":"DEGRADED"`. (jcardinal)
 - 2026-09-21 — Created `_Worker_Monitor_Clickup::CheckWebhook` (OneUptime, `*/10`, stricter than the email watchdog). Recreated the inbound webhook under the service account (`pk_87469444`, new id `bd6168ab-…`, deleting the old OAuth-owned one) so both this monitor and `_Worker_Clickup_Health` can see it — the two were previously blind to it (token-ownership gotcha above). (jcardinal)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toga-ai",
-  "version": "1.0.921",
+  "version": "1.0.923",
   "description": "TOGA Technology Team Claude Knowledge System — shared AI coding harness with skills, knowledge base CLI, and project installer for Claude Code.",
   "keywords": [
     "claude",

package/rules/common/architecture-principles.md

@@ -29,7 +29,8 @@ not a script. When a principle and a real constraint collide, reason it out and
 - **Data-drive the UI.** Labels, colors, options, config come from Surface/settings and
   `labelRecordFieldId` — not hardcoded. Model anything data-drivable through those layers.
 - **Reuse before build.** A fundamental shared component (the table first) belongs in `blox`,
-  themed per app — not copied.
+  themed per app — not copied. Nudged by `scripts/hooks/platform-reuse-reminder.js` on every
+  new `src/` file in a platform app or blox (silence: `TOGA_REUSE_REMINDER_DISABLED=1`).
 - **Standard before custom.** Discuss standard-vs-custom before adding any custom field.
 
 ## Reversibility gate

package/scripts/hooks/platform-reuse-reminder.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * platform-reuse-reminder.js — PRE-CREATE nudge to reuse before building in the 2.0
+ * platform apps.
+ *
+ * Why this exists: the platform has ~10 apps sharing one component library
+ * (toga25-blox). New pages keep getting fresh components, hooks and styles that already
+ * exist in blox or in another app. The "reuse before build" rule
+ * (rules/common/architecture-principles.md) is passive; this puts it in context at the
+ * moment a new file is about to be created.
+ *
+ * How it works: registered on PreToolUse for Write|Edit. It fires only when ALL hold:
+ *   - the target file does NOT exist yet (a new file),
+ *   - it ends .tsx / .ts / .css (not .test.ts / .d.ts),
+ *   - it sits under the `src/` of a platform app — a folder whose vite.config.ts calls
+ *     defineTogaApp — or under the `src/` of the toga25-blox repo itself.
+ * Then it adds a short reminder through the PreToolUse additionalContext channel.
+ * Once per file path per session (state file in the OS temp dir, keyed on session id).
+ *
+ * It never blocks. It always exits 0 and fails open on any error.
+ *
+ * Escape hatch: set TOGA_REUSE_REMINDER_DISABLED=1 to silence the reminder.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// Single-source platform consolidation rule (lives in toga25-blox).
+const CONSOLIDATION_DOC = 'toga25-blox/docs/consolidation.md';
+const BLOX_INVENTORY = '../toga25-blox/INVENTORY.md';
+const APP_REUSE_DOC = 'docs/architecture/reusable-components.md';
+const BLOX_PACKAGE_NAME = '@toga/blox';
+const BLOX_DIR_NAME = 'toga25-blox';
+const MAX_WALK_UP_LEVELS = 15;
+const MAX_SEEN_PATHS = 500;
+
+function readPayload() {
+  let raw = '';
+  try { raw = fs.readFileSync(0, 'utf8'); } catch (e) { /* no stdin */ }
+  let data = {};
+  if (raw && raw.trim()) {
+    try { data = JSON.parse(raw); } catch (e) { data = {}; }
+  }
+  if (!data.tool_name && process.env.CLAUDE_TOOL_NAME) data.tool_name = process.env.CLAUDE_TOOL_NAME;
+  if (!data.tool_input && process.env.CLAUDE_TOOL_INPUT) {
+    try { data.tool_input = JSON.parse(process.env.CLAUDE_TOOL_INPUT); } catch (e) { /* ignore */ }
+  }
+  if (!data.session_id) data.session_id = process.env.CLAUDE_SESSION_ID || process.env.CLAUDE_CODE_SESSION_ID;
+  return data;
+}
+
+function isWatchedExtension(filePath) {
+  const p = filePath.toLowerCase();
+  if (p.endsWith('.d.ts') || p.endsWith('.test.ts') || p.endsWith('.test.tsx')) return false;
+  return /\.(tsx|ts|css)$/.test(p);
+}
+
+function isBloxRoot(dir) {
+  if (path.basename(dir).toLowerCase() !== BLOX_DIR_NAME) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+      return pkg && pkg.name === BLOX_PACKAGE_NAME;
+    } catch (e) { return false; }
+  }
+  return fs.existsSync(path.join(dir, 'package.json'));
+}
+
+function isPlatformAppRoot(dir) {
+  try {
+    return fs.readFileSync(path.join(dir, 'vite.config.ts'), 'utf8').includes('defineTogaApp');
+  } catch (e) { return false; }
+}
+
+/* Walk up from the file to the nearest project root. Returns { root, isBlox } when the
+ * nearest root is a platform app or blox, else null. The file must be under root/src/. */
+function findPlatformRoot(filePath) {
+  let dir = path.dirname(filePath);
+  for (let i = 0; i < MAX_WALK_UP_LEVELS; i++) {
+    const app = isPlatformAppRoot(dir);
+    const blox = !app && isBloxRoot(dir);
+    if (app || blox) {
+      const rel = path.relative(dir, filePath).replace(/\\/g, '/');
+      return rel.startsWith('src/') ? { root: dir, isBlox: blox } : null;
+    }
+    if (fs.existsSync(path.join(dir, 'package.json'))) return null; // some other project
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+
+function sessionKey(data) {
+  const sid = (data && data.session_id) || String(process.ppid || process.pid);
+  return String(sid).replace(/[^A-Za-z0-9_-]/g, '').slice(0, 64) || 'x';
+}
+
+/* True the first time this path is seen this session; records it. */
+function firstTimeThisSession(data, normPath) {
+  const sf = path.join(os.tmpdir(), 'toga-reuse-reminder-' + sessionKey(data) + '.json');
+  let seen = [];
+  try { seen = JSON.parse(fs.readFileSync(sf, 'utf8')) || []; } catch (e) { seen = []; }
+  if (!Array.isArray(seen)) seen = [];
+  if (seen.includes(normPath)) return false;
+  seen.push(normPath);
+  try { fs.writeFileSync(sf, JSON.stringify(seen.slice(-MAX_SEEN_PATHS))); } catch (e) { /* non-fatal */ }
+  return true;
+}
+
+function reminder(isBlox) {
+  const where = isBlox
+    ? 'New file in toga25-blox. Before creating it: check INVENTORY.md in this repo'
+    : 'New file in a platform app. Before creating it: check `' + BLOX_INVENTORY + '` and this app\'s `' +
+      APP_REUSE_DOC + '`';
+  return [
+    '<system-reminder>',
+    where + ' — reuse or extend an existing piece first.',
+    'If this duplicates something in another page or app, consolidate instead',
+    '(rule: `' + CONSOLIDATION_DOC + '`).',
+    '</system-reminder>',
+  ].join('\n');
+}
+
+function main() {
+  if (process.env.TOGA_REUSE_REMINDER_DISABLED === '1') return;
+
+  const data = readPayload();
+  if (!/^(Write|Edit)$/.test(data.tool_name || '')) return;
+
+  const input = data.tool_input || {};
+  const filePath = typeof input.file_path === 'string' ? input.file_path : '';
+  if (!filePath || !isWatchedExtension(filePath)) return;
+
+  const abs = path.resolve(data.cwd || process.cwd(), filePath);
+  if (fs.existsSync(abs)) return; // only new files
+
+  const hit = findPlatformRoot(abs);
+  if (!hit) return;
+
+  if (!firstTimeThisSession(data, abs.replace(/\\/g, '/').toLowerCase())) return;
+
+  console.log(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      additionalContext: reminder(hit.isBlox),
+    },
+  }));
+}
+
+try { main(); } catch (e) { /* fail-open: never block or brick an edit */ }
+process.exitCode = 0; // always 0; exitCode (not exit()) lets stdout flush on Windows pipes