@clinebot/core 0.0.12 → 0.0.14

package/dist/runtime/commands.d.ts

@@ -0,0 +1,11 @@
+import type { UserInstructionConfigWatcher } from "../agents";
+export type RuntimeCommandKind = "skill" | "workflow";
+export type AvailableRuntimeCommand = {
+    id: string;
+    name: string;
+    instructions: string;
+    kind: RuntimeCommandKind;
+};
+export declare function listAvailableRuntimeCommandsFromWatcher(watcher: UserInstructionConfigWatcher): AvailableRuntimeCommand[];
+export declare function resolveRuntimeSlashCommandFromWatcher(input: string, watcher: UserInstructionConfigWatcher): string;
+export declare function listAvailableRuntimeCommandsForKindFromWatcher(watcher: UserInstructionConfigWatcher, kind: RuntimeCommandKind): AvailableRuntimeCommand[];

package/dist/runtime/skills.d.ts

@@ -0,0 +1,13 @@
+import type { UserInstructionConfigWatcher } from "../agents";
+export type AvailableSkill = {
+    id: string;
+    name: string;
+    instructions: string;
+};
+export declare function listAvailableSkillsFromWatcher(watcher: UserInstructionConfigWatcher): AvailableSkill[];
+/**
+ * Expands a leading slash command (e.g. "/release") to skill instructions.
+ * If the input starts with "/<skill-name>", that prefix is replaced and the
+ * remaining input is preserved unchanged.
+ */
+export declare function resolveSkillsSlashCommandFromWatcher(input: string, watcher: UserInstructionConfigWatcher): string;

package/dist/session/session-service.d.ts

@@ -3,35 +3,35 @@ import type { SqliteSessionStore } from "../storage/sqlite-session-store";
 import type { SessionSource, SessionStatus } from "../types/common";
 import type { SessionManifest } from "./session-manifest";
 import { UnifiedSessionPersistenceService } from "./unified-session-persistence-service";
