@zaalipro/dsh-workflows 0.1.0-rc.12

package/lib/types/commands/aliases.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDefinitionSummary } from '../registry/types.js';
+/** Allocate aliases in UTF-16 name order without stealing a sibling's bare name. */
+export declare function allocateWorkflowCommandNames(definitions: readonly Pick<WorkflowDefinitionSummary, 'name'>[], occupiedNames: ReadonlySet<string>): ReadonlyMap<string, string>;
+//# sourceMappingURL=aliases.d.ts.map

package/lib/types/commands/aliases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aliases.d.ts","sourceRoot":"","sources":["../../../src/commands/aliases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAA;AAErE,oFAAoF;AACpF,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,SAAS,IAAI,CAAC,yBAAyB,EAAE,MAAM,CAAC,EAAE,EAC/D,aAAa,EAAE,WAAW,CAAC,MAAM,CAAC,GACjC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAqB7B"}

package/lib/types/commands/aliases.js

@@ -0,0 +1,25 @@
+/** Allocate aliases in UTF-16 name order without stealing a sibling's bare name. */
+export function allocateWorkflowCommandNames(definitions, occupiedNames) {
+    const allocated = new Map();
+    const reservedBareNames = new Set(definitions.map(definition => definition.name));
+    const used = new Set();
+    const sortedNames = [...reservedBareNames].sort();
+    for (const definitionName of sortedNames) {
+        if (occupiedNames.has(definitionName))
+            continue;
+        allocated.set(definitionName, definitionName);
+        used.add(definitionName);
+    }
+    for (const definitionName of sortedNames) {
+        if (allocated.has(definitionName))
+            continue;
+        let commandName = `workflow-${definitionName}`;
+        while (reservedBareNames.has(commandName) || used.has(commandName) || occupiedNames.has(commandName)) {
+            commandName = `workflow-${commandName}`;
+        }
+        allocated.set(definitionName, commandName);
+        used.add(commandName);
+    }
+    return allocated;
+}
+//# sourceMappingURL=aliases.js.map

package/lib/types/commands/aliases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aliases.js","sourceRoot":"","sources":["../../../src/commands/aliases.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,MAAM,UAAU,4BAA4B,CAC1C,WAA+D,EAC/D,aAAkC;IAElC,MAAM,SAAS,GAAG,IAAI,GAAG,EAAkB,CAAA;IAC3C,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAA;IACjF,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAA;IAC9B,MAAM,WAAW,GAAG,CAAC,GAAG,iBAAiB,CAAC,CAAC,IAAI,EAAE,CAAA;IAEjD,KAAK,MAAM,cAAc,IAAI,WAAW,EAAE,CAAC;QACzC,IAAI,aAAa,CAAC,GAAG,CAAC,cAAc,CAAC;YAAE,SAAQ;QAC/C,SAAS,CAAC,GAAG,CAAC,cAAc,EAAE,cAAc,CAAC,CAAA;QAC7C,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;IAC1B,CAAC;IACD,KAAK,MAAM,cAAc,IAAI,WAAW,EAAE,CAAC;QACzC,IAAI,SAAS,CAAC,GAAG,CAAC,cAAc,CAAC;YAAE,SAAQ;QAC3C,IAAI,WAAW,GAAG,YAAY,cAAc,EAAE,CAAA;QAC9C,OAAO,iBAAiB,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,aAAa,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;YACrG,WAAW,GAAG,YAAY,WAAW,EAAE,CAAA;QACzC,CAAC;QACD,SAAS,CAAC,GAAG,CAAC,cAAc,EAAE,WAAW,CAAC,CAAA;QAC1C,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;IACvB,CAAC;IACD,OAAO,SAAS,CAAA;AAClB,CAAC"}

package/lib/types/commands/index.d.ts

