@curdx/flow 2.3.1 → 2.3.3

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
   },
   "metadata": {
     "description": "Claude Code Discipline Layer — spec-driven workflow + goal-backward verification + Karpathy 4 principles enforced via gates. Stops Claude from faking \"done\" on non-trivial features.",
-    "version": "2.3.1"
+    "version": "2.3.3"
   },
   "allowCrossMarketplaceDependenciesOn": [
     "context7-marketplace"
@@ -16,7 +16,7 @@
       "name": "curdx-flow",
       "source": "./",
       "description": "Claude Code Discipline Layer — spec-driven workflow + goal-backward verification + Karpathy 4 principles enforced via gates. Stops Claude from faking \"done\" on non-trivial features.",
-      "version": "2.3.1",
+      "version": "2.3.3",
       "author": {
         "name": "wdx",
         "email": "bydongxin@gmail.com"

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "curdx-flow",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "Claude Code Discipline Layer — spec-driven workflow + goal-backward verification + Karpathy 4 principles enforced via gates. Stops Claude from faking \"done\" on non-trivial features.",
   "author": {
     "name": "wdx",

package/cli/lib/doctor-claude-settings.js

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 
 const PROJECT_ONLY_IGNORED_SETTINGS = [
@@ -99,6 +100,23 @@ const CURDX_FLOW_REQUIRED_TOOLS = [
   "Glob",
 ];
 const CURDX_FLOW_PLUGIN_ID = "curdx-flow@curdx-flow-marketplace";
+const CURDX_FLOW_PLUGIN_OPTIONS = {
+  autonomous_blocking: {
+    type: "boolean",
+    default: true,
+  },
+  daily_dependency_check: {
+    type: "boolean",
+    default: true,
+  },
+  monitor_interval_seconds: {
+    type: "number",
+    default: 8,
+    integer: true,
+    min: 3,
+    max: 60,
+  },
+};
 const CURDX_FLOW_REQUIRED_PLUGIN_IDS = ["context7-plugin@context7-marketplace"];
 const HTTP_HOOK_SETTINGS = ["allowedHttpHookUrls", "httpHookAllowedEnvVars"];
 const PERSISTED_EFFORT_LEVELS = ["low", "medium", "high", "xhigh"];
@@ -171,6 +189,201 @@ function pushScopedWarning(target, kind, message, scope = "project") {
   target.push(warning);
 }
 
+function createCurdxFlowPluginOptionsState() {
+  const definitions = Object.entries(CURDX_FLOW_PLUGIN_OPTIONS).map(([key, value]) => ({
+    key,
+    type: value.type,
+    default: value.default,
+    min: value.min,
+    max: value.max,
+    integer: value.integer === true,
+  }));
+
+  const repoEffective = Object.fromEntries(
+    definitions.map((definition) => [
+      definition.key,
+      { value: definition.default, source: "default" },
+    ])
+  );
+
+  return {
+    pluginId: CURDX_FLOW_PLUGIN_ID,
+    definitions,
+    user: {
+      pluginConfigsPresent: false,
+      pluginConfigPresent: false,
+      optionsPresent: false,
+      overrides: {},
+    },
+    project: {
+      pluginConfigsPresent: false,
+      pluginConfigPresent: false,
+      optionsPresent: false,
+      overrides: {},
+    },
+    local: {
+      pluginConfigsPresent: false,
+      pluginConfigPresent: false,
+      optionsPresent: false,
+      overrides: {},
+    },
+    repoEffective,
+    machineEffective: structuredClone(repoEffective),
+  };
+}
+
+function pluginScopeLabel(scope) {
+  if (scope === "local") return "settings.local.json";
+  if (scope === "user") return "~/.claude/settings.json";
+  return "settings.json";
+}
+
+function invalidSettingKindForScope(scope) {
+  if (scope === "local") return "invalid-local-setting";
+  if (scope === "user") return "invalid-user-setting";
+  return "invalid-project-setting";
+}
+
+function applyCurdxFlowPluginOptionOverride(pluginOptionsState, key, value, scope) {
+  pluginOptionsState.machineEffective[key] = {
+    value,
+    source: scope,
+  };
+
+  if (scope === "project" || scope === "local") {
+    pluginOptionsState.repoEffective[key] = {
+      value,
+      source: scope,
+    };
+  }
+}
+
+function auditCurdxFlowPluginOptions(parsed, warnings, pluginOptionsState, scope = "project") {
+  if (!isNonArrayObject(parsed) || !("pluginConfigs" in parsed)) {
+    return;
+  }
+
+  const target = scope === "local"
+    ? pluginOptionsState.local
+    : scope === "user"
+      ? pluginOptionsState.user
+      : pluginOptionsState.project;
+  const settingsLabel = pluginScopeLabel(scope);
+  target.pluginConfigsPresent = true;
+
+  if (!isNonArrayObject(parsed.pluginConfigs)) {
+    pushScopedWarning(
+      warnings,
+      invalidSettingKindForScope(scope),
+      `pluginConfigs in ${settingsLabel} must be an object keyed by plugin@marketplace id`,
+      scope
+    );
+    return;
+  }
+
+  const pluginConfig = parsed.pluginConfigs[CURDX_FLOW_PLUGIN_ID];
+  if (pluginConfig === undefined) {
+    return;
+  }
+
+  target.pluginConfigPresent = true;
+
+  if (!isNonArrayObject(pluginConfig)) {
+    pushScopedWarning(
+      warnings,
+      invalidSettingKindForScope(scope),
+      `pluginConfigs[${CURDX_FLOW_PLUGIN_ID}] in ${settingsLabel} must be an object when set`,
+      scope
+    );
+    return;
+  }
+
+  if (!("options" in pluginConfig)) {
+    return;
+  }
+
+  target.optionsPresent = true;
+
+  if (!isNonArrayObject(pluginConfig.options)) {
+    pushScopedWarning(
+      warnings,
+      invalidSettingKindForScope(scope),
+      `pluginConfigs[${CURDX_FLOW_PLUGIN_ID}].options in ${settingsLabel} must be an object when set`,
+      scope
+    );
+    return;
+  }
+
+  for (const [key, value] of Object.entries(pluginConfig.options)) {
+    const definition = CURDX_FLOW_PLUGIN_OPTIONS[key];
+
+    if (!definition) {
+      pushScopedWarning(
+        warnings,
+        "unknown-plugin-option",
+        `unknown CurDX-Flow plugin option in ${settingsLabel}: ${key}`,
+        scope
+      );
+      continue;
+    }
+
+    if (definition.type === "boolean" && typeof value !== "boolean") {
+      pushScopedWarning(
+        warnings,
+        invalidSettingKindForScope(scope),
+        `CurDX-Flow plugin option ${key} in ${settingsLabel} must be boolean`,
+        scope
+      );
+      continue;
+    }
+
+    if (definition.type === "number") {
+      if (typeof value !== "number" || Number.isNaN(value)) {
+        pushScopedWarning(
+          warnings,
+          invalidSettingKindForScope(scope),
+          `CurDX-Flow plugin option ${key} in ${settingsLabel} must be a number`,
+          scope
+        );
+        continue;
+      }
+
+      if (definition.integer && !Number.isInteger(value)) {
+        pushScopedWarning(
+          warnings,
+          invalidSettingKindForScope(scope),
+          `CurDX-Flow plugin option ${key} in ${settingsLabel} must be an integer`,
+          scope
+        );
+        continue;
+      }
+
+      if (typeof definition.min === "number" && value < definition.min) {
+        pushScopedWarning(
+          warnings,
+          invalidSettingKindForScope(scope),
+          `CurDX-Flow plugin option ${key} in ${settingsLabel} must be between ${definition.min} and ${definition.max}`,
+          scope
+        );
+        continue;
+      }
+
+      if (typeof definition.max === "number" && value > definition.max) {
+        pushScopedWarning(
+          warnings,
+          invalidSettingKindForScope(scope),
+          `CurDX-Flow plugin option ${key} in ${settingsLabel} must be between ${definition.min} and ${definition.max}`,
+          scope
+        );
+        continue;
+      }
+    }
+
+    target.overrides[key] = value;
+    applyCurdxFlowPluginOptionOverride(pluginOptionsState, key, value, scope);
+  }
+}
+
 function auditLocalClaudeSettings(parsed, warnings) {
   const scope = "local";
   const permissions = parsed?.permissions && typeof parsed.permissions === "object"
@@ -362,10 +575,15 @@ function auditLocalClaudeSettings(parsed, warnings) {
   }
 }
 
-export async function readProjectClaudeSettings(cwd = process.cwd()) {
+export async function readProjectClaudeSettings(cwd = process.cwd(), { homeDir = os.homedir() } = {}) {
   const settingsPath = path.join(cwd, ".claude", "settings.json");
   const localSettingsPath = path.join(cwd, ".claude", "settings.local.json");
+  const userSettingsPath = path.join(homeDir, ".claude", "settings.json");
   const state = {
+    userExists: false,
+    userInvalid: false,
+    userParseError: null,
+    userWarnings: [],
     exists: false,
     localExists: false,
     invalid: false,
@@ -374,8 +592,16 @@ export async function readProjectClaudeSettings(cwd = process.cwd()) {
     localInvalid: false,
     localParseError: null,
     localWarnings: [],
+    pluginOptions: createCurdxFlowPluginOptionsState(),
   };
 
+  try {
+    const userStat = await fs.stat(userSettingsPath);
+    state.userExists = userStat.isFile();
+  } catch {
+    state.userExists = false;
+  }
+
   try {
     const localStat = await fs.stat(localSettingsPath);
     state.localExists = localStat.isFile();
@@ -383,6 +609,16 @@ export async function readProjectClaudeSettings(cwd = process.cwd()) {
     state.localExists = false;
   }
 
+  if (state.userExists) {
+    try {
+      const userParsed = JSON.parse(await fs.readFile(userSettingsPath, "utf-8"));
+      auditCurdxFlowPluginOptions(userParsed, state.userWarnings, state.pluginOptions, "user");
+    } catch (error) {
+      state.userInvalid = true;
+      state.userParseError = error?.message || String(error);
+    }
+  }
+
   let parsed;
   try {
     const stat = await fs.stat(settingsPath);
@@ -407,6 +643,8 @@ export async function readProjectClaudeSettings(cwd = process.cwd()) {
     const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
     const deny = Array.isArray(permissions.deny) ? permissions.deny : [];
 
+    auditCurdxFlowPluginOptions(parsed, state.warnings, state.pluginOptions, "project");
+
     if ("enabledPlugins" in parsed && (
       !parsed.enabledPlugins ||
       typeof parsed.enabledPlugins !== "object" ||
@@ -726,6 +964,7 @@ export async function readProjectClaudeSettings(cwd = process.cwd()) {
   if (state.localExists) {
     try {
       const localParsed = JSON.parse(await fs.readFile(localSettingsPath, "utf-8"));
+      auditCurdxFlowPluginOptions(localParsed, state.localWarnings, state.pluginOptions, "local");
       auditLocalClaudeSettings(localParsed, state.localWarnings);
     } catch (error) {
       state.localInvalid = true;

package/cli/lib/doctor-report.js

@@ -13,7 +13,54 @@ function pluginErrorDetails(plugin) {
 }
 
 function projectSettingsWarningDetails(warning) {
+  if (warning?.scope === "user") {
+    if (warning.kind === "unknown-plugin-option") {
+      return [
+        "~/.claude/settings.json applies across all your repositories on this machine",
+        "remove the unknown key or rename it to a supported CurDX-Flow plugin option under pluginConfigs[curdx-flow@curdx-flow-marketplace].options",
+      ];
+    }
+
+    if (
+      warning.kind === "invalid-user-setting" &&
+      (
+        warning.message?.includes("pluginConfigs[curdx-flow@curdx-flow-marketplace]") ||
+        warning.message?.includes("CurDX-Flow plugin option")
+      )
+    ) {
+      return [
+        "CurDX-Flow plugin options in ~/.claude/settings.json apply across all local repositories unless a project or local override wins",
+        "use boolean values for autonomous_blocking and daily_dependency_check, and keep monitor_interval_seconds as an integer between 3 and 60",
+      ];
+    }
+
+    return [
+      "~/.claude/settings.json applies across all your repositories on this machine",
+      "fix or remove the user-scoped override if CurDX-Flow behaves unexpectedly everywhere",
+    ];
+  }
+
   if (warning?.scope === "local") {
+    if (warning.kind === "unknown-plugin-option") {
+      return [
+        "settings.local.json overrides shared project settings on this machine",
+        "remove the unknown key or rename it to a supported CurDX-Flow plugin option under pluginConfigs[curdx-flow@curdx-flow-marketplace].options",
+      ];
+    }
+
+    if (
+      warning.kind === "invalid-local-setting" &&
+      (
+        warning.message?.includes("pluginConfigs[curdx-flow@curdx-flow-marketplace]") ||
+        warning.message?.includes("CurDX-Flow plugin option")
+      )
+    ) {
+      return [
+        "CurDX-Flow plugin options in settings.local.json override project and user settings on this machine",
+        "use boolean values for autonomous_blocking and daily_dependency_check, and keep monitor_interval_seconds as an integer between 3 and 60",
+      ];
+    }
+
     if (warning.kind === "invalid-local-setting") {
       return [
         "settings.local.json is the highest-precedence repo-scoped settings surface on this machine",
@@ -41,6 +88,26 @@ function projectSettingsWarningDetails(warning) {
     ];
   }
 
+  if (warning.kind === "unknown-plugin-option") {
+    return [
+      "CurDX-Flow only reads keys declared in the plugin manifest",
+      "remove the unknown key or rename it under pluginConfigs[curdx-flow@curdx-flow-marketplace].options",
+    ];
+  }
+
+  if (
+    warning.kind === "invalid-project-setting" &&
+    (
+      warning.message?.includes("pluginConfigs[curdx-flow@curdx-flow-marketplace]") ||
+      warning.message?.includes("CurDX-Flow plugin option")
+    )
+  ) {
+    return [
+      "CurDX-Flow non-sensitive plugin options belong under pluginConfigs[curdx-flow@curdx-flow-marketplace].options in .claude/settings.json",
+      "use boolean values for autonomous_blocking and daily_dependency_check, and keep monitor_interval_seconds as an integer between 3 and 60",
+    ];
+  }
+
   if (!warning?.kind) {
     return [
       "project settings are shared with collaborators",
@@ -116,6 +183,11 @@ function projectSettingsWarningDetails(warning) {
   ];
 }
 
+function formatInlineValue(value) {
+  if (typeof value === "string") return `"${value}"`;
+  return String(value);
+}
+
 export function buildDoctorReport({
   claudeVersionValue,
   nodeVersion,
@@ -403,6 +475,129 @@ export function buildDoctorReport({
     }
   }
 
+  if (
+    bundledPluginRuntimeDefaults?.exists ||
+    projectClaudeSettings?.pluginOptions
+  ) {
+    const configuredOptionsSection = createSection("CurDX-Flow configured options:");
+    const optionState = projectClaudeSettings?.pluginOptions;
+    const userOverrides = optionState?.user?.overrides || {};
+    const projectOverrides = optionState?.project?.overrides || {};
+    const localOverrides = optionState?.local?.overrides || {};
+    const machineEffective = optionState?.machineEffective || optionState?.repoEffective || {};
+    const definitions = bundledPluginRuntimeDefaults?.userConfig?.length
+      ? bundledPluginRuntimeDefaults.userConfig
+      : (optionState?.definitions || []);
+
+    pushSectionLine(
+      configuredOptionsSection,
+      "info",
+      "Scope precedence      settings.local.json > settings.json > ~/.claude/settings.json > bundled default",
+      [
+        "managed settings and command-line overrides are not inspected here",
+        "effective values below reflect this machine only",
+      ]
+    );
+
+    if (projectClaudeSettings?.userExists) {
+      if (Object.keys(userOverrides).length > 0) {
+        const summary = Object.entries(userOverrides)
+          .map(([key, value]) => `${key}=${formatInlineValue(value)}`)
+          .join(", ");
+        pushSectionLine(
+          configuredOptionsSection,
+          "info",
+          `~/.claude/settings.json ${Object.keys(userOverrides).length} valid override(s)`,
+          [
+            summary,
+            "user-scoped overrides apply across repositories unless project/local settings win",
+          ]
+        );
+      } else {
+        pushSectionLine(
+          configuredOptionsSection,
+          "info",
+          "~/.claude/settings.json present without valid CurDX-Flow overrides"
+        );
+      }
+    } else {
+      pushSectionLine(
+        configuredOptionsSection,
+        "info",
+        "~/.claude/settings.json not present"
+      );
+    }
+
+    if (Object.keys(projectOverrides).length > 0) {
+      const summary = Object.entries(projectOverrides)
+        .map(([key, value]) => `${key}=${formatInlineValue(value)}`)
+        .join(", ");
+      pushSectionLine(
+        configuredOptionsSection,
+        "info",
+        `.claude/settings.json ${Object.keys(projectOverrides).length} valid override(s)`,
+        [
+          summary,
+          "path: pluginConfigs[curdx-flow@curdx-flow-marketplace].options",
+        ]
+      );
+    } else {
+      pushSectionLine(
+        configuredOptionsSection,
+        "info",
+        ".claude/settings.json no CurDX-Flow repo override"
+      );
+    }
+
+    if (projectClaudeSettings?.localExists) {
+      if (Object.keys(localOverrides).length > 0) {
+        const summary = Object.entries(localOverrides)
+          .map(([key, value]) => `${key}=${formatInlineValue(value)}`)
+          .join(", ");
+        pushSectionLine(
+          configuredOptionsSection,
+          "info",
+          `.claude/settings.local.json ${Object.keys(localOverrides).length} valid override(s)`,
+          [
+            summary,
+            "local overrides have higher precedence than .claude/settings.json on this machine",
+          ]
+        );
+      } else {
+        pushSectionLine(
+          configuredOptionsSection,
+          "info",
+          ".claude/settings.local.json present without valid CurDX-Flow overrides"
+        );
+      }
+    } else {
+      pushSectionLine(
+        configuredOptionsSection,
+        "info",
+        ".claude/settings.local.json not present"
+      );
+    }
+
+    for (const definition of definitions) {
+      const effective = machineEffective[definition.key] || {
+        value: definition.default,
+        source: "default",
+      };
+      const sourceLabel = effective.source === "local"
+        ? "local"
+        : effective.source === "project"
+          ? "project"
+          : effective.source === "user"
+            ? "user"
+          : "bundled default";
+      pushSectionLine(
+        configuredOptionsSection,
+        "ok",
+        `${definition.key.padEnd(22)} ${formatInlineValue(effective.value)} (${sourceLabel})`
+      );
+    }
+  }
+
   const localProjectSection = createSection("Local project:");
   if (projectState?.exists) {
     pushSectionLine(localProjectSection, "ok", `.flow/                ${cwd}`);
@@ -490,6 +685,33 @@ export function buildDoctorReport({
   }
 
   const projectSettingsSection = createSection("Project Claude settings:");
+  const userSettingsSection = createSection("User Claude settings:");
+
+  if (projectClaudeSettings?.userExists) {
+    if (projectClaudeSettings.userInvalid) {
+      pushSectionLine(
+        userSettingsSection,
+        "err",
+        "~/.claude/settings.json invalid JSON",
+        [projectClaudeSettings.userParseError]
+      );
+    } else if ((projectClaudeSettings.userWarnings || []).length > 0) {
+      pushSectionLine(userSettingsSection, "warn", "~/.claude/settings.json affects CurDX-Flow globally");
+      for (const warning of projectClaudeSettings.userWarnings) {
+        pushSectionLine(
+          userSettingsSection,
+          "warn",
+          warning.message,
+          projectSettingsWarningDetails(warning)
+        );
+      }
+    } else {
+      pushSectionLine(userSettingsSection, "ok", "~/.claude/settings.json present");
+    }
+  } else {
+    pushSectionLine(userSettingsSection, "info", "~/.claude/settings.json not present");
+  }
+
   if (projectClaudeSettings?.exists) {
     if (projectClaudeSettings.invalid) {
       pushSectionLine(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curdx/flow",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "Skill-first discipline layer and CLI installer for Claude Code",
   "type": "module",
   "bin": {