-export interface SessionRowShape {
-    session_id: string;
+export interface SessionRow {
+    sessionId: string;
     source: string;
     pid: number;
-    started_at: string;
-    ended_at?: string | null;
-    exit_code?: number | null;
+    startedAt: string;
+    endedAt?: string | null;
+    exitCode?: number | null;
     status: SessionStatus;
-    status_lock?: number;
-    interactive: number;
+    statusLock: number;
+    interactive: boolean;
     provider: string;
     model: string;
     cwd: string;
-    workspace_root: string;
-    team_name?: string | null;
-    enable_tools: number;
-    enable_spawn: number;
-    enable_teams: number;
-    parent_session_id?: string | null;
-    parent_agent_id?: string | null;
-    agent_id?: string | null;
-    conversation_id?: string | null;
-    is_subagent: number;
+    workspaceRoot: string;
+    teamName?: string | null;
+    enableTools: boolean;
+    enableSpawn: boolean;
+    enableTeams: boolean;
+    parentSessionId?: string | null;
+    parentAgentId?: string | null;
+    agentId?: string | null;
+    conversationId?: string | null;
+    isSubagent: boolean;
     prompt?: string | null;
-    metadata_json?: string | null;
-    transcript_path: string;
-    hook_path: string;
-    messages_path?: string | null;
-    updated_at?: string;
+    metadata?: Record<string, unknown> | null;
+    transcriptPath: string;
+    hookPath: string;
+    messagesPath?: string | null;
+    updatedAt: string;
 }
 export interface CreateRootSessionInput {
     sessionId: string;

package/dist/session/unified-session-persistence-service.d.ts

@@ -3,7 +3,7 @@ import type { LlmsProviders } from "@clinebot/llms";
 import type { SessionStatus } from "../types/common";
 import { SessionArtifacts } from "./session-artifacts";
 import { type SessionManifest } from "./session-manifest";
-import type { CreateRootSessionWithArtifactsInput, RootSessionArtifacts, SessionRowShape, UpsertSubagentInput } from "./session-service";
+import type { CreateRootSessionWithArtifactsInput, RootSessionArtifacts, SessionRow, UpsertSubagentInput } from "./session-service";
 export interface PersistedSessionUpdateInput {
     sessionId: string;
     expectedStatusLock?: number;
@@ -11,7 +11,7 @@ export interface PersistedSessionUpdateInput {
     endedAt?: string | null;
     exitCode?: number | null;
     prompt?: string | null;
-    metadataJson?: string | null;
+    metadata?: Record<string, unknown> | null;
     title?: string | null;
     parentSessionId?: string | null;
     parentAgentId?: string | null;
@@ -21,13 +21,13 @@ export interface PersistedSessionUpdateInput {
 }
 export interface SessionPersistenceAdapter {
     ensureSessionsDir(): string;
-    upsertSession(row: SessionRowShape): Promise<void>;
-    getSession(sessionId: string): Promise<SessionRowShape | undefined>;
+    upsertSession(row: SessionRow): Promise<void>;
+    getSession(sessionId: string): Promise<SessionRow | undefined>;
     listSessions(options: {
         limit: number;
         parentSessionId?: string;
         status?: string;
-    }): Promise<SessionRowShape[]>;
+    }): Promise<SessionRow[]>;
     updateSession(input: PersistedSessionUpdateInput): Promise<{
         updated: boolean;
         statusLock: number;
@@ -91,7 +91,7 @@ export declare class UnifiedSessionPersistenceService {
     handleSubAgentEnd(rootSessionId: string, context: SubAgentEndContext): Promise<void>;
     private isPidAlive;
     private reconcileDeadRunningSession;
-    listSessions(limit?: number): Promise<SessionRowShape[]>;
+    listSessions(limit?: number): Promise<SessionRow[]>;
     reconcileDeadSessions(limit?: number): Promise<number>;
     deleteSession(sessionId: string): Promise<{
         deleted: boolean;

package/dist/session/utils/helpers.d.ts

@@ -1,11 +1,11 @@
 import type { AgentConfig, AgentEvent, AgentResult } from "@clinebot/agents";
 import type { LlmsProviders } from "@clinebot/llms";
 import type { SessionRecord } from "../../types/sessions";
-import type { SessionRowShape } from "../session-service";
+import type { SessionRow } from "../session-service";
 import type { StoredMessageWithMetadata } from "./types";
 export declare function extractWorkspaceMetadataFromSystemPrompt(systemPrompt: string): string | undefined;
 export declare function hasRuntimeHooks(hooks: AgentConfig["hooks"]): boolean;
 export declare function mergeAgentExtensions(explicitExtensions: AgentConfig["extensions"] | undefined, loadedExtensions: AgentConfig["extensions"] | undefined): AgentConfig["extensions"];
 export declare function serializeAgentEvent(event: AgentEvent): string;
 export declare function withLatestAssistantTurnMetadata(messages: LlmsProviders.Message[], result: AgentResult, previousMessages?: LlmsProviders.MessageWithMetadata[]): StoredMessageWithMetadata[];
-export declare function toSessionRecord(row: SessionRowShape): SessionRecord;
+export declare function toSessionRecord(row: SessionRow): SessionRecord;

package/dist/tools/schemas.d.ts

@@ -5,6 +5,7 @@
  * and are used for both validation and JSON Schema generation.
  */
 import { z } from "zod";
+export declare const INPUT_ARG_CHAR_LIMIT = 6000;
 export declare const ReadFileLineRangeSchema: z.ZodObject<{
     start_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     end_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;

package/package.json

@@ -1,11 +1,11 @@
 {
 	"name": "@clinebot/core",
-	"version": "0.0.12",
+	"version": "0.0.14",
 	"main": "./dist/index.node.js",
 	"dependencies": {
-		"@clinebot/agents": "0.0.12",
-		"@clinebot/llms": "0.0.12",
-		"@clinebot/shared": "0.0.12",
+		"@clinebot/agents": "0.0.14",
+		"@clinebot/llms": "0.0.14",
+		"@clinebot/shared": "0.0.14",
 		"@opentelemetry/api": "^1.9.0",
 		"@opentelemetry/api-logs": "^0.56.0",
 		"@opentelemetry/exporter-logs-otlp-http": "^0.56.0",
@@ -14,7 +14,6 @@
 		"@opentelemetry/sdk-logs": "^0.56.0",
 		"@opentelemetry/sdk-metrics": "^1.30.1",
 		"@opentelemetry/semantic-conventions": "^1.37.0",
-		"better-sqlite3": "^11.10.0",
 		"jiti": "^1.21.7",
 		"nanoid": "^5.1.7",
 		"simple-git": "^3.32.3",
@@ -52,6 +51,9 @@
 		"test:e2e": "vitest run --config vitest.e2e.config.ts",
 		"test:watch": "vitest --config vitest.config.ts"
 	},
+	"engines": {
+		"node": ">=20"
+	},
 	"type": "module",
 	"types": "./dist/index.node.d.ts"
 }

package/src/agents/plugin-loader.test.ts

@@ -1,16 +1,12 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 import {
 	loadAgentPluginFromPath,
 	loadAgentPluginsFromPaths,
 } from "./plugin-loader";
 
-const TEST_DIR = fileURLToPath(new URL(".", import.meta.url));
-const REPO_ROOT = resolve(TEST_DIR, "..", "..", "..", "..");
-
 describe("plugin-loader", () => {
 	it("loads default-exported plugin from path", async () => {
 		const dir = await mkdtemp(join(tmpdir(), "core-plugin-loader-"));
@@ -193,15 +189,19 @@ describe("plugin-loader", () => {
 			const pluginPath = join(dir, "portable-subagents.ts");
 			await writeFile(
 				pluginPath,
-				await readFile(
-					resolve(REPO_ROOT, "apps/examples/subagent-plugin/index.ts"),
-					"utf8",
-				),
+				[
+					"import { resolveClineDataDir } from '@clinebot/shared/storage';",
+					"import YAML from 'yaml';",
+					"export default {",
+					"  name: typeof resolveClineDataDir === 'function' ? YAML.stringify({ ok: true }) : 'invalid',",
+					"  manifest: { capabilities: ['tools'] },",
+					"};",
+				].join("\n"),
 				"utf8",
 			);
 
 			await expect(
-				loadAgentPluginFromPath(pluginPath, { cwd: dir }),
+				loadAgentPluginFromPath(pluginPath, { cwd: dir, useCache: true }),
 			).rejects.toThrow(/Cannot find (package|module) 'yaml'/i);
 		} finally {
 			await rm(dir, { recursive: true, force: true });

package/src/agents/plugin-loader.ts

@@ -17,6 +17,7 @@ type PluginLike = {
 export interface LoadAgentPluginFromPathOptions {
 	exportName?: string;
 	cwd?: string;
+	useCache?: boolean;
 }
 
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
@@ -130,12 +131,13 @@ function collectPluginImportAliases(
 
 async function importPluginModule(
 	absolutePath: string,
+	options: LoadAgentPluginFromPathOptions = {},
 ): Promise<Record<string, unknown>> {
 	const aliases = collectPluginImportAliases(absolutePath);
 	const jiti = createJiti(absolutePath, {
 		alias: aliases,
-		cache: false,
-		requireCache: false,
+		cache: options.useCache,
+		requireCache: options.useCache,
 		esmResolve: true,
 		interopDefault: false,
 		nativeModules: [...BUILTIN_MODULES],
@@ -149,7 +151,7 @@ export async function loadAgentPluginFromPath(
 	options: LoadAgentPluginFromPathOptions = {},
 ): Promise<AgentPlugin> {
 	const absolutePath = resolve(options.cwd ?? process.cwd(), pluginPath);
-	const moduleExports = await importPluginModule(absolutePath);
+	const moduleExports = await importPluginModule(absolutePath, options);
 	const exportName = options.exportName ?? "plugin";
 	const plugin = (moduleExports.default ??
 		moduleExports[exportName]) as unknown;

package/src/auth/cline.ts

@@ -180,35 +180,7 @@ async function requestAuthorizationUrl(
 	authUrl.searchParams.set("redirect_uri", params.callbackUrl);
 	authUrl.searchParams.set("state", params.state);
 
-	const response = await fetch(authUrl.toString(), {
-		method: "GET",
-		redirect: "manual",
-		headers: await resolveHeaders(options.headers),
-		signal: AbortSignal.timeout(
-			options.requestTimeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS,
-		),
-	});
-
-	if (response.status >= 300 && response.status < 400) {
-		const redirectUrl = response.headers.get("location");
-		if (redirectUrl) {
-			return redirectUrl;
-		}
-	}
-
-	if (!response.ok) {
-		const text = await response.text().catch(() => "");
-		throw new Error(
-			`Authentication request failed: ${response.status} ${text}`,
-		);
-	}
-
-	const body = (await response.json()) as { redirect_url?: string };
-	if (typeof body.redirect_url === "string" && body.redirect_url.length > 0) {
-		return body.redirect_url;
-	}
-
-	throw new Error("Authentication request did not return a redirect URL");
+	return authUrl.toString();
 }
 
 async function exchangeAuthorizationCode(

package/src/index.node.ts

@@ -138,6 +138,11 @@ export {
 	saveLocalProviderOAuthCredentials,
 	saveLocalProviderSettings,
 } from "./providers/local-provider-service";
+export type { AvailableRuntimeCommand } from "./runtime/commands";
+export {
+	listAvailableRuntimeCommandsFromWatcher,
+	resolveRuntimeSlashCommandFromWatcher,
+} from "./runtime/commands";
 export {
 	formatRulesForSystemPrompt,
 	isRuleEnabled,
@@ -159,6 +164,11 @@ export type {
 	RuntimeBuilderInput,
 	SessionRuntime,
 } from "./runtime/session-runtime";
+export type { AvailableSkill } from "./runtime/skills";
+export {
+	listAvailableSkillsFromWatcher,
+	resolveSkillsSlashCommandFromWatcher,
+} from "./runtime/skills";
 export {
 	type DesktopToolApprovalOptions,
 	requestDesktopToolApproval,

package/src/runtime/commands.test.ts

@@ -0,0 +1,98 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { createUserInstructionConfigWatcher } from "../agents";
+import {
+	listAvailableRuntimeCommandsFromWatcher,
+	resolveRuntimeSlashCommandFromWatcher,
+} from "./commands";
+
+describe("runtime command registry", () => {
+	const tempRoots: string[] = [];
+
+	afterEach(async () => {
+		await Promise.all(
+			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
+		);
+		tempRoots.length = 0;
+	});
+
+	it("lists workflow and skill commands together", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-runtime-commands-"));
+		tempRoots.push(tempRoot);
+		const skillDir = join(tempRoot, "skills", "debug");
+		const workflowsDir = join(tempRoot, "workflows");
+		await mkdir(skillDir, { recursive: true });
+		await mkdir(workflowsDir, { recursive: true });
+		await writeFile(join(skillDir, "SKILL.md"), "Use the debugging skill.");
+		await writeFile(
+			join(workflowsDir, "release.md"),
+			`---
+name: release
+---
+Run the release workflow.`,
+		);
+
+		const watcher = createUserInstructionConfigWatcher({
+			skills: { directories: [join(tempRoot, "skills")] },
+			rules: { directories: [] },
+			workflows: { directories: [workflowsDir] },
+		});
+
+		try {
+			await watcher.start();
+			expect(listAvailableRuntimeCommandsFromWatcher(watcher)).toEqual([
+				{
+					id: "debug",
+					name: "debug",
+					instructions: "Use the debugging skill.",
+					kind: "skill",
+				},
+				{
+					id: "release",
+					name: "release",
+					instructions: "Run the release workflow.",
+					kind: "workflow",
+				},
+			]);
+		} finally {
+			watcher.stop();
+		}
+	});
+
+	it("expands skill and workflow slash commands with workflow precedence", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-runtime-commands-"));
+		tempRoots.push(tempRoot);
+		const skillDir = join(tempRoot, "skills", "ship");
+		const workflowsDir = join(tempRoot, "workflows");
+		await mkdir(skillDir, { recursive: true });
+		await mkdir(workflowsDir, { recursive: true });
+		await writeFile(join(skillDir, "SKILL.md"), "Use the ship skill.");
+		await writeFile(
+			join(workflowsDir, "ship.md"),
+			`---
+name: ship
+---
+Run the ship workflow.`,
+		);
+
+		const watcher = createUserInstructionConfigWatcher({
+			skills: { directories: [join(tempRoot, "skills")] },
+			rules: { directories: [] },
+			workflows: { directories: [workflowsDir] },
+		});
+
+		try {
+			await watcher.start();
+			expect(resolveRuntimeSlashCommandFromWatcher("/ship", watcher)).toBe(
+				"Run the ship workflow.",
+			);
+			expect(resolveRuntimeSlashCommandFromWatcher("/ship now", watcher)).toBe(
+				"Run the ship workflow. now",
+			);
+		} finally {
+			watcher.stop();
+		}
+	});
+});

package/src/runtime/commands.ts

@@ -0,0 +1,83 @@
+import type {
+	SkillConfig,
+	UserInstructionConfigWatcher,
+	WorkflowConfig,
+} from "../agents";
+
+export type RuntimeCommandKind = "skill" | "workflow";
+
+export type AvailableRuntimeCommand = {
+	id: string;
+	name: string;
+	instructions: string;
+	kind: RuntimeCommandKind;
+};
+
+type CommandRecord = {
+	item: SkillConfig | WorkflowConfig;
+};
+
+function isCommandEnabled(command: SkillConfig | WorkflowConfig): boolean {
+	return command.disabled !== true;
+}
+
+function listCommandsForKind(
+	watcher: UserInstructionConfigWatcher,
+	kind: RuntimeCommandKind,
+): AvailableRuntimeCommand[] {
+	return [...watcher.getSnapshot(kind).entries()]
+		.map(([id, record]) => ({ id, record: record as CommandRecord }))
+		.filter(({ record }) => isCommandEnabled(record.item))
+		.map(({ id, record }) => ({
+			id,
+			name: record.item.name,
+			instructions: record.item.instructions,
+			kind,
+		}))
+		.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function listAvailableRuntimeCommandsFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+): AvailableRuntimeCommand[] {
+	const byName = new Map<string, AvailableRuntimeCommand>();
+	for (const command of [
+		...listCommandsForKind(watcher, "workflow"),
+		...listCommandsForKind(watcher, "skill"),
+	]) {
+		if (!byName.has(command.name)) {
+			byName.set(command.name, command);
+		}
+	}
+	return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function resolveRuntimeSlashCommandFromWatcher(
+	input: string,
+	watcher: UserInstructionConfigWatcher,
+): string {
+	if (!input.startsWith("/") || input.length < 2) {
+		return input;
+	}
+	const match = input.match(/^\/(\S+)/);
+	if (!match) {
+		return input;
+	}
+	const name = match[1];
+	if (!name) {
+		return input;
+	}
+	const commandLength = name.length + 1;
+	const remainder = input.slice(commandLength);
+	const matched = listAvailableRuntimeCommandsFromWatcher(watcher).find(
+		(command) => command.name === name,
+	);
+	return matched ? `${matched.instructions}${remainder}` : input;
+}
+
+export function listAvailableRuntimeCommandsForKindFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+	kind: RuntimeCommandKind,
+): AvailableRuntimeCommand[] {
+	return listCommandsForKind(watcher, kind);
+}

package/src/runtime/index.ts

@@ -1,3 +1,8 @@
+export {
+	type AvailableRuntimeCommand,
+	listAvailableRuntimeCommandsFromWatcher,
+	resolveRuntimeSlashCommandFromWatcher,
+} from "./commands";
 export {
 	formatRulesForSystemPrompt,
 	isRuleEnabled,
@@ -16,6 +21,11 @@ export type {
 	RuntimeBuilderInput,
 	SessionRuntime,
 } from "./session-runtime";
+export {
+	type AvailableSkill,
+	listAvailableSkillsFromWatcher,
+	resolveSkillsSlashCommandFromWatcher,
+} from "./skills";
 export {
 	type DesktopToolApprovalOptions,
 	requestDesktopToolApproval,

package/src/runtime/skills.ts

@@ -0,0 +1,44 @@
+import type { UserInstructionConfigWatcher } from "../agents";
+import {
+	listAvailableRuntimeCommandsForKindFromWatcher,
+	resolveRuntimeSlashCommandFromWatcher,
+} from "./commands";
+
+export type AvailableSkill = {
+	id: string;
+	name: string;
+	instructions: string;
+};
+
+function matchesLeadingSlashCommand(input: string, name: string): boolean {
+	const match = input.match(/^\/(\S+)/);
+	return match?.[1] === name;
+}
+
+export function listAvailableSkillsFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+): AvailableSkill[] {
+	return listAvailableRuntimeCommandsForKindFromWatcher(watcher, "skill").map(
+		(skill) => ({
+			id: skill.id,
+			name: skill.name,
+			instructions: skill.instructions,
+		}),
+	);
+}
+
+/**
+ * Expands a leading slash command (e.g. "/release") to skill instructions.
+ * If the input starts with "/<skill-name>", that prefix is replaced and the
+ * remaining input is preserved unchanged.
+ */
+export function resolveSkillsSlashCommandFromWatcher(
+	input: string,
+	watcher: UserInstructionConfigWatcher,
+): string {
+	const resolved = resolveRuntimeSlashCommandFromWatcher(input, watcher);
+	const matched = listAvailableSkillsFromWatcher(watcher).some((skill) =>
+		matchesLeadingSlashCommand(input, skill.name),
+	);
+	return matched ? resolved : input;
+}

package/src/runtime/workflows.ts

@@ -1,4 +1,8 @@
-import type { UserInstructionConfigWatcher, WorkflowConfig } from "../agents";
+import type { UserInstructionConfigWatcher } from "../agents";
+import {
+	listAvailableRuntimeCommandsForKindFromWatcher,
+	resolveRuntimeSlashCommandFromWatcher,
+} from "./commands";
 
 export type AvailableWorkflow = {
 	id: string;
@@ -6,23 +10,22 @@ export type AvailableWorkflow = {
 	instructions: string;
 };
 
-function isWorkflowEnabled(workflow: WorkflowConfig): boolean {
-	return workflow.disabled !== true;
+function matchesLeadingSlashCommand(input: string, name: string): boolean {
+	const match = input.match(/^\/(\S+)/);
+	return match?.[1] === name;
 }
 
 export function listAvailableWorkflowsFromWatcher(
 	watcher: UserInstructionConfigWatcher,
 ): AvailableWorkflow[] {
-	const snapshot = watcher.getSnapshot("workflow");
-	return [...snapshot.entries()]
-		.map(([id, record]) => ({ id, workflow: record.item as WorkflowConfig }))
-		.filter(({ workflow }) => isWorkflowEnabled(workflow))
-		.map(({ id, workflow }) => ({
-			id,
-			name: workflow.name,
-			instructions: workflow.instructions,
-		}))
-		.sort((a, b) => a.name.localeCompare(b.name));
+	return listAvailableRuntimeCommandsForKindFromWatcher(
+		watcher,
+		"workflow",
+	).map((workflow) => ({
+		id: workflow.id,
+		name: workflow.name,
+		instructions: workflow.instructions,
+	}));
 }
 
 /**
@@ -34,21 +37,9 @@ export function resolveWorkflowSlashCommandFromWatcher(
 	input: string,
 	watcher: UserInstructionConfigWatcher,
 ): string {
-	if (!input.startsWith("/") || input.length < 2) {
-		return input;
-	}
-	const match = input.match(/^\/(\S+)/);
-	if (!match) {
-		return input;
-	}
-	const workflowName = match[1];
-	if (!workflowName) {
-		return input;
-	}
-	const commandLength = workflowName.length + 1;
-	const remainder = input.slice(commandLength);
-	const matched = listAvailableWorkflowsFromWatcher(watcher).find(
-		(workflow) => workflow.name === workflowName,
+	const resolved = resolveRuntimeSlashCommandFromWatcher(input, watcher);
+	const matched = listAvailableWorkflowsFromWatcher(watcher).some((workflow) =>
+		matchesLeadingSlashCommand(input, workflow.name),
 	);
-	return matched ? `${matched.instructions}${remainder}` : input;
+	return matched ? resolved : input;
 }