dsh-agent-plugins-market 0.9.0 → 0.9.2

package/lib/packages/market-runtime/src/runtime/surfaces/extension-hooks.js

@@ -0,0 +1,294 @@
+/** Session-owned command hooks; execution, decoding, merging, and durable records use the host protocol. */
+import { readFile } from 'node:fs/promises';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { carrierKeyOf } from '@deepseek-ai/dsh-scope';
+import { DEFAULT_HOOK_TIMEOUT_MS, DEFAULT_STDERR_SUMMARY_MAX_CHARS, appendHookInvoked, appendHookResult, createDetachedRuns, matchesMatcher, mergeHookOutputs, runHook } from '@deepseek-ai/dsh-hook-protocol';
+import { qualifiedSuiteId } from '../../../../market-catalog/src/index.js';
+import { expandPluginPaths, pluginPathEnvironment, pluginRootOf, suiteDataDir } from '../../../../market-catalog/src/index.js';
+import { normalizeHookDocuments, standaloneHookDocument } from '../../../../market-catalog/src/index.js';
+import { hookConfigPath } from './hooks-mounts.js';
+const CONTEXT_SOURCE = { kind: 'hooks-claude-code' };
+/**
+ * Own one live Agent's hooks. Supply a live context injected with shell and
+ * sessionProjections, plus a synchronous live authorization check. Reconcile before
+ * awaiting start; agent/created is deliberately not observed. Dispose before the
+ * Agent or its context tears down. Each command rechecks authorization.
+ * Subagent events use the exact parent carrier, but identify the child on stdin.
+ * Like the host bridge, input rewrites, systemMessage and run-level halt are not
+ * applied; SubagentStop is observation-only. Unknown remote child cwd is empty.
+ * Every command receives its suite's path variables in the process environment,
+ * the same values its command string expands to.
+ */
+export class ExtensionHooks {
+    ctx;
+    agent;
+    isSuiteAllowed;
+    isHookAllowed;
+    dataRoot;
+    selected = new Map();
+    pending = Promise.resolve();
+    runs = createDetachedRuns();
+    listeners = [];
+    children = new Map();
+    startup;
+    closing;
+    disposed = false;
+    revision = 0;
+    handler = 0;
+    constructor(ctx, agent, isSuiteAllowed, 
+    /**
+     * Live check for one hook's own identity: the event and its declaration index,
+     * the same position the session inventory published a row for. Absent keeps the
+     * parent-suite contract, which is what a suite with no individual row requires.
+     */
+    isHookAllowed, 
+    /** Plugin storage root; supplies the suite's data directory to hook processes. */
+    dataRoot) {
+        this.ctx = ctx;
+        this.agent = agent;
+        this.isSuiteAllowed = isSuiteAllowed;
+        this.isHookAllowed = isHookAllowed;
+        this.dataRoot = dataRoot;
+        this.listeners.push(ctx.on('agent/pre-step', (event, next) => {
+            // A submitted prompt is authored input. A claimed batch can also carry this
+            // plugin's own metadata, which is neither a prompt nor prompt content.
+            const authored = event.messages.filter(message => message.source.kind === 'user');
+            if (event.agent !== agent || this.disposed || authored.length === 0)
+                return next();
+            return this.track(async () => {
+                const merged = await this.runPoint('UserPromptSubmit', '', { ...base(agent, 'UserPromptSubmit'), prompt: text(authored.flatMap(message => message.content)) }, agent, event.turn, event.signal);
+                if (this.disposed)
+                    return next();
+                if (merged.decision === 'deny')
+                    return { kind: 'reject' };
+                const downstream = await next();
+                const context = contextFrom(merged);
+                return !this.disposed && context && downstream.kind === 'enter' ? { ...downstream, messages: [...downstream.messages, context] } : downstream;
+            });
+        }));
+        this.listeners.push(ctx.on('tools/pre-execute', (exec, next) => {
+            if (exec.agent !== agent || this.disposed)
+                return next();
+            return this.track(async () => {
+                const merged = await this.runPoint('PreToolUse', exec.name, { ...base(agent, 'PreToolUse'), tool_name: exec.name, tool_input: exec.arguments, tool_use_id: exec.callId }, agent, this.lastTurn(), exec.signal);
+                if (this.disposed)
+                    return next();
+                if (merged.decision === 'deny')
+                    return { kind: 'deny', reason: merged.reason ?? 'blocked by PreToolUse hook' };
+                if (merged.decision === 'ask')
+                    return { kind: 'ask', ...(merged.reason === undefined ? {} : { reason: merged.reason }) };
+                return next();
+            });
+        }));
+        this.listeners.push(ctx.on('tools/post-execute', (exec, result, next) => {
+            if (exec.agent !== agent || this.disposed)
+                return next();
+            return this.track(async () => {
+                const merged = await this.runPoint('PostToolUse', exec.name, { ...base(agent, 'PostToolUse'), tool_name: exec.name, tool_input: exec.arguments, tool_use_id: exec.callId, tool_response: text(result.content) }, agent, this.lastTurn(), exec.signal);
+                if (this.disposed)
+                    return next();
+                const context = contextFrom(merged);
+                if (merged.decision === 'deny')
+                    return {
+                        kind: 'block',
+                        feedback: [{ type: 'text', text: merged.reason ?? 'blocked by PostToolUse hook' }],
+                        ...(context ? { additionalContexts: [context] } : {})
+                    };
+                const downstream = await next();
+                return !this.disposed && context ? { ...downstream, additionalContexts: [context, ...(downstream.additionalContexts ?? [])] } : downstream;
+            });
+        }));
+        this.listeners.push(ctx.on('agent/turn-stopping', event => {
+            if (event.agent !== agent || this.disposed)
+                return;
+            return this.track(async () => {
+                const merged = await this.runPoint('Stop', '', { ...base(agent, 'Stop'), stop_hook_active: false }, agent, event.turn, event.signal);
+                if (!this.disposed && merged.decision === 'deny')
+                    agent.steer(createUserMessage({ content: [{ type: 'text', text: merged.reason ?? 'continue: blocked by Stop hook' }], source: CONTEXT_SOURCE }));
+            });
+        }));
+        const observeSubagent = this.observeSubagent.bind(this);
+        // Subagent lifecycle payloads omit the parent; Cordis binds this to its routing carrier.
+        this.listeners.push(ctx.on('subagent/start', function (info) {
+            if (carrierKeyOf(this) === agent)
+                observeSubagent('SubagentStart', info);
+        }));
+        this.listeners.push(ctx.on('subagent/end', function (info) {
+            if (carrierKeyOf(this) === agent)
+                observeSubagent('SubagentStop', info);
+        }));
+    }
+    /** Replace selection; malformed suites are dropped with diagnostics. Does not replay startup. */
+    reconcile(suites) {
+        if (this.disposed)
+            return Promise.resolve([]);
+        const revision = ++this.revision;
+        this.selected.clear();
+        const run = this.pending.then(async () => {
+            const selected = new Map();
+            const diagnostics = [];
+            for (const suite of suites) {
+                if (!suite.enabled || !suite.activeSurfaces.hooks || this.disposed || revision !== this.revision)
+                    continue;
+                const suiteId = qualifiedSuiteId(suite.sourceId, suite.id);
+                try {
+                    let raw = suite.hooks === undefined ? undefined : { hooks: suite.hooks.events };
+                    let file = suite.manifest.path;
+                    if (raw === undefined && suite.resources === undefined) {
+                        const path = await hookConfigPath(suite.root);
+                        if (path !== undefined) {
+                            file = path;
+                            raw = JSON.parse(await readFile(path, 'utf8'));
+                        }
+                    }
+                    if (raw === undefined)
+                        continue;
+                    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+                        throw new Error('hooks must be an event table');
+                    const errors = [];
+                    const hooks = normalizeHookDocuments(suite.hooks?.projectRoot, [{ file, settings: standaloneHookDocument(raw) }], errors);
+                    diagnostics.push(...errors.map(reason => ({ suiteId, reason })));
+                    if (hooks)
+                        selected.set(suiteId, { suite, hooks });
+                }
+                catch (error) {
+                    diagnostics.push({ suiteId, reason: String(error) });
+                }
+            }
+            if (!this.disposed && revision === this.revision)
+                this.selected = selected;
+            return diagnostics;
+        });
+        this.pending = run.then(() => undefined);
+        return run;
+    }
+    /** Run SessionStart once, after already-submitted reconciliation, and await its context injection. */
+    start(source, signal) {
+        if (this.startup)
+            return this.startup;
+        if (this.disposed)
+            return Promise.resolve();
+        this.startup = this.track(async () => {
+            await this.pending;
+            const merged = await this.runPoint('SessionStart', source, { ...base(this.agent, 'SessionStart'), source }, this.agent, undefined, signal);
+            const context = contextFrom(merged);
+            if (!this.disposed && !signal?.aborted && context)
+                this.agent.inject(context);
+        });
+        return this.startup;
+    }
+    /** Stop admission, unregister listeners, abort and await owned runs. Repeated calls share completion. */
+    dispose() {
+        if (this.closing)
+            return this.closing;
+        this.disposed = true;
+        this.selected.clear();
+        this.children.clear();
+        for (const unregister of this.listeners.splice(0))
+            unregister();
+        this.closing = Promise.all([this.runs.drain(), this.pending]).then(() => undefined);
+        return this.closing;
+    }
+    observeSubagent(point, info) {
+        if (this.disposed)
+            return;
+        const child = this.children.get(info.runId) ?? (info.local ? this.ctx.get('agents')?.get(info.id) : undefined);
+        if (point === 'SubagentStart' && child)
+            this.children.set(info.runId, child);
+        if (point === 'SubagentStop')
+            this.children.delete(info.runId);
+        void this.track(async () => {
+            const merged = await this.runPoint(point, 'general-purpose', {
+                ...base(child, point, info.id),
+                agent_id: info.id,
+                agent_type: 'general-purpose',
+                ...(point === 'SubagentStop' ? { stop_hook_active: false } : {})
+            }, child);
+            const context = contextFrom(merged);
+            if (!this.disposed && point === 'SubagentStart' && context && child && this.children.get(info.runId) === child)
+                child.inject(context);
+        }).catch(error => {
+            this.ctx.logger.warn('extension-hooks: ' + point + ' hook failed: ' + String(error));
+        });
+    }
+    track(work) {
+        const run = work();
+        this.runs.track(run);
+        return run;
+    }
+    lastTurn() {
+        const boundary = this.ctx.sessionProjections.stateOf(this.agent.session, 'turnBoundary');
+        return boundary?.openTurnStartSeq == null ? undefined : boundary.lastTurn;
+    }
+    async runPoint(point, query, payload, subject, turn, signal) {
+        const outputs = [];
+        const ownerSignal = signal ? AbortSignal.any([signal, this.runs.signal]) : this.runs.signal;
+        for (const [key, selection] of this.selected) {
+            const { suite, hooks } = selection;
+            const cwd = subject?.session.header.cwd;
+            const projectDir = hooks.projectRoot ?? cwd;
+            // One context drives both the inline substitution and the process
+            // environment, so a command and its own process.env reads agree.
+            const root = pluginRootOf(suite);
+            const data = root === undefined || this.dataRoot === undefined ? undefined : suiteDataDir(this.dataRoot, suite.sourceId, suite.id);
+            const pathContext = { ...(root === undefined ? {} : { root }), ...(data === undefined ? {} : { data }), ...(projectDir === undefined ? {} : { projectDir }) };
+            const env = pluginPathEnvironment(pathContext);
+            // The declaration index counts every command hook of this event in declaration
+            // order and across matcher groups, exactly as the session inventory numbered
+            // its rows: a hook whose matcher does not apply still advances the position.
+            let index = 0;
+            for (const group of hooks.events[point] ?? []) {
+                const matched = matchesMatcher(group.matcher, query, 'claude-code');
+                for (const hook of group.hooks) {
+                    const position = index++;
+                    if (!matched)
+                        continue;
+                    if (this.disposed || ownerSignal.aborted || this.selected.get(key) !== selection)
+                        break;
+                    let allowed = false;
+                    try {
+                        allowed = this.isSuiteAllowed(suite) === true && this.isHookAllowed?.(suite, point, position) !== false;
+                    }
+                    catch (error) {
+                        this.ctx.logger.warn('extension-hooks: authorization failed for ' + key + ': ' + String(error));
+                    }
+                    if (!allowed)
+                        continue;
+                    const handlerId = 'extension-hooks:' + this.agent.id + ':' + key + ':' + point + ':' + ++this.handler;
+                    if (subject && turn !== undefined)
+                        appendHookInvoked(subject.session, { turn, point, dialect: 'claude-code', handlerId, ...(group.matcher === undefined ? {} : { matcher: group.matcher }) });
+                    const { output, durationMs } = await runHook(this.ctx.shell, { command: expandPluginPaths(hook.command, pathContext), ...(hook.timeout === undefined ? {} : { timeoutSec: hook.timeout }) }, {
+                        payload,
+                        defaultTimeoutMs: DEFAULT_HOOK_TIMEOUT_MS,
+                        signal: ownerSignal,
+                        trailingNewline: true,
+                        expectedEventName: point,
+                        ...(cwd === undefined ? {} : { cwd }),
+                        ...(Object.keys(env).length === 0 ? {} : { env })
+                    }, () => performance.now());
+                    if (subject && turn !== undefined)
+                        appendHookResult(subject.session, { turn, point, handlerId, output, durationMs, stderrSummaryMaxChars: DEFAULT_STDERR_SUMMARY_MAX_CHARS });
+                    if (output.updatedInput !== undefined || output.systemMessage !== undefined || output.continue === false)
+                        this.ctx.logger.warn('extension-hooks: ' + key + ' ' + point + ': updatedInput, systemMessage, and run-level halt are not supported by the host bridge');
+                    if (!this.disposed && !ownerSignal.aborted)
+                        outputs.push(output);
+                }
+            }
+        }
+        return mergeHookOutputs(outputs);
+    }
+}
+function base(agent, point, id = '') {
+    return { session_id: agent?.session.header.id ?? id, transcript_path: '', cwd: agent?.session.header.cwd ?? '', hook_event_name: point };
+}
+function text(content) {
+    return content
+        .filter(block => block.type === 'text')
+        .map(block => block.text)
+        .join('');
+}
+function contextFrom(merged) {
+    return merged.additionalContext.length === 0
+        ? undefined
+        : createUserMessage({ content: merged.additionalContext.map(text => ({ type: 'text', text })), source: CONTEXT_SOURCE });
+}