@@ -0,0 +1,66 @@
+import { allocateWorkflowCommandNames } from './aliases.js';
+import type { WorkflowRegistry } from '../registry/index.js';
+import type { WorkflowSupervisor } from '../supervisor/index.js';
+export * from './parser.js';
+export * from './aliases.js';
+export declare const name = "commands";
+export interface CommandsConfig {
+    readonly enabled?: boolean;
+    /** Root composition registers the protected skill as a separate child. */
+    readonly registerSkill?: boolean;
+}
+export declare const CommandsConfig: {
+    readonly enabled: true;
+};
+export interface CommandResult {
+    readonly content: string;
+    readonly isError?: boolean;
+}
+export declare const COMMAND_SUCCESS: {
+    pause: (display: string) => string;
+    resume: (display: string) => string;
+    stop: (display: string) => string;
+};
+export declare const CREATE_WORKFLOW_COMMAND_DESCRIPTION = "Author, smoke-check, and save a new workflow (create-workflow skill)";
+export declare const WORKFLOWS_COMMAND_DESCRIPTION = "Open saved workflows and live runs";
+/**
+ * The steered user message must be exactly what the user typed. Enforcement
+ * (no interview, validate_only, auto-save) lives in the skill content and the
+ * tool defaults — not in visible user text.
+ */
+export declare function createWorkflowSteerText(detail: string): string;
+export interface WorkflowCommandServices {
+    readonly registry: Pick<WorkflowRegistry, 'get'>;
+    readonly supervisor: Pick<WorkflowSupervisor, 'start' | 'pause' | 'resume' | 'stop' | 'save'>;
+    readonly agent: any;
+    readonly recorder?: {
+        launch?(session: any, start: () => Promise<any>): Promise<any>;
+    };
+    readonly cwd?: string;
+    readonly signal?: AbortSignal;
+}
+/** Execute a parsed command in small standalone fixtures as well as a Host. */
+export declare function executeWorkflowCommand(input: string, services: WorkflowCommandServices): Promise<CommandResult>;
+/** Resolve candidate packaged-skill URLs from source or an installed lib layout. */
+export declare function packagedSkillCandidates(here?: string | URL): readonly URL[];
+/** Resolve the shipped skill asset from source or an installed lib layout. */
+export declare function packagedSkillPath(here?: string | URL): URL;
+/** Split YAML frontmatter from the registered Markdown body. */
+export declare function parsePackagedSkillDocument(text: string): {
+    readonly description: string;
+    readonly content: string;
+};
+export declare function readPackagedSkillFrom(candidates: readonly URL[]): Promise<string>;
+export declare function readPackagedSkillSyncFrom(candidates: readonly URL[]): string;
+export declare function readPackagedSkill(): Promise<string>;
+export declare function readPackagedSkillSync(): string;
+/** Prefer a future protected binding; stock rc.2 uses its provider rank seam. */
+export declare function registerTrustedWorkflowSkill(ctx: any): Promise<() => void>;
+export declare function registerTrustedWorkflowSkillSync(ctx: any, options?: {
+    readonly required?: boolean;
+}): () => unknown;
+/** Mount Host commands and exact-Agent definition aliases. */
+export declare function applyCommands(ctx: any, config?: CommandsConfig): (() => Promise<void>) | undefined;
+export declare const apply: typeof applyCommands;
+export { allocateWorkflowCommandNames };
+//# sourceMappingURL=index.d.ts.map

package/lib/types/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/index.ts"],"names":[],"mappings":"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"}

package/lib/types/commands/index.js

