@danypops/papyrus 0.44.9 → 0.44.10

package/src/cli/playbooks-command.ts

@@ -0,0 +1,313 @@
+import type { CommandContext } from "@stricli/core";
+import { buildApplication, buildCommand, buildRouteMap, numberParser } from "@stricli/core";
+import type { PapyrusClient } from "../client.ts";
+import type { OperationName } from "../service.ts";
+import { artifactLabel, type CliArtifact } from "./shared.ts";
+import { runStricliToString } from "./stricli-run.ts";
+
+type PlaybooksClient = Pick<PapyrusClient, "call">;
+
+interface PlaybooksContext extends CommandContext {
+	readonly client: PlaybooksClient;
+	readonly json: boolean;
+}
+
+function parseStringArray(value: string): string[] {
+	const parsed = JSON.parse(value) as unknown;
+	if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string")) throw new Error("value must be a JSON string array");
+	return parsed as string[];
+}
+
+function parseObject(value: string): Record<string, unknown> {
+	const parsed = JSON.parse(value) as unknown;
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("value must be a JSON object");
+	return parsed as Record<string, unknown>;
+}
+
+/**
+ * No further shape assertion here -- --arguments-json is genuinely polymorphic (an array on
+ * create, a {name: value} map on invoke) and --steps-json accepts a mix of plain prose strings
+ * and structured step objects that a single string-array assertion would wrongly reject. The
+ * service validates the real shape for whichever operation actually receives it. Typed as a
+ * concrete array-or-object union rather than bare `unknown` -- Stricli's flag-type inference
+ * doesn't correctly propagate a parser returning `unknown` through to the command function.
+ */
+function parseAny(value: string): unknown[] | Record<string, unknown> {
+	return JSON.parse(value) as unknown[] | Record<string, unknown>;
+}
+
+function render(this: PlaybooksContext, result: unknown, human: string): void {
+	this.process.stdout.write(this.json ? JSON.stringify(result) : human);
+}
+
+const createCommand = buildCommand({
+	func: async function (
+		this: PlaybooksContext,
+		flags: {
+			title: string;
+			body?: string;
+			trigger?: string;
+			stepsJson?: unknown[] | Record<string, unknown>;
+			toolsJson?: string[];
+			labelsJson?: string[];
+			extraJson?: Record<string, unknown>;
+			argumentsJson?: unknown[] | Record<string, unknown>;
+			projectRoot?: string;
+		},
+	) {
+		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("playbooks.create", {
+			title: flags.title,
+			body: flags.body,
+			trigger: flags.trigger,
+			steps: flags.stepsJson,
+			tools: flags.toolsJson,
+			labels: flags.labelsJson,
+			extra: flags.extraJson,
+			arguments: flags.argumentsJson,
+			project_root: flags.projectRoot,
+		});
+		render.call(this, artifact, `Created playbook: ${artifactLabel(artifact)}`);
+	},
+	parameters: {
+		flags: {
+			title: { brief: "Playbook title", kind: "parsed", parse: String, placeholder: "text" },
+			body: { brief: "Playbook body", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			trigger: { brief: "When this playbook applies", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			stepsJson: {
+				brief: "JSON array of steps (strings and/or {kind:'doc'|'rule'|'call'|'task',...} objects)",
+				kind: "parsed",
+				parse: parseAny,
+				placeholder: "json",
+				optional: true,
+			},
+			toolsJson: { brief: "JSON string array of tool names", kind: "parsed", parse: parseStringArray, placeholder: "json", optional: true },
+			labelsJson: { brief: "JSON string array of labels", kind: "parsed", parse: parseStringArray, placeholder: "json", optional: true },
+			extraJson: { brief: "JSON object of extra fields", kind: "parsed", parse: parseObject, placeholder: "json", optional: true },
+			argumentsJson: {
+				brief: "JSON array of declared argument definitions",
+				kind: "parsed",
+				parse: parseAny,
+				placeholder: "json",
+				optional: true,
+			},
+			projectRoot: { brief: "Project scope", kind: "parsed", parse: String, placeholder: "path", optional: true },
+		},
+	},
+	docs: { brief: "Create a Playbook" },
+});
+
+const listCommand = buildCommand({
+	func: async function (this: PlaybooksContext, flags: { status?: string; text?: string; limit?: number; projectRoot?: string }) {
+		const rows = await this.client.call<Record<string, unknown>, CliArtifact[]>("playbooks.list", {
+			status: flags.status,
+			text: flags.text,
+			limit: flags.limit,
+			project_root: flags.projectRoot,
+		});
+		render.call(this, rows, rows.length === 0 ? "No playbooks found." : rows.map((row) => artifactLabel(row)).join("\n"));
+	},
+	parameters: {
+		flags: {
+			status: { brief: "Filter by status", kind: "parsed", parse: String, placeholder: "status", optional: true },
+			text: { brief: "Substring match against title/body", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			limit: { brief: "Maximum playbooks to return", kind: "parsed", parse: numberParser, optional: true },
+			projectRoot: { brief: "Project scope", kind: "parsed", parse: String, placeholder: "path", optional: true },
+		},
+	},
+	docs: { brief: "List Playbooks" },
+});
+
+const showCommand = buildCommand({
+	func: async function (this: PlaybooksContext, _flags: Record<string, never>, id: string) {
+		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("playbooks.show", { id });
+		render.call(this, artifact, `${artifactLabel(artifact)}\n\n${artifact.body ?? ""}`);
+	},
+	parameters: { flags: {}, positional: { kind: "tuple", parameters: [{ brief: "Playbook id", parse: String, placeholder: "id" }] } },
+	docs: { brief: "Show one Playbook" },
+});
+
+const previewCommand = buildCommand({
+	func: async function (this: PlaybooksContext, flags: { argumentsJson?: unknown[] | Record<string, unknown> }, id: string) {
+		const rendered = await this.client.call<Record<string, unknown>, string>("playbooks.preview", { id, arguments: flags.argumentsJson });
+		render.call(this, rendered, rendered);
+	},
+	parameters: {
+		flags: {
+			argumentsJson: {
+				brief: "JSON object supplying argument values",
+				kind: "parsed",
+				parse: parseAny,
+				placeholder: "json",
+				optional: true,
+			},
+		},
+		positional: { kind: "tuple", parameters: [{ brief: "Playbook id", parse: String, placeholder: "id" }] },
+	},
+	docs: { brief: "Render a Playbook's whole composition tree as text, creating nothing" },
+});
+
+const invokeCommand = buildCommand({
+	func: async function (
+		this: PlaybooksContext,
+		flags: { argumentsJson?: unknown[] | Record<string, unknown>; runId?: string; projectRoot?: string },
+		id: string,
+	) {
+		const invocation = await this.client.call<Record<string, unknown>, { entryTaskId: string; missingArguments?: string[] }>(
+			"playbooks.invoke",
+			{ id, arguments: flags.argumentsJson, run_id: flags.runId, project_root: flags.projectRoot },
+		);
+		render.call(
+			this,
+			invocation,
+			invocation.missingArguments
+				? `Missing required argument(s): ${invocation.missingArguments.join(", ")}.`
+				: `Invoked: entry task ${invocation.entryTaskId} focused. Drive it forward with \`tasks start/submit/complete\` like any other task.`,
+		);
+	},
+	parameters: {
+		flags: {
+			argumentsJson: {
+				brief: "JSON object supplying argument values",
+				kind: "parsed",
+				parse: parseAny,
+				placeholder: "json",
+				optional: true,
+			},
+			runId: { brief: "Run id to associate with this invocation", kind: "parsed", parse: String, placeholder: "id", optional: true },
+			projectRoot: { brief: "Project scope", kind: "parsed", parse: String, placeholder: "path", optional: true },
+		},
+		positional: { kind: "tuple", parameters: [{ brief: "Playbook id", parse: String, placeholder: "id" }] },
+	},
+	docs: { brief: "Compile a Playbook's steps into real Tasks and focus the first one" },
+});
+
+function buildEnableDisableCommand(action: "enable" | "disable") {
+	return buildCommand({
+		func: async function (this: PlaybooksContext, _flags: Record<string, never>, id: string) {
+			const artifact = await this.client.call<Record<string, unknown>, CliArtifact>(`playbooks.${action}` as OperationName, { id });
+			render.call(this, artifact, artifactLabel(artifact));
+		},
+		parameters: { flags: {}, positional: { kind: "tuple", parameters: [{ brief: "Playbook id", parse: String, placeholder: "id" }] } },
+		docs: { brief: `${action[0]!.toUpperCase()}${action.slice(1)} a Playbook` },
+	});
+}
+
+const assignProjectCommand = buildCommand({
+	func: async function (this: PlaybooksContext, _flags: Record<string, never>, id: string, projectRoot?: string) {
+		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("playbooks.assign_project", {
+			id,
+			project_root: projectRoot,
+		});
+		render.call(this, artifact, projectRoot ? `Assigned ${id} to ${projectRoot}` : `Unscoped ${id}`);
+	},
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple",
+			parameters: [
+				{ brief: "Playbook id", parse: String, placeholder: "id" },
+				{ brief: "New project scope, omit to unscope", parse: String, placeholder: "project-root", optional: true },
+			],
+		},
+	},
+	docs: { brief: "Reassign a Playbook's project scope, or unscope it" },
+});
+
+const updateCommand = buildCommand({
+	func: async function (this: PlaybooksContext, flags: { title?: string; body?: string; labelsJson?: string[] }, id: string) {
+		if (flags.title === undefined && flags.body === undefined && flags.labelsJson === undefined)
+			throw new Error("playbooks update requires --title, --body, or --labels-json");
+		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("playbooks.update", {
+			id,
+			title: flags.title,
+			body: flags.body,
+			labels: flags.labelsJson,
+		});
+		render.call(this, artifact, artifactLabel(artifact));
+	},
+	parameters: {
+		flags: {
+			title: { brief: "New title", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			body: { brief: "New body", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			labelsJson: { brief: "JSON string array of labels", kind: "parsed", parse: parseStringArray, placeholder: "json", optional: true },
+		},
+		positional: { kind: "tuple", parameters: [{ brief: "Playbook id", parse: String, placeholder: "id" }] },
+	},
+	docs: { brief: "Change a Playbook's title/body/labels" },
+});
+
+function buildPairedIdCommand(
+	operation: OperationName,
+	fields: readonly [string, string],
+	human: (artifact: CliArtifact, second: string) => string,
+	brief: string,
+) {
+	return buildCommand({
+		func: async function (this: PlaybooksContext, _flags: Record<string, never>, first: string, second: string) {
+			const artifact = await this.client.call<Record<string, unknown>, CliArtifact>(operation, {
+				[fields[0]]: first,
+				[fields[1]]: second,
+			});
+			render.call(this, artifact, human(artifact, second));
+		},
+		parameters: {
+			flags: {},
+			positional: {
+				kind: "tuple",
+				parameters: [
+					{ brief: "First playbook id", parse: String, placeholder: "id" },
+					{ brief: "Second playbook id", parse: String, placeholder: "id" },
+				],
+			},
+		},
+		docs: { brief },
+	});
+}
+
+const app = buildApplication(
+	buildRouteMap({
+		routes: {
+			create: createCommand,
+			list: listCommand,
+			show: showCommand,
+			preview: previewCommand,
+			invoke: invokeCommand,
+			enable: buildEnableDisableCommand("enable"),
+			disable: buildEnableDisableCommand("disable"),
+			"assign-project": assignProjectCommand,
+			update: updateCommand,
+			contain: buildPairedIdCommand(
+				"playbooks.contain",
+				["parent_id", "child_id"],
+				(artifact, second) => `Nested: ${second} → ${artifactLabel(artifact)}`,
+				"Nest a child Playbook inside a parent",
+			),
+			uncontain: buildPairedIdCommand(
+				"playbooks.uncontain",
+				["parent_id", "child_id"],
+				(artifact, second) => `Removed ${second} from ${artifactLabel(artifact)}`,
+				"Remove a parent/child Playbook nesting",
+			),
+			depend: buildPairedIdCommand(
+				"playbooks.depend",
+				["id", "dependency_id"],
+				(artifact, second) => `Dependency added: ${artifactLabel(artifact)} waits for ${second}`,
+				"Chain a prerequisite Playbook before another",
+			),
+			undepend: buildPairedIdCommand(
+				"playbooks.undepend",
+				["id", "dependency_id"],
+				(artifact, second) => `Dependency removed: ${artifactLabel(artifact)} no longer waits for ${second}`,
+				"Remove a Playbook dependency",
+			),
+		},
+		docs: { brief: "Playbook operations" },
+	}),
+	{ name: "playbooks", scanner: { caseStyle: "allow-kebab-for-camel" } },
+);
+
+export async function runPlaybooksCli(args: string[], client: PlaybooksClient): Promise<string> {
+	const json = args.includes("--json");
+	const positional = args.filter((arg) => arg !== "--json");
+	return runStricliToString(app, positional, { client, json });
+}

package/src/cli/rules-command.ts

@@ -0,0 +1,220 @@
+import type { CommandContext } from "@stricli/core";
+import { buildApplication, buildCommand, buildRouteMap, numberParser } from "@stricli/core";
+import type { PapyrusClient } from "../client.ts";
+import type { OperationName } from "../service.ts";
+import { artifactLabel, type CliArtifact } from "./shared.ts";
+import { runStricliToString } from "./stricli-run.ts";
+
+type RulesClient = Pick<PapyrusClient, "call">;
+
+interface RulesContext extends CommandContext {
+	readonly client: RulesClient;
+	readonly json: boolean;
+	/** The caller's own project root -- distinct from any --project-root flag; only `injectable` uses this. */
+	readonly callerProjectRoot: string;
+}
+
+function parseStringArray(value: string): string[] {
+	const parsed = JSON.parse(value) as unknown;
+	if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string")) throw new Error("value must be a JSON string array");
+	return parsed as string[];
+}
+
+function parseObject(value: string): Record<string, unknown> {
+	const parsed = JSON.parse(value) as unknown;
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("value must be a JSON object");
+	return parsed as Record<string, unknown>;
+}
+
+function render(this: RulesContext, result: unknown, human: string): void {
+	this.process.stdout.write(this.json ? JSON.stringify(result) : human);
+}
+
+const createCommand = buildCommand({
+	func: async function (
+		this: RulesContext,
+		flags: {
+			title: string;
+			body?: string;
+			condition?: string;
+			ruleAction?: string;
+			severity?: string;
+			labelsJson?: string[];
+			extraJson?: Record<string, unknown>;
+			projectRoot?: string;
+		},
+	) {
+		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("rules.create", {
+			title: flags.title,
+			body: flags.body,
+			condition: flags.condition,
+			rule_action: flags.ruleAction,
+			severity: flags.severity,
+			labels: flags.labelsJson,
+			extra: flags.extraJson,
+			project_root: flags.projectRoot,
+		});
+		render.call(this, artifact, `Created rule: ${artifactLabel(artifact)}`);
+	},
+	parameters: {
+		flags: {
+			title: { brief: "Rule title", kind: "parsed", parse: String, placeholder: "text" },
+			body: { brief: "Rule body", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			condition: { brief: "When this rule applies", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			ruleAction: { brief: "What the rule requires", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			severity: { brief: "block|warn|info", kind: "parsed", parse: String, placeholder: "severity", optional: true },
+			labelsJson: { brief: "JSON string array of labels", kind: "parsed", parse: parseStringArray, placeholder: "json", optional: true },
+			extraJson: { brief: "JSON object of extra fields", kind: "parsed", parse: parseObject, placeholder: "json", optional: true },
+			projectRoot: { brief: "Project scope", kind: "parsed", parse: String, placeholder: "path", optional: true },
+		},
+	},
+	docs: { brief: "Create a Rule" },
+});
+
+const listCommand = buildCommand({
+	func: async function (this: RulesContext, flags: { status?: string; text?: string; limit?: number; projectRoot?: string }) {
+		const rows = await this.client.call<Record<string, unknown>, CliArtifact[]>("rules.list", {
+			status: flags.status,
+			text: flags.text,
+			limit: flags.limit,
+			project_root: flags.projectRoot,
+		});
+		render.call(this, rows, rows.length === 0 ? "No rules found." : rows.map((row) => artifactLabel(row)).join("\n"));
+	},
+	parameters: {
+		flags: {
+			status: { brief: "Filter by status", kind: "parsed", parse: String, placeholder: "status", optional: true },
+			text: { brief: "Substring match against title/body", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			limit: { brief: "Maximum rules to return", kind: "parsed", parse: numberParser, optional: true },
+			projectRoot: { brief: "Project scope", kind: "parsed", parse: String, placeholder: "path", optional: true },
+		},
+	},
+	docs: { brief: "List Rules" },
+});
+
+const assignProjectCommand = buildCommand({
+	func: async function (this: RulesContext, _flags: Record<string, never>, id: string, projectRoot?: string) {
+		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("rules.assign_project", {
+			id,
+			project_root: projectRoot,
+		});
+		render.call(this, artifact, projectRoot ? `Assigned ${id} to ${projectRoot}` : `Unscoped ${id}`);
+	},
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple",
+			parameters: [
+				{ brief: "Rule id", parse: String, placeholder: "id" },
+				{ brief: "New project scope, omit to unscope", parse: String, placeholder: "project-root", optional: true },
+			],
+		},
+	},
+	docs: { brief: "Reassign a Rule's project scope, or unscope it" },
+});
+
+const showCommand = buildCommand({
+	func: async function (this: RulesContext, _flags: Record<string, never>, id: string) {
+		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("rules.show", { id });
+		render.call(this, artifact, `${artifactLabel(artifact)}\n\n${artifact.body ?? ""}`);
+	},
+	parameters: { flags: {}, positional: { kind: "tuple", parameters: [{ brief: "Rule id", parse: String, placeholder: "id" }] } },
+	docs: { brief: "Show one Rule" },
+});
+
+const previewCommand = buildCommand({
+	func: async function (this: RulesContext, _flags: Record<string, never>, id: string) {
+		const preview = await this.client.call<Record<string, unknown>, string>("rules.preview", { id });
+		render.call(this, preview, preview);
+	},
+	parameters: { flags: {}, positional: { kind: "tuple", parameters: [{ brief: "Rule id", parse: String, placeholder: "id" }] } },
+	docs: { brief: "Render a Rule's own condition/action/body preview text" },
+});
+
+function buildEnableDisableCommand(action: "enable" | "disable") {
+	return buildCommand({
+		func: async function (this: RulesContext, _flags: Record<string, never>, id: string) {
+			const artifact = await this.client.call<Record<string, unknown>, CliArtifact>(`rules.${action}` as OperationName, { id });
+			render.call(this, artifact, artifactLabel(artifact));
+		},
+		parameters: { flags: {}, positional: { kind: "tuple", parameters: [{ brief: "Rule id", parse: String, placeholder: "id" }] } },
+		docs: { brief: `${action[0]!.toUpperCase()}${action.slice(1)} a Rule` },
+	});
+}
+
+const gateCommand = buildCommand({
+	func: async function (this: RulesContext, _flags: Record<string, never>, id: string, taskId: string) {
+		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("rules.gate", { id, task_id: taskId });
+		render.call(this, artifact, `Gated ${taskId} with rule ${artifactLabel(artifact)}`);
+	},
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple",
+			parameters: [
+				{ brief: "Rule id", parse: String, placeholder: "rule-id" },
+				{ brief: "Task id to gate", parse: String, placeholder: "task-id" },
+			],
+		},
+	},
+	docs: { brief: "Attach a Rule as a gate condition on a Task" },
+});
+
+const injectableCommand = buildCommand({
+	func: async function (this: RulesContext) {
+		const rows = await this.client.call<Record<string, unknown>, CliArtifact[]>("rules.injectable", {
+			project_root: this.callerProjectRoot,
+		});
+		render.call(this, rows, rows.length === 0 ? "No injectable rules." : rows.map((row) => row.title).join("\n"));
+	},
+	parameters: { flags: {} },
+	docs: { brief: "List Rules currently injectable into the agent system prompt for this project" },
+});
+
+const updateCommand = buildCommand({
+	func: async function (this: RulesContext, flags: { title?: string; body?: string; labelsJson?: string[] }, id: string) {
+		if (flags.title === undefined && flags.body === undefined && flags.labelsJson === undefined)
+			throw new Error("rules update requires --title, --body, or --labels-json");
+		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("rules.update", {
+			id,
+			title: flags.title,
+			body: flags.body,
+			labels: flags.labelsJson,
+		});
+		render.call(this, artifact, artifactLabel(artifact));
+	},
+	parameters: {
+		flags: {
+			title: { brief: "New title", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			body: { brief: "New body", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			labelsJson: { brief: "JSON string array of labels", kind: "parsed", parse: parseStringArray, placeholder: "json", optional: true },
+		},
+		positional: { kind: "tuple", parameters: [{ brief: "Rule id", parse: String, placeholder: "id" }] },
+	},
+	docs: { brief: "Change a Rule's title/body/labels" },
+});
+
+const app = buildApplication(
+	buildRouteMap({
+		routes: {
+			create: createCommand,
+			list: listCommand,
+			"assign-project": assignProjectCommand,
+			show: showCommand,
+			preview: previewCommand,
+			enable: buildEnableDisableCommand("enable"),
+			disable: buildEnableDisableCommand("disable"),
+			gate: gateCommand,
+			injectable: injectableCommand,
+			update: updateCommand,
+		},
+		docs: { brief: "Rule operations" },
+	}),
+	{ name: "rules", scanner: { caseStyle: "allow-kebab-for-camel" } },
+);
+
+export async function runRulesCli(args: string[], client: RulesClient, projectRoot: string = process.cwd()): Promise<string> {
+	const json = args.includes("--json");
+	const positional = args.filter((arg) => arg !== "--json");
+	return runStricliToString(app, positional, { client, json, callerProjectRoot: projectRoot });
+}

package/src/cli/session-identity-command.ts

@@ -0,0 +1,58 @@
+import type { CommandContext } from "@stricli/core";
+import { buildApplication, buildCommand, buildRouteMap } from "@stricli/core";
+import type { PapyrusClient } from "../client.ts";
+import { runStricliToString } from "./stricli-run.ts";
+
+type SessionIdentityClient = Pick<PapyrusClient, "call">;
+
+interface SessionIdentityContext extends CommandContext {
+	readonly client: SessionIdentityClient;
+	readonly json: boolean;
+}
+
+function render(this: SessionIdentityContext, result: unknown): void {
+	this.process.stdout.write(this.json ? JSON.stringify(result) : JSON.stringify(result, null, 2));
+}
+
+const registerCommand = buildCommand({
+	func: async function (this: SessionIdentityContext, flags: { sessionId: string }) {
+		const result = await this.client.call<Record<string, unknown>, { sessionId: string; secret: string }>("session.register", {
+			session_id: flags.sessionId,
+		});
+		render.call(this, result);
+	},
+	parameters: {
+		flags: {
+			sessionId: { brief: "Session id to register", kind: "parsed", parse: String, placeholder: "id" },
+		},
+	},
+	docs: { brief: "Register a session identity, receiving back a secret for later mutations" },
+});
+
+const releaseCommand = buildCommand({
+	func: async function (this: SessionIdentityContext, flags: { sessionId: string; sessionSecret?: string }) {
+		const result = await this.client.call<Record<string, unknown>, { released: boolean }>("session.release", {
+			session_id: flags.sessionId,
+			...(flags.sessionSecret ? { session_secret: flags.sessionSecret } : {}),
+		});
+		render.call(this, result);
+	},
+	parameters: {
+		flags: {
+			sessionId: { brief: "Session id to release", kind: "parsed", parse: String, placeholder: "id" },
+			sessionSecret: { brief: "Secret returned at registration", kind: "parsed", parse: String, placeholder: "secret", optional: true },
+		},
+	},
+	docs: { brief: "Release a registered session identity" },
+});
+
+const app = buildApplication(
+	buildRouteMap({ routes: { register: registerCommand, release: releaseCommand }, docs: { brief: "Session identity operations" } }),
+	{ name: "session", scanner: { caseStyle: "allow-kebab-for-camel" } },
+);
+
+export async function runSessionIdentityCli(args: string[], client: SessionIdentityClient): Promise<string> {
+	const json = args.includes("--json");
+	const positional = args.filter((arg) => arg !== "--json");
+	return runStricliToString(app, positional, { client, json });
+}

package/src/cli/shared.ts

@@ -0,0 +1,5 @@
+export type CliArtifact = { id: string; alias: string; title: string; status: string; body?: string };
+
+export function artifactLabel(artifact: CliArtifact): string {
+	return `${artifact.alias} ${artifact.title}`;
+}

package/src/cli/stricli-run.ts

@@ -0,0 +1,30 @@
+import type { Application, CommandContext } from "@stricli/core";
+import { run } from "@stricli/core";
+
+/**
+ * Every run*Cli export keeps the pre-Stricli (args, client) => Promise<string> contract so
+ * test/cli-parity.test.ts and cli.ts's main() dispatch don't need to change per migrated command.
+ * Stricli itself never throws for a user-facing failure (invalid flag, unknown route) -- it
+ * writes to context.process.stderr and sets context.process.exitCode instead -- so this captures
+ * both in memory and converts a nonzero exit code back into a thrown Error to match every other
+ * run*Cli function's own contract.
+ */
+export async function runStricliToString<CONTEXT extends CommandContext>(
+	app: Application<CONTEXT>,
+	args: string[],
+	contextWithoutProcess: Omit<CONTEXT, "process">,
+): Promise<string> {
+	const chunks: string[] = [];
+	const errors: string[] = [];
+	const process: {
+		stdout: { write: (text: string) => void };
+		stderr: { write: (text: string) => void };
+		exitCode?: number | string | null;
+	} = {
+		stdout: { write: (text: string) => chunks.push(text) },
+		stderr: { write: (text: string) => errors.push(text) },
+	};
+	await run(app, args, { ...contextWithoutProcess, process } as CONTEXT);
+	if (process.exitCode) throw new Error(errors.join("").trim() || `command failed with exit code ${process.exitCode}`);
+	return chunks.join("");
+}