create-claude-cabinet 0.29.0 → 0.29.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-cabinet",
-  "version": "0.29.0",
+  "version": "0.29.2",
   "description": "Claude Cabinet — opinionated process scaffolding for Claude Code projects",
   "bin": {
     "create-claude-cabinet": "bin/create-claude-cabinet.js"

package/templates/site-audit-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-cabinet/site-audit",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Comprehensive deployed-site quality audit engine for Claude Cabinet. Runs checks across performance, accessibility, security, SEO, content, DNS, and privacy against a deployed URL; single-site and comparison modes; standalone HTML report.",
   "type": "module",
   "bin": {

package/templates/skills/verify/SKILL.md

@@ -286,24 +286,41 @@ the skill handles all `e2e/` directory navigation internally.** No
    on macOS — Playwright inherits display access) and human verdicts
    (file-based IPC when stdin is not a TTY).
 
+   **Progress streaming:** Immediately after starting the background
+   command, arm a Monitor on the progress file:
+
+   ```
+   Monitor({
+     description: "verify progress",
+     command: "tail -f e2e/.verify-progress.jsonl | grep -E --line-buffered 'check-fail|scenario-start|scenario-end|run-end|verdict-pending'",
+     persistent: true
+   })
+   ```
+
+   This streams scenario starts, failures, and verdict requests as
+   real-time conversation notifications. Check passes are filtered
+   out to avoid noise. When a `verdict-pending` event arrives,
+   handle it immediately (see below).
+
    **Human verdict orchestration:** When the runtime hits a human
    verdict step in non-TTY mode, it writes
-   `e2e/.verdict-pending.json` and polls for `e2e/.verdict-response.json`.
-   The skill monitors for the pending file while the background
-   command runs:
-
-   1. Start the npm command via Bash with `run_in_background: true`
-   2. Poll `e2e/.verdict-pending.json` (check every 3-5 seconds)
-   3. When found, read it — contains `checkId`, `description`,
-      `screenshotPath` (absolute path to the screenshot)
-   4. Read the screenshot image and show it to the user
-   5. Ask the user for their verdict (P/I/S/N + optional notes)
-   6. Write `e2e/.verdict-response.json`:
+   `e2e/.verdict-pending.json` and emits a `verdict-pending` event
+   to the progress file. The Monitor delivers the event as a
+   notification. On receiving a `verdict-pending` notification:
+
+   1. Read `e2e/.verdict-pending.json` — contains `checkId`,
+      `description`, `screenshotPath` (absolute path to screenshot)
+   2. Read the screenshot image and show it to the user
+   3. Ask the user for their verdict (P/I/S/N + optional notes)
+   4. Write `e2e/.verdict-response.json`:
       ```json
       { "verdict": "P", "notes": "looks great" }
       ```
-   7. The runtime picks up the response, records it, continues
-   8. Go back to step 2 until the background command completes
+   5. The runtime picks up the response, records it, continues
+
+   When a `check-fail` notification arrives, surface it immediately:
+   show the step text and error message so the user knows what failed
+   without waiting for the end summary.
 
    The runtime times out after 10 minutes per verdict (auto-skips
    with `human:S` if no response). The pending/response files are

package/templates/skills/verify/install.sh

@@ -452,7 +452,7 @@ fi
 
 # .gitignore updates at project root.
 GITIGNORE_ROOT=".gitignore"
-GITIGNORE_ENTRIES=("e2e/reports/" "e2e/screenshots/" "e2e/traces/" "e2e/fixtures/articles/" "e2e/.env.local" "e2e/node_modules/" "e2e/.last-verify-run" "e2e/.verdict-pending.json" "e2e/.verdict-response.json")
+GITIGNORE_ENTRIES=("e2e/reports/" "e2e/screenshots/" "e2e/traces/" "e2e/fixtures/articles/" "e2e/.env.local" "e2e/node_modules/" "e2e/.last-verify-run" "e2e/.verdict-pending.json" "e2e/.verdict-response.json" "e2e/.verify-progress.jsonl")
 
 if [[ $DRY_RUN -eq 1 ]]; then
   for entry in "${GITIGNORE_ENTRIES[@]}"; do

package/templates/verify-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cabinet-verify",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Walkthrough verification harness for Claude Cabinet. Cucumber + Playwright scenarios with human-in-the-loop verdict pause.",
   "type": "module",
   "main": "./dist/src/index.js",

package/templates/verify-runtime/src/human-verdict.ts

@@ -4,6 +4,7 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import * as readline from 'readline';
 import { recordVerdict, getCurrentScenarioFile } from './verdict-recorder.js';
+import { emitProgress } from './progress.js';
 import { getFreshPass } from './fresh-pass-cache.js';
 import { computePathHash } from './path-hash.js';
 import { out } from './output.js';
@@ -155,6 +156,7 @@ export async function askHumanVerdict(
       acItemId: options?.acItemId ?? null,
     }), 'utf8');
 
+    emitProgress({ event: 'verdict-pending', checkId, description, screenshotPath: path.resolve(screenshotPath) });
     process.stderr.write(`\n  ${out.c.yellow('⏳')} Waiting for verdict on ${out.c.bold(checkId)} via file IPC...\n`);
 
     // Poll for response (500ms intervals, 10 min timeout)