package/lib/packages/market-runtime/src/runtime/surfaces/hook-dry-run.js

@@ -0,0 +1,122 @@
+/**
+ * One declared command hook's bounded dry run.
+ *
+ * The declaration is resolved by the caller from the scanned catalog; this
+ * module only runs an already-resolved command. A client never supplies the
+ * command text, and the run directory is always the user's home directory, so a
+ * dry run cannot be steered at an arbitrary path or an arbitrary program.
+ *
+ * The host shell is reached as the executor seam (resolve plus execute),
+ * without injecting shell, because this read may run outside any session
+ * fiber. A profile that provides no shell answers a result-level error instead
+ * of throwing.
+ */
+import { homedir } from 'node:os';
+/** Per-stream cap, in characters, on the output one result carries. */
+export const HOOK_RUN_MAX_OUTPUT_CHARS = 32_768;
+/** Timeout applied when the declaration carries none. */
+export const HOOK_RUN_DEFAULT_TIMEOUT_SEC = 30;
+/** Hard ceiling on any dry run, whatever the declaration asks for. */
+export const HOOK_RUN_MAX_TIMEOUT_MS = 60_000;
+/** A resolved declaration that named no runnable hook. */
+export const HOOK_RUN_UNKNOWN_DECLARATION = 'hook-run-unknown-declaration';
+/** A matched declaration that carries no command (a rejected declaration exists only as a diagnostic). */
+export const HOOK_RUN_NO_COMMAND = 'hook-run-no-command';
+/** No shell executor is mounted in this profile. */
+export const HOOK_RUN_SHELL_UNAVAILABLE = 'hook-run-shell-unavailable';
+/** The executor rejected the run before it produced an outcome. */
+export const HOOK_RUN_FAILED = 'hook-run-failed';
+/**
+ * Narrow a resolved shell seam to the executor surface, or answer undefined.
+ *
+ * The seam is read without injecting shell, so its value is untyped at the
+ * boundary. A service that only exposes the legacy run shape is not an
+ * executor and is reported as unavailable rather than run against.
+ * @param value - the service resolved from the context, if any.
+ * @returns the executor surface, or undefined when no executor is mounted.
+ */
+export function hookRunShellOf(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const shell = value;
+    return typeof shell.resolve === 'function' && typeof shell.execute === 'function' ? shell : undefined;
+}
+/**
+ * The synthetic stdin payload one dry run writes.
+ *
+ * It carries the same event name the declaration fired under and the directory
+ * the command runs in, so a script that reads stdin sees a coherent event,
+ * plus dry_run: true so it can refuse to act for real.
+ * @param event - the declared event the hook belongs to.
+ * @param cwd - the directory the command runs in.
+ * @returns the JSON payload, newline terminated.
+ */
+export function hookRunStdin(event, cwd) {
+    return (JSON.stringify({
+        hook_event_name: event,
+        session_id: 'dry-run',
+        transcript_path: '',
+        cwd,
+        permission_mode: 'default',
+        dry_run: true
+    }) + '\n');
+}
+/** One bounded stream: the text a result carries and whether it was cut. */
+function bounded(text, truncated) {
+    return text.length <= HOOK_RUN_MAX_OUTPUT_CHARS ? { text, truncated } : { text: text.slice(0, HOOK_RUN_MAX_OUTPUT_CHARS), truncated: true };
+}
+/** One result that reports a failure without running anything. */
+export function hookRunFailure(code) {
+    return { cwd: homedir(), stdout: '', stderr: '', durationMs: 0, timedOut: false, truncated: false, error: code };
+}
+/**
+ * Run one resolved command in the home directory under a bounded timeout.
+ *
+ * The timeout is the declaration's own, defaulted to HOOK_RUN_DEFAULT_TIMEOUT_SEC
+ * and capped at HOOK_RUN_MAX_TIMEOUT_MS; the command's cwd is the home
+ * directory whatever the caller passes elsewhere. Both streams are capped
+ * independently, and an executor rejection becomes a result, so the request
+ * never fails with a thrown error.
+ * @param shell - the resolved host shell executor.
+ * @param command - the declaration's own command text.
+ * @param options - the event, declared timeout, and suite environment.
+ * @returns the bounded result of the run.
+ */
+export async function runHookDryRun(shell, command, options) {
+    const cwd = homedir();
+    const timeoutMs = Math.min((options.timeoutSec ?? HOOK_RUN_DEFAULT_TIMEOUT_SEC) * 1000, HOOK_RUN_MAX_TIMEOUT_MS);
+    const started = performance.now();
+    try {
+        const spec = shell.resolve({
+            command,
+            workdir: cwd,
+            timeoutMs,
+            stdin: hookRunStdin(options.event, cwd),
+            stdoutMaxBytes: HOOK_RUN_MAX_OUTPUT_CHARS,
+            ...(options.env === undefined ? {} : { env: options.env })
+        });
+        const result = await (await shell.execute(spec)).result();
+        const stdout = bounded(result.stdout.text, result.stdout.truncated);
+        const stderr = bounded(result.stderr.text, result.stderr.truncated);
+        return {
+            cwd,
+            ...(result.exitCode === null ? {} : { exitCode: result.exitCode }),
+            stdout: stdout.text,
+            stderr: stderr.text,
+            durationMs: performance.now() - started,
+            timedOut: result.timedOut,
+            truncated: stdout.truncated || stderr.truncated
+        };
+    }
+    catch (error) {
+        return {
+            cwd,
+            stdout: '',
+            stderr: '',
+            durationMs: performance.now() - started,
+            timedOut: false,
+            truncated: false,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}

package/lib/{runtime → packages/market-runtime/src/runtime}/surfaces/hooks-mounts.js

@@ -19,7 +19,7 @@ import { tmpdir } from 'node:os';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { SerialPassQueue } from '../core/mount-lifecycle.js';
-import { qualifiedSuiteId } from '../../catalog/paths.js';
+import { qualifiedSuiteId } from '../../../../market-catalog/src/index.js';
 export class HooksMountRegistry {
     ctx;
     live = new Map();

package/lib/{runtime → packages/market-runtime/src/runtime}/surfaces/project-runtime.js

@@ -1,29 +1,30 @@
 import { CommandMountRegistry } from './commands-mounts.js';
-import { expandPluginPaths, pluginRootOf } from '../../catalog/plugin-variables.js';
-import { suiteDataDir } from '../../catalog/paths.js';
-import { McpMountRegistry } from '../mcp/mcp-mounts.js';
+import { expandPluginPaths, pluginRootOf } from '../../../../market-catalog/src/index.js';
+import { suiteDataDir } from '../../../../market-catalog/src/index.js';
 import { HooksMountRegistry } from './hooks-mounts.js';
 import { readFile } from 'node:fs/promises';
-import { stripFrontmatter } from '../../catalog/skills-parse.js';
+import { stripFrontmatter } from '../../../../market-catalog/src/index.js';
 import { parseFrontmatterRecord } from '../../application/panels/user-store.js';
 /** Mount under existing and newly created agents; the caller owns refresh and teardown. */
-export function mountProjectCommands(ctx, catalog, t, dataRoot) {
-    return mountProjectSurface(ctx, catalog, 'commands', scope => new CommandMountRegistry(scope, t, dataRoot));
+export function mountProjectCommands(ctx, catalog, t, dataRoot, allows) {
+    return mountProjectSurface(ctx, catalog, 'commands', scope => new CommandMountRegistry(scope, t, dataRoot), false, allows);
 }
 /** MCP uses a separate injected child so network startup cannot delay local commands. */
-export function mountProjectMcp(ctx, catalog, dataRoot) {
+export function mountProjectMcp(ctx, catalog, dataRoot, mcpMounts, allows) {
     return mountProjectSurface(ctx, catalog, 'tools', scope => {
-        const registry = new McpMountRegistry(scope, dataRoot);
+        const registry = mcpMounts(scope, dataRoot);
         registry.setBackendProvider(() => catalog.mcpBackend());
         return registry;
-    });
+    }, false, allows);
 }
 /** Wait for both bridge dependencies before attempting a scoped hook mount. */
 export function mountProjectHooks(ctx, catalog) {
     return mountProjectSurface(ctx, catalog, ['shell', 'sessionProjections'], scope => new HooksMountRegistry(scope));
 }
 /** Kimi's startup skill and system-prompt declarations use the existing scoped prompt service. */
-export function mountSuiteInstructions(ctx, catalog, dataRoot) {
+export function mountSuiteInstructions(ctx, catalog, dataRoot, 
+/** Whether one user-dimension suite may contribute instructions; absent allows all. */
+suiteAllowed) {
     return mountProjectSurface(ctx, catalog, 'systemPrompt', (scope, agent) => {
         let text = '';
         const host = scope;
@@ -31,7 +32,8 @@ export function mountSuiteInstructions(ctx, catalog, dataRoot) {
         return {
             async reconcile(projectSuites) {
                 const projectDir = agent.session.header.cwd;
-                const result = await suiteInstructions([...(await catalog.enabledUserSuites()), ...projectSuites], {
+                const userSuites = (await catalog.enabledUserSuites()).filter(suite => suiteAllowed?.(suite) !== false);
+                const result = await suiteInstructions([...userSuites, ...projectSuites], {
                     ...(dataRoot === undefined ? {} : { dataRoot }),
                     ...(projectDir === undefined ? {} : { projectDir })
                 });
@@ -82,7 +84,14 @@ export async function suiteInstructions(suites, paths = {}) {
     }
     return { text: chunks.join('\n\n'), errors };
 }
-function mountProjectSurface(ctx, catalog, service, create, withoutProject = false) {
+function mountProjectSurface(ctx, catalog, service, create, withoutProject = false, 
+/**
+ * The workspace switch this surface answers, read on every refresh. A
+ * switched-off surface reconciles to an empty snapshot, which is the same
+ * "nothing wanted" pass a project with no such files already produces: the
+ * agent-scoped seat stays attached and only the data it serves collapses.
+ */
+allows) {
     const host = ctx;
     const mounts = new Map();
     const serviceLabel = typeof service === 'string' ? service : service.join(',');
@@ -101,7 +110,8 @@ function mountProjectSurface(ctx, catalog, service, create, withoutProject = fal
                 queue = queue.catch(warn).then(async () => {
                     if (!active)
                         return;
-                    const snapshot = cwd === undefined ? { enabledSuites: [] } : await catalog.readProjectCatalog(cwd);
+                    const off = allows?.() === false;
+                    const snapshot = cwd === undefined || off ? { enabledSuites: [] } : await catalog.readProjectCatalog(cwd);
                     if (!active)
                         return;
                     const diagnostics = await registry.reconcile([...snapshot.enabledSuites]);