@walwal-harness/cli 7.1.40 → 7.1.42

package/HR-Resource/cdo/SKILL.md

@@ -27,7 +27,15 @@ Before design work, read `.harness/conventions/shared.md`, `.harness/conventions
 
 ## Worker Activity Telemetry
 
-Before launching any fresh worker session, update `.harness/progress.json` with `scripts/harness-progress-set.sh` so dashboards can show the worker as active. Record the worker name, owning CXX, report path, and `status:"running"` under `company_state.workers`, increment `company_state.active_workers`, and set `conductor.current_action` to `spawn:{worker-name}`. After the worker report is accepted, update that worker to `status:"complete"` and decrement `active_workers`. Do not leave `active_workers:0` while a worker session is running.
+When CEO routes this mission to you, set yourself as the live agent on entry so the dashboard shows the handoff: `bash scripts/harness-progress-set.sh . '.current_agent="cdo" | .agent_status="running"'`.
+
+Before launching any fresh worker session, update `.harness/progress.json` with `scripts/harness-progress-set.sh` so dashboards can show the worker as active. Record the worker name, owning CXX, report path, and `status:"running"` under `company_state.workers`, increment `company_state.active_workers`, and set `conductor.current_action` to `spawn:{worker-name}`. After the worker report is accepted, update that worker to `status:"complete"` and decrement `active_workers`. Do not leave `active_workers:0` while a worker session is running. Require every worker report to open with a `## Status` line whose body is `IN_PROGRESS` while the worker runs and `COMPLETE` once the report is final, so the dashboard shows true worker liveness instead of guessing from file timestamps.
+
+On exit, after writing `cdo.md` and handing back to CEO, run `bash scripts/harness-progress-set.sh . '.agent_status="completed"'` so the loop advances and the dashboard reflects the finished step. Do not clear `conductor.state`; only the CEO's Company Loop Termination step ends the loop.
+
+## Operating Mode — Status Briefing & Agenda
+
+When the active goal is operating (perpetual, `mission-state.json` lifecycle `operating`), CEO periodically orders a 현황 보고. In it, confirm — with worker-backed evidence — whether your hired workers' live deliverables still operate correctly toward the goal (for CDO: is the shipped UI/UX/brand still consistent and usable?). If you discover a regression, drift, incident, opportunity, or risk, do not silently fix it or sit on it: raise it as an agenda item so CEO can adjudicate and route the next cycle: `bash scripts/harness-agenda.sh . <goal-rel> raise cdo <kind> "<title>" "<evidence-path>"` (kinds: loss, drift, incident, opportunity, risk, verification-gap). When CEO routes a decided agenda item to you, execute it through hired workers, get CQO verification where behavior must be proven, and report so CEO can close the item.
 
 ## Rule
 

package/HR-Resource/ceo/SKILL.md

@@ -32,6 +32,37 @@ CEO is authorized to approve routine company operations without Owner confirmati
 
 If an operational choice is reversible and uses existing project-local credentials or configuration, CEO decides, records the rationale in `ceo.md`, and continues. Escalate only for new secrets, new spending, legal/business acceptance, unavailable external production access, destructive data action, or a direct conflict with the Owner's stated direction.
 
+## Company Loop Termination
+
+There are exactly two legitimate ways to end the company loop, and each requires an explicit **runtime transition**. Writing `ceo.md` and `mission-state.json` is not enough: the autonomous Stop loop and the dashboard read `progress.json` runtime state (`conductor.state`, `agent_status`, `current_agent`), not your documents. If you finish a report but never fire the transition, the loop stays `running` and the harness keeps prompting you to continue — this is the "is it done or not?" ambiguity. Avoid it by always ending in one of these two states:
+
+1. **COMPLETE** — the mission is genuinely finished: the final Owner report is in `ceo.md`, all required CXX/worker/OPS evidence is collected, and `mission-state.json` is terminal (`complete`/`closed`/`cancelled`/`superseded`) with `active:false`. As the **literal final action of the turn**, run:
+   `bash scripts/harness-company-complete.sh . <reason>`
+2. **BLOCKED on external authority** — the next action genuinely needs authority the harness cannot infer or obtain (new credentials/secrets, payment approval, legal/business acceptance, unavailable production access, destructive data action, or a direct conflict with the Owner's stated direction). Record the exact missing authority and the internally recommended default in `ceo.md`, set `mission-state.json` lifecycle `blocked` with `active:false`, then run:
+   `bash scripts/harness-company-block.sh . "<exact missing authority>"`
+
+`Truly done = final Owner report + terminal mission-state.json + the matching runtime transition fired.` Until one of these two transitions runs, the mission is still in progress: keep routing CXX and worker work autonomously between turns. Never fire the completion transition while real CXX/worker/verification work remains, and never end a turn in the `running` state with no further action queued.
+
+**Completion applies only to FINITE goals.** A perpetual/operating goal (next section) NEVER completes — `harness-company-complete.sh` must not be run for it.
+
+## Operating (Perpetual) Goals — the never-ending company loop
+
+First, **classify the goal**:
+
+- **Finite** goal — "build X", "add Y", "fix Z": has a definite done state. Use the Company Loop Termination above.
+- **Operating (perpetual)** goal — "run/operate/monitor/keep growing X", "지속/영구 운영", "make money continuously", anything that should *never* stop (e.g. "build a trading bot and keep it profitable forever"): it must run as a standing company that cycles indefinitely.
+
+For an operating goal, set `mission-state.json` to `{"lifecycle":"operating","active":true}` (it stays active forever) and **never** call `harness-company-complete.sh`. The only ways an operating goal ends are: the Owner explicitly orders it stopped (then run `harness-company-complete.sh`), or a true external-authority block (then `harness-company-block.sh`).
+
+Run it as an **agenda-driven standing executive loop**. The agenda is the shared meetup file every CXX co-writes at `.harness/documents/{goal}/agenda.json`, managed with `scripts/harness-agenda.sh`. Each operating tick:
+
+1. **Read the agenda** (`scripts/harness-agenda.sh . {goal} list`).
+2. **If there are active items**, you are *forced* to drive them: for every `open` item, decide and record the decision (`scripts/harness-agenda.sh . {goal} decide <id> "<decision>" <owning-cxx>`), then route that CXX to execute through hired workers and CQO-verify; when an item's work is done and verified, close it (`... close <id>`). Do not end the turn with active agenda.
+3. **If the agenda is empty ("보고사항 없음")**, run a **status-briefing round**: require each relevant CXX (COO/CDO/CTO/CQO/OPS) to file a 현황 보고 — confirm that its workers' *live deliverables* still operate correctly toward the goal — and to raise any newly discovered loss/drift/opportunity/risk as a new agenda item (`scripts/harness-agenda.sh . {goal} raise <cxx> <kind> "<title>" "<evidence>"`). This is how the company discovers its own next work.
+4. **If a full briefing round genuinely surfaces nothing**, record the operating heartbeat (`scripts/harness-company-cycle.sh . {goal}`) and end the turn — the hourly wake loop resumes the next cycle. This keeps the company always-on without burning a turn spinning.
+
+The canonical operating cycle for a self-improving system: `OPS monitor → on loss/drift/opportunity, COO researches + backtests a new strategy → CTO applies it safely → CQO verifies → OPS operates and watches → (repeat)`. Losses are not failures to report to the Owner; they are agenda items that trigger the next research→apply→operate cycle autonomously.
+
 ## Lazy Rule Loading
 
 Before routing or accepting CXX work, enforce lazy loading:
@@ -51,8 +82,8 @@ Before routing or accepting CXX work, enforce lazy loading:
    - CTO: architecture, platform, API, account, web/app/backend/frontend wiring.
    - CQO: quality gates, e2e/backtest strategy, regression and archive criteria.
    - OPS: build/service environment monitoring, CQO verification watch, port map checks, launch observation, production watch, and exception monitoring.
-4. Route completed outputs to the next responsible CXX.
-5. Report outcomes, final acceptance requests, and true external-authority blocks to the Owner.
+4. Route completed outputs to the next responsible CXX. Keep `progress.json` `current_agent` honest as you route so the dashboard shows the live handoff: each CXX sets `current_agent` to its own role on entry; set it back with `bash scripts/harness-progress-set.sh . '.current_agent="ceo" | .agent_status="running"'` whenever you resume between CXX steps and before the final report.
+5. Report outcomes, final acceptance requests, and true external-authority blocks to the Owner, then fire the Company Loop Termination transition (complete or blocked).
 
 ## Hard Rules
 

package/HR-Resource/coo/SKILL.md

@@ -37,7 +37,15 @@ During planning, COO must determine whether the active runtime exposes MCP serve
 
 ## Worker Activity Telemetry
 
-Before launching any fresh worker session, update `.harness/progress.json` with `scripts/harness-progress-set.sh` so dashboards can show the worker as active. Record the worker name, owning CXX, report path, and `status:"running"` under `company_state.workers`, increment `company_state.active_workers`, and set `conductor.current_action` to `spawn:{worker-name}`. After the worker report is accepted, update that worker to `status:"complete"` and decrement `active_workers`. Do not leave `active_workers:0` while a worker session is running.
+When CEO routes this mission to you, set yourself as the live agent on entry so the dashboard shows the handoff: `bash scripts/harness-progress-set.sh . '.current_agent="coo" | .agent_status="running"'`.
+
+Before launching any fresh worker session, update `.harness/progress.json` with `scripts/harness-progress-set.sh` so dashboards can show the worker as active. Record the worker name, owning CXX, report path, and `status:"running"` under `company_state.workers`, increment `company_state.active_workers`, and set `conductor.current_action` to `spawn:{worker-name}`. After the worker report is accepted, update that worker to `status:"complete"` and decrement `active_workers`. Do not leave `active_workers:0` while a worker session is running. Require every worker report to open with a `## Status` line whose body is `IN_PROGRESS` while the worker runs and `COMPLETE` once the report is final, so the dashboard shows true worker liveness instead of guessing from file timestamps.
+
+On exit, after writing `coo.md` and handing back to CEO, run `bash scripts/harness-progress-set.sh . '.agent_status="completed"'` so the loop advances and the dashboard reflects the finished step. Do not clear `conductor.state`; only the CEO's Company Loop Termination step ends the loop.
+
+## Operating Mode — Status Briefing & Agenda
+
+When the active goal is operating (perpetual, `mission-state.json` lifecycle `operating`), CEO periodically orders a 현황 보고. In it, confirm — with worker-backed evidence — whether your hired workers' live deliverables still operate correctly toward the goal (for COO: is the current strategy/plan still valid and performing in research/backtest?). If you discover a loss, drift, regression, incident, opportunity, or risk, do not silently fix it or sit on it: raise it as an agenda item so CEO can adjudicate and route the next cycle: `bash scripts/harness-agenda.sh . <goal-rel> raise coo <kind> "<title>" "<evidence-path>"` (kinds: loss, drift, incident, opportunity, risk, verification-gap). When CEO routes a decided agenda item to you, execute it through hired workers, get CQO verification where behavior must be proven, and report so CEO can close the item.
 
 ## Non-Execution Rule
 

package/HR-Resource/cqo/SKILL.md

@@ -26,7 +26,15 @@ Before quality work, read `.harness/conventions/shared.md`, `.harness/convention
 
 ## Worker Activity Telemetry
 
-Before launching any fresh worker session, update `.harness/progress.json` with `scripts/harness-progress-set.sh` so dashboards can show the worker as active. Record the worker name, owning CXX, report path, and `status:"running"` under `company_state.workers`, increment `company_state.active_workers`, and set `conductor.current_action` to `spawn:{worker-name}`. After the worker report is accepted, update that worker to `status:"complete"` and decrement `active_workers`. Do not leave `active_workers:0` while a worker session is running.
+When CEO routes this mission to you, set yourself as the live agent on entry so the dashboard shows the handoff: `bash scripts/harness-progress-set.sh . '.current_agent="cqo" | .agent_status="running"'`.
+
+Before launching any fresh worker session, update `.harness/progress.json` with `scripts/harness-progress-set.sh` so dashboards can show the worker as active. Record the worker name, owning CXX, report path, and `status:"running"` under `company_state.workers`, increment `company_state.active_workers`, and set `conductor.current_action` to `spawn:{worker-name}`. After the worker report is accepted, update that worker to `status:"complete"` and decrement `active_workers`. Do not leave `active_workers:0` while a worker session is running. Require every worker report to open with a `## Status` line whose body is `IN_PROGRESS` while the worker runs and `COMPLETE` once the report is final, so the dashboard shows true worker liveness instead of guessing from file timestamps.
+
+On exit, after writing `cqo.md` and handing back to CEO, run `bash scripts/harness-progress-set.sh . '.agent_status="completed"'` so the loop advances and the dashboard reflects the finished step. Do not clear `conductor.state`; only the CEO's Company Loop Termination step ends the loop.
+
+## Operating Mode — Status Briefing & Agenda
+
+When the active goal is operating (perpetual, `mission-state.json` lifecycle `operating`), CEO periodically orders a 현황 보고. In it, confirm — with evaluator-worker evidence — whether the live system still passes the quality/regression bar toward the goal (for CQO: are regression/e2e/perf/security gates still green on the running system?). If you discover a regression, quality drift, incident, or verification gap, do not silently sit on it: raise it as an agenda item so CEO can adjudicate and route the next cycle: `bash scripts/harness-agenda.sh . <goal-rel> raise cqo <kind> "<title>" "<evidence-path>"` (kinds: loss, drift, incident, opportunity, risk, verification-gap). When CEO routes a decided agenda item to you, run the evaluator/tester workers, issue a verdict, and report so CEO can close the item.
 
 ## Hard Rules
 

package/HR-Resource/cto/SKILL.md

@@ -28,13 +28,21 @@ Before engineering work, read `.harness/conventions/shared.md`, `.harness/conven
 
 ## Worker Activity Telemetry
 
-Before launching any fresh worker session, update `.harness/progress.json` with `scripts/harness-progress-set.sh` so dashboards can show the worker as active. Record the worker name, owning CXX, report path, and `status:"running"` under `company_state.workers`, increment `company_state.active_workers`, and set `conductor.current_action` to `spawn:{worker-name}`. After the worker report is accepted, update that worker to `status:"complete"` and decrement `active_workers`. Do not leave `active_workers:0` while a worker session is running.
+When CEO routes this mission to you, set yourself as the live agent on entry so the dashboard shows the handoff: `bash scripts/harness-progress-set.sh . '.current_agent="cto" | .agent_status="running"'`.
+
+Before launching any fresh worker session, update `.harness/progress.json` with `scripts/harness-progress-set.sh` so dashboards can show the worker as active. Record the worker name, owning CXX, report path, and `status:"running"` under `company_state.workers`, increment `company_state.active_workers`, and set `conductor.current_action` to `spawn:{worker-name}`. After the worker report is accepted, update that worker to `status:"complete"` and decrement `active_workers`. Do not leave `active_workers:0` while a worker session is running. Require every worker report to open with a `## Status` line whose body is `IN_PROGRESS` while the worker runs and `COMPLETE` once the report is final, so the dashboard shows true worker liveness instead of guessing from file timestamps.
+
+On exit, after writing `cto.md` and handing back to CEO, run `bash scripts/harness-progress-set.sh . '.agent_status="completed"'` so the loop advances and the dashboard reflects the finished step. Do not clear `conductor.state`; only the CEO's Company Loop Termination step ends the loop.
+
+## Operating Mode — Status Briefing & Agenda
+
+When the active goal is operating (perpetual, `mission-state.json` lifecycle `operating`), CEO periodically orders a 현황 보고. In it, confirm — with worker-backed evidence — whether your hired workers' live deliverables still operate correctly toward the goal (for CTO: is the running system stable — errors, latency, uptime, resource limits?). If you discover a failure, drift, incident, opportunity, or risk, do not silently fix it or sit on it: raise it as an agenda item so CEO can adjudicate and route the next cycle: `bash scripts/harness-agenda.sh . <goal-rel> raise cto <kind> "<title>" "<evidence-path>"` (kinds: loss, drift, incident, opportunity, risk, verification-gap). When CEO routes a decided agenda item to you, implement it through hired workers, get CQO verification, and report so CEO can close the item.
 
 ## Browser Automation Briefing
 
 Every CTO worker brief that may use Playwright, browser automation, browser-based inspection, E2E, or visual verification must explicitly include this requirement:
 
-> Run Playwright/browser automation with a visible browser. Set `headless: false` in launch/config code, use headed test mode (`--headed`, `PWDEBUG=1`, or equivalent), prefer `channel: 'chrome'` when available, and do not use headless mode unless the Owner has explicitly approved an exception in this mission.
+> Run Playwright/browser automation with a visible browser. Set `headless: false` in launch/config code, use headed test mode (`--headed`, `PWDEBUG=1`, or equivalent), prefer `channel: 'chrome'` when available, and do not use headless mode unless the Owner has explicitly approved an exception in this mission. Pace it middle-fast: `slowMo: 120` (ms) — observable but brisk. Do not use `slowMo: 300`+ (too slow); raise it only if the Owner explicitly asks to slow the demo down.
 
 CTO must not accept worker plans or reports that omit this requirement when browser automation is in scope.
 

package/HR-Resource/ops/SKILL.md

@@ -52,13 +52,13 @@ OPS must actively watch the runtime while CQO evaluator workers test the product
 
 ## Dev-Mode Prompt Inspector
 
-When OPS builds or runs a React/Next.js UI in development mode, and screen-level discussion would benefit from selecting visible UI elements and mapping intended REST/API behavior, OPS must use the installed `harness-ops-prompt-inspector` skill.
+When OPS builds or runs a React/Next.js or static HTML UI in development mode, and screen-level discussion would benefit from selecting visible UI elements and mapping intended REST/API behavior, OPS must use the installed `harness-ops-prompt-inspector` skill.
 
 - Use Prompt Inspector only for development builds or verification environments. Do not inject it into production builds or production service environments.
 - Install it from the project-local skill path under `.claude/skills/harness-ops-prompt-inspector/` or `.codex/skills/harness-ops-prompt-inspector/`; do not download it at mission runtime.
 - Run its installer against the target app path before or during the dev-mode run so the toolbar is available in the browser for UI/API binding notes.
 - Record the install result, target app path, dev server URL, and generated API discovery evidence in OPS environment evidence.
-- If the project is not React/Next.js or the build is not development mode, report Prompt Inspector as not applicable instead of forcing installation.
+- If the project is not React/Next.js, static HTML, or the build is not development mode, report Prompt Inspector as not applicable instead of forcing installation.
 
 ## Post-Launch Watch
 
@@ -92,13 +92,21 @@ After service launch, OPS continues the same monitoring duty against `runtime.pr
 
 ## Worker Activity Telemetry
 
-Before launching any fresh worker session, update `.harness/progress.json` with `scripts/harness-progress-set.sh` so dashboards can show the worker as active. Record the worker name, owning CXX, report path, and `status:"running"` under `company_state.workers`, increment `company_state.active_workers`, and set `conductor.current_action` to `spawn:{worker-name}`. After the worker report is accepted, update that worker to `status:"complete"` and decrement `active_workers`. Do not leave `active_workers:0` while a worker session is running.
+When CEO routes this mission to you, set yourself as the live agent on entry so the dashboard shows the handoff: `bash scripts/harness-progress-set.sh . '.current_agent="ops" | .agent_status="running"'`.
+
+Before launching any fresh worker session, update `.harness/progress.json` with `scripts/harness-progress-set.sh` so dashboards can show the worker as active. Record the worker name, owning CXX, report path, and `status:"running"` under `company_state.workers`, increment `company_state.active_workers`, and set `conductor.current_action` to `spawn:{worker-name}`. After the worker report is accepted, update that worker to `status:"complete"` and decrement `active_workers`. Do not leave `active_workers:0` while a worker session is running. Require every worker report to open with a `## Status` line whose body is `IN_PROGRESS` while the worker runs and `COMPLETE` once the report is final, so the dashboard shows true worker liveness instead of guessing from file timestamps.
+
+On exit, after writing `ops.md` and handing back to CEO, run `bash scripts/harness-progress-set.sh . '.agent_status="completed"'` so the loop advances and the dashboard reflects the finished step. Do not clear `conductor.state`; only the CEO's Company Loop Termination step ends the loop.
+
+## Operating Mode — Status Briefing & Agenda
+
+When the active goal is operating (perpetual, `mission-state.json` lifecycle `operating`), OPS is the primary monitor of the never-ending loop. On every CEO 현황 보고, report — with monitoring evidence (logs, health, ports, metrics, P&L or domain KPIs) — whether the live system still operates correctly toward the goal. Any loss, drawdown, drift, incident, degraded health, or opportunity MUST become an agenda item so CEO can adjudicate and route the next research→apply→operate cycle: `bash scripts/harness-agenda.sh . <goal-rel> raise ops <kind> "<title>" "<evidence-path>"` (kinds: loss, drift, incident, opportunity, risk, verification-gap). OPS does not fix systems itself — it surfaces the agenda and supplies evidence; CTO owns the fix, COO owns new-strategy research, CQO owns verification. A clean monitoring round with nothing to raise is itself a valid briefing result.
 
 ## Browser Automation Briefing
 
 Every OPS worker brief that may use Playwright, browser automation, browser-based monitoring, E2E, or visual/runtime verification must explicitly include this requirement:
 
-> Run Playwright/browser automation with a visible browser. Set `headless: false` in launch/config code, use headed test mode (`--headed`, `PWDEBUG=1`, or equivalent), prefer `channel: 'chrome'` when available, and do not use headless mode unless the Owner has explicitly approved an exception in this mission.
+> Run Playwright/browser automation with a visible browser. Set `headless: false` in launch/config code, use headed test mode (`--headed`, `PWDEBUG=1`, or equivalent), prefer `channel: 'chrome'` when available, and do not use headless mode unless the Owner has explicitly approved an exception in this mission. Pace it middle-fast: `slowMo: 120` (ms) — observable but brisk. Do not use `slowMo: 300`+ (too slow); raise it only if the Owner explicitly asks to slow the demo down.
 
 OPS must not accept worker plans or reports that omit this requirement when browser automation is in scope.
 

package/HR-Resource/ops-prompt-inspector/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: harness-ops-prompt-inspector
-description: "OPS-only dev-mode visual API binding for React/Next.js UI elements and REST endpoints."
+description: "OPS-only dev-mode visual API binding for React/Next.js or static HTML UI elements and REST endpoints."
 permissionMode: bypassPermissions
 ---
 
 # OPS Prompt Inspector
 
-OPS-only visual tool for binding UI elements to REST APIs in React/Next.js projects during development builds.
+OPS-only visual tool for binding UI elements to REST APIs in React/Next.js or static HTML projects during development builds.
 
 Use this skill only when OPS is responsible for a dev-mode build/run or verification environment where screen-level communication would be improved by an on-page inspector. Do not install it into production builds.
 
@@ -29,9 +29,9 @@ bash scripts/install.sh <project_path>
 ```
 
 This automatically:
-1. Detects project type (Next.js App/Pages Router)
-2. Copies component to `components/PromptInspector.tsx`
-3. Injects into root layout (dev mode only)
+1. Detects project type (Next.js App/Pages Router or static `index.html`)
+2. Copies component to `components/PromptInspector.tsx`, or static script to `public/prompt-inspector-static.js`
+3. Injects into root layout or `index.html` (dev mode only)
 4. Discovers all APIs in the project
 
 ## Workflow
@@ -85,7 +85,7 @@ After setup, toolbar appears at bottom-right in dev mode:
 
 ## Manual Setup (if auto fails)
 
-1. Copy `assets/PromptInspector.tsx` to project's `components/`
+1. For React/Next.js, copy `assets/PromptInspector.tsx` to project's `components/`
 
 2. Add to root layout:
 ```tsx
@@ -95,6 +95,11 @@ import { PromptInspector } from '@/components/PromptInspector';
 {process.env.NODE_ENV === 'development' && <PromptInspector />}
 ```
 
+3. For static HTML, copy `assets/prompt-inspector-static.js` to `public/` and add before `</body>`:
+```html
+<script src="/public/prompt-inspector-static.js" data-harness-ops-prompt-inspector></script>
+```
+
 ## Handler Templates
 
 See [references/handler-templates.md](references/handler-templates.md) for code generation patterns.

package/HR-Resource/ops-prompt-inspector/assets/prompt-inspector-static.js

@@ -0,0 +1,180 @@
+(function () {
+  const VERSION = '1.2.0-static';
+  const ID = 'harness-ops-prompt-inspector';
+  if (window.__HARNESS_OPS_PROMPT_INSPECTOR__) return;
+  window.__HARNESS_OPS_PROMPT_INSPECTOR__ = { version: VERSION };
+
+  const state = {
+    selecting: false,
+    target: null,
+    bindings: [],
+  };
+
+  const css = `
+    #${ID}-bar{position:fixed;right:18px;bottom:18px;z-index:2147483647;display:flex;gap:8px;align-items:center;background:#111827;color:#fff;border:1px solid #374151;border-radius:8px;padding:10px;box-shadow:0 16px 36px rgba(0,0,0,.32);font:13px/1.4 -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}
+    #${ID}-bar button,#${ID}-panel button{border:0;border-radius:6px;padding:8px 10px;background:#2563eb;color:#fff;cursor:pointer;font:inherit}
+    #${ID}-bar button.secondary,#${ID}-panel button.secondary{background:#374151}
+    #${ID}-bar button.danger{background:#dc2626}
+    #${ID}-panel{position:fixed;right:18px;bottom:76px;width:min(420px,calc(100vw - 36px));z-index:2147483647;background:#fff;color:#111827;border:1px solid #d1d5db;border-radius:8px;box-shadow:0 18px 48px rgba(0,0,0,.28);padding:14px;font:13px/1.45 -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}
+    #${ID}-panel h3{margin:0 0 10px;font-size:15px}
+    #${ID}-panel label{display:block;margin:10px 0 4px;color:#374151;font-weight:600}
+    #${ID}-panel input,#${ID}-panel textarea,#${ID}-panel select{width:100%;box-sizing:border-box;border:1px solid #d1d5db;border-radius:6px;padding:8px;font:inherit}
+    #${ID}-panel textarea{min-height:72px;resize:vertical}
+    #${ID}-panel .row{display:flex;gap:8px;margin-top:12px}
+    #${ID}-highlight{position:fixed;z-index:2147483646;pointer-events:none;border:2px solid #f59e0b;background:rgba(245,158,11,.12);border-radius:4px}
+    .${ID}-badge{position:absolute;z-index:2147483645;background:#f59e0b;color:#111827;border-radius:999px;padding:2px 7px;font:11px/1.4 -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;box-shadow:0 2px 8px rgba(0,0,0,.24)}
+  `;
+
+  const style = document.createElement('style');
+  style.textContent = css;
+  document.head.appendChild(style);
+
+  const bar = document.createElement('div');
+  bar.id = `${ID}-bar`;
+  bar.innerHTML = `
+    <strong>Prompt Inspector</strong>
+    <button type="button" data-action="select">Select</button>
+    <button type="button" class="secondary" data-action="export">Export</button>
+    <button type="button" class="danger" data-action="clear">Clear</button>
+  `;
+  document.body.appendChild(bar);
+
+  const highlight = document.createElement('div');
+  highlight.id = `${ID}-highlight`;
+  highlight.hidden = true;
+  document.body.appendChild(highlight);
+
+  function selectorFor(el) {
+    if (!el || el === document.body) return 'body';
+    if (el.id) return `#${CSS.escape(el.id)}`;
+    const parts = [];
+    let node = el;
+    while (node && node.nodeType === 1 && node !== document.body && parts.length < 4) {
+      let part = node.tagName.toLowerCase();
+      if (node.classList && node.classList.length) {
+        part += `.${Array.from(node.classList).slice(0, 2).map((c) => CSS.escape(c)).join('.')}`;
+      }
+      const parent = node.parentElement;
+      if (parent) {
+        const same = Array.from(parent.children).filter((child) => child.tagName === node.tagName);
+        if (same.length > 1) part += `:nth-of-type(${same.indexOf(node) + 1})`;
+      }
+      parts.unshift(part);
+      node = parent;
+    }
+    return parts.join(' > ');
+  }
+
+  function positionHighlight(el) {
+    if (!el) {
+      highlight.hidden = true;
+      return;
+    }
+    const rect = el.getBoundingClientRect();
+    highlight.hidden = false;
+    highlight.style.left = `${rect.left}px`;
+    highlight.style.top = `${rect.top}px`;
+    highlight.style.width = `${rect.width}px`;
+    highlight.style.height = `${rect.height}px`;
+  }
+
+  function panelFor(el) {
+    const selector = selectorFor(el);
+    const panel = document.createElement('div');
+    panel.id = `${ID}-panel`;
+    panel.innerHTML = `
+      <h3>Bind selected element</h3>
+      <label>Selector</label>
+      <input value="${selector.replace(/"/g, '&quot;')}" data-field="selector">
+      <label>Mode</label>
+      <select data-field="mode">
+        <option value="comment">Comment Only</option>
+        <option value="api">Connect API</option>
+      </select>
+      <label>API / Note</label>
+      <input placeholder="GET /api/example or short title" data-field="api">
+      <label>Comment</label>
+      <textarea placeholder="Describe intended behavior, visual issue, or API binding." data-field="comment"></textarea>
+      <div class="row">
+        <button type="button" data-action="save">Save</button>
+        <button type="button" class="secondary" data-action="cancel">Cancel</button>
+      </div>
+    `;
+    document.body.appendChild(panel);
+    panel.querySelector('[data-action="save"]').addEventListener('click', () => {
+      const binding = {
+        route: `${location.pathname}${location.hash || ''}`,
+        selector: panel.querySelector('[data-field="selector"]').value,
+        mode: panel.querySelector('[data-field="mode"]').value,
+        api: panel.querySelector('[data-field="api"]').value.trim(),
+        comment: panel.querySelector('[data-field="comment"]').value.trim(),
+      };
+      state.bindings.push(binding);
+      addBadge(el, state.bindings.length);
+      panel.remove();
+      state.target = null;
+      positionHighlight(null);
+    });
+    panel.querySelector('[data-action="cancel"]').addEventListener('click', () => {
+      panel.remove();
+      state.target = null;
+      positionHighlight(null);
+    });
+  }
+
+  function addBadge(el, index) {
+    const rect = el.getBoundingClientRect();
+    const badge = document.createElement('div');
+    badge.className = `${ID}-badge`;
+    badge.textContent = `PI-${index}`;
+    badge.style.left = `${Math.max(6, rect.left + window.scrollX)}px`;
+    badge.style.top = `${Math.max(6, rect.top + window.scrollY - 20)}px`;
+    document.body.appendChild(badge);
+  }
+
+  function exportMarkdown() {
+    const lines = [`# Prompt Inspector`, ``, `Route: ${location.pathname}${location.hash || ''}`, ``];
+    state.bindings.forEach((binding, i) => {
+      lines.push(`## ${i + 1}. ${binding.mode === 'api' ? 'API Binding' : 'Comment'}`);
+      lines.push(`- Selector: \`${binding.selector}\``);
+      if (binding.api) lines.push(`- API: ${binding.api}`);
+      if (binding.comment) lines.push(`- Comment: ${binding.comment}`);
+      lines.push('');
+    });
+    const markdown = lines.join('\n');
+    navigator.clipboard?.writeText(markdown).catch(() => {});
+    console.log(markdown);
+    alert(`Prompt Inspector export copied/logged. Bindings: ${state.bindings.length}`);
+  }
+
+  document.addEventListener('mouseover', (event) => {
+    if (!state.selecting || bar.contains(event.target)) return;
+    positionHighlight(event.target);
+  }, true);
+
+  document.addEventListener('click', (event) => {
+    if (!state.selecting || bar.contains(event.target)) return;
+    event.preventDefault();
+    event.stopPropagation();
+    state.selecting = false;
+    state.target = event.target;
+    bar.querySelector('[data-action="select"]').textContent = 'Select';
+    document.getElementById(`${ID}-panel`)?.remove();
+    panelFor(event.target);
+  }, true);
+
+  bar.addEventListener('click', (event) => {
+    const action = event.target && event.target.getAttribute('data-action');
+    if (action === 'select') {
+      state.selecting = !state.selecting;
+      event.target.textContent = state.selecting ? 'Selecting...' : 'Select';
+      if (!state.selecting) positionHighlight(null);
+    }
+    if (action === 'export') exportMarkdown();
+    if (action === 'clear') {
+      state.bindings = [];
+      document.querySelectorAll(`.${ID}-badge`).forEach((el) => el.remove());
+      positionHighlight(null);
+    }
+  });
+})();

package/HR-Resource/ops-prompt-inspector/scripts/setup.py

@@ -34,6 +34,9 @@ def find_project_type(project_path: Path) -> dict:
         'components_dir': None,
     }
 
+    # Check for static/vanilla apps
+    static_index = project_path / 'index.html'
+
     # Check for Next.js App Router
     app_layout = project_path / 'app' / 'layout.tsx'
     app_layout_js = project_path / 'app' / 'layout.js'
@@ -81,6 +84,10 @@ def find_project_type(project_path: Path) -> dict:
         result['type'] = 'nextjs-pages'
         result['layout_file'] = src_pages_app_js
         result['components_dir'] = project_path / 'src' / 'components'
+    elif static_index.exists():
+        result['type'] = 'static-html'
+        result['layout_file'] = static_index
+        result['components_dir'] = project_path / 'public'
 
     return result
 
@@ -227,6 +234,46 @@ def inject_into_layout(layout_file: Path, project_type: str) -> bool:
     return True
 
 
+def copy_static_inspector(public_dir: Path, script_dir: Path, force_update: bool = False) -> bool:
+    """Copy the static Prompt Inspector browser script."""
+    public_dir.mkdir(parents=True, exist_ok=True)
+    source = script_dir.parent / 'assets' / 'prompt-inspector-static.js'
+    dest = public_dir / 'prompt-inspector-static.js'
+    if not source.exists():
+        print(f"  Error: Source static inspector not found at {source}")
+        return False
+    if dest.exists() and not force_update:
+        print(f"  Static inspector already exists at {dest}")
+        return True
+    shutil.copy(source, dest)
+    print(f"  Installed static Prompt Inspector at {dest}")
+    return True
+
+
+def inject_into_static_html(index_file: Path) -> bool:
+    """Inject the static inspector script into index.html."""
+    content = index_file.read_text(encoding='utf-8')
+    marker = 'data-harness-ops-prompt-inspector'
+    if marker in content:
+        print(f"  Static inspector already injected in {index_file}")
+        return True
+
+    script_tag = '    <script src="/public/prompt-inspector-static.js" data-harness-ops-prompt-inspector></script>'
+    if '</body>' in content:
+        new_content = content.replace('</body>', f'{script_tag}\n</body>')
+    else:
+        new_content = content + f'\n{script_tag}\n'
+
+    backup_file = index_file.with_suffix(index_file.suffix + '.backup')
+    if not backup_file.exists():
+        shutil.copy(index_file, backup_file)
+        print(f"  Backup created at {backup_file}")
+
+    index_file.write_text(new_content, encoding='utf-8')
+    print(f"  Injected static inspector into {index_file}")
+    return True
+
+
 def main():
     if len(sys.argv) < 2:
         print("Usage: python setup.py <project_path> [options]")
@@ -266,9 +313,9 @@ def main():
 
     if not project_info['type']:
         print("Could not detect project type.")
-        print("Supported: Next.js (App Router / Pages Router)")
-        print("\nManual setup required. Copy PromptInspector.tsx to your components folder")
-        print("and import it in your root layout/app file.")
+        print("Supported: Next.js (App Router / Pages Router), static index.html")
+        print("\nManual setup required. Copy PromptInspector.tsx or prompt-inspector-static.js")
+        print("and import it in your root layout/app file or index.html.")
         return 1
 
     print(f"Detected: {project_info['type']}")
@@ -277,6 +324,12 @@ def main():
 
     # Check-only mode
     if check_only:
+        if project_info['type'] == 'static-html':
+            dest = project_info['components_dir'] / 'prompt-inspector-static.js'
+            print(f"\n  Static install check:")
+            print(f"  └─ Installed: {'yes' if dest.exists() else 'no'}")
+            return 0 if dest.exists() else 1
+
         source = script_dir.parent / 'assets' / 'PromptInspector.tsx'
         dest = project_info['components_dir'] / 'PromptInspector.tsx'
 
@@ -299,6 +352,16 @@ def main():
 
     print("\nSetting up Prompt Inspector...")
 
+    if project_info['type'] == 'static-html':
+        if not copy_static_inspector(project_info['components_dir'], script_dir, force_update):
+            return 1
+        if not inject_into_static_html(project_info['layout_file']):
+            return 1
+        print("\nSetup complete!")
+        print("Run your dev server and look for the toolbar in the bottom-right corner.")
+        print("The static inspector is intended for development servers only.")
+        return 0
+
     # Step 1: Copy component
     if not copy_component(project_info['components_dir'], script_dir, force_update):
         return 1

package/apps/harness-dashboard/app/api/metrics/route.ts

@@ -0,0 +1,17 @@
+import { NextResponse } from "next/server";
+import { sampleMetrics } from "@/lib/metrics/sampler";
+import { resolveHarnessRoot } from "@/lib/harness-root";
+
+// node:fs + ps/tmux child_process require the Node.js runtime (not Edge).
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+export const revalidate = 0;
+
+export async function GET() {
+  const root = resolveHarnessRoot();
+  const sample = await sampleMetrics(root);
+  return NextResponse.json(sample, {
+    status: 200,
+    headers: { "Cache-Control": "no-store" },
+  });
+}

package/apps/harness-dashboard/app/api/wake/route.ts

@@ -0,0 +1,41 @@
+import { NextResponse } from "next/server";
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { resolveHarnessRoot } from "@/lib/harness-root";
+
+export const dynamic = "force-dynamic";
+
+// Per-project hourly-wake launchd control, keyed by HARNESS_BASE_PORT. The
+// dashboard runs locally for the Owner, so it may toggle the Owner's own
+// launchd job. Only the fixed subcommands status|on|off are ever invoked.
+function runControl(action: "status" | "on" | "off") {
+  const root = resolveHarnessRoot();
+  const script = path.join(root, "scripts", "harness-wake-control.sh");
+  if (!existsSync(script)) {
+    return { supported: false, enabled: false, error: "harness-wake-control.sh not installed in this project" };
+  }
+  try {
+    const out = execFileSync("bash", [script, action, root], {
+      encoding: "utf8",
+      timeout: 20000,
+    });
+    const lastLine = out.trim().split("\n").filter(Boolean).pop() ?? "{}";
+    return JSON.parse(lastLine);
+  } catch (e) {
+    return { supported: false, enabled: false, error: (e as Error).message };
+  }
+}
+
+export async function GET() {
+  return NextResponse.json(runControl("status"));
+}
+
+export async function POST(req: Request) {
+  const body = (await req.json().catch(() => ({}))) as { action?: string };
+  const action = body.action === "on" ? "on" : body.action === "off" ? "off" : null;
+  if (!action) {
+    return NextResponse.json({ error: "action must be 'on' or 'off'" }, { status: 400 });
+  }
+  return NextResponse.json(runControl(action));
+}