@scheduler-systems/gal-run 0.0.408 → 0.0.411

package/dist/index.cjs

@@ -3970,7 +3970,7 @@ var cliVersion, defaultApiUrl, BUILD_CONSTANTS, constants_default;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
-    cliVersion = true ? "0.0.408" : "0.0.0-dev";
+    cliVersion = true ? "0.0.411" : "0.0.0-dev";
     defaultApiUrl = true ? "https://api.gal.run" : "http://localhost:3000";
     BUILD_CONSTANTS = Object.freeze([cliVersion, defaultApiUrl]);
     constants_default = BUILD_CONSTANTS;
@@ -4880,7 +4880,7 @@ function detectEnvironment() {
     return "dev";
   }
   try {
-    const version2 = true ? "0.0.408" : void 0;
+    const version2 = true ? "0.0.411" : void 0;
     if (version2 && version2.includes("-local")) {
       return "dev";
     }
@@ -5249,7 +5249,7 @@ function getId() {
 }
 function getCliVersion() {
   try {
-    return true ? "0.0.408" : "0.0.0-dev";
+    return true ? "0.0.411" : "0.0.0-dev";
   } catch {
     return "0.0.0-dev";
   }
@@ -5663,9 +5663,38 @@ var init_llm_analysis = __esm({
 });
 
 // ../../packages/types/dist/feature-flags.js
+var ALL_PAGE_IDS;
 var init_feature_flags = __esm({
   "../../packages/types/dist/feature-flags.js"() {
     "use strict";
+    ALL_PAGE_IDS = [
+      "dashboard",
+      "discovery",
+      "proposals",
+      "team",
+      "background-agents",
+      "cli",
+      "vscode",
+      "docs",
+      "billing",
+      "settings",
+      "workflow-testing",
+      "project-scope-configs",
+      "enforcement-overrides",
+      "domain-compliance",
+      "tool-compliance",
+      "audit-logs",
+      "enforcement-policies",
+      "enforcement-compliance",
+      "enforcement-audit",
+      "enforcement-domains",
+      "enforcement-hooks",
+      "enforcement-sdlc",
+      "enforcement-security",
+      "enforcement-tools",
+      "enforcement-system",
+      "browser-profiles"
+    ];
   }
 });
 
@@ -5677,6 +5706,49 @@ var init_billing = __esm({
 });
 
 // ../../packages/types/dist/telemetry.js
+function isEnhancedEvent(event) {
+  return "resource" in event && "severity" in event;
+}
+function upgradeToEnhancedEvent(legacy) {
+  return {
+    id: legacy.id,
+    timestamp: legacy.timestamp,
+    severity: legacy.payload.success === false ? "ERROR" : "INFO",
+    resource: {
+      "service.name": "gal-cli",
+      "service.version": legacy.payload.cliVersion || "unknown",
+      "host.os": legacy.payload.platform || "linux",
+      "host.arch": "x64",
+      // Default, not available in legacy
+      "process.runtime.version": legacy.payload.nodeVersion
+    },
+    eventType: legacy.eventType,
+    attributes: {
+      command: legacy.payload.command ?? null,
+      success: legacy.payload.success ?? null,
+      error_type: legacy.payload.errorType ?? null,
+      duration_ms: legacy.payload.durationMs ?? null,
+      notification_type: legacy.payload.notificationType ?? null,
+      rate_limit_hit: legacy.payload.rateLimitHit ?? null,
+      sync_age_hours: legacy.payload.syncAgeHours ?? null,
+      files_synced: legacy.payload.filesTracked ?? null
+    },
+    installationId: legacy.installationId
+  };
+}
+function severityToNumber(severity) {
+  const levels = {
+    DEBUG: 100,
+    INFO: 200,
+    NOTICE: 300,
+    WARNING: 400,
+    ERROR: 500,
+    CRITICAL: 600,
+    ALERT: 700,
+    EMERGENCY: 800
+  };
+  return levels[severity];
+}
 var init_telemetry2 = __esm({
   "../../packages/types/dist/telemetry.js"() {
     "use strict";
@@ -5729,16 +5801,27 @@ function normalizeBackgroundAgentRunnerLabel(value) {
     return value;
   return RETIRED_BACKGROUND_AGENT_RUNNER_LABELS[value];
 }
-var ACTIVE_BACKGROUND_AGENT_RUNNER_LABELS, RETIRED_BACKGROUND_AGENT_RUNNER_LABELS, DEFAULT_RUNNER_LABEL;
+var SESSION_AGENTS, DEFAULT_SESSION_AGENT, ACTIVE_BACKGROUND_AGENT_RUNNER_LABELS, SECURITY_GATED_RUNNER_LABELS, RETIRED_BACKGROUND_AGENT_RUNNER_LABELS, DEFAULT_RUNNER_LABEL;
 var init_session = __esm({
   "../../packages/types/dist/session.js"() {
     "use strict";
+    SESSION_AGENTS = [
+      { id: "claude", displayName: "Claude Code", icon: "\u{1F916}", description: "Anthropic Claude Code CLI" },
+      { id: "codex", displayName: "Codex CLI", icon: "\u{1F31F}", description: "OpenAI Codex CLI" },
+      { id: "gemini", displayName: "Gemini CLI", icon: "\u{1F48E}", description: "Google Gemini CLI" },
+      { id: "cursor-agent", displayName: "Cursor Agent", icon: "\u{1F3AF}", description: "Cursor AI Agent" },
+      { id: "copilot", displayName: "GitHub Copilot", icon: "\u{1F680}", description: "GitHub Copilot CLI" }
+    ];
+    DEFAULT_SESSION_AGENT = "claude";
     ACTIVE_BACKGROUND_AGENT_RUNNER_LABELS = [
       "agents-standard-runc-x64",
       "agents-medium-runc-x64",
       "agents-high-runc-x64",
       "agents-kali-runc"
     ];
+    SECURITY_GATED_RUNNER_LABELS = /* @__PURE__ */ new Set([
+      "agents-kali-runc"
+    ]);
     RETIRED_BACKGROUND_AGENT_RUNNER_LABELS = {
       "arc-linux-agents": "agents-standard-runc-x64",
       "arc-linux-agents-runc": "agents-standard-runc-x64",
@@ -5761,9 +5844,198 @@ var init_workflow = __esm({
 });
 
 // ../../packages/types/dist/work-item.js
+function normalizeStringList(values) {
+  if (!values)
+    return values;
+  const normalized = values.map((value) => typeof value === "string" ? value.trim() : "").filter((value) => value.length > 0);
+  return normalized.length > 0 ? normalized : void 0;
+}
+function isProcessExecutionMode(value) {
+  return typeof value === "string" && PROCESS_EXECUTION_MODES.includes(value);
+}
+function normalizeOperationsProcessStep(raw) {
+  if (!raw)
+    return void 0;
+  const executionPath = typeof raw.executionPath === "string" ? raw.executionPath.trim() : raw.executionPath;
+  const result = {
+    ...raw,
+    processKey: String(raw.processKey ?? "").trim(),
+    title: String(raw.title ?? "").trim(),
+    executionPath
+  };
+  if (raw.updatedBy) {
+    result.updatedBy = raw.updatedBy.trim();
+  }
+  if (raw.source) {
+    result.source = raw.source;
+  }
+  if (raw.approvalGate) {
+    const approvers = normalizeStringList(raw.approvalGate.approvers);
+    result.approvalGate = {
+      ...raw.approvalGate,
+      approvers
+    };
+  }
+  if (raw.automationScope) {
+    const allowedProfiles = normalizeStringList(raw.automationScope.allowedProfiles);
+    result.automationScope = {
+      ...raw.automationScope,
+      allowedProfiles
+    };
+  }
+  if (raw.matchCriteria) {
+    const repositoryPatterns = normalizeStringList(raw.matchCriteria.repositoryPatterns);
+    const commandPatterns = normalizeStringList(raw.matchCriteria.commandPatterns);
+    result.matchCriteria = {
+      ...raw.matchCriteria,
+      repositoryPatterns,
+      commandPatterns
+    };
+  }
+  return result;
+}
+function resolveOperationsBoundaryDecision(params) {
+  const processKey = params.processKey?.trim();
+  const boundary = normalizeOperationsProcessStep(params.boundary ?? void 0);
+  if (!boundary) {
+    if (!processKey) {
+      return {
+        canExecute: true,
+        requiresReview: false,
+        boundaryState: "missing"
+      };
+    }
+    return {
+      canExecute: false,
+      requiresReview: false,
+      boundaryState: "missing",
+      processKey,
+      reason: `Missing Operations boundary contract for process "${processKey}". Treating as manual-only and refusing autonomous dispatch.`
+    };
+  }
+  const executionPath = boundary.executionPath;
+  const hasValidExecutionPath = isProcessExecutionMode(executionPath);
+  if (!boundary.processKey || !boundary.title || !hasValidExecutionPath) {
+    const malformedPath = typeof executionPath === "string" && executionPath.length > 0 ? executionPath : "(missing)";
+    const malformedReason = !hasValidExecutionPath ? `Operations boundary contract for process "${processKey || boundary.processKey || "(unknown)"}" has invalid executionPath "${malformedPath}". Treating as manual-only and refusing autonomous dispatch.` : "Operations boundary contract is incomplete or malformed. Treating as manual-only and refusing autonomous dispatch.";
+    return {
+      canExecute: false,
+      requiresReview: false,
+      boundaryState: "invalid",
+      processKey: processKey || boundary.processKey || void 0,
+      reason: malformedReason
+    };
+  }
+  const resolvedProcessKey = boundary.processKey.trim();
+  if (processKey && processKey !== resolvedProcessKey) {
+    return {
+      canExecute: false,
+      requiresReview: false,
+      boundaryState: "mismatch",
+      processKey,
+      executionPath,
+      reason: `Process key "${processKey}" does not match Operations boundary "${resolvedProcessKey}". Refusing dispatch until the contract is aligned.`
+    };
+  }
+  if (!boundary.enabled) {
+    return {
+      canExecute: false,
+      requiresReview: false,
+      boundaryState: "disabled",
+      processKey: resolvedProcessKey,
+      executionPath,
+      reason: `Operations boundary "${resolvedProcessKey}" is disabled.`
+    };
+  }
+  if (executionPath === "manual" || executionPath === "workforce") {
+    return {
+      canExecute: false,
+      requiresReview: false,
+      boundaryState: executionPath,
+      processKey: resolvedProcessKey,
+      executionPath,
+      reason: `Operations boundary "${resolvedProcessKey}" is ${executionPath}-only and cannot be dispatched to a background agent.`
+    };
+  }
+  if (executionPath === "hybrid") {
+    return {
+      canExecute: true,
+      requiresReview: true,
+      boundaryState: "hybrid",
+      processKey: resolvedProcessKey,
+      executionPath,
+      reason: `Operations boundary "${resolvedProcessKey}" allows agent execution but requires human review checkpoints.`
+    };
+  }
+  return {
+    canExecute: true,
+    requiresReview: false,
+    boundaryState: "agent",
+    processKey: resolvedProcessKey,
+    executionPath
+  };
+}
+function validateExecutionIdentityEnvelope(envelope) {
+  if (!envelope || typeof envelope !== "object") {
+    return "ExecutionIdentityEnvelope is missing or not an object";
+  }
+  const e = envelope;
+  const requiredStringFields = [
+    "requesterId",
+    "credentialOwnerId",
+    "executionOwnerId",
+    "credentialResolutionMethod",
+    "resolvedAt"
+  ];
+  for (const field of requiredStringFields) {
+    if (typeof e[field] !== "string" || e[field].trim().length === 0) {
+      return `ExecutionIdentityEnvelope.${field} is missing or empty`;
+    }
+  }
+  const validMethods = [
+    "explicit-credential-user",
+    "caller-identity",
+    "token-label",
+    "org-credential-owner",
+    "provider-credential-owner"
+  ];
+  if (!validMethods.includes(e.credentialResolutionMethod)) {
+    return `ExecutionIdentityEnvelope.credentialResolutionMethod "${e.credentialResolutionMethod}" is not a valid resolution method`;
+  }
+  return null;
+}
+function normalizeWorkItemExecutionContext(raw) {
+  const result = { ...raw };
+  if (result.relatedProcessKeys) {
+    result.relatedProcessKeys = result.relatedProcessKeys.filter((k) => typeof k === "string" && k.trim().length > 0);
+  }
+  if (result.operationsBoundary) {
+    result.operationsBoundary = normalizeOperationsProcessStep(result.operationsBoundary);
+  }
+  return result;
+}
+function serializeWorkItemExecutionContext(ctx) {
+  return JSON.stringify(normalizeWorkItemExecutionContext(ctx));
+}
+function parseWorkItemExecutionContext(raw) {
+  if (!raw || raw.trim().length === 0) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return { context: normalizeWorkItemExecutionContext(parsed) };
+    }
+    return { legacyText: raw };
+  } catch {
+    return { legacyText: raw };
+  }
+}
+var PROCESS_EXECUTION_MODES;
 var init_work_item = __esm({
   "../../packages/types/dist/work-item.js"() {
     "use strict";
+    PROCESS_EXECUTION_MODES = ["agent", "hybrid", "manual", "workforce"];
   }
 });
 
@@ -5796,10 +6068,17 @@ var init_config_governance = __esm({
 });
 
 // ../../packages/types/dist/credentials.js
-var CREDENTIAL_PROVIDER_CONFIGS;
+function getCredentialProviderConfig(provider) {
+  return CREDENTIAL_PROVIDER_CONFIGS.find((c) => c.id === provider);
+}
+function isValidCredentialProvider(value) {
+  return CREDENTIAL_PROVIDERS.includes(value);
+}
+var CREDENTIAL_PROVIDERS, CREDENTIAL_PROVIDER_CONFIGS;
 var init_credentials = __esm({
   "../../packages/types/dist/credentials.js"() {
     "use strict";
+    CREDENTIAL_PROVIDERS = ["claude", "codex", "gemini", "cursor"];
     CREDENTIAL_PROVIDER_CONFIGS = [
       {
         id: "claude",
@@ -5895,9 +6174,33 @@ var init_orchestrator_brain = __esm({
 });
 
 // ../../packages/types/dist/provider-usage.js
+function calculateHealthState(usagePercent, thresholds = DEFAULT_USAGE_THRESHOLDS) {
+  if (usagePercent === null)
+    return "ok";
+  if (usagePercent >= thresholds.criticalThreshold)
+    return "critical";
+  if (usagePercent >= thresholds.warningThreshold)
+    return "warning";
+  return "ok";
+}
+function calculateHeadroom(currentUsage, limit) {
+  if (limit === null)
+    return null;
+  return Math.max(0, limit - currentUsage);
+}
+function calculateUsagePercent(currentUsage, limit) {
+  if (limit === null || limit === 0)
+    return null;
+  return Math.min(100, currentUsage / limit * 100);
+}
+var DEFAULT_USAGE_THRESHOLDS;
 var init_provider_usage = __esm({
   "../../packages/types/dist/provider-usage.js"() {
     "use strict";
+    DEFAULT_USAGE_THRESHOLDS = {
+      warningThreshold: 70,
+      criticalThreshold: 90
+    };
   }
 });
 
@@ -5909,9 +6212,47 @@ var init_worker_pool = __esm({
 });
 
 // ../../packages/types/dist/provider-precedence.js
+function mapAgentToProvider(agent) {
+  const mapping = {
+    claude: "claude",
+    codex: "codex",
+    gemini: "gemini"
+  };
+  return mapping[agent] ?? "claude";
+}
+function mapProviderToAgent(provider) {
+  const mapping = {
+    claude: "claude",
+    codex: "codex",
+    gemini: "gemini"
+  };
+  return mapping[provider];
+}
+function determineFallbackReason(requestedChecks, fallbackChecks) {
+  if (!requestedChecks.credentials)
+    return "fallback_credentials";
+  if (!requestedChecks.capacity)
+    return "fallback_capacity";
+  if (!requestedChecks.quota)
+    return "fallback_quota";
+  if (!requestedChecks.health)
+    return "fallback_health";
+  if (!requestedChecks.policy)
+    return "fallback_policy";
+  return "fallback_capacity";
+}
+function formatProviderSelection(result) {
+  if (result.reason === "requested") {
+    return `Selected ${result.provider} (requested)`;
+  }
+  const requested = result.requestedProvider ?? "claude";
+  return `Selected ${result.provider} (fallback from ${requested}: ${result.reason})`;
+}
+var DEFAULT_PROVIDER_PRECEDENCE;
 var init_provider_precedence = __esm({
   "../../packages/types/dist/provider-precedence.js"() {
     "use strict";
+    DEFAULT_PROVIDER_PRECEDENCE = ["codex", "claude", "gemini"];
   }
 });
 
@@ -5923,23 +6264,78 @@ var init_sdlc_enforcement = __esm({
 });
 
 // ../../packages/types/dist/supervisor-directive.js
+var DEFAULT_DIRECTIVE_POLICY;
 var init_supervisor_directive = __esm({
   "../../packages/types/dist/supervisor-directive.js"() {
     "use strict";
+    DEFAULT_DIRECTIVE_POLICY = {
+      maxCapacityPerOrg: 10,
+      maxRetryAttempts: 3,
+      minRetryDelayMs: 5e3,
+      // 5 seconds
+      allowedAgents: ["claude", "codex", "gemini", "any"],
+      enforceIdempotency: true,
+      idempotencyWindowMs: 3e5
+      // 5 minutes
+    };
   }
 });
 
 // ../../packages/types/dist/browser-automation.js
+var BROWSER_BACKEND_FALLBACK_ORDER, BROWSER_BACKEND_CONFIGS, FAILURE_REMEDIATIONS;
 var init_browser_automation = __esm({
   "../../packages/types/dist/browser-automation.js"() {
     "use strict";
+    BROWSER_BACKEND_FALLBACK_ORDER = [
+      "chrome-devtools",
+      "playwright",
+      "claude-chrome"
+    ];
+    BROWSER_BACKEND_CONFIGS = {
+      "chrome-devtools": {
+        displayName: "Chrome DevTools MCP",
+        mcpServerName: "chrome-devtools",
+        description: "Direct Chrome DevTools Protocol via chrome-devtools-mcp"
+      },
+      "playwright": {
+        displayName: "Playwright MCP",
+        mcpServerName: "playwright",
+        description: "Playwright browser automation via @anthropic/playwright-mcp"
+      },
+      "claude-chrome": {
+        displayName: "Claude Chrome",
+        mcpServerName: "claude-in-chrome",
+        description: "Claude built-in Chrome automation via Claude-in-Chrome MCP"
+      }
+    };
+    FAILURE_REMEDIATIONS = {
+      BACKEND_NOT_AVAILABLE: "No browser automation backend is available. Ensure at least one MCP server (chrome-devtools, playwright, or claude-chrome) is configured in approved config or user MCP config.",
+      BACKEND_CONNECTION_FAILED: "Browser backend was detected but connection failed. Check that the MCP server process is running and the browser is accessible.",
+      PERMISSION_DENIED: "Insufficient permissions for this browser action. Check MCP server configuration and ensure the agent has browser automation permissions.",
+      AUTH_REQUIRED: "The target page requires authentication. Navigate to the login page first or provide credentials via environment variables.",
+      BROWSER_NOT_FOUND: "Browser binary not found. Install Chrome/Chromium or set the CHROME_PATH environment variable.",
+      ELEMENT_NOT_FOUND: "Target element not found in the DOM. Verify the selector/UID and ensure the page has fully loaded.",
+      PAGE_TIMEOUT: "Page operation timed out. Check network connectivity, increase timeout, or verify the target URL is reachable.",
+      SCREENSHOT_FAILED: "Screenshot capture failed. Try a different capture mode (viewport instead of full_page) or check browser state.",
+      INVALID_SELECTOR: "The provided CSS/XPath selector is malformed. Verify the selector syntax and try again.",
+      MCP_SERVER_ERROR: "The MCP server returned an error. Check MCP server logs for details and ensure the server version is up to date."
+    };
   }
 });
 
 // ../../packages/types/dist/team-assignment.js
+var DEFAULT_TEAM_ASSIGNMENT_CONFIG;
 var init_team_assignment = __esm({
   "../../packages/types/dist/team-assignment.js"() {
     "use strict";
+    DEFAULT_TEAM_ASSIGNMENT_CONFIG = {
+      supervisorWorkerRatio: 3,
+      maxTotalWorkers: 12,
+      providerCaps: { claude: 6, codex: 4, gemini: 4 },
+      maxPendingAssignments: 20,
+      maxWorkersPerRepo: 4,
+      fairnessWeight: 0.5
+    };
   }
 });
 
@@ -6111,8 +6507,310 @@ var init_learning = __esm({
   }
 });
 
+// ../../packages/types/dist/enforcement-mode.js
+function checkEnforcement(toolName, toolInput, settings, sessionRole, userLogin) {
+  if (!settings.enabled || settings.mode === "off") {
+    return {
+      allowed: true,
+      mode: settings.mode,
+      sessionRole,
+      isWarning: false
+    };
+  }
+  if (sessionRole === "worker") {
+    return {
+      allowed: true,
+      mode: settings.mode,
+      sessionRole,
+      isWarning: false
+    };
+  }
+  if (userLogin && settings.exemptUsers && settings.exemptUsers.includes(userLogin)) {
+    return {
+      allowed: true,
+      mode: settings.mode,
+      sessionRole,
+      isWarning: false
+    };
+  }
+  if (ALWAYS_ALLOWED_TOOLS.includes(toolName)) {
+    return {
+      allowed: true,
+      mode: settings.mode,
+      sessionRole,
+      isWarning: false
+    };
+  }
+  const blockedTools = settings.blockedTools && settings.blockedTools.length > 0 ? settings.blockedTools : DEFAULT_BLOCKED_TOOLS;
+  const isBlockedTool = blockedTools.includes(toolName);
+  let isBlockedBash = false;
+  if (toolName === "Bash") {
+    const command = String(toolInput?.command || "");
+    isBlockedBash = BLOCKED_BASH_PATTERNS.some((pattern) => command.includes(pattern));
+  }
+  const isBlocked = isBlockedTool || isBlockedBash;
+  if (!isBlocked) {
+    return {
+      allowed: true,
+      mode: settings.mode,
+      sessionRole,
+      isWarning: false
+    };
+  }
+  const org = "your organization";
+  const blockMessage = (settings.blockMessage || DEFAULT_BLOCK_MESSAGE).replace(/\{tool\}/g, toolName).replace(/\{org\}/g, org);
+  if (settings.mode === "warn") {
+    return {
+      allowed: true,
+      mode: settings.mode,
+      sessionRole,
+      reason: `\u26A0\uFE0F WARNING: ${blockMessage}`,
+      isWarning: true
+    };
+  }
+  return {
+    allowed: false,
+    mode: settings.mode,
+    sessionRole,
+    reason: blockMessage,
+    isWarning: false
+  };
+}
+var DEFAULT_BLOCKED_TOOLS, BLOCKED_BASH_PATTERNS, ALWAYS_ALLOWED_TOOLS, DEFAULT_ENFORCEMENT_MODE_SETTINGS, DEFAULT_BLOCK_MESSAGE;
+var init_enforcement_mode = __esm({
+  "../../packages/types/dist/enforcement-mode.js"() {
+    "use strict";
+    DEFAULT_BLOCKED_TOOLS = [
+      "Edit",
+      "Write",
+      "MultiEdit",
+      "NotebookEdit"
+    ];
+    BLOCKED_BASH_PATTERNS = [
+      "git push",
+      "git commit",
+      "git add",
+      "git stash",
+      "git rebase",
+      "git merge",
+      "git cherry-pick",
+      "npm publish",
+      "pnpm publish",
+      "make deploy",
+      "make release"
+    ];
+    ALWAYS_ALLOWED_TOOLS = [
+      "Read",
+      "Glob",
+      "Grep",
+      "LSP",
+      "WebFetch",
+      "WebSearch",
+      "AskUserQuestion",
+      "TodoWrite",
+      "Task",
+      "Skill",
+      "EnterPlanMode",
+      "ExitPlanMode"
+    ];
+    DEFAULT_ENFORCEMENT_MODE_SETTINGS = {
+      mode: "off",
+      enabled: false
+    };
+    DEFAULT_BLOCK_MESSAGE = "\u{1F6AB} This action is blocked by your organization's enforcement policy.\nYour org ({org}) requires all implementation work to go through the background agent queue.\n\nTo proceed:\n  1. Create a GitHub issue describing the work\n  2. Use `gal dispatch` or the dashboard to queue a background agent\n  3. Monitor and review the agent's output\n\nBlocked tool: {tool}";
+  }
+});
+
+// ../../packages/types/dist/sdlc-evaluation.js
+var init_sdlc_evaluation = __esm({
+  "../../packages/types/dist/sdlc-evaluation.js"() {
+    "use strict";
+  }
+});
+
+// ../../packages/types/dist/oss-model-eval.js
+var OSS_EVAL_SCHEMA_VERSION, OSS_EVAL_DATASET_PATH, OSS_EVAL_TASK_SET_MODES, OSS_EVAL_CANONICAL_PROVIDERS, OSS_EVAL_METRIC_IDS, DEFAULT_OSS_EVAL_THRESHOLDS, DEFAULT_OSS_EVAL_WEIGHTS, DEFAULT_OSS_EVAL_WIN_CRITERIA, OSS_EVAL_METRICS, DEFAULT_OSS_EVAL_SPEC;
+var init_oss_model_eval = __esm({
+  "../../packages/types/dist/oss-model-eval.js"() {
+    "use strict";
+    OSS_EVAL_SCHEMA_VERSION = "v1";
+    OSS_EVAL_DATASET_PATH = "/sessions";
+    OSS_EVAL_TASK_SET_MODES = ["intersection", "all"];
+    OSS_EVAL_CANONICAL_PROVIDERS = ["claude", "codex", "oss"];
+    OSS_EVAL_METRIC_IDS = [
+      "pr_merge_rate",
+      "ci_pass_rate_first_attempt",
+      "task_completion_rate",
+      "review_score"
+    ];
+    DEFAULT_OSS_EVAL_THRESHOLDS = {
+      prMergeRate: 0.75,
+      ciPassRateFirstAttempt: 0.65,
+      taskCompletionRate: 0.8,
+      reviewScore: 0.85
+    };
+    DEFAULT_OSS_EVAL_WEIGHTS = {
+      prMergeRate: 0.3,
+      ciPassRateFirstAttempt: 0.2,
+      taskCompletionRate: 0.35,
+      reviewScore: 0.15
+    };
+    DEFAULT_OSS_EVAL_WIN_CRITERIA = {
+      minimumSharedTasks: 20,
+      minimumCompositeScore: 0.75,
+      requireAllMetricThresholds: true
+    };
+    OSS_EVAL_METRICS = {
+      pr_merge_rate: {
+        id: "pr_merge_rate",
+        label: "PR Merge Rate",
+        numeratorDefinition: "PR merged",
+        denominatorDefinition: "Session has mapped PR",
+        thresholdKey: "prMergeRate",
+        weightKey: "prMergeRate"
+      },
+      ci_pass_rate_first_attempt: {
+        id: "ci_pass_rate_first_attempt",
+        label: "CI Pass Rate (First Attempt)",
+        numeratorDefinition: "PR CI passed on first attempt",
+        denominatorDefinition: "Session has mapped PR with CI evidence",
+        thresholdKey: "ciPassRateFirstAttempt",
+        weightKey: "ciPassRateFirstAttempt"
+      },
+      task_completion_rate: {
+        id: "task_completion_rate",
+        label: "Task Completion Rate",
+        numeratorDefinition: "Issue closed with no human reopen",
+        denominatorDefinition: "Session has mapped issue",
+        thresholdKey: "taskCompletionRate",
+        weightKey: "taskCompletionRate"
+      },
+      review_score: {
+        id: "review_score",
+        label: "Review Score",
+        numeratorDefinition: "PR had no requested changes",
+        denominatorDefinition: "Session has mapped PR with review evidence",
+        thresholdKey: "reviewScore",
+        weightKey: "reviewScore"
+      }
+    };
+    DEFAULT_OSS_EVAL_SPEC = {
+      schemaVersion: OSS_EVAL_SCHEMA_VERSION,
+      datasetPath: OSS_EVAL_DATASET_PATH,
+      defaultTaskSetMode: "intersection",
+      metrics: OSS_EVAL_METRICS,
+      thresholds: DEFAULT_OSS_EVAL_THRESHOLDS,
+      weights: DEFAULT_OSS_EVAL_WEIGHTS,
+      winCriteria: DEFAULT_OSS_EVAL_WIN_CRITERIA
+    };
+  }
+});
+
+// ../../packages/types/dist/ab-routing.js
+function laneToEvalProvider(lane, vendorProvider) {
+  if (lane === "oss")
+    return "oss";
+  if (vendorProvider === "codex")
+    return "codex";
+  return "claude";
+}
+var DEFAULT_AB_ROUTING_CONFIG, AB_ROUTING_MODES;
+var init_ab_routing = __esm({
+  "../../packages/types/dist/ab-routing.js"() {
+    "use strict";
+    DEFAULT_AB_ROUTING_CONFIG = {
+      enabled: false,
+      mode: "vendor_only"
+    };
+    AB_ROUTING_MODES = [
+      "vendor_only",
+      "oss_only",
+      "percentage",
+      "round_robin",
+      "conditional"
+    ];
+  }
+});
+
 // ../../packages/types/dist/index.js
-var GAL_TERMS_URL, GAL_PRIVACY_URL, PLATFORM_PATTERNS;
+var dist_exports = {};
+__export(dist_exports, {
+  AB_ROUTING_MODES: () => AB_ROUTING_MODES,
+  ACTIVE_BACKGROUND_AGENT_RUNNER_LABELS: () => ACTIVE_BACKGROUND_AGENT_RUNNER_LABELS,
+  ALL_PAGE_IDS: () => ALL_PAGE_IDS,
+  ALL_PLATFORM_IDS: () => ALL_PLATFORM_IDS,
+  ALWAYS_ALLOWED_TOOLS: () => ALWAYS_ALLOWED_TOOLS,
+  BLOCKED_BASH_PATTERNS: () => BLOCKED_BASH_PATTERNS,
+  BROWSER_BACKEND_CONFIGS: () => BROWSER_BACKEND_CONFIGS,
+  BROWSER_BACKEND_FALLBACK_ORDER: () => BROWSER_BACKEND_FALLBACK_ORDER,
+  CREDENTIAL_PROVIDERS: () => CREDENTIAL_PROVIDERS,
+  CREDENTIAL_PROVIDER_CONFIGS: () => CREDENTIAL_PROVIDER_CONFIGS,
+  CREDENTIAL_SYNC_PLATFORMS: () => CREDENTIAL_SYNC_PLATFORMS,
+  DEFAULT_AB_ROUTING_CONFIG: () => DEFAULT_AB_ROUTING_CONFIG,
+  DEFAULT_BLOCKED_TOOLS: () => DEFAULT_BLOCKED_TOOLS,
+  DEFAULT_BLOCK_MESSAGE: () => DEFAULT_BLOCK_MESSAGE,
+  DEFAULT_DIRECTIVE_POLICY: () => DEFAULT_DIRECTIVE_POLICY,
+  DEFAULT_DISPATCH_CATEGORIES: () => DEFAULT_DISPATCH_CATEGORIES,
+  DEFAULT_ENFORCEMENT_MODE_SETTINGS: () => DEFAULT_ENFORCEMENT_MODE_SETTINGS,
+  DEFAULT_ENFORCEMENT_SETTINGS: () => DEFAULT_ENFORCEMENT_SETTINGS,
+  DEFAULT_OSS_EVAL_SPEC: () => DEFAULT_OSS_EVAL_SPEC,
+  DEFAULT_OSS_EVAL_THRESHOLDS: () => DEFAULT_OSS_EVAL_THRESHOLDS,
+  DEFAULT_OSS_EVAL_WEIGHTS: () => DEFAULT_OSS_EVAL_WEIGHTS,
+  DEFAULT_OSS_EVAL_WIN_CRITERIA: () => DEFAULT_OSS_EVAL_WIN_CRITERIA,
+  DEFAULT_PROVIDER_PRECEDENCE: () => DEFAULT_PROVIDER_PRECEDENCE,
+  DEFAULT_RUNNER_LABEL: () => DEFAULT_RUNNER_LABEL,
+  DEFAULT_SESSION_AGENT: () => DEFAULT_SESSION_AGENT,
+  DEFAULT_TEAM_ASSIGNMENT_CONFIG: () => DEFAULT_TEAM_ASSIGNMENT_CONFIG,
+  DEFAULT_USAGE_THRESHOLDS: () => DEFAULT_USAGE_THRESHOLDS,
+  ERROR_CODE_CATEGORIES: () => ERROR_CODE_CATEGORIES,
+  ErrorCategory: () => ErrorCategory,
+  FAILURE_REMEDIATIONS: () => FAILURE_REMEDIATIONS,
+  GAL_PRIVACY_URL: () => GAL_PRIVACY_URL,
+  GAL_TERMS_URL: () => GAL_TERMS_URL,
+  HOOKABLE_PLATFORMS: () => HOOKABLE_PLATFORMS,
+  OSS_EVAL_CANONICAL_PROVIDERS: () => OSS_EVAL_CANONICAL_PROVIDERS,
+  OSS_EVAL_DATASET_PATH: () => OSS_EVAL_DATASET_PATH,
+  OSS_EVAL_METRICS: () => OSS_EVAL_METRICS,
+  OSS_EVAL_METRIC_IDS: () => OSS_EVAL_METRIC_IDS,
+  OSS_EVAL_SCHEMA_VERSION: () => OSS_EVAL_SCHEMA_VERSION,
+  OSS_EVAL_TASK_SET_MODES: () => OSS_EVAL_TASK_SET_MODES,
+  PLATFORM_DIRECTORIES: () => PLATFORM_DIRECTORIES,
+  PLATFORM_DIRECTORY_MAP: () => PLATFORM_DIRECTORY_MAP,
+  PLATFORM_DISPLAY_MAP: () => PLATFORM_DISPLAY_MAP,
+  PLATFORM_INSTRUCTION_FILE_MAP: () => PLATFORM_INSTRUCTION_FILE_MAP,
+  PLATFORM_PATTERNS: () => PLATFORM_PATTERNS,
+  PLATFORM_REGISTRY: () => PLATFORM_REGISTRY,
+  RETIRED_BACKGROUND_AGENT_RUNNER_LABELS: () => RETIRED_BACKGROUND_AGENT_RUNNER_LABELS,
+  SECURITY_GATED_RUNNER_LABELS: () => SECURITY_GATED_RUNNER_LABELS,
+  SESSION_AGENTS: () => SESSION_AGENTS,
+  SESSION_RUNNER_PLATFORMS: () => SESSION_RUNNER_PLATFORMS,
+  STABLE_PLATFORM_IDS: () => STABLE_PLATFORM_IDS,
+  SessionErrorCode: () => SessionErrorCode,
+  calculateHeadroom: () => calculateHeadroom,
+  calculateHealthState: () => calculateHealthState,
+  calculateUsagePercent: () => calculateUsagePercent,
+  checkEnforcement: () => checkEnforcement,
+  determineFallbackReason: () => determineFallbackReason,
+  formatProviderSelection: () => formatProviderSelection,
+  getCredentialProviderConfig: () => getCredentialProviderConfig,
+  isActiveBackgroundAgentRunnerLabel: () => isActiveBackgroundAgentRunnerLabel,
+  isEnhancedEvent: () => isEnhancedEvent,
+  isValidCredentialProvider: () => isValidCredentialProvider,
+  laneToEvalProvider: () => laneToEvalProvider,
+  mapAgentToProvider: () => mapAgentToProvider,
+  mapProviderToAgent: () => mapProviderToAgent,
+  normalizeBackgroundAgentRunnerLabel: () => normalizeBackgroundAgentRunnerLabel,
+  normalizeOperationsProcessStep: () => normalizeOperationsProcessStep,
+  normalizeWorkItemExecutionContext: () => normalizeWorkItemExecutionContext,
+  parseWorkItemExecutionContext: () => parseWorkItemExecutionContext,
+  platformsWithCapability: () => platformsWithCapability,
+  resolveOperationsBoundaryDecision: () => resolveOperationsBoundaryDecision,
+  serializeWorkItemExecutionContext: () => serializeWorkItemExecutionContext,
+  severityToNumber: () => severityToNumber,
+  upgradeToEnhancedEvent: () => upgradeToEnhancedEvent,
+  validateExecutionIdentityEnvelope: () => validateExecutionIdentityEnvelope
+});
+var GAL_TERMS_URL, GAL_PRIVACY_URL, PLATFORM_DIRECTORIES, PLATFORM_PATTERNS, DEFAULT_ENFORCEMENT_SETTINGS, DEFAULT_DISPATCH_CATEGORIES;
 var init_dist2 = __esm({
   "../../packages/types/dist/index.js"() {
     "use strict";
@@ -6169,8 +6867,13 @@ var init_dist2 = __esm({
     init_memory();
     init_secrets();
     init_learning();
+    init_enforcement_mode();
+    init_sdlc_evaluation();
+    init_oss_model_eval();
+    init_ab_routing();
     GAL_TERMS_URL = "https://scheduler-systems.com/legal/en/gal-terms.pdf";
     GAL_PRIVACY_URL = "https://scheduler-systems.com/legal/en/gal-privacy.pdf";
+    PLATFORM_DIRECTORIES = PLATFORM_DIRECTORY_MAP;
     PLATFORM_PATTERNS = {
       claude: {
         platform: "claude",
@@ -6349,6 +7052,24 @@ var init_dist2 = __esm({
         ruleExtensions: []
       }
     };
+    DEFAULT_ENFORCEMENT_SETTINGS = {
+      enabled: false,
+      level: "warn",
+      blockOnMismatch: false,
+      requireSync: false,
+      allowOverrides: true,
+      notifyOnViolation: false
+    };
+    DEFAULT_DISPATCH_CATEGORIES = [
+      { id: "bug-fixes", name: "Bug Fixes", description: "Fix bugs with clear reproduction steps and specific file locations", enabled: true },
+      { id: "test-writing", name: "Test Writing", description: "Write or update tests for existing code", enabled: true },
+      { id: "documentation", name: "Documentation", description: "Update docs, README files, code comments", enabled: true },
+      { id: "ci-fixes", name: "CI/Lint Fixes", description: "Fix CI failures, lint errors, type errors", enabled: true },
+      { id: "refactoring", name: "Code Refactoring", description: "Refactor code patterns across multiple files", enabled: false },
+      { id: "new-features", name: "New Features", description: "Implement new features from specs", enabled: false },
+      { id: "security-fixes", name: "Security Patches", description: "Fix security vulnerabilities", enabled: false },
+      { id: "migrations", name: "Migrations", description: "Database or dependency migrations", enabled: false }
+    ];
   }
 });
 
@@ -13937,7 +14658,8 @@ var init_HttpWorkItemRepository = __esm({
           priority: request.priority,
           source: request.source,
           context: request.context,
-          preferredAgent: request.preferredAgent
+          preferredAgent: request.preferredAgent,
+          ...request.runnerLabel ? { runnerLabel: request.runnerLabel } : {}
         };
         const response = await this.fetchJson("/api/work-items", {
           method: "POST",
@@ -46579,7 +47301,17 @@ function rememberSessionStart(inputData) {
       }),
       'utf-8',
     );
-  } catch {}
+  } catch (startError) {
+    // Log so session-start tracking failures are diagnosable (#4970)
+    try {
+      const logDir = path.join(os.homedir(), '.gal', 'logs');
+      if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+      fs.appendFileSync(
+        path.join(logDir, 'usage-hook.log'),
+        \`[\${new Date().toISOString()}] rememberSessionStart failed: \${startError.message || startError}\\n\`,
+      );
+    } catch {}
+  }
 }
 
 function selfClean() {
@@ -46951,7 +47683,17 @@ try {
     \`gal report-usage --provider claude --seconds \${durationSeconds} --org \${JSON.stringify(orgName)} --json\`,
     { stdio: 'pipe', timeout: 15000, shell: true },
   );
-} catch {}
+} catch (reportError) {
+  // Log to a file so usage-reporting failures are diagnosable (#4970)
+  try {
+    const logDir = path.join(os.homedir(), '.gal', 'logs');
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+    const stderr = reportError && reportError.stderr ? reportError.stderr.toString() : '';
+    const stdout = reportError && reportError.stdout ? reportError.stdout.toString() : '';
+    const entry = \`[\${new Date().toISOString()}] report-usage failed (org=\${orgName}, seconds=\${durationSeconds})\\n  exit=\${reportError.status || 'unknown'}\\n  stderr: \${stderr.trim() || '(none)'}\\n  stdout: \${stdout.trim() || '(none)'}\\n\\n\`;
+    fs.appendFileSync(path.join(logDir, 'usage-hook.log'), entry);
+  } catch {}
+}
 
 process.exit(0);
 `;
@@ -55608,6 +56350,382 @@ var init_system_enforcer = __esm({
   }
 });
 
+// src/enforcement/workflow-enforcement-hook.ts
+var workflow_enforcement_hook_exports = {};
+__export(workflow_enforcement_hook_exports, {
+  generateWorkflowEnforcementHook: () => generateWorkflowEnforcementHook,
+  generateWorkflowEnforcementHookNode: () => generateWorkflowEnforcementHookNode
+});
+function generateWorkflowEnforcementHook(options) {
+  const { apiUrl, orgName, sessionRole } = options;
+  const hookScript = `#!/usr/bin/env python3
+"""
+GAL Workflow Enforcement Hook - Background Agents Only Mode
+Generated by GAL CLI for org: ${orgName}
+API: ${apiUrl}
+
+Enforces the organization's workflow policy:
+- 'background-only': Blocks implementation tools in local sessions
+- 'warn': Warns but allows implementation tools in local sessions
+- 'off': No restrictions
+
+Fail-open: If GAL API is unreachable, all tools are allowed.
+"""
+import json
+import os
+import sys
+import time
+
+try:
+    from urllib.request import Request, urlopen
+    from urllib.error import URLError
+except ImportError:
+    # Fallback: if urllib is unavailable, fail open
+    def main():
+        print(json.dumps({"decision": "allow"}))
+        sys.exit(0)
+    if __name__ == "__main__":
+        main()
+    sys.exit(0)
+
+# Configuration
+API_URL = "${apiUrl}"
+ORG_NAME = "${orgName}"
+CACHE_TTL_SECONDS = 300  # 5 minutes
+CACHE_FILE = os.path.join(os.path.expanduser("~"), ".gal", "enforcement-cache.json")
+
+# Tool classifications
+BLOCKED_TOOLS = ${JSON.stringify(DEFAULT_BLOCKED_TOOLS)}
+BLOCKED_BASH_PATTERNS = ${JSON.stringify(BLOCKED_BASH_PATTERNS)}
+ALWAYS_ALLOWED = ${JSON.stringify(ALWAYS_ALLOWED_TOOLS)}
+
+${sessionRole === "worker" ? `
+# This session is a worker (background agent) \u2014 skip all enforcement
+def main():
+    print(json.dumps({"decision": "allow"}))
+
+if __name__ == "__main__":
+    main()
+    sys.exit(0)
+` : ""}
+
+def load_cached_settings():
+    """Load enforcement settings from local cache if still fresh."""
+    try:
+        if not os.path.exists(CACHE_FILE):
+            return None
+        with open(CACHE_FILE, "r") as f:
+            cache = json.load(f)
+        if cache.get("orgName") != ORG_NAME:
+            return None
+        cached_at = cache.get("cachedAt", 0)
+        if time.time() - cached_at > CACHE_TTL_SECONDS:
+            return None
+        return cache.get("settings")
+    except Exception:
+        return None
+
+
+def save_cached_settings(settings):
+    """Save enforcement settings to local cache."""
+    try:
+        cache_dir = os.path.dirname(CACHE_FILE)
+        os.makedirs(cache_dir, exist_ok=True)
+        with open(CACHE_FILE, "w") as f:
+            json.dump({
+                "orgName": ORG_NAME,
+                "settings": settings,
+                "cachedAt": time.time(),
+            }, f)
+    except Exception:
+        pass  # Non-critical \u2014 next call will re-fetch
+
+
+def fetch_enforcement_settings():
+    """Fetch enforcement settings from GAL API. Returns None on failure (fail-open)."""
+    # Try cache first
+    cached = load_cached_settings()
+    if cached is not None:
+        return cached
+
+    # Fetch from API
+    url = f"{API_URL}/organizations/{ORG_NAME}/workflow-enforcement"
+    try:
+        # Use GAL auth token if available
+        token = os.environ.get("GAL_AUTH_TOKEN") or os.environ.get("GAL_API_KEY")
+        headers = {"Content-Type": "application/json"}
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+
+        req = Request(url, headers=headers)
+        with urlopen(req, timeout=5) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+            save_cached_settings(data)
+            return data
+    except Exception:
+        # Fail open \u2014 if API is unreachable, allow everything
+        return None
+
+
+def is_worker_session():
+    """Check if this is a background agent (worker) session."""
+    # Background agents set these env vars
+    if os.environ.get("GAL_SESSION_ROLE") == "worker":
+        return True
+    if os.environ.get("GAL_BACKGROUND_AGENT") == "true":
+        return True
+    if os.environ.get("GITHUB_ACTIONS") == "true" and os.environ.get("GAL_SESSION_ID"):
+        return True
+    return False
+
+
+def check_tool(tool_name, tool_input, settings):
+    """Check if a tool call should be allowed based on enforcement settings."""
+    mode = settings.get("mode", "off")
+    enabled = settings.get("enabled", False)
+
+    if not enabled or mode == "off":
+        return {"decision": "allow"}
+
+    # Always-allowed tools pass through
+    if tool_name in ALWAYS_ALLOWED:
+        return {"decision": "allow"}
+
+    # Check if user is exempt
+    user_login = os.environ.get("GAL_USER_LOGIN", "")
+    exempt_users = settings.get("exemptUsers", [])
+    if user_login and user_login in exempt_users:
+        return {"decision": "allow"}
+
+    # Check blocked tools
+    custom_blocked = settings.get("blockedTools") or BLOCKED_TOOLS
+    is_blocked_tool = tool_name in custom_blocked
+
+    # Check Bash command patterns
+    is_blocked_bash = False
+    if tool_name == "Bash":
+        command = str(tool_input.get("command", ""))
+        is_blocked_bash = any(p in command for p in BLOCKED_BASH_PATTERNS)
+
+    if not is_blocked_tool and not is_blocked_bash:
+        return {"decision": "allow"}
+
+    # Build message
+    block_msg = settings.get("blockMessage") or ${JSON.stringify(DEFAULT_BLOCK_MESSAGE)}
+    block_msg = block_msg.replace("{tool}", tool_name).replace("{org}", ORG_NAME)
+
+    if mode == "warn":
+        # Warn mode: allow but print warning to stderr
+        sys.stderr.write(f"\\n\\033[33m[GAL] WARNING: {block_msg}\\033[0m\\n\\n")
+        return {"decision": "allow"}
+
+    # background-only mode: block
+    return {
+        "decision": "block",
+        "reason": block_msg,
+    }
+
+
+def main():
+    # Workers (background agents) are never restricted
+    if is_worker_session():
+        print(json.dumps({"decision": "allow"}))
+        return
+
+    # Read hook input
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, Exception):
+        print(json.dumps({"decision": "allow"}))
+        return
+
+    tool_name = hook_input.get("tool_name", "")
+    tool_input = hook_input.get("tool_input", {}) or {}
+
+    # Fetch enforcement settings (cached)
+    settings = fetch_enforcement_settings()
+    if settings is None:
+        # Fail open
+        print(json.dumps({"decision": "allow"}))
+        return
+
+    result = check_tool(tool_name, tool_input, settings)
+    print(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()
+`;
+  return {
+    platform: "claude",
+    hookType: "pre_tool_use",
+    filename: "gal-workflow-enforcement.py",
+    content: hookScript,
+    settingsSnippet: {
+      hooks: {
+        pre_tool_use: [{
+          command: "python3 .claude/hooks/gal-workflow-enforcement.py",
+          timeout: 1e4
+        }]
+      }
+    }
+  };
+}
+function generateWorkflowEnforcementHookNode(options) {
+  const { apiUrl, orgName, sessionRole } = options;
+  const hookScript = `#!/usr/bin/env node
+/**
+ * GAL Workflow Enforcement Hook - Background Agents Only Mode
+ * Generated by GAL CLI for org: ${orgName}
+ * API: ${apiUrl}
+ *
+ * Enforces the organization's workflow policy for Cursor/Windsurf.
+ * Fail-open: If GAL API is unreachable, all tools are allowed.
+ */
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const API_URL = '${apiUrl}';
+const ORG_NAME = '${orgName}';
+const CACHE_TTL_MS = 300000; // 5 minutes
+const CACHE_FILE = path.join(require('os').homedir(), '.gal', 'enforcement-cache.json');
+
+const BLOCKED_TOOLS = ${JSON.stringify(DEFAULT_BLOCKED_TOOLS)};
+const BLOCKED_BASH_PATTERNS = ${JSON.stringify(BLOCKED_BASH_PATTERNS)};
+const ALWAYS_ALLOWED = ${JSON.stringify(ALWAYS_ALLOWED_TOOLS)};
+
+${sessionRole === "worker" ? `
+// Worker session \u2014 skip enforcement
+console.log(JSON.stringify({ decision: 'allow' }));
+process.exit(0);
+` : ""}
+
+function isWorkerSession() {
+  return (
+    process.env.GAL_SESSION_ROLE === 'worker' ||
+    process.env.GAL_BACKGROUND_AGENT === 'true' ||
+    (process.env.GITHUB_ACTIONS === 'true' && process.env.GAL_SESSION_ID)
+  );
+}
+
+function loadCachedSettings() {
+  try {
+    if (!fs.existsSync(CACHE_FILE)) return null;
+    const cache = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
+    if (cache.orgName !== ORG_NAME) return null;
+    if (Date.now() - (cache.cachedAt || 0) > CACHE_TTL_MS) return null;
+    return cache.settings;
+  } catch { return null; }
+}
+
+function saveCachedSettings(settings) {
+  try {
+    const dir = path.dirname(CACHE_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(CACHE_FILE, JSON.stringify({
+      orgName: ORG_NAME,
+      settings,
+      cachedAt: Date.now(),
+    }));
+  } catch { /* non-critical */ }
+}
+
+async function fetchSettings() {
+  const cached = loadCachedSettings();
+  if (cached) return cached;
+
+  try {
+    const url = \`\${API_URL}/organizations/\${ORG_NAME}/workflow-enforcement\`;
+    const token = process.env.GAL_AUTH_TOKEN || process.env.GAL_API_KEY;
+    const headers = { 'Content-Type': 'application/json' };
+    if (token) headers['Authorization'] = \`Bearer \${token}\`;
+
+    const resp = await fetch(url, { headers, signal: AbortSignal.timeout(5000) });
+    if (!resp.ok) return null;
+    const data = await resp.json();
+    saveCachedSettings(data);
+    return data;
+  } catch { return null; }
+}
+
+const rl = readline.createInterface({ input: process.stdin });
+let input = '';
+rl.on('line', (line) => { input += line; });
+rl.on('close', async () => {
+  if (isWorkerSession()) {
+    console.log(JSON.stringify({ decision: 'allow' }));
+    return;
+  }
+
+  let hookInput;
+  try { hookInput = JSON.parse(input); } catch {
+    console.log(JSON.stringify({ decision: 'allow' }));
+    return;
+  }
+
+  const toolName = hookInput.tool_name || '';
+  const toolInput = hookInput.tool_input || {};
+
+  const settings = await fetchSettings();
+  if (!settings || !settings.enabled || settings.mode === 'off') {
+    console.log(JSON.stringify({ decision: 'allow' }));
+    return;
+  }
+
+  if (ALWAYS_ALLOWED.includes(toolName)) {
+    console.log(JSON.stringify({ decision: 'allow' }));
+    return;
+  }
+
+  const customBlocked = settings.blockedTools || BLOCKED_TOOLS;
+  const isBlockedTool = customBlocked.includes(toolName);
+  let isBlockedBash = false;
+  if (toolName === 'Bash') {
+    const cmd = String(toolInput.command || '');
+    isBlockedBash = BLOCKED_BASH_PATTERNS.some((p) => cmd.includes(p));
+  }
+
+  if (!isBlockedTool && !isBlockedBash) {
+    console.log(JSON.stringify({ decision: 'allow' }));
+    return;
+  }
+
+  const msg = (settings.blockMessage || ${JSON.stringify(DEFAULT_BLOCK_MESSAGE)})
+    .replace(/\\{tool\\}/g, toolName)
+    .replace(/\\{org\\}/g, ORG_NAME);
+
+  if (settings.mode === 'warn') {
+    process.stderr.write(\`\\n\\x1b[33m[GAL] WARNING: \${msg}\\x1b[0m\\n\\n\`);
+    console.log(JSON.stringify({ decision: 'allow' }));
+    return;
+  }
+
+  console.log(JSON.stringify({ decision: 'block', reason: msg }));
+});
+`;
+  return {
+    platform: "cursor",
+    hookType: "pre_tool_use",
+    filename: "gal-workflow-enforcement.js",
+    content: hookScript,
+    settingsSnippet: {
+      hooks: {
+        pre_tool_use: {
+          command: "node .cursor/hooks/gal-workflow-enforcement.js",
+          timeout: 1e4
+        }
+      }
+    }
+  };
+}
+var init_workflow_enforcement_hook = __esm({
+  "src/enforcement/workflow-enforcement-hook.ts"() {
+    "use strict";
+    init_dist2();
+  }
+});
+
 // src/enforcement/index.ts
 var init_enforcement = __esm({
   "src/enforcement/index.ts"() {
@@ -55618,6 +56736,7 @@ var init_enforcement = __esm({
     init_config_validator();
     init_hook_generator();
     init_system_enforcer();
+    init_workflow_enforcement_hook();
   }
 });
 
@@ -58146,6 +59265,183 @@ Native SDLC enforcement updated to ${level} for ${orgName}.
     }
   });
   enforce.addCommand(sdlcCommand);
+  const workflowCommand = new Command("workflow").description("Manage workflow enforcement mode (background agents only)");
+  workflowCommand.command("status").description("Show the current workflow enforcement mode").option("--json", "Output as JSON").action(async (options) => {
+    const { authToken, orgName, apiUrl } = getAuthAndOrg2();
+    const spinner = options.json ? null : ora("Fetching workflow enforcement settings...").start();
+    try {
+      const res = await fetchApi3(
+        `${apiUrl}/organizations/${encodeURIComponent(orgName)}/workflow-enforcement`,
+        authToken
+      );
+      if (!res.ok) {
+        const data2 = await res.json().catch(() => ({}));
+        throw new Error(data2.error || `HTTP ${res.status}`);
+      }
+      const data = await res.json();
+      spinner?.stop();
+      if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+      }
+      const mode = data.mode || "off";
+      const enabled = data.enabled === true;
+      const modeColor = mode === "background-only" ? source_default.red : mode === "warn" ? source_default.yellow : source_default.dim;
+      console.log(source_default.bold("\nWorkflow Enforcement Settings\n"));
+      console.log(`  Organization: ${source_default.cyan(orgName)}`);
+      console.log(`  Enabled:      ${enabled ? source_default.green("yes") : source_default.dim("no")}`);
+      console.log(`  Mode:         ${modeColor(mode)}`);
+      if (mode === "background-only") {
+        console.log();
+        console.log(source_default.yellow("  Local sessions are restricted to orchestration only."));
+        console.log(source_default.yellow("  All implementation must go through the background agent queue."));
+      } else if (mode === "warn") {
+        console.log();
+        console.log(source_default.dim("  Warnings are shown for local implementation but not blocked."));
+      }
+      if (data.exemptUsers?.length) {
+        console.log(`  Exempt Users: ${data.exemptUsers.join(", ")}`);
+      }
+      if (data.updatedBy) {
+        console.log(`  Updated By:   ${data.updatedBy}`);
+      }
+      if (data.updatedAt) {
+        console.log(`  Updated At:   ${data.updatedAt}`);
+      }
+      console.log();
+    } catch (error3) {
+      spinner?.stop();
+      const msg = error3 instanceof Error ? error3.message : String(error3);
+      if (options.json) {
+        console.log(JSON.stringify({ error: msg }));
+      } else {
+        console.error(source_default.red("Error fetching workflow enforcement settings:"), msg);
+      }
+      process.exit(1);
+    }
+  });
+  workflowCommand.command("check").description("Check if a tool call would be allowed under current enforcement policy").requiredOption("--tool <toolName>", "Tool name to check (e.g., Edit, Write, Bash)").option("--command <command>", "Bash command to check (when tool is Bash)").option("--json", "Output as JSON").action(async (options) => {
+    const { authToken, orgName, apiUrl } = getAuthAndOrg2();
+    try {
+      const res = await fetchApi3(
+        `${apiUrl}/organizations/${encodeURIComponent(orgName)}/workflow-enforcement`,
+        authToken
+      );
+      if (!res.ok) {
+        if (options.json) {
+          console.log(JSON.stringify({ allowed: true, mode: "off", reason: "API unavailable \u2014 fail open" }));
+        } else {
+          console.log(source_default.green("\u2713 Allowed (API unavailable \u2014 fail open)"));
+        }
+        return;
+      }
+      const settings = await res.json();
+      const { checkEnforcement: checkEnforcement2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
+      const toolInput = {};
+      if (options.command) {
+        toolInput.command = options.command;
+      }
+      const result = checkEnforcement2(
+        options.tool,
+        toolInput,
+        settings,
+        "orchestrator"
+        // CLI is always an orchestrator
+      );
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      if (result.allowed && !result.isWarning) {
+        console.log(source_default.green(`\u2713 ${options.tool} is allowed`));
+      } else if (result.isWarning) {
+        console.log(source_default.yellow(`\u26A0 ${options.tool} triggers a warning`));
+        if (result.reason) {
+          console.log(source_default.dim(result.reason));
+        }
+      } else {
+        console.log(source_default.red(`\u2717 ${options.tool} is blocked`));
+        if (result.reason) {
+          console.log(result.reason);
+        }
+      }
+    } catch (error3) {
+      const msg = error3 instanceof Error ? error3.message : String(error3);
+      if (options.json) {
+        console.log(JSON.stringify({ error: msg }));
+      } else {
+        console.error(source_default.red("Error checking enforcement:"), msg);
+      }
+      process.exit(1);
+    }
+  });
+  workflowCommand.command("install").description("Install workflow enforcement hook for Claude Code").option("--path <path>", "Base path (default: current directory)").option("--force", "Overwrite existing hook").option("--dry-run", "Show what would be installed without making changes").action(async (options) => {
+    const spinner = ora();
+    const { orgName, apiUrl } = getAuthAndOrg2();
+    const basePath = options.path || process.cwd();
+    try {
+      spinner.start("Generating workflow enforcement hook...");
+      const { generateWorkflowEnforcementHook: generateWorkflowEnforcementHook2 } = await Promise.resolve().then(() => (init_workflow_enforcement_hook(), workflow_enforcement_hook_exports));
+      const hook = generateWorkflowEnforcementHook2({
+        apiUrl,
+        orgName
+      });
+      const claudeHooksDir = (0, import_node_path3.join)(basePath, ".claude", "hooks");
+      const hookPath = (0, import_node_path3.join)(claudeHooksDir, hook.filename);
+      if (options.dryRun) {
+        spinner.info("[DRY RUN] Would install workflow enforcement hook");
+        console.log(source_default.dim(`  Path: ${hookPath}`));
+        console.log(source_default.dim(`  API: ${apiUrl}`));
+        console.log(source_default.dim(`  Org: ${orgName}`));
+        return;
+      }
+      if ((0, import_node_fs2.existsSync)(hookPath) && !options.force) {
+        spinner.fail("Workflow enforcement hook already exists. Use --force to overwrite.");
+        return;
+      }
+      await (0, import_promises4.mkdir)(claudeHooksDir, { recursive: true });
+      await (0, import_promises4.writeFile)(hookPath, hook.content, "utf-8");
+      await (0, import_promises4.chmod)(hookPath, 493);
+      const settingsPath = (0, import_node_path3.join)(basePath, ".claude", "settings.json");
+      let settings = {};
+      try {
+        const existing2 = await (0, import_promises4.readFile)(settingsPath, "utf-8");
+        settings = JSON.parse(existing2);
+      } catch {
+        settings = {};
+      }
+      const hooks = settings.hooks && typeof settings.hooks === "object" ? { ...settings.hooks } : {};
+      const existing = Array.isArray(hooks.PreToolUse) ? [...hooks.PreToolUse] : [];
+      const filtered = existing.filter((entry) => {
+        if (!entry || typeof entry !== "object") return true;
+        return entry.command !== "python3 .claude/hooks/gal-workflow-enforcement.py";
+      });
+      filtered.push({
+        type: "command",
+        command: "python3 .claude/hooks/gal-workflow-enforcement.py",
+        timeout: 1e4
+      });
+      hooks.PreToolUse = filtered;
+      settings.hooks = hooks;
+      await (0, import_promises4.writeFile)(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+      spinner.succeed("Installed workflow enforcement hook");
+      console.log(source_default.dim(`  Hook: ${hookPath}`));
+      console.log(source_default.dim(`  Settings: ${settingsPath}`));
+      console.log();
+      console.log(source_default.blue("The hook will check your org's enforcement mode before each tool call."));
+      if (orgName) {
+        console.log(source_default.dim(`  Organization: ${orgName}`));
+        console.log(source_default.dim(`  API: ${apiUrl}`));
+      }
+    } catch (error3) {
+      spinner.fail("Failed to install workflow enforcement hook");
+      if (error3 instanceof Error) {
+        console.error(source_default.red(error3.message));
+      }
+      process.exit(1);
+    }
+  });
+  enforce.addCommand(workflowCommand);
   enforce.command("domains").description("Manage domain allowlist and exceptions").option("--json", "Output as JSON").action(async (options) => {
     const { authToken, orgName, apiUrl } = getAuthAndOrg2();
     const spinner = options.json ? null : ora("Fetching domain exceptions...").start();
@@ -66817,6 +68113,23 @@ async function reportDriftStatus(result, projectId, apiUrl, authToken) {
   } catch {
   }
 }
+function displayQualityScores(qualityScore) {
+  console.log(source_default.bold("Config Quality:"));
+  console.log();
+  const overallPct = (qualityScore.overall * 100).toFixed(0);
+  const overallColor = qualityScore.overall >= 0.7 ? source_default.green : qualityScore.overall >= 0.4 ? source_default.yellow : source_default.red;
+  console.log(`  Overall: ${overallColor(overallPct + "%")} ${source_default.dim(`(${qualityScore.totalEvaluations} evaluations)`)}`);
+  if (qualityScore.byPhase) {
+    const phases = Object.entries(qualityScore.byPhase).sort(([a], [b]) => a.localeCompare(b));
+    for (const [phase, data] of phases) {
+      if (!data) continue;
+      const pct = (data.score * 100).toFixed(0);
+      const color = data.score >= 0.7 ? source_default.green : data.score >= 0.4 ? source_default.yellow : source_default.red;
+      console.log(`  ${phase.padEnd(15)} ${color(pct + "%")} ${source_default.dim(`(${data.evaluationCount} evals)`)}`);
+    }
+  }
+  console.log();
+}
 function createStatusCommand3() {
   const command = new Command("status").description("Check sync status, drift, and pending proposals").option("--json", "Output as JSON").option("-d, --directory <path>", "Project directory to check", process.cwd()).option("--check-update", "Check for updates from organization (requires network)").option("--no-report", "Skip reporting drift status to API").action(async (options) => {
     try {
@@ -66876,6 +68189,27 @@ function createStatusCommand3() {
         console.log(source_default.bold(`Config Sync (${source_default.dim(directory)}):`));
         displayStatus(result, proposals);
       }
+      if (health.allHealthy && config2.defaultOrg && config2.apiUrl && authToken) {
+        try {
+          const qualitySpinner = options.json ? null : ora("Checking config quality...").start();
+          const response = await fetch(
+            `${config2.apiUrl}/organizations/${encodeURIComponent(config2.defaultOrg)}/approved-config?platform=claude`,
+            {
+              headers: { Authorization: `Bearer ${authToken}` },
+              signal: AbortSignal.timeout(5e3)
+            }
+          );
+          qualitySpinner?.stop();
+          if (response.ok) {
+            const configData = await response.json();
+            const qualityScore = configData?.qualityScore;
+            if (qualityScore && !options.json) {
+              displayQualityScores(qualityScore);
+            }
+          }
+        } catch {
+        }
+      }
       process.exit(0);
     } catch (error3) {
       const err = error3 instanceof Error ? error3 : new Error(String(error3));
@@ -71815,7 +73149,7 @@ var init_index = __esm({
 });
 
 // src/bootstrap.ts
-var cliVersion10 = true ? "0.0.408" : "0.0.0-dev";
+var cliVersion10 = true ? "0.0.411" : "0.0.0-dev";
 var args = process.argv.slice(2);
 var requestedGlobalHelp = args.length === 1 && (args[0] === "--help" || args[0] === "-h");
 var requestedVersion = args.length === 1 && (args[0] === "--version" || args[0] === "-V");