feat: improve Dashboard workflows and project activation

CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to @rpamis/comet will be documented in this file.
 
+## What's Changed [0.4.0-beta.15] - 2026-08-03
+
+### Changed
+
+- **Dashboard change explorer**: Dashboard now loads the current project overview with lightweight change rows, paginates active, archived, and all changes in batches of five, and fetches full artifact details only when selected so large projects remain responsive.
+- **Global project activation**: A global initialization now stores complete Native or Classic defaults once, and the first explicit `/comet` invocation activates each unconfigured project from those defaults. Artifacts stay inside the project, activated projects keep stable settings when global defaults change, existing Classic projects retain Classic ownership, and project-scoped initialization remains optional for local asset copies or overrides.
+- **Hook isolation**: Comet now installs its blocking Router only for project-scoped integrations and keeps it in a dedicated matcher group. Setup, update, and Doctor remove historical global Comet Hooks while preserving user-owned Hook entries and configuration.
+
+### Fixed
+
+- **Classic build recovery**: Full Classic workflows now return to plan creation after context recovery when no implementation plan is recorded, and block project source writes until the plan is restored and linked.
+- **Ambient Resume cleanup**: Disabling the Ambient Resume probe now removes Comet-managed instructions from `AGENTS.md` and `CLAUDE.md` while preserving user-authored content.
+- **External write compatibility**: Comet Hooks now remain neutral for unknown or project-external write targets, including paths redirected through symlinks or junctions, and evaluate only the in-project targets from mixed write operations so unrelated Hooks such as memory writers can continue independently.
+
 ## What's Changed [0.4.0-beta.14] - 2026-08-02
 
 ### Fixed

README-zh.md

@@ -117,6 +117,18 @@ npm install -g @rpamis/comet
 
 ## 快速开始
 
+一次全局初始化即可让已选宿主中的 `/comet` 在所有项目可用：
+
+```bash
+comet init --scope global
+cd your-project
+# 在宿主中调用 /comet
+```
+
+首次在一个尚未配置的项目中调用 `/comet` 时，Comet 会把 `~/.comet/config.yaml` 中的全局默认值固化为项目的 `.comet/config.yaml`，并只在该项目内创建产物目录。之后修改全局默认值不会改写已经激活的项目。Hook 继续识别这份项目配置与 `.comet/current-change.json`；仅触发 Hook、`comet status` 或普通只读解析不会自动初始化项目。
+
+如需把 Skill、Rule 与 Hook 直接复制到项目，或显式覆盖该项目的工作流设置，仍可执行项目初始化：
+
 ```bash
 cd your-project
 comet init
@@ -204,7 +216,7 @@ Comet Eval的自动化双Agent架构能够在线上与LangSmith/LangFuse环境
 | `--language <lang>` | 技能语言：`en` 或 `zh`（跳过交互式语言选择）         |
 | `--platform <platform>` | 只初始化指定平台；项目范围内可使用自定义平台 id |
 | `--workflow <mode>` | 初始化工作流：`native`、`classic` 或 `both`          |
-| `--root <path>`     | Native 的项目内产物根目录，例如 `docs`               |
+| `--root <path>`     | Native 的项目内产物根目录；全局范围时保存为项目相对默认值 |
 | `--codegraph <action>` | 非交互式项目索引操作：显式选择 `init` 或 `skip`    |
 | `--skip-existing`   | 跳过已安装的组件                                     |
 | `--overwrite`       | 覆盖已安装的组件                                     |

README.md

@@ -134,6 +134,18 @@ npm install -g @rpamis/comet
 
 ## Quick Start
 
+A single global initialization makes `/comet` available through the selected hosts in every project:
+
+```bash
+comet init --scope global
+cd your-project
+# Invoke /comet in the host
+```
+
+The first `/comet` invocation in an unconfigured project snapshots the defaults from `~/.comet/config.yaml` into the project's `.comet/config.yaml` and creates artifacts only inside that project. Later global-default changes do not rewrite activated projects. Hooks then recognize the project config and `.comet/current-change.json`; Hook events, `comet status`, and ordinary read-only resolution never initialize a project by themselves.
+
+Run project initialization only when you want project-local copies of Skills, Rules, and Hooks, or explicit project overrides:
+
 ```bash
 cd your-project
 comet init
@@ -222,7 +234,7 @@ Initializes Comet for selected AI coding platforms. Interactive setup selects Na
 | `--language <lang>` | Skill language: `en` or `zh` (skips interactive language prompt)               |
 | `--platform <platform>` | Initialize only this platform; project scope accepts custom platform ids    |
 | `--workflow <mode>` | Workflows to initialize: `native`, `classic`, or `both`                        |
-| `--root <path>`     | Project-relative Native artifact root, such as `docs`                          |
+| `--root <path>`     | Project-relative Native artifact root; global scope stores it as a project default |
 | `--codegraph <action>` | Non-interactive project index action: explicitly choose `init` or `skip`    |
 | `--skip-existing`   | Skip already installed components                                              |
 | `--overwrite`       | Overwrite already installed components                                         |

app/cli/index.ts

@@ -62,6 +62,7 @@ const workflow = program.command('workflow').description('Resolve the configured
 workflow
   .command('resolve [path]')
   .description('Resolve /comet to its permanent Native or Classic entry')
+  .option('--activate', 'Create project configuration from global defaults when missing')
   .option('--json', 'Output as JSON')
   .action(async (targetPath = '.', options) => {
     const { workflowResolveCommand } = await import('../commands/workflow.js');

app/commands/doctor.ts

@@ -22,8 +22,8 @@ import {
   getAssetsDir,
   getManagedSkillPaths,
   getManagedSkillPathsForSelection,
-  installCometHooksForPlatform,
 } from '../../domains/skill/platform-install.js';
+import { reconcileCometHooksForPlatform } from '../../domains/skill/hook-lifecycle.js';
 import {
   getPlatformRuleDestinations,
   getLegacyPlatformRuleDestinations,
@@ -653,6 +653,24 @@ function getScopeBases(
   return bases;
 }
 
+function globalHookCheckResult(
+  platform: Platform,
+  scope: InstallScope,
+  inspection: Awaited<ReturnType<typeof inspectCometHooksForPlatform>>,
+): CheckResult {
+  const globalHookPresent =
+    inspection.present || inspection.managedPresent === true || inspection.legacyPresent === true;
+  return {
+    check: `hooks: ${platform.name} (${scope})`,
+    status: globalHookPresent || inspection.error ? 'warn' : 'pass',
+    message: inspection.error
+      ? `${inspection.error} — run: comet doctor --repair --scope global`
+      : globalHookPresent
+        ? 'global blocking Hook remains — run: comet doctor --repair --scope global'
+        : 'no global blocking Hook present',
+  };
+}
+
 async function checkPlatformComponents(
   baseDir: string,
   platform: (typeof PLATFORMS)[number],
@@ -740,6 +758,10 @@ async function checkPlatformComponents(
       scope,
       workflowSelection,
     );
+    if (scope === 'global') {
+      results.push(globalHookCheckResult(platform, scope, inspection));
+      return results;
+    }
     results.push({
       check: `hooks: ${platform.name} (${scope})`,
       status:
@@ -775,6 +797,36 @@ async function getPlatformsForSkillInspection(
   }));
 }
 
+async function getGlobalHookOnlyInspections(
+  baseDir: string,
+  knownPlatformIds: ReadonlySet<string>,
+): Promise<
+  Array<{
+    platform: Platform;
+    inspection: Awaited<ReturnType<typeof inspectCometHooksForPlatform>>;
+  }>
+> {
+  const results: Array<{
+    platform: Platform;
+    inspection: Awaited<ReturnType<typeof inspectCometHooksForPlatform>>;
+  }> = [];
+  for (const platform of PLATFORMS) {
+    if (knownPlatformIds.has(platform.id) || !platform.supportsHooks || !platform.hookFormat) {
+      continue;
+    }
+    const inspection = await inspectCometHooksForPlatform(baseDir, platform, 'global');
+    if (
+      inspection.present ||
+      inspection.managedPresent ||
+      inspection.legacyPresent ||
+      inspection.error
+    ) {
+      results.push({ platform, inspection });
+    }
+  }
+  return results;
+}
+
 async function checkSkillCompleteness(
   projectPath: string,
   scope: DoctorScope,
@@ -796,6 +848,7 @@ async function checkSkillCompleteness(
     );
     const total = managedSkills.length;
     const platforms = await getPlatformsForSkillInspection(base.baseDir, base.scope, scope);
+    const detectedPlatformIds = new Set<string>();
     for (const { platform, inspectComponents } of platforms) {
       const skillsDirs = getPlatformSkillsDirs(platform, base.scope);
       const canonicalSkillsDir = skillsDirs[0];
@@ -818,6 +871,7 @@ async function checkSkillCompleteness(
       }
 
       if (!detectedSkillsDir) continue;
+      detectedPlatformIds.add(platform.id);
       anyCometInstall = true;
       scopeState[base.scope].hasInstall = true;
       const isLegacy = detectedSkillsDir !== canonicalSkillsDir;
@@ -855,6 +909,14 @@ async function checkSkillCompleteness(
         );
       }
     }
+    if (base.scope === 'global') {
+      for (const { platform, inspection } of await getGlobalHookOnlyInspections(
+        base.baseDir,
+        detectedPlatformIds,
+      )) {
+        results.push(globalHookCheckResult(platform, base.scope, inspection));
+      }
+    }
   }
 
   if (scope === 'auto' && !scopeState.project.hasInstall && scopeState.global.hasComplete) {
@@ -1317,15 +1379,41 @@ async function repairDoctorState(
         ? 'native'
         : 'classic';
   const targets: Array<{ baseDir: string; scope: InstallScope; platform: Platform }> = [];
+  const hookOnlyTargets: Array<{ baseDir: string; scope: InstallScope; platform: Platform }> = [];
 
   for (const base of getScopeBases(projectPath, scope, context)) {
     const platforms = await getPlatformsForSkillInspection(base.baseDir, base.scope, scope);
+    const installedPlatformIds = new Set<string>();
     for (const { platform, inspectComponents } of platforms) {
       if (!inspectComponents || !(await hasManagedInstall(base.baseDir, platform, base.scope))) {
         continue;
       }
+      installedPlatformIds.add(platform.id);
       targets.push({ baseDir: base.baseDir, scope: base.scope, platform });
     }
+    if (base.scope === 'global') {
+      for (const { platform } of await getGlobalHookOnlyInspections(
+        base.baseDir,
+        installedPlatformIds,
+      )) {
+        hookOnlyTargets.push({ baseDir: base.baseDir, scope: base.scope, platform });
+      }
+    }
+  }
+
+  for (const target of hookOnlyTargets) {
+    const hookResult = await reconcileCometHooksForPlatform(
+      target.baseDir,
+      target.platform,
+      target.scope,
+      workflowSelection,
+    );
+    if (hookResult.status === 'failed') {
+      throw new Error(
+        `failed to repair Hook for ${target.platform.name} (${target.scope}): ${hookResult.reason}`,
+      );
+    }
+    repaired.push(`${target.platform.name} (${target.scope}) Hook`);
   }
 
   for (const target of targets) {
@@ -1334,7 +1422,7 @@ async function repairDoctorState(
       const runtime = hookRouterRuntimePaths(baseDir, platform, targetScope);
       await copyFile(runtime.source, runtime.destination);
     }
-    const hookResult = await installCometHooksForPlatform(
+    const hookResult = await reconcileCometHooksForPlatform(
       baseDir,
       platform,
       targetScope,

app/commands/init.ts

@@ -25,12 +25,11 @@ import type { InstallMode } from '../../platform/install/types.js';
 import {
   copyCometSkillsForPlatform,
   copyCometRulesForPlatform,
-  installCometHooksForPlatform,
   createWorkingDirs,
-  mergeProjectConfig,
   prepareNativeSkillInstallTarget,
 } from '../../domains/skill/platform-install.js';
-import { installCometProjectInstructions } from '../../domains/skill/project-instructions.js';
+import { reconcileCometHooksForPlatform } from '../../domains/skill/hook-lifecycle.js';
+import { syncCometProjectInstructions } from '../../domains/skill/project-instructions.js';
 import { LANGUAGES, type LanguageConfig } from '../../domains/skill/languages.js';
 import { resolveInitWorkflow } from '../../domains/comet-entry/init-workflow.js';
 import type { CometWorkflow, InitWorkflowSelection } from '../../domains/comet-entry/types.js';
@@ -59,7 +58,11 @@ import {
   readWorkflowProjectConfigSnapshot,
 } from '../../domains/workflow-contract/project-config-reader.js';
 import { writeWorkflowProjectConfig } from '../../domains/workflow-contract/project-config-writer.js';
-import type { WorkflowProjectConfig } from '../../domains/workflow-contract/types.js';
+import { writeWorkflowGlobalConfig } from '../../domains/workflow-contract/global-config.js';
+import type {
+  WorkflowGlobalConfig,
+  WorkflowProjectConfig,
+} from '../../domains/workflow-contract/types.js';
 import { installSuperpowersForPlatforms } from '../../domains/integrations/superpowers.js';
 import {
   hasCodegraphProjectIndex,
@@ -502,9 +505,6 @@ export async function initCommand(
 
   const detected = await detectPlatforms(projectPath);
   const scope = await selectScope(options, lang);
-  if (scope === 'global' && options.artifactRoot !== undefined) {
-    throw new Error('--root is only valid for project-scope initialization');
-  }
   if (scope === 'global' && options.codegraph === 'init') {
     throw new Error('--codegraph init is only valid for project-scope initialization');
   }
@@ -535,8 +535,15 @@ export async function initCommand(
     configuredWorkflows.includes('native') &&
     configuredWorkflows.includes('classic')
       ? 'both'
-      : (suggestedWorkflowDecision?.workflow ?? 'classic');
+      : (suggestedWorkflowDecision?.workflow ?? 'native');
   const workflowSelection = await selectWorkflow(options, lang, suggestedWorkflowSelection);
+  if (
+    scope === 'global' &&
+    options.artifactRoot !== undefined &&
+    !includesWorkflow(workflowSelection, 'native')
+  ) {
+    throw new Error('--root is only valid when the Native workflow is enabled');
+  }
   const workflow: CometWorkflow = workflowSelection === 'both' ? 'native' : workflowSelection;
   const workflowDecision =
     scope === 'project'
@@ -918,7 +925,7 @@ export async function initCommand(
           status,
           reason,
           cleanupFailed = 0,
-        } = await installCometHooksForPlatform(baseDir, platform, scope, workflowSelection);
+        } = await reconcileCometHooksForPlatform(baseDir, platform, scope, workflowSelection);
         cometComponentInstalled ||= status === 'installed';
         if (status === 'installed') {
           if (scope === 'project') projectRouterInstalled = true;
@@ -1068,6 +1075,10 @@ export async function initCommand(
   const cometInstallComplete =
     results.length > 0 && results.every((result) => result.comet !== 'failed');
   const projectInitializationComplete = cometInstallComplete && classicOpenSpecRootReady;
+  const globalWorkflowConfigReady =
+    scope !== 'global' ||
+    !includesWorkflow(workflowSelection, 'classic') ||
+    osGlobalStatus === 'installed';
 
   if (
     scope === 'project' &&
@@ -1097,8 +1108,15 @@ export async function initCommand(
       }
       workingDirsCreated = true;
 
-      if (includesWorkflow(workflowSelection, 'native')) {
-        await installCometProjectInstructions(projectPath, language.id);
+      if (
+        includesWorkflow(workflowSelection, 'native') ||
+        initialProjectConfigDocument?.ambient_resume === false
+      ) {
+        await syncCometProjectInstructions(
+          projectPath,
+          language.id,
+          initialProjectConfigDocument?.ambient_resume ?? true,
+        );
       }
 
       const successfulCometPlatforms = new Set(
@@ -1215,8 +1233,32 @@ export async function initCommand(
         projectConfigCreated = initialProjectConfigDocument === null;
         projectConfigUpdated = initialProjectConfigDocument !== null;
       }
-    } else if (scope === 'global') {
-      await mergeProjectConfig(baseDir, language.artifactLanguage);
+    } else if (scope === 'global' && globalWorkflowConfigReady) {
+      const defaults = defaultProjectConfig(
+        options.artifactRoot ?? 'docs',
+        language.artifactLanguage,
+      );
+      const selectedWorkflows =
+        workflowSelection === 'both' ? (['native', 'classic'] as const) : [workflowSelection];
+      const config: WorkflowGlobalConfig = {
+        schema: 'comet.global.v1',
+        default_workflow: workflow,
+        workflows: [...selectedWorkflows],
+        ambient_resume: true,
+        ...(includesWorkflow(workflowSelection, 'native') ? { native: defaults.native } : {}),
+        ...(includesWorkflow(workflowSelection, 'classic')
+          ? {
+              classic: {
+                artifact_layout: 'docs',
+                language: language.artifactLanguage,
+                context_compression: 'off',
+                review_mode: 'standard',
+                auto_transition: true,
+              },
+            }
+          : {}),
+      };
+      await writeWorkflowGlobalConfig(baseDir, config);
     }
   } catch (error) {
     finalizationFailure = (error as Error).message;