@@ -0,0 +1,550 @@
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { readFileSync } from 'node:fs';
+import { parseWorkflowCommand, WORKFLOW_COMMAND_HELP } from './parser.js';
+import { allocateWorkflowCommandNames } from './aliases.js';
+export * from './parser.js';
+export * from './aliases.js';
+export const name = 'commands';
+export const CommandsConfig = { enabled: true };
+export const COMMAND_SUCCESS = {
+    pause: (display) => `Paused workflow "${display}". Open /workflows to resume or stop it.`,
+    resume: (display) => `Resumed workflow "${display}". Open /workflows to watch it.`,
+    stop: (display) => `Stopped workflow "${display}".`,
+};
+export const CREATE_WORKFLOW_COMMAND_DESCRIPTION = 'Author, smoke-check, and save a new workflow (create-workflow skill)';
+export const WORKFLOWS_COMMAND_DESCRIPTION = 'Open saved workflows and live runs';
+/**
+ * The steered user message must be exactly what the user typed. Enforcement
+ * (no interview, validate_only, auto-save) lives in the skill content and the
+ * tool defaults — not in visible user text.
+ */
+export function createWorkflowSteerText(detail) {
+    const trimmed = detail.trim();
+    return trimmed === '' ? '/create-workflow' : `/create-workflow ${trimmed}`;
+}
+const DEFAULT_SKILL_DESCRIPTION = 'Author, smoke-check, and save a new saved workflow (invoke via /create-workflow).';
+const CREATE_WORKFLOW_PROVIDER = 'workflow-authoring';
+const CREATE_WORKFLOW_RANK = 0;
+const CREATE_WORKFLOW_LOCATOR = Object.freeze({ name: 'create-workflow' });
+function renderThrown(error) {
+    try {
+        return error instanceof Error ? error.message : String(error);
+    }
+    catch {
+        return '[unrenderable workflow command failure]';
+    }
+}
+function cwdOf(agent) {
+    const cwd = agent?.session?.header?.cwd;
+    return typeof cwd === 'string' && cwd.length > 0 ? { cwd } : {};
+}
+function commandSuccess(text) { return { kind: 'success', text }; }
+function commandError(error) { return { kind: 'error', text: renderThrown(error) }; }
+function officialFromCommandResult(result) {
+    return result.isError === true ? { kind: 'error', text: result.content } : commandSuccess(result.content);
+}
+function isAbortError(error, signal) {
+    return signal?.aborted === true
+        || (typeof error === 'object' && error !== null && error.name === 'AbortError');
+}
+/** Execute a parsed command in small standalone fixtures as well as a Host. */
+export async function executeWorkflowCommand(input, services) {
+    const command = parseWorkflowCommand(input);
+    if (command.kind === 'empty')
+        return { content: WORKFLOW_COMMAND_HELP };
+    if (command.kind === 'malformed')
+        return { content: command.error, isError: true };
+    const signal = services.signal;
+    try {
+        signal?.throwIfAborted();
+        if (command.kind === 'launch') {
+            const definition = await services.registry.get(command.name, { cwd: services.cwd ?? cwdOf(services.agent).cwd, signal });
+            if (definition === undefined)
+                return { content: `no saved workflow named "${command.name}"`, isError: true };
+            const start = () => services.supervisor.start({ definition, args: command.args, parent: services.agent, signal });
+            const launched = typeof services.recorder?.launch === 'function'
+                ? await services.recorder.launch(services.agent.session, start)
+                : await start();
+            return { content: `Started workflow "${launched.displayName}" in the background. Open /workflows to watch it.` };
+        }
+        if (command.kind === 'pause') {
+            await services.supervisor.pause(command.displayName, services.agent, signal);
+            return { content: COMMAND_SUCCESS.pause(command.displayName) };
+        }
+        if (command.kind === 'resume') {
+            await services.supervisor.resume(command.displayName, services.agent, signal);
+            return { content: COMMAND_SUCCESS.resume(command.displayName) };
+        }
+        if (command.kind === 'stop') {
+            await services.supervisor.stop(command.displayName, services.agent, signal);
+            return { content: COMMAND_SUCCESS.stop(command.displayName) };
+        }
+        const path = await services.supervisor.save(command.displayName, services.agent, undefined, signal);
+        return { content: `Saved workflow "${command.displayName}" to ${path}.` };
+    }
+    catch (error) {
+        return { content: renderThrown(error), isError: true };
+    }
+}
+/** Resolve candidate packaged-skill URLs from source or an installed lib layout. */
+export function packagedSkillCandidates(here = import.meta.url) {
+    const base = typeof here === 'string' ? new URL(here) : here;
+    return [
+        new URL('../../skills/create-workflow/SKILL.md', base),
+        new URL('../../../skills/create-workflow/SKILL.md', base),
+    ];
+}
+/** Resolve the shipped skill asset from source or an installed lib layout. */
+export function packagedSkillPath(here = import.meta.url) {
+    return packagedSkillCandidates(here)[baseUsesLibLayout(here) ? 1 : 0];
+}
+function baseUsesLibLayout(here) {
+    const path = String(typeof here === 'string' ? here : here.pathname);
+    return path.includes('/lib/');
+}
+function validSkill(text) {
+    return /^---\s*\n/u.test(text)
+        && /^name:\s*create-workflow\s*$/mu.test(text)
+        && /\/create-workflow/u.test(text)
+        && /^user-invocable:\s*true\s*$/mu.test(text)
+        && /^model-invocable:\s*true\s*$/mu.test(text);
+}
+/** Split YAML frontmatter from the registered Markdown body. */
+export function parsePackagedSkillDocument(text) {
+    if (!validSkill(text))
+        throw new Error('invalid skill');
+    const match = /^---\r?\n[\s\S]*?\r?\n---\r?\n([\s\S]*)$/u.exec(text);
+    const content = (match?.[1] ?? '').replace(/^\uFEFF/u, '').replace(/^(?:\r?\n)+/u, '');
+    const description = text.match(/^description:\s*(.+)$/mu)?.[1]?.trim() || DEFAULT_SKILL_DESCRIPTION;
+    return { description, content };
+}
+export async function readPackagedSkillFrom(candidates) {
+    const fs = await import('node:fs/promises');
+    let last;
+    for (const candidate of candidates) {
+        try {
+            const text = await fs.readFile(candidate, 'utf8');
+            if (!validSkill(text))
+                throw new Error('invalid skill');
+            return text;
+        }
+        catch (error) {
+            last = error;
+        }
+    }
+    throw new Error(`packaged create-workflow skill is missing or invalid: ${renderThrown(last)}`);
+}
+export function readPackagedSkillSyncFrom(candidates) {
+    let last;
+    for (const candidate of candidates) {
+        try {
+            const text = readFileSync(candidate, 'utf8');
+            if (!validSkill(text))
+                throw new Error('invalid skill');
+            return text;
+        }
+        catch (error) {
+            last = error;
+        }
+    }
+    throw new Error(`packaged create-workflow skill is missing or invalid: ${renderThrown(last)}`);
+}
+export async function readPackagedSkill() {
+    return readPackagedSkillFrom(packagedSkillCandidates());
+}
+export function readPackagedSkillSync() {
+    return readPackagedSkillSyncFrom(packagedSkillCandidates());
+}
+function registrationForSkill(text) {
+    const parsed = parsePackagedSkillDocument(text);
+    return {
+        name: 'create-workflow',
+        description: parsed.description,
+        content: parsed.content,
+        source: 'bundled',
+        invocation: { modelInvocable: true, userInvocable: true },
+    };
+}
+/** Stock rc.2 provider whose rank keeps the product procedure above project/user collisions. */
+function createWorkflowSkillProvider(text) {
+    const registration = registrationForSkill(text);
+    const definition = Object.freeze({
+        ...registration,
+        provider: CREATE_WORKFLOW_PROVIDER,
+    });
+    const candidate = Object.freeze({
+        name: definition.name,
+        description: definition.description,
+        source: definition.source,
+        provider: CREATE_WORKFLOW_PROVIDER,
+        invocation: definition.invocation,
+        rank: CREATE_WORKFLOW_RANK,
+        locator: CREATE_WORKFLOW_LOCATOR,
+    });
+    return Object.freeze({
+        name: CREATE_WORKFLOW_PROVIDER,
+        list: () => Promise.resolve([candidate]),
+        get: (selected) => Promise.resolve(selected === candidate ? definition : undefined),
+    });
+}
+function asDisposer(value) {
+    if (typeof value === 'function')
+        return value;
+    if (typeof value?.dispose === 'function') {
+        return () => value.dispose();
+    }
+    return () => undefined;
+}
+/** Prefer a future protected binding; stock rc.2 uses its provider rank seam. */
+export async function registerTrustedWorkflowSkill(ctx) {
+    const content = await readPackagedSkill();
+    const trusted = ctx?.skills?.registerTrustedPackageSkill;
+    if (typeof trusted === 'function') {
+        return asDisposer(trusted.call(ctx.skills, registrationForSkill(content), { protectedName: 'create-workflow' }));
+    }
+    const registerProvider = ctx?.skills?.registerProvider;
+    if (typeof registerProvider === 'function') {
+        return asDisposer(registerProvider.call(ctx.skills, () => createWorkflowSkillProvider(content)));
+    }
+    throw new Error('protected packaged skill registration is unavailable');
+}
+export function registerTrustedWorkflowSkillSync(ctx, options = {}) {
+    const trusted = ctx?.skills?.registerTrustedPackageSkill;
+    if (typeof trusted === 'function') {
+        return asDisposer(trusted.call(ctx.skills, registrationForSkill(readPackagedSkillSync()), { protectedName: 'create-workflow' }));
+    }
+    const registerProvider = ctx?.skills?.registerProvider;
+    if (typeof registerProvider === 'function') {
+        const content = readPackagedSkillSync();
+        return asDisposer(registerProvider.call(ctx.skills, () => createWorkflowSkillProvider(content)));
+    }
+    if (options.required !== false)
+        throw new Error('protected packaged skill registration is unavailable');
+    return () => undefined;
+}
+function on(ctx, event, listener) {
+    const disposer = ctx?.on?.(event, listener);
+    return typeof disposer === 'function' ? disposer : () => undefined;
+}
+function agentList(ctx) {
+    const value = ctx?.agents?.list?.();
+    return Array.isArray(value) ? value : [];
+}
+function effectiveCommandNames(ctx, agent) {
+    const names = new Set();
+    const list = ctx?.commands?.list?.(agent);
+    if (Array.isArray(list))
+        for (const item of list)
+            if (typeof item?.name === 'string')
+                names.add(item.name);
+    return names;
+}
+function occupiedCommandNames(ctx, state) {
+    const ownHandlers = new Set([...state.registrations.values()].map(registration => registration.handler));
+    const occupied = new Set();
+    for (const name of effectiveCommandNames(ctx, state.agent)) {
+        const found = ctx?.commands?.find?.(state.agent, name);
+        if (found !== undefined && ownHandlers.has(found.handler))
+            continue;
+        if (found === undefined && [...state.registrations.values()].some(registration => registration.commandName === name))
+            continue;
+        occupied.add(name);
+    }
+    return occupied;
+}
+function queueRefresh(ctx, state, supervisor, track) {
+    if (state.disposed || state.refreshQueued)
+        return;
+    state.refreshQueued = true;
+    queueMicrotask(() => {
+        state.refreshQueued = false;
+        if (!state.disposed)
+            track(refreshAliases(ctx, state, supervisor));
+    });
+}
+function scheduleReconcile(ctx, state, supervisor) {
+    if (state.disposed || state.reconcileQueued)
+        return;
+    state.reconcileQueued = true;
+    queueMicrotask(() => {
+        state.reconcileQueued = false;
+        if (state.disposed)
+            return;
+        try {
+            reconcileAliases(ctx, state, supervisor);
+        }
+        catch { /* contained: owner inject is probed at attach */ }
+    });
+}
+async function refreshAliases(ctx, state, supervisor) {
+    state.abort?.abort(new Error('workflow alias refresh superseded'));
+    const abort = new AbortController();
+    state.abort = abort;
+    let definitions;
+    try {
+        definitions = await ctx.workflows.list({ ...cwdOf(state.agent), signal: abort.signal });
+    }
+    catch (error) {
+        if (abort.signal.aborted || state.disposed || isAbortError(error, abort.signal))
+            return;
+        ctx?.logger?.warn?.(`workflow alias catalog refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+        return;
+    }
+    if (abort.signal.aborted || state.disposed)
+        return;
+    state.definitions.clear();
+    for (const definition of definitions)
+        state.definitions.set(definition.name, definition);
+    reconcileAliases(ctx, state, supervisor);
+}
+function reconcileAliases(ctx, state, supervisor) {
+    if (state.disposed)
+        return;
+    const allocations = allocateWorkflowCommandNames([...state.definitions.values()], occupiedCommandNames(ctx, state));
+    for (const [canonical, registration] of [...state.registrations]) {
+        const definition = state.definitions.get(canonical);
+        if (definition !== undefined
+            && registration.description === definition.description
+            && registration.commandName === allocations.get(canonical))
+            continue;
+        try {
+            void registration.dispose();
+        }
+        catch { /* contained */ }
+        state.registrations.delete(canonical);
+    }
+    for (const definition of state.definitions.values()) {
+        if (state.registrations.has(definition.name))
+            continue;
+        const alias = allocations.get(definition.name);
+        if (alias === undefined)
+            continue;
+        state.registrations.set(definition.name, makeAlias(ctx, state, supervisor, definition, alias));
+    }
+}
+function makeAlias(ctx, state, supervisor, definition, commandName) {
+    const handler = async (invocation) => {
+        const raw = String(invocation?.rawInput ?? '').trim();
+        let args = {};
+        if (raw !== '') {
+            try {
+                const parsed = JSON.parse(raw);
+                if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+                    throw new Error('object');
+                args = parsed;
+            }
+            catch {
+                return { kind: 'error', text: `/${commandName} args must be one JSON object (wrap arrays/scalars in a field)` };
+            }
+        }
+        const agent = invocation.agent;
+        try {
+            const full = await ctx.workflows.get(definition.name, { ...cwdOf(agent), signal: invocation.signal });
+            if (full === undefined)
+                return { kind: 'error', text: `no saved workflow named "${definition.name}"` };
+            const launch = () => supervisor.start({ definition: full, args, parent: agent, signal: invocation.signal });
+            const launched = typeof ctx.workflowRunRecorder?.launch === 'function'
+                ? await ctx.workflowRunRecorder.launch(agent.session, launch)
+                : await launch();
+            return commandSuccess(`Started workflow "${launched.displayName}" in the background. Open /workflows to watch it.`);
+        }
+        catch (error) {
+            return commandError(error);
+        }
+    };
+    const contribution = {
+        name: commandName,
+        description: commandName === definition.name
+            ? definition.description
+            : `Saved workflow "${definition.name}": ${definition.description}`,
+        input: { hint: '[json-args]' },
+        handler,
+    };
+    const owner = state.agent?.ctx;
+    const hasFallback = typeof ctx?.commands?.registerFallback === 'function';
+    if (hasFallback) {
+        if (typeof owner?.inject !== 'function') {
+            throw new Error('workflow command aliases require exact-Agent command injection');
+        }
+        const fiber = owner.inject(['commands'], (registrationCtx) => {
+            if (typeof registrationCtx?.commands?.registerFallback !== 'function') {
+                throw new Error('workflow command aliases require the official commands.registerFallback seam');
+            }
+            registrationCtx.commands.registerFallback(contribution);
+        });
+        const dispose = asDisposer(fiber);
+        if (fiber === undefined || (typeof fiber !== 'function' && typeof fiber?.dispose !== 'function')) {
+            throw new Error('workflow command aliases require exact-Agent command injection');
+        }
+        return { commandName, description: definition.description, handler, dispose };
+    }
+    const register = ctx?.commands?.register;
+    if (typeof register !== 'function') {
+        throw new Error('workflow command aliases require exact-Agent command injection');
+    }
+    return {
+        commandName,
+        description: definition.description,
+        handler,
+        dispose: asDisposer(register.call(ctx.commands, contribution)),
+    };
+}
+/** Mount Host commands and exact-Agent definition aliases. */
+export function applyCommands(ctx, config = {}) {
+    if (config.enabled === false)
+        return;
+    const cleanup = [];
+    const commands = ctx?.commands;
+    if (typeof commands?.register !== 'function')
+        throw new Error('workflow command registry is unavailable');
+    const hasFallback = typeof commands.registerFallback === 'function';
+    const supervisor = ctx.workflowSupervisor;
+    if (config.registerSkill !== false && ctx?.skills?.registerTrustedPackageSkill !== undefined) {
+        cleanup.push(asDisposer(registerTrustedWorkflowSkillSync(ctx)));
+    }
+    const workflowCommand = commands.register({
+        name: 'workflow',
+        description: 'Launch a saved workflow or pause/resume/stop/save a run',
+        input: { hint: '<name> [json-args] | pause|resume|stop|save <display-name>' },
+        handler: async (invocation) => {
+            try {
+                invocation.signal?.throwIfAborted();
+                return officialFromCommandResult(await executeWorkflowCommand(String(invocation?.rawInput ?? ''), {
+                    registry: ctx.workflows,
+                    supervisor,
+                    agent: invocation.agent,
+                    recorder: ctx.workflowRunRecorder,
+                    signal: invocation.signal,
+                }));
+            }
+            catch (error) {
+                return commandError(error);
+            }
+        },
+    });
+    cleanup.push(asDisposer(workflowCommand));
+    const createCommand = commands.register({
+        name: 'create-workflow',
+        description: CREATE_WORKFLOW_COMMAND_DESCRIPTION,
+        input: { hint: '[what the workflow should do]' },
+        handler: (invocation) => {
+            try {
+                invocation.signal?.throwIfAborted();
+                const detail = String(invocation.rawInput ?? '').trim();
+                invocation.agent.steer(createUserMessage({
+                    content: [{ type: 'text', text: createWorkflowSteerText(detail) }],
+                    source: { kind: 'user' },
+                }));
+                return commandSuccess('Opened the workflow authoring skill.');
+            }
+            catch (error) {
+                return commandError(error);
+            }
+        },
+    });
+    cleanup.push(asDisposer(createCommand));
+    const states = new Map();
+    const pendingDisposals = new Set();
+    const track = (task) => {
+        pendingDisposals.add(task.catch(error => {
+            if (isAbortError(error))
+                return undefined;
+            const message = error instanceof Error ? error.message : String(error);
+            if (/registerFallback|exact-Agent command injection/u.test(message))
+                return undefined;
+            throw error;
+        }));
+    };
+    const addAgent = (agent) => {
+        if (agent === undefined || states.has(agent))
+            return;
+        if (!hasFallback) {
+            const cwd = cwdOf(agent).cwd;
+            if (cwd === undefined)
+                return;
+            for (const existing of states.keys()) {
+                if (cwdOf(existing).cwd === cwd)
+                    return;
+            }
+        }
+        if (hasFallback) {
+            if (typeof agent?.ctx?.inject !== 'function') {
+                throw new Error('workflow command aliases require exact-Agent command injection');
+            }
+            const probe = agent.ctx.inject(['commands'], (registrationCtx) => {
+                if (typeof registrationCtx?.commands?.registerFallback !== 'function') {
+                    throw new Error('workflow command aliases require the official commands.registerFallback seam');
+                }
+            });
+            try {
+                void asDisposer(probe)();
+            }
+            catch { /* contained */ }
+        }
+        const state = {
+            agent,
+            registrations: new Map(),
+            definitions: new Map(),
+            disposed: false,
+            refreshQueued: false,
+            reconcileQueued: false,
+        };
+        states.set(agent, state);
+        track(refreshAliases(ctx, state, supervisor));
+    };
+    const removeAgent = (agent) => {
+        const state = states.get(agent);
+        if (state === undefined)
+            return;
+        state.disposed = true;
+        state.abort?.abort(new Error('workflow alias owner disposed'));
+        for (const registration of state.registrations.values()) {
+            try {
+                const result = registration.dispose();
+                if (result !== undefined && typeof result?.then === 'function') {
+                    const pending = Promise.resolve(result);
+                    pendingDisposals.add(pending);
+                    void pending.then(() => pendingDisposals.delete(pending), () => pendingDisposals.delete(pending));
+                }
+            }
+            catch { /* contained */ }
+        }
+        state.registrations.clear();
+        states.delete(agent);
+    };
+    for (const agent of agentList(ctx))
+        addAgent(agent);
+    cleanup.push(on(ctx, 'agent/created', event => addAgent(event?.agent ?? event)));
+    cleanup.push(on(ctx, 'agent/disposed', event => removeAgent(event?.agent ?? event)));
+    cleanup.push(on(ctx, 'workflows/change', () => { for (const state of states.values())
+        queueRefresh(ctx, state, supervisor, track); }));
+    cleanup.push(on(ctx, 'commands/change', () => { for (const state of states.values())
+        scheduleReconcile(ctx, state, supervisor); }));
+    let disposed = false;
+    let disposal;
+    const dispose = () => {
+        if (disposal !== undefined)
+            return disposal;
+        disposed = true;
+        disposal = (async () => {
+            for (const agent of [...states.keys()])
+                removeAgent(agent);
+            for (const item of cleanup.splice(0)) {
+                try {
+                    await item();
+                }
+                catch { /* contained */ }
+            }
+            await Promise.allSettled([...pendingDisposals]);
+            pendingDisposals.clear();
+        })();
+        return disposal;
+    };
+    void disposed;
+    if (typeof ctx.effect === 'function')
+        ctx.effect(() => dispose, 'dsh-workflows: commands');
+    return dispose;
+}
+export const apply = applyCommands;
+export { allocateWorkflowCommandNames };
+//# sourceMappingURL=index.js.map