package/templates/verify-runtime/src/index.ts

@@ -49,6 +49,11 @@ export {
   traceFilePath,
 } from './trace.js';
 
+export {
+  initProgress,
+  emitProgress,
+} from './progress.js';
+
 export {
   computePathHash,
   computePathHashSafe,

package/templates/verify-runtime/src/launch-options.ts

@@ -20,9 +20,12 @@ export function resolveLaunchOptions(env: Record<string, string | undefined>): L
     slowMo = 1000;
   }
 
-  return {
-    headless,
-    slowMo,
-    args: ['--window-size=1500,1000'],
-  };
+  const windowSize = env.CABINET_VERIFY_WINDOW_SIZE || (demo ? '1100,750' : '1500,1000');
+  const args = [`--window-size=${windowSize}`];
+  if (demo) {
+    const windowPos = env.CABINET_VERIFY_WINDOW_POSITION || '0,0';
+    args.push(`--window-position=${windowPos}`);
+  }
+
+  return { headless, slowMo, args };
 }

package/templates/verify-runtime/src/progress.ts

@@ -0,0 +1,17 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+const PROGRESS_FILE = '.verify-progress.jsonl';
+
+let progressPath = '';
+
+export function initProgress(cwd: string): void {
+  progressPath = path.resolve(cwd, PROGRESS_FILE);
+  try { fs.writeFileSync(progressPath, '', 'utf8'); } catch { /* tolerate */ }
+}
+
+export function emitProgress(event: Record<string, unknown>): void {
+  if (!progressPath) return;
+  const line = JSON.stringify({ ...event, ts: new Date().toISOString() });
+  try { fs.appendFileSync(progressPath, line + '\n', 'utf8'); } catch { /* tolerate */ }
+}

package/templates/verify-runtime/src/world.ts

@@ -53,6 +53,7 @@ import { resolveLaunchOptions, isDemoMode } from './launch-options.js';
 import { initDemo, drainDemo } from './demo-recorder.js';
 import { pauseOnFailure } from './pause-on-failure.js';
 import { traceEnabled, traceFilePath } from './trace.js';
+import { initProgress, emitProgress } from './progress.js';
 
 // Default 240s — catches real hangs without killing legit long steps.
 // Steps that legitimately take longer (rewrites, manual think-time)
@@ -64,6 +65,7 @@ let browser: Browser | undefined;
 BeforeAll(async () => {
   const opts = resolveLaunchOptions(process.env);
   initDemo(process.env);
+  initProgress(process.cwd());
   if (isDemoMode(process.env) && opts.slowMo > 0) {
     out.writeln(`  ${out.c.dim('[demo] slowMo: ' + opts.slowMo + 'ms')}`);
   }
@@ -97,6 +99,7 @@ BeforeAll(async () => {
 AfterAll(async () => {
   drainDemo();
   const summary = await endRun();
+  emitProgress({ event: 'run-end', passed: summary.passed, failed: summary.failed, total: summary.total });
   out.runSummary({
     runId: summary.runId,
     total: summary.total,
@@ -183,6 +186,7 @@ Before(async function (this: CabinetVerifyWorld, scenario) {
 
   out.scenarioStart(scenario.pickle.name, scenario.gherkinDocument.uri || 'unknown');
   setScenarioContext(scenario.gherkinDocument.uri || 'unknown', scenario.pickle.name, this.role);
+  emitProgress({ event: 'scenario-start', name: scenario.pickle.name, file: scenario.gherkinDocument.uri || 'unknown' });
 });
 
 After(async function (this: CabinetVerifyWorld, scenario) {
@@ -212,6 +216,7 @@ After(async function (this: CabinetVerifyWorld, scenario) {
     this.tracing = false;
   }
 
+  emitProgress({ event: 'scenario-end', name: scenario.pickle.name, status: scenario.result?.status ?? 'UNKNOWN' });
   await this.context?.close();
 });
 
@@ -225,6 +230,15 @@ AfterStep(async function (this: CabinetVerifyWorld, { result, pickleStep }) {
     }
   }
 
+  if (result && pickleStep?.text) {
+    const stepStatus = result.status.toString();
+    if (stepStatus === 'PASSED') {
+      emitProgress({ event: 'check-pass', step: pickleStep.text });
+    } else if (stepStatus === 'FAILED') {
+      emitProgress({ event: 'check-fail', step: pickleStep.text, error: (result as { message?: string }).message ?? '' });
+    }
+  }
+
   if (result) {
     await pauseOnFailure(
       this.page,

package/templates/verify-runtime/test/demo-mode.test.ts

@@ -19,10 +19,12 @@ describe('isDemoMode', () => {
 });
 
 describe('resolveLaunchOptions', () => {
-  it('DEMO=1 defaults slowMo to 1000 when SLOW_MO unset', () => {
+  it('DEMO=1 defaults slowMo to 1000, smaller window, positioned top-left', () => {
     const opts = resolveLaunchOptions({ CABINET_VERIFY_DEMO: '1' });
     assert.equal(opts.slowMo, 1000);
     assert.equal(opts.headless, false);
+    assert.ok(opts.args.includes('--window-size=1100,750'));
+    assert.ok(opts.args.includes('--window-position=0,0'));
   });
 
   it('DEMO=1 respects explicit SLOW_MO=250', () => {