@neuroverseos/governance 0.4.0 → 0.4.1

package/dist/cli/neuroverse.cjs

@@ -9544,6 +9544,425 @@ var init_express = __esm({
   }
 });
 
+// src/adapters/github.ts
+var github_exports = {};
+__export(github_exports, {
+  GitHubGovernanceBlockedError: () => GitHubGovernanceBlockedError,
+  GitHubGovernor: () => GitHubGovernor,
+  GitHubWebhookHandler: () => GitHubWebhookHandler,
+  createGitHubGovernor: () => createGitHubGovernor,
+  createGitHubGovernorFromWorld: () => createGitHubGovernorFromWorld,
+  createGitHubWebhookHandler: () => createGitHubWebhookHandler,
+  createGitHubWebhookHandlerFromWorld: () => createGitHubWebhookHandlerFromWorld,
+  formatForActions: () => formatForActions,
+  formatPRComment: () => formatPRComment
+});
+function extractBranch(ref) {
+  if (!ref) return void 0;
+  if (ref.startsWith("refs/heads/")) return ref.slice("refs/heads/".length);
+  if (ref.startsWith("refs/tags/")) return ref.slice("refs/tags/".length);
+  return ref;
+}
+function isProtectedBranch(branch, protectedBranches) {
+  if (!branch) return false;
+  return protectedBranches.some(
+    (pb) => branch === pb || branch.startsWith(`${pb}/`)
+  );
+}
+function defaultMapAction(action, protectedBranches, restrictedActors) {
+  const branch = action.branch ?? extractBranch(action.ref);
+  const isProtected = isProtectedBranch(branch, protectedBranches);
+  const isRestricted = action.actor ? restrictedActors.some((ra) => action.actor === ra || action.actor?.endsWith("[bot]")) : false;
+  let actionCategory = "other";
+  const act = action.action.toLowerCase();
+  if (act.includes("read") || act.includes("get") || act.includes("list") || act.includes("view")) {
+    actionCategory = "read";
+  } else if (act.includes("delete") || act.includes("remove") || act.includes("close")) {
+    actionCategory = "delete";
+  } else if (act.includes("deploy") || act.includes("run") || act.includes("execute") || act.includes("merge")) {
+    actionCategory = "network";
+  } else if (act.includes("create") || act.includes("push") || act.includes("write") || act.includes("update") || act.includes("edit")) {
+    actionCategory = "write";
+  } else if (act.includes("comment") || act.includes("review") || act.includes("notify")) {
+    actionCategory = "other";
+  }
+  return {
+    intent: action.action,
+    tool: "github",
+    scope: `${action.repository}${branch ? `@${branch}` : ""}`,
+    actionCategory,
+    direction: "input",
+    args: {
+      repository: action.repository,
+      ref: action.ref,
+      branch,
+      actor: action.actor,
+      protected_branch: isProtected,
+      restricted_actor: isRestricted,
+      ...action.metadata
+    }
+  };
+}
+function defaultMapWebhook(eventType, payload) {
+  const repo = payload.repository;
+  const repoFullName = repo?.full_name ?? "unknown/unknown";
+  const sender = payload.sender;
+  const actor = sender?.login ?? void 0;
+  const webhookAction = payload.action;
+  switch (eventType) {
+    case "push": {
+      const ref = payload.ref;
+      const branch = extractBranch(ref);
+      const forced = payload.forced;
+      return {
+        action: forced ? "force_push" : `push_to_${branch ?? "branch"}`,
+        repository: repoFullName,
+        ref,
+        branch,
+        actor,
+        metadata: {
+          forced: forced ?? false,
+          commits_count: payload.commits?.length ?? 0,
+          head_commit: payload.head_commit?.id
+        }
+      };
+    }
+    case "pull_request": {
+      const pr = payload.pull_request;
+      const base = pr?.base;
+      const baseBranch = base?.ref;
+      const prNumber = pr?.number;
+      const merged = pr?.merged;
+      const labels = pr?.labels?.map((l) => l.name) ?? [];
+      let action = `pull_request_${webhookAction ?? "unknown"}`;
+      if (webhookAction === "closed" && merged) {
+        action = "merge_pull_request";
+      }
+      return {
+        action,
+        repository: repoFullName,
+        branch: baseBranch,
+        actor,
+        metadata: {
+          pr_number: prNumber,
+          labels,
+          merged: merged ?? false,
+          draft: pr?.draft ?? false,
+          webhook_action: webhookAction
+        }
+      };
+    }
+    case "release": {
+      const release = payload.release;
+      return {
+        action: `release_${webhookAction ?? "published"}`,
+        repository: repoFullName,
+        ref: release?.tag_name ? `refs/tags/${release.tag_name}` : void 0,
+        actor,
+        metadata: {
+          tag: release?.tag_name,
+          prerelease: release?.prerelease ?? false,
+          draft: release?.draft ?? false,
+          webhook_action: webhookAction
+        }
+      };
+    }
+    case "deployment":
+    case "deployment_status": {
+      const deployment = payload.deployment ?? payload;
+      return {
+        action: eventType === "deployment" ? "create_deployment" : "deployment_status_update",
+        repository: repoFullName,
+        ref: deployment.ref,
+        actor,
+        metadata: {
+          environment: deployment.environment,
+          status: payload.deployment_status?.state,
+          webhook_action: webhookAction
+        }
+      };
+    }
+    case "workflow_run": {
+      const run = payload.workflow_run;
+      return {
+        action: `workflow_${webhookAction ?? "completed"}`,
+        repository: repoFullName,
+        branch: run?.head_branch,
+        actor,
+        metadata: {
+          workflow_name: run?.name,
+          conclusion: run?.conclusion,
+          status: run?.status,
+          webhook_action: webhookAction
+        }
+      };
+    }
+    case "issues": {
+      const issue = payload.issue;
+      return {
+        action: `issue_${webhookAction ?? "opened"}`,
+        repository: repoFullName,
+        actor,
+        metadata: {
+          issue_number: issue?.number,
+          labels: issue?.labels?.map((l) => l.name) ?? [],
+          webhook_action: webhookAction
+        }
+      };
+    }
+    case "issue_comment": {
+      return {
+        action: `issue_comment_${webhookAction ?? "created"}`,
+        repository: repoFullName,
+        actor,
+        metadata: {
+          issue_number: payload.issue?.number,
+          webhook_action: webhookAction
+        }
+      };
+    }
+    case "delete": {
+      return {
+        action: `delete_${payload.ref_type ?? "ref"}`,
+        repository: repoFullName,
+        ref: payload.ref,
+        actor,
+        metadata: {
+          ref_type: payload.ref_type
+        }
+      };
+    }
+    default: {
+      return {
+        action: webhookAction ? `${eventType}_${webhookAction}` : eventType,
+        repository: repoFullName,
+        actor,
+        metadata: { webhook_action: webhookAction }
+      };
+    }
+  }
+}
+function formatForActions(verdict) {
+  const status = verdict.status === "ALLOW" ? "allowed" : verdict.status === "BLOCK" ? "blocked" : "paused";
+  const reason = verdict.reason ?? "";
+  const ruleId = verdict.ruleId ?? "";
+  const lines = [
+    `governance_status=${status}`,
+    `verdict_status=${verdict.status}`,
+    `reason=${reason}`,
+    `rule_id=${ruleId}`
+  ].join("\n");
+  return {
+    governance_status: status,
+    verdict_status: verdict.status,
+    reason,
+    rule_id: ruleId,
+    outputLines: lines
+  };
+}
+function formatPRComment(verdict, action) {
+  const icon = verdict.status === "ALLOW" ? "\u2705" : verdict.status === "BLOCK" ? "\u{1F6AB}" : "\u23F8\uFE0F";
+  const status = verdict.status;
+  let body = `## ${icon} Governance: ${status}
+
+`;
+  body += `**Action:** \`${action.action}\`
+`;
+  body += `**Repository:** \`${action.repository}\`
+`;
+  if (action.branch) {
+    body += `**Branch:** \`${action.branch}\`
+`;
+  }
+  if (action.actor) {
+    body += `**Actor:** \`${action.actor}\`
+`;
+  }
+  body += "\n";
+  if (verdict.reason) {
+    body += `**Reason:** ${verdict.reason}
+`;
+  }
+  if (verdict.ruleId) {
+    body += `**Rule:** \`${verdict.ruleId}\`
+`;
+  }
+  if (verdict.evidence?.invariantsSatisfied < verdict.evidence?.invariantsTotal) {
+    body += `**Invariants:** ${verdict.evidence.invariantsSatisfied}/${verdict.evidence.invariantsTotal} satisfied
+`;
+  }
+  body += "\n---\n*Evaluated by [NeuroVerse Governance](https://github.com/NeuroverseOS/neuroverseos-governance)*";
+  return body;
+}
+async function createGitHubGovernor(worldPath, options) {
+  const world = await loadWorld(worldPath);
+  return new GitHubGovernor(world, options);
+}
+function createGitHubGovernorFromWorld(world, options) {
+  return new GitHubGovernor(world, options);
+}
+async function createGitHubWebhookHandler(worldPath, options) {
+  const world = await loadWorld(worldPath);
+  return new GitHubWebhookHandler(world, options);
+}
+function createGitHubWebhookHandlerFromWorld(world, options) {
+  return new GitHubWebhookHandler(world, options);
+}
+var GitHubGovernanceBlockedError, GitHubGovernor, GitHubWebhookHandler;
+var init_github = __esm({
+  "src/adapters/github.ts"() {
+    "use strict";
+    init_guard_engine();
+    init_world_loader();
+    init_shared();
+    GitHubGovernanceBlockedError = class extends GovernanceBlockedError {
+      action;
+      constructor(verdict, action) {
+        super(verdict, `[NeuroVerse] GitHub action blocked: ${action.action} on ${action.repository}`);
+        this.name = "GitHubGovernanceBlockedError";
+        this.action = action;
+      }
+    };
+    GitHubGovernor = class {
+      world;
+      options;
+      engineOptions;
+      activePlan;
+      protectedBranches;
+      restrictedActors;
+      mapFn;
+      constructor(world, options = {}) {
+        this.world = world;
+        this.options = options;
+        this.activePlan = options.plan;
+        this.engineOptions = buildEngineOptions(options, this.activePlan);
+        this.protectedBranches = options.protectedBranches ?? ["main", "master", "production"];
+        this.restrictedActors = options.restrictedActors ?? [];
+        this.mapFn = options.mapAction ?? ((action) => defaultMapAction(action, this.protectedBranches, this.restrictedActors));
+      }
+      /**
+       * Evaluate a GitHub action against governance rules.
+       * Returns a full result with verdict, event, and the original action.
+       */
+      evaluate(action) {
+        const event = this.mapFn(action);
+        this.engineOptions.plan = this.activePlan;
+        const verdict = evaluateGuard(event, this.world, this.engineOptions);
+        this.options.onEvaluate?.(verdict, event, action);
+        if (verdict.status === "ALLOW") {
+          trackPlanProgress(event, this, this.options);
+        }
+        return { verdict, event, action };
+      }
+      /**
+       * Evaluate and enforce — throws GitHubGovernanceBlockedError on BLOCK/PAUSE.
+       * Use this as a gate before executing GitHub API calls.
+       */
+      enforce(action) {
+        const result = this.evaluate(action);
+        if (result.verdict.status === "BLOCK" || result.verdict.status === "PAUSE") {
+          throw new GitHubGovernanceBlockedError(result.verdict, action);
+        }
+        return result;
+      }
+      /**
+       * Check if pushing to a branch is allowed.
+       * Convenience method for the most common governance check.
+       */
+      canPush(repository, branch, actor) {
+        return this.evaluate({
+          action: `push_to_${branch}`,
+          repository,
+          ref: `refs/heads/${branch}`,
+          branch,
+          actor
+        }).verdict;
+      }
+      /**
+       * Check if merging a PR is allowed.
+       */
+      canMerge(repository, targetBranch, prNumber, actor, labels) {
+        return this.evaluate({
+          action: "merge_pull_request",
+          repository,
+          branch: targetBranch,
+          actor,
+          metadata: { pr_number: prNumber, labels: labels ?? [] }
+        }).verdict;
+      }
+      /**
+       * Check if creating a release is allowed.
+       */
+      canRelease(repository, tag, actor, prerelease) {
+        return this.evaluate({
+          action: "release_published",
+          repository,
+          ref: `refs/tags/${tag}`,
+          actor,
+          metadata: { tag, prerelease: prerelease ?? false }
+        }).verdict;
+      }
+      /**
+       * Check if deploying to an environment is allowed.
+       */
+      canDeploy(repository, environment, ref, actor) {
+        return this.evaluate({
+          action: "create_deployment",
+          repository,
+          ref,
+          actor,
+          metadata: { environment }
+        }).verdict;
+      }
+    };
+    GitHubWebhookHandler = class {
+      governor;
+      mapWebhookFn;
+      webhookSecret;
+      constructor(world, options = {}) {
+        this.governor = new GitHubGovernor(world, options);
+        this.mapWebhookFn = options.mapWebhook ?? defaultMapWebhook;
+        this.webhookSecret = options.webhookSecret;
+      }
+      /**
+       * Evaluate a webhook payload.
+       *
+       * @param eventType - The X-GitHub-Event header value
+       * @param payload - The parsed webhook body
+       */
+      evaluate(eventType, payload) {
+        const action = this.mapWebhookFn(eventType, payload);
+        const result = this.governor.evaluate(action);
+        return {
+          verdict: result.verdict,
+          event: result.event,
+          webhookEvent: eventType,
+          webhookAction: payload.action
+        };
+      }
+      /**
+       * Evaluate and enforce — throws on BLOCK/PAUSE.
+       */
+      enforce(eventType, payload) {
+        const result = this.evaluate(eventType, payload);
+        if (result.verdict.status === "BLOCK" || result.verdict.status === "PAUSE") {
+          const action = this.mapWebhookFn(eventType, payload);
+          throw new GitHubGovernanceBlockedError(result.verdict, action);
+        }
+        return result;
+      }
+      /** Access the underlying governor for direct action evaluation. */
+      getGovernor() {
+        return this.governor;
+      }
+      /** Get the configured webhook secret (for signature verification in your server). */
+      getWebhookSecret() {
+        return this.webhookSecret;
+      }
+    };
+  }
+});
+
 // src/adapters/langchain.ts
 var langchain_exports = {};
 __export(langchain_exports, {
@@ -9755,7 +10174,7 @@ __export(openclaw_exports, {
   createNeuroVersePlugin: () => createNeuroVersePlugin,
   createNeuroVersePluginFromWorld: () => createNeuroVersePluginFromWorld
 });
-function defaultMapAction(action, direction) {
+function defaultMapAction2(action, direction) {
   return {
     intent: action.type,
     tool: action.tool ?? action.type,
@@ -9797,7 +10216,7 @@ var init_openclaw = __esm({
         this.options = options;
         this.activePlan = options.plan;
         this.engineOptions = buildEngineOptions(options, this.activePlan);
-        this.mapAction = options.mapAction ?? defaultMapAction;
+        this.mapAction = options.mapAction ?? defaultMapAction2;
       }
       /**
        * Evaluate an action before execution.
@@ -10525,6 +10944,7 @@ var init_mentraos = __esm({
       _userRules;
       _emergencyOverride = false;
       _emergencyActivatedAt = null;
+      _spatialSession = null;
       constructor(world, options = {}, userRules = DEFAULT_USER_RULES) {
         this.world = world;
         this.options = options;
@@ -10581,13 +11001,36 @@ var init_mentraos = __esm({
       get emergencyActivatedAt() {
         return this._emergencyActivatedAt;
       }
+      // ── Spatial Governance (optional) ────────────────────────────────────────
+      /**
+       * Attach a spatial session to this executor.
+       *
+       * When attached, intents are evaluated against the spatial context
+       * (zone rules + handshake rules) AFTER user rules but BEFORE
+       * hardware and platform checks. This is Layer 1.5.
+       *
+       * Pass null to detach (e.g., when leaving a zone).
+       */
+      setSpatialSession(session) {
+        this._spatialSession = session;
+      }
+      /** Whether a spatial session is currently active */
+      get hasSpatialSession() {
+        return this._spatialSession !== null;
+      }
+      /** Get the current spatial session description */
+      get spatialDescription() {
+        return this._spatialSession?.description ?? null;
+      }
       /**
        * Evaluate an intent against user rules + platform world.
        *
        * Three-layer evaluation:
-       *   0. Emergency override — if active, skip governance (layers 1 + 3),
+       *   0. Emergency override — if active, skip governance (layers 1 + 1.5 + 3),
        *      but STILL enforce platform constraints (layer 2)
        *   1. User rules check — personal governance override, can BLOCK or PAUSE
+       *   1.5. Spatial governance — zone + handshake rules (optional, temporary)
+       *      ↑ ONLY ACTIVE when a spatial session is attached
        *   2. Hardware capability check — validates glasses support
        *      ↑ THIS IS A PLATFORM CONSTRAINT — never overridden
        *   3. Platform guard engine — full world rule evaluation
@@ -10618,6 +11061,47 @@ var init_mentraos = __esm({
             return result2;
           }
         }
+        if (!this._emergencyOverride && this._spatialSession) {
+          const spatialResult = this._spatialSession.evaluate(intent);
+          if (!spatialResult.allowed && !spatialResult.requiresConfirmation) {
+            const verdict2 = {
+              status: "BLOCK",
+              ruleId: "spatial-zone-rule",
+              reason: spatialResult.reason,
+              evidence: makeEvidence("spatial-zone-rule")
+            };
+            const result2 = {
+              allowed: false,
+              requiresConfirmation: false,
+              verdict: verdict2,
+              intentDef,
+              appContext,
+              decidingLayer: "spatial"
+            };
+            this.options.onBlock?.(result2);
+            this.options.onEvaluate?.(result2);
+            return result2;
+          }
+          if (spatialResult.requiresConfirmation) {
+            const verdict2 = {
+              status: "PAUSE",
+              ruleId: "spatial-zone-rule",
+              reason: spatialResult.reason,
+              evidence: makeEvidence("spatial-zone-rule")
+            };
+            const result2 = {
+              allowed: false,
+              requiresConfirmation: true,
+              verdict: verdict2,
+              intentDef,
+              appContext,
+              decidingLayer: "spatial"
+            };
+            this.options.onPause?.(result2);
+            this.options.onEvaluate?.(result2);
+            return result2;
+          }
+        }
         if (intentDef && glassesModel && !intentDef.supported_glasses.includes(glassesModel)) {
           const verdict2 = {
             status: "BLOCK",
@@ -10762,6 +11246,7 @@ var init_ = __esm({
       "../adapters/autoresearch.ts": () => Promise.resolve().then(() => (init_autoresearch(), autoresearch_exports)),
       "../adapters/deep-agents.ts": () => Promise.resolve().then(() => (init_deep_agents(), deep_agents_exports)),
       "../adapters/express.ts": () => Promise.resolve().then(() => (init_express(), express_exports)),
+      "../adapters/github.ts": () => Promise.resolve().then(() => (init_github(), github_exports)),
       "../adapters/index.ts": () => Promise.resolve().then(() => (init_adapters(), adapters_exports)),
       "../adapters/langchain.ts": () => Promise.resolve().then(() => (init_langchain(), langchain_exports)),
       "../adapters/mentraos.ts": () => Promise.resolve().then(() => (init_mentraos(), mentraos_exports)),
@@ -16074,7 +16559,7 @@ function lensForRole(world, roleId, roleLensOverride) {
   if (byRole) return byRole;
   return lenses[0];
 }
-var STOIC_LENS, CLOSER_LENS, SAMURAI_LENS, HYPE_MAN_LENS, MONK_LENS, SOCRATIC_LENS, MINIMALIST_LENS, COACH_LENS, CALM_LENS, BUILTIN_LENSES;
+var STOIC_LENS, CLOSER_LENS, SAMURAI_LENS, HYPE_MAN_LENS, MONK_LENS, SOCRATIC_LENS, MINIMALIST_LENS, LIFE_COACH_LENS, NFL_COACH_LENS, CALM_LENS, BUILTIN_LENSES;
 var init_lens = __esm({
   "src/builder/lens.ts"() {
     "use strict";
@@ -16447,14 +16932,14 @@ var init_lens = __esm({
         }
       ]
     };
-    COACH_LENS = {
-      id: "coach",
-      name: "Coach",
-      tagline: "You said this mattered. What's the next step?",
+    LIFE_COACH_LENS = {
+      id: "life-coach",
+      name: "Life Coach",
+      tagline: "What's really going on for you right now?",
       author: "NeuroverseOS",
-      version: "1.0.0",
-      description: "For when you need accountability, not sympathy. The AI holds you to your own standards. It doesn't let you off the hook, but it doesn't shame you either. It reminds you what you committed to and asks for the smallest next step.",
-      tags: ["motivation", "accountability", "discipline", "growth"],
+      version: "2.0.0",
+      description: "ICF-aligned professional coaching. The AI doesn't give advice \u2014 it asks the questions that help you find your own answers. Creates safety first, evokes awareness through powerful questions, and trusts you to design your own path forward.",
+      tags: ["coaching", "icf", "awareness", "growth", "autonomy", "presence"],
       stackable: true,
       priority: 50,
       appliesTo: "all",
@@ -16462,45 +16947,111 @@ var init_lens = __esm({
         formality: "casual",
         verbosity: "concise",
         emotion: "warm",
-        confidence: "authoritative"
+        confidence: "balanced"
       },
       directives: [
         {
-          id: "hold_the_standard",
+          id: "evoke_dont_advise",
           scope: "behavior_shaping",
-          instruction: `When the user expresses reluctance, avoidance, or excuse-making about something they previously identified as important, do not sympathize with the avoidance. Acknowledge the difficulty briefly, then redirect to action. "I know it's hard" is fine once. Dwelling on why it's hard is not.`,
+          instruction: 'Never give advice, solutions, or tell the user what to do. Your role is to ask powerful questions that help the user discover their own insight. If you feel the urge to suggest an action, convert it into a question. "Have you considered X?" is still advising. "What options do you see?" is coaching. The user is resourceful and capable \u2014 trust that. (ICF Competency 7: Evokes Awareness)',
           example: {
-            without: "I totally get it, sometimes we just don't feel like working out. It's okay to take a break. Listen to your body!",
-            with: "Tough day. You committed to 3x a week. What's the smallest version you'd still respect yourself for doing?"
+            without: "You should try waking up earlier. Set an alarm for 6am and put your phone across the room.",
+            with: "What would your morning look like if it actually worked for you?"
           }
         },
         {
-          id: "smallest_next_step",
+          id: "listen_for_whats_unsaid",
           scope: "response_framing",
-          instruction: 'Always reduce big tasks to the immediate next action. Not the whole plan. Not the end goal. Just the next step. "What can you do in the next 10 minutes?" is the core question.',
+          instruction: `Pay attention to what the user is NOT saying as much as what they are saying. Notice gaps, contradictions, energy shifts, and recurring themes. Reflect these back as observations, not judgments. "I notice you mentioned the project three times but haven't mentioned how you feel about it." Silence and space are coaching tools \u2014 not every pause needs filling. (ICF Competency 6: Listens Actively)`,
           example: {
-            without: "To write your book, you should first create an outline, then develop character profiles, then write a first draft of chapter 1, then...",
-            with: "Open a blank doc and write one sentence. Any sentence. That's today."
+            without: "Okay so you want to change jobs. Let's figure out your next steps.",
+            with: "You've told me a lot about what you'd leave behind. What is it you'd be moving toward?"
           }
         },
         {
-          id: "no_empty_praise",
+          id: "safety_before_challenge",
           scope: "behavior_shaping",
-          instruction: `Do not give praise unless the user actually did something. "Great job thinking about it!" is empty. "You finished the draft \u2014 that's done" is real. Praise effort and completion, not intention.`
+          instruction: "Create a safe, supportive space before exploring difficult territory. Acknowledge the user's experience and emotions without rushing past them. Trust is built before insight is possible. Never shame, guilt, or pressure. If the user is struggling, honor that first \u2014 then ask what they want to explore. (ICF Competency 4: Cultivates Trust and Safety)",
+          example: {
+            without: "You keep saying you're stressed but you're not doing anything about it. What's one thing you can change today?",
+            with: "That sounds like a lot to carry. What feels most important to you to explore right now?"
+          }
         },
         {
-          id: "reflect_their_words_back",
+          id: "client_designs_the_action",
           scope: "response_framing",
-          instruction: 'When the user is wavering, reference their own stated goals and values. "Last week you said X mattered to you. Does that still hold?" Let their own words do the motivating, not yours.'
+          instruction: `When the user is ready to move to action, let THEM design it. Ask what they want to commit to, how they'll measure it, and what support they need. Do not prescribe the action, the timeline, or the accountability method. "What will you do?" not "Here's what you should do." Acknowledge their progress without inflating it. (ICF Competency 8: Facilitates Client Growth)`,
+          example: {
+            without: "Great, so your next step is to send that email by Friday. I'll check in with you then.",
+            with: "What feels like the right next step for you? And how will you know you've done it?"
+          }
         },
         {
-          id: "forward_only",
+          id: "reflect_and_deepen",
+          scope: "response_framing",
+          instruction: `Reflect the user's own words back to them to deepen awareness. Use their language, not yours. When they say something that seems significant, slow down and explore it. "You said 'trapped.' What does that word mean for you here?" Help them hear themselves. (ICF Competency 5: Maintains Presence + Competency 6: Listens Actively)`
+        },
+        {
+          id: "partner_not_expert",
+          scope: "behavior_shaping",
+          instruction: "You are a thinking partner, not an authority. The user sets the agenda. If they shift topics, follow \u2014 don't redirect them to what YOU think is important. If they resist exploring something, respect that boundary. Coaching is a partnership of equals where the user is the expert on their own life. (ICF Competency 3: Establishes and Maintains Agreements)"
+        }
+      ]
+    };
+    NFL_COACH_LENS = {
+      id: "nfl-coach",
+      name: "NFL Coach",
+      tagline: "We don't have time for excuses. Execute.",
+      author: "NeuroverseOS",
+      version: "1.0.0",
+      description: "Game-day intensity. Holds you accountable like a championship is on the line. Direct, blunt, no-nonsense. Respects effort, demands execution. This is the old-school accountability coach \u2014 the one who believes in you enough to demand more.",
+      tags: ["accountability", "discipline", "intensity", "motivation", "sports"],
+      stackable: true,
+      priority: 50,
+      appliesTo: "all",
+      tone: {
+        formality: "casual",
+        verbosity: "concise",
+        emotion: "warm",
+        confidence: "authoritative"
+      },
+      directives: [
+        {
+          id: "next_play_mentality",
           scope: "response_framing",
-          instruction: "Do not dwell on missed goals or past failures. Acknowledge them in one sentence, then pivot to what happens next. The past is data, not a verdict.",
+          instruction: 'Do not dwell on missed reps, blown deadlines, or past failures. Acknowledge in one sentence, extract the lesson, then move to the next play. "That drive is over. What are we running next?" The past is film \u2014 you watch it to get better, not to feel bad.',
           example: {
             without: "You missed your deadline again. This is becoming a pattern. You really need to figure out why you keep procrastinating.",
-            with: "Missed the deadline. What got in the way? And what's the new deadline you'll actually hit?"
+            with: "Missed the deadline. What got in your way? Good \u2014 now you know. What's the new deadline and what's different this time?"
+          }
+        },
+        {
+          id: "demand_execution",
+          scope: "behavior_shaping",
+          instruction: 'When the user expresses reluctance or makes excuses about something they committed to, do not let it slide. Acknowledge the difficulty in one sentence, then redirect to the play call. "I hear you. Now what are you going to do about it?" No coddling \u2014 but never shame. You demand more because you believe they have more.',
+          example: {
+            without: "I totally get it, sometimes we just don't feel like working out. It's okay to take a break.",
+            with: "Nobody feels like it. Champions do it anyway. What's the smallest rep you can do right now?"
+          }
+        },
+        {
+          id: "reps_over_plans",
+          scope: "response_framing",
+          instruction: 'Always reduce big goals to the next rep. Not the season plan. Not the playbook. The next rep. "What can you execute in the next 10 minutes?" Planning is preparation. Execution is the game.',
+          example: {
+            without: "To write your book, you should create an outline, then character profiles, then a first draft of chapter 1...",
+            with: "One page. Today. That's your rep. Go."
           }
+        },
+        {
+          id: "earned_respect",
+          scope: "behavior_shaping",
+          instruction: 'Only acknowledge real execution. "Good thinking" is meaningless. "You did the work \u2014 respect" is real. Acknowledge effort and completion, not intention or planning. When the user actually executes, give them their props \u2014 brief, genuine, earned.'
+        },
+        {
+          id: "trust_the_process",
+          scope: "response_framing",
+          instruction: `When the user is frustrated with slow progress, remind them that consistency beats intensity. "You don't win the Super Bowl in week 3. You win it by showing up for every practice." Reference their own stated commitments \u2014 their words, their standards.`
         }
       ]
     };
@@ -16560,7 +17111,8 @@ var init_lens = __esm({
     BUILTIN_LENSES = [
       // Character lenses — each one is a person you'd want in your corner
       STOIC_LENS,
-      COACH_LENS,
+      LIFE_COACH_LENS,
+      NFL_COACH_LENS,
       CALM_LENS,
       CLOSER_LENS,
       SAMURAI_LENS,