peaks-loop 4.0.54 → 4.1.1

package/dist/cli/commands/workflow-lifecycle-commands.js

@@ -11,18 +11,16 @@ import { addJsonOption, printResult } from '../cli-helpers.js';
 import { resolveCallerId } from '../../services/session/resolve-caller-id.js';
 import { findProjectRoot } from '../../services/config/config-safety.js';
 import { getCurrentSessionId } from '../../services/skills/skill-presence-service.js';
-import { initWorkflow, terminalizeWorkflow, } from '../../services/workflow/workflow-presence-lifecycle.js';
+import { initWorkflow, terminalizeWorkflow } from '../../services/workflow/workflow-presence-lifecycle.js';
 import { readGraph, emptyGraph } from '../../services/workflow/workflow-graph-store.js';
 import { WORKFLOW_ID_REGEX, TERMINAL_REASONS } from '../../services/workflow/workflow-graph-types.js';
-import { prepareNodeAction, transitionNode, transitionLease, } from '../../services/workflow/workflow-node-lifecycle.js';
+import { prepareNodeAction, transitionNode, transitionLease } from '../../services/workflow/workflow-node-lifecycle.js';
 function deriveCallerId() {
     try {
         return resolveCallerId({});
     }
     catch (err) {
-        throw fail('workflow.init', 'PEAKS_CALLER_NOT_RESOLVED', getErrorMessage(err), { callerId: null }, [
-            'Resolve the IDE session identity before running workflow commands.',
-        ]);
+        throw fail('workflow.init', 'PEAKS_CALLER_NOT_RESOLVED', getErrorMessage(err), { callerId: null }, ['Resolve the IDE session identity before running workflow commands.']);
     }
 }
 function deriveProjectRoot(options) {
@@ -71,7 +69,7 @@ function deriveSessionId(options) {
     const fromEnv = process.env.PEAKS_SESSION_ID;
     if (typeof fromEnv === 'string' && fromEnv.length > 0)
         return fromEnv;
-    return getCurrentSessionId(findProjectRoot(options.project ?? process.cwd()) ?? (options.project ?? process.cwd())) ?? UNKNOWN_SESSION_ID;
+    return (getCurrentSessionId(findProjectRoot(options.project ?? process.cwd()) ?? options.project ?? process.cwd()) ?? UNKNOWN_SESSION_ID);
 }
 /**
  * Tier 3 resolving to `unknown-sid` means NO session is bound at all. A
@@ -82,7 +80,7 @@ function deriveSessionId(options) {
 function buildSessionNotBoundEnvelope(sessionId, projectRoot) {
     return fail('workflow.init', 'PEAKS_SESSION_NOT_BOUND', `No peaks session is bound for '${projectRoot}' (derived session id '${sessionId}'): --session-id, PEAKS_SESSION_ID and the project binding are all absent.`, { workflowId: null }, [
         'Run `peaks workspace init --project <p>` to bind a session, then re-run.',
-        'Or pass `--session-id <sid>` explicitly.',
+        'Or pass `--session-id <sid>` explicitly.'
     ]);
 }
 export function registerWorkflowLifecycleCommand(parent, io) {
@@ -90,7 +88,8 @@ export function registerWorkflowLifecycleCommand(parent, io) {
     // to avoid Commander.js's "cannot add command 'workflow' as already have
     // command 'workflow'" duplicate-registration throw at CLI startup.
     const existingWorkflow = parent.commands.find((c) => c.name() === 'workflow');
-    const workflow = existingWorkflow ?? parent.command('workflow').description('workflow lifecycle commands (RD §4)');
+    const workflow = existingWorkflow ??
+        parent.command('workflow').description('workflow lifecycle commands (RD §4)');
     addJsonOption(workflow
         .command('init')
         .description('Initialize a workflow graph + canonical lease + caller index.')
@@ -119,13 +118,13 @@ export function registerWorkflowLifecycleCommand(parent, io) {
                 callerId,
                 skill: options.skill ?? 'peaks-code',
                 workflowId,
-                ...(options.parentWorkflow ? { parentWorkflowId: options.parentWorkflow } : {}),
+                ...(options.parentWorkflow ? { parentWorkflowId: options.parentWorkflow } : {})
             });
             printResult(io, ok('workflow.init', {
                 envelopeVersion: '4.0.8',
                 workflowId: result.workflowId,
                 graphRef: result.graphRef,
-                events: result.events,
+                events: result.events
             }), asJson);
         }
         catch (err) {
@@ -161,7 +160,7 @@ export function registerWorkflowLifecycleCommand(parent, io) {
                 projectRoot,
                 sessionId,
                 graphRef: `graphs/${workflowId}.json`,
-                workflowId,
+                workflowId
             });
             printResult(io, ok('workflow.graph.show', { envelopeVersion: '4.0.8', graph }), asJson);
         }
@@ -221,7 +220,10 @@ export function registerWorkflowLifecycleCommand(parent, io) {
             const existing = readGraph({ projectRoot, sessionId, graphRef, workflowId });
             const nodeId = options.node ?? `node-${Date.now().toString(36)}`;
             const kind = (options.kind ?? 'step');
-            const dependsOn = (options.dependsOn ?? '').split(',').map((s) => s.trim()).filter((s) => s.length > 0);
+            const dependsOn = (options.dependsOn ?? '')
+                .split(',')
+                .map((s) => s.trim())
+                .filter((s) => s.length > 0);
             const updated = prepareNodeAction({
                 workflowId,
                 nodeId,
@@ -230,10 +232,10 @@ export function registerWorkflowLifecycleCommand(parent, io) {
                     kind,
                     label: options.label ?? nodeId,
                     status: 'prepared',
-                    dependsOn,
+                    dependsOn
                 },
                 dependsOn,
-                status: 'prepared',
+                status: 'prepared'
             });
             // Persist via the graph store
             // (not inlined so the CLI delegates everything to the service).
@@ -306,7 +308,7 @@ export function registerWorkflowLifecycleCommand(parent, io) {
                 workflowId,
                 nodeId,
                 status: 'lost',
-                terminalReason: reason,
+                terminalReason: reason
             }), asJson);
         }
         catch (err) {
@@ -341,14 +343,14 @@ export function registerWorkflowLifecycleCommand(parent, io) {
                 workflowId,
                 graphRef: `graphs/${workflowId}.json`,
                 reason: options.reason,
-                ...(options.requireConsumed ? { requireConsumed: true } : {}),
+                ...(options.requireConsumed ? { requireConsumed: true } : {})
             });
             printResult(io, ok('workflow.terminalize', {
                 envelopeVersion: '4.0.8',
                 lease: result.lease,
                 graph: result.graph,
                 events: result.events,
-                indexCleared: result.indexCleared,
+                indexCleared: result.indexCleared
             }), asJson);
         }
         catch (err) {

package/dist/cli/commands/workflow-plan-commands-actions.d.ts

@@ -0,0 +1,20 @@
+import { type ProgramIO } from '../cli-helpers.js';
+export interface PlanReadOptions {
+    readonly type: string;
+    readonly project?: string;
+    readonly sessionId?: string;
+    readonly json?: boolean;
+}
+export interface PlanRefreshOptions extends PlanReadOptions {
+    readonly apply?: boolean;
+}
+export interface PlanDetectTriggerOptions {
+    readonly project?: string;
+    readonly rid?: string;
+    readonly sessionId?: string;
+    readonly refresh?: boolean;
+    readonly json?: boolean;
+}
+export declare function runPlanRead(io: ProgramIO, options: PlanReadOptions): void;
+export declare function runPlanRefresh(io: ProgramIO, options: PlanRefreshOptions): void;
+export declare function runPlanDetectTrigger(io: ProgramIO, options: PlanDetectTriggerOptions): void;

package/dist/cli/commands/workflow-plan-commands-actions.js

@@ -0,0 +1,115 @@
+/**
+ * Action handlers for the `peaks workflow plan` subcommands (slice 025).
+ *
+ * Extracted from `workflow-plan-commands.ts` (strict-remediation c1). The
+ * command registration re-exports these as its programmatic test entry points.
+ * Behaviour is unchanged: each command still emits its own `workflow.plan.*`
+ * envelope, and session/project resolution delegates to the shared
+ * `workflow-plan-commands-session` module instead of four per-command copies.
+ */
+import { fail, getErrorMessage } from 'peaks-loop-shared/result';
+import { printResult } from '../cli-helpers.js';
+import { readPlan } from '../../services/workflow/plan-reader.js';
+import { refreshPlan } from '../../services/workflow/plan-refresher.js';
+import { detectTrigger } from '../../services/workflow/plan-trigger-detector.js';
+import { resolveProjectRoot, resolveSessionId } from './workflow-plan-commands-session.js';
+const VALID_TYPES = ['security', 'perf'];
+// F-1 (slice 025 security): reject rids that contain path separators,
+// null bytes, or traversal sequences.
+const REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function isPlanType(value) {
+    return VALID_TYPES.includes(value);
+}
+function isValidRequestId(value) {
+    return REQUEST_ID_PATTERN.test(value);
+}
+function invalidPlanTypeResult(command, type) {
+    return fail(command, 'INVALID_TYPE', `Unsupported plan type: ${type}`, { supportedTypes: VALID_TYPES }, ['Use --type security or --type perf']);
+}
+export function runPlanRead(io, options) {
+    if (!isPlanType(options.type)) {
+        printResult(io, invalidPlanTypeResult('workflow.plan.read', options.type), options.json === true);
+        process.exitCode = 1;
+        return;
+    }
+    const projectRoot = resolveProjectRoot(options.project);
+    const sessionId = resolveSessionId({ io, command: 'workflow.plan.read', asJson: options.json }, projectRoot, options.sessionId);
+    if (sessionId === null)
+        return;
+    try {
+        const result = readPlan({ type: options.type, project: projectRoot, sessionId });
+        printResult(io, result, options.json === true);
+    }
+    catch (error) {
+        printResult(io, fail('workflow.plan.read', 'READ_FAILED', getErrorMessage(error), null, [
+            'Check that --project is a valid repo root with a peaks session'
+        ]), options.json === true);
+        process.exitCode = 1;
+    }
+}
+export function runPlanRefresh(io, options) {
+    if (!isPlanType(options.type)) {
+        printResult(io, invalidPlanTypeResult('workflow.plan.refresh', options.type), options.json === true);
+        process.exitCode = 1;
+        return;
+    }
+    const projectRoot = resolveProjectRoot(options.project);
+    const sessionId = resolveSessionId({ io, command: 'workflow.plan.refresh', asJson: options.json }, projectRoot, options.sessionId);
+    if (sessionId === null)
+        return;
+    try {
+        const result = refreshPlan({
+            type: options.type,
+            project: projectRoot,
+            sessionId,
+            apply: options.apply === true
+        });
+        printResult(io, result, options.json === true);
+    }
+    catch (error) {
+        printResult(io, fail('workflow.plan.refresh', 'REFRESH_FAILED', getErrorMessage(error), null, [
+            'Check that --project is a valid repo root and the session exists'
+        ]), options.json === true);
+        process.exitCode = 1;
+    }
+}
+function missingRidResult(command) {
+    return fail(command, 'MISSING_RID', 'Missing --rid', null, ['Pass --rid <request-id>']);
+}
+function invalidRidResult(command, rid) {
+    return fail(command, 'INVALID_RID', 'request id must match [A-Za-z0-9][A-Za-z0-9._-]*', { rid }, [
+        'Pass --rid <alphanumeric.request-id>'
+    ]);
+}
+export function runPlanDetectTrigger(io, options) {
+    const command = 'workflow.plan.detect-trigger';
+    if (options.rid === undefined || options.rid === '') {
+        printResult(io, missingRidResult(command), options.json === true);
+        process.exitCode = 1;
+        return;
+    }
+    if (!isValidRequestId(options.rid)) {
+        printResult(io, invalidRidResult(command, options.rid), options.json === true);
+        process.exitCode = 1;
+        return;
+    }
+    const projectRoot = resolveProjectRoot(options.project);
+    const sessionId = resolveSessionId({ io, command, asJson: options.json }, projectRoot, options.sessionId);
+    if (sessionId === null)
+        return;
+    try {
+        const result = detectTrigger({
+            project: projectRoot,
+            rid: options.rid,
+            sessionId,
+            ...(options.refresh === true ? { manualOverride: true } : {})
+        });
+        printResult(io, result, options.json === true);
+    }
+    catch (error) {
+        printResult(io, fail('workflow.plan.detect-trigger', 'DETECT_FAILED', getErrorMessage(error), null, [
+            'Check that --project is a valid repo root and --rid is set'
+        ]), options.json === true);
+        process.exitCode = 1;
+    }
+}

package/dist/cli/commands/workflow-plan-commands-session.d.ts

@@ -0,0 +1,17 @@
+import { type ProgramIO } from '../cli-helpers.js';
+/** The emit context shared by every plan subcommand: where and how to report. */
+export interface PlanCommandContext {
+    readonly io: ProgramIO;
+    readonly command: string;
+    readonly asJson: boolean | undefined;
+}
+export declare function isValidSessionId(value: string): boolean;
+/**
+ * Resolve the session id for a plan subcommand: an explicit `--session-id` is
+ * validated; otherwise the active session is read and validated defensively. On
+ * any rejection the subcommand envelope is printed, the exit code set to 1 and
+ * `null` returned so the caller can bail without touching the result path.
+ */
+export declare function resolveSessionId(ctx: PlanCommandContext, projectRoot: string, explicit: string | undefined): string | null;
+/** Resolve the project root: an explicit `--project`, else the discovered root. */
+export declare function resolveProjectRoot(projectArg: string | undefined): string;

package/dist/cli/commands/workflow-plan-commands-session.js

@@ -0,0 +1,59 @@
+/**
+ * Shared session-id / project-root resolution for the `peaks workflow plan`
+ * command family (slice 025).
+ *
+ * Extracted from `workflow-plan-commands.ts` (strict-remediation c1) so one
+ * implementation backs every plan subcommand instead of the per-command copies
+ * the slice originally shipped — the same single-source form `request-commands.ts`
+ * already uses for its session-id guard (`guardSessionId`). This is a behaviour
+ * move, not a logic change: same predicates, same branch order, same envelope.
+ */
+import { fail } from 'peaks-loop-shared/result';
+import { printResult } from '../cli-helpers.js';
+import { getSessionId } from '../../services/session/session-manager.js';
+import { findProjectRoot } from '../../services/config/config-safety.js';
+// F-1 (slice 025 security): reject session ids that look like path
+// traversal payloads. Canonical pattern is YYYY-MM-DD-<slug>.
+const SESSION_ID_PATTERN = /^\d{4}-\d{2}-\d{2}-[a-z][a-z0-9-]*[a-z0-9]$/;
+export function isValidSessionId(value) {
+    return SESSION_ID_PATTERN.test(value);
+}
+function invalidSessionIdResult(ctx, sessionId) {
+    return fail(ctx.command, 'INVALID_SESSION_ID', 'session id must match YYYY-MM-DD-slug pattern', { sessionId }, ['Use --session-id <YYYY-MM-DD-slug>']);
+}
+/**
+ * Resolve the session id for a plan subcommand: an explicit `--session-id` is
+ * validated; otherwise the active session is read and validated defensively. On
+ * any rejection the subcommand envelope is printed, the exit code set to 1 and
+ * `null` returned so the caller can bail without touching the result path.
+ */
+export function resolveSessionId(ctx, projectRoot, explicit) {
+    if (explicit !== undefined && explicit.length > 0) {
+        if (!isValidSessionId(explicit)) {
+            printResult(ctx.io, invalidSessionIdResult(ctx, explicit), ctx.asJson === true);
+            process.exitCode = 1;
+            return null;
+        }
+        return explicit;
+    }
+    const sid = getSessionId(projectRoot);
+    if (sid === null || sid === undefined) {
+        printResult(ctx.io, fail(ctx.command, 'NO_ACTIVE_SESSION', 'No active session — pass --session-id explicitly or run peaks workspace init', { projectRoot }, ['Run peaks workspace init or pass --session-id <YYYY-MM-DD-slug>']), ctx.asJson === true);
+        process.exitCode = 1;
+        return null;
+    }
+    // Defensive: even active-session resolution must satisfy the pattern.
+    if (!isValidSessionId(sid)) {
+        printResult(ctx.io, invalidSessionIdResult(ctx, sid), ctx.asJson === true);
+        process.exitCode = 1;
+        return null;
+    }
+    return sid;
+}
+/** Resolve the project root: an explicit `--project`, else the discovered root. */
+export function resolveProjectRoot(projectArg) {
+    if (projectArg === undefined || projectArg === '') {
+        return findProjectRoot(process.cwd()) ?? process.cwd();
+    }
+    return projectArg;
+}

package/dist/cli/commands/workflow-plan-commands.d.ts

@@ -10,29 +10,18 @@
  * - `read`           (2) JSON-gated — slice workflow reads plan hash.
  * - `refresh`        (3) destructive write needs explicit `--apply`.
  * - `detect-trigger` (2) JSON-gated — slice workflow needs the verdict.
+ *
+ * strict-remediation c1 split: the action handlers and session/project
+ * resolution moved to `workflow-plan-commands-actions.ts` and
+ * `workflow-plan-commands-session.ts`. This module keeps only the commander
+ * registration and re-exports the action entry points, so the public surface —
+ * `registerWorkflowPlanCommands` plus the underscore test hooks `_runPlanRead` /
+ * `_runPlanRefresh` / `_runPlanDetectTrigger` — is byte-for-byte the same that
+ * `_register.ts` and the integration suite already import.
  */
-import { Command } from 'commander';
+import type { Command } from 'commander';
 import { type ProgramIO } from '../cli-helpers.js';
-declare function runPlanRead(io: ProgramIO, options: {
-    type: string;
-    project?: string;
-    sessionId?: string;
-    json?: boolean;
-}): void;
-declare function runPlanRefresh(io: ProgramIO, options: {
-    type: string;
-    project?: string;
-    sessionId?: string;
-    apply?: boolean;
-    json?: boolean;
-}): void;
-declare function runPlanDetectTrigger(io: ProgramIO, options: {
-    project?: string;
-    rid?: string;
-    sessionId?: string;
-    refresh?: boolean;
-    json?: boolean;
-}): void;
+import { runPlanDetectTrigger, runPlanRead, runPlanRefresh } from './workflow-plan-commands-actions.js';
 export declare function registerWorkflowPlanCommands(program: Command, io: ProgramIO): void;
 export { runPlanRead as _runPlanRead };
 export { runPlanRefresh as _runPlanRefresh };

package/dist/cli/commands/workflow-plan-commands.js

@@ -1,159 +1,33 @@
-import { fail, getErrorMessage } from 'peaks-loop-shared/result';
-import { addJsonOption, printResult } from '../cli-helpers.js';
-import { readPlan } from '../../services/workflow/plan-reader.js';
-import { refreshPlan } from '../../services/workflow/plan-refresher.js';
-import { detectTrigger } from '../../services/workflow/plan-trigger-detector.js';
-import { getSessionId } from '../../services/session/session-manager.js';
-import { findProjectRoot } from '../../services/config/config-safety.js';
-const VALID_TYPES = ['security', 'perf'];
-// F-1 (slice 025 security): reject session ids that look like path
-// traversal payloads. Canonical pattern is YYYY-MM-DD-<slug>.
-const SESSION_ID_PATTERN = /^\d{4}-\d{2}-\d{2}-[a-z][a-z0-9-]*[a-z0-9]$/;
-// F-1 (slice 025 security): reject rids that contain path separators,
-// null bytes, or traversal sequences.
-const REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-function isPlanType(value) {
-    return VALID_TYPES.includes(value);
-}
-function isValidSessionId(value) {
-    return SESSION_ID_PATTERN.test(value);
-}
-function isValidRequestId(value) {
-    return REQUEST_ID_PATTERN.test(value);
-}
-function resolveSessionId(io, command, projectRoot, explicit, asJson) {
-    if (explicit !== undefined && explicit.length > 0) {
-        if (!isValidSessionId(explicit)) {
-            printResult(io, fail(command, 'INVALID_SESSION_ID', 'session id must match YYYY-MM-DD-slug pattern', { sessionId: explicit }, ['Use --session-id <YYYY-MM-DD-slug>']), asJson === true);
-            process.exitCode = 1;
-            return null;
-        }
-        return explicit;
-    }
-    const sid = getSessionId(projectRoot);
-    if (sid === null || sid === undefined) {
-        printResult(io, fail(command, 'NO_ACTIVE_SESSION', 'No active session — pass --session-id explicitly or run peaks workspace init', { projectRoot }, ['Run peaks workspace init or pass --session-id <YYYY-MM-DD-slug>']), asJson === true);
-        process.exitCode = 1;
-        return null;
-    }
-    // Defensive: even active-session resolution must satisfy the pattern.
-    if (!isValidSessionId(sid)) {
-        printResult(io, fail(command, 'INVALID_SESSION_ID', 'session id must match YYYY-MM-DD-slug pattern', { sessionId: sid }, ['Use --session-id <YYYY-MM-DD-slug>']), asJson === true);
-        process.exitCode = 1;
-        return null;
-    }
-    return sid;
-}
-function resolveProjectRoot(projectArg) {
-    if (projectArg === undefined || projectArg === '') {
-        return findProjectRoot(process.cwd()) ?? process.cwd();
-    }
-    return projectArg;
-}
-function runPlanRead(io, options) {
-    if (!isPlanType(options.type)) {
-        printResult(io, fail('workflow.plan.read', 'INVALID_TYPE', `Unsupported plan type: ${options.type}`, { supportedTypes: VALID_TYPES }, ['Use --type security or --type perf']), options.json === true);
-        process.exitCode = 1;
-        return;
-    }
-    const projectRoot = resolveProjectRoot(options.project);
-    const sessionId = resolveSessionId(io, 'workflow.plan.read', projectRoot, options.sessionId, options.json);
-    if (sessionId === null)
-        return;
-    try {
-        const result = readPlan({ type: options.type, project: projectRoot, sessionId });
-        printResult(io, result, options.json === true);
-    }
-    catch (error) {
-        printResult(io, fail('workflow.plan.read', 'READ_FAILED', getErrorMessage(error), null, ['Check that --project is a valid repo root with a peaks session']), options.json === true);
-        process.exitCode = 1;
-    }
-}
-function runPlanRefresh(io, options) {
-    if (!isPlanType(options.type)) {
-        printResult(io, fail('workflow.plan.refresh', 'INVALID_TYPE', `Unsupported plan type: ${options.type}`, { supportedTypes: VALID_TYPES }, ['Use --type security or --type perf']), options.json === true);
-        process.exitCode = 1;
-        return;
-    }
-    const projectRoot = resolveProjectRoot(options.project);
-    const sessionId = resolveSessionId(io, 'workflow.plan.refresh', projectRoot, options.sessionId, options.json);
-    if (sessionId === null)
-        return;
-    try {
-        const result = refreshPlan({
-            type: options.type,
-            project: projectRoot,
-            sessionId,
-            apply: options.apply === true
-        });
-        printResult(io, result, options.json === true);
-    }
-    catch (error) {
-        printResult(io, fail('workflow.plan.refresh', 'REFRESH_FAILED', getErrorMessage(error), null, ['Check that --project is a valid repo root and the session exists']), options.json === true);
-        process.exitCode = 1;
-    }
-}
-function runPlanDetectTrigger(io, options) {
-    if (options.rid === undefined || options.rid === '') {
-        printResult(io, fail('workflow.plan.detect-trigger', 'MISSING_RID', 'Missing --rid', null, ['Pass --rid <request-id>']), options.json === true);
-        process.exitCode = 1;
-        return;
-    }
-    if (!isValidRequestId(options.rid)) {
-        printResult(io, fail('workflow.plan.detect-trigger', 'INVALID_RID', 'request id must match [A-Za-z0-9][A-Za-z0-9._-]*', { rid: options.rid }, ['Pass --rid <alphanumeric.request-id>']), options.json === true);
-        process.exitCode = 1;
-        return;
-    }
-    const projectRoot = resolveProjectRoot(options.project);
-    const sessionId = resolveSessionId(io, 'workflow.plan.detect-trigger', projectRoot, options.sessionId, options.json);
-    if (sessionId === null)
-        return;
-    try {
-        const result = detectTrigger({
-            project: projectRoot,
-            rid: options.rid,
-            sessionId,
-            ...(options.refresh === true ? { manualOverride: true } : {})
-        });
-        printResult(io, result, options.json === true);
-    }
-    catch (error) {
-        printResult(io, fail('workflow.plan.detect-trigger', 'DETECT_FAILED', getErrorMessage(error), null, ['Check that --project is a valid repo root and --rid is set']), options.json === true);
-        process.exitCode = 1;
-    }
+import { addJsonOption } from '../cli-helpers.js';
+import { runPlanDetectTrigger, runPlanRead, runPlanRefresh } from './workflow-plan-commands-actions.js';
+/** Options shared by all three plan subcommands (registered on the command). */
+function withPlanCommonOptions(command) {
+    return command
+        .option('--project <path>', 'project root', process.cwd())
+        .option('--session-id <sid>', 'session id (defaults to the active session)');
 }
 export function registerWorkflowPlanCommands(program, io) {
-    let workflowCmd = program.commands.find((c) => c.name() === 'workflow');
-    if (workflowCmd === undefined) {
-        workflowCmd = program.command('workflow').description('Plan workflow routing dry-run graphs');
-    }
+    const workflowCmd = program.commands.find((c) => c.name() === 'workflow') ??
+        program.command('workflow').description('Plan workflow routing dry-run graphs');
     const plan = workflowCmd
         .command('plan')
         .description('Read, refresh, or detect-trigger for security / perf plans (slice 025)');
-    addJsonOption(plan
+    addJsonOption(withPlanCommonOptions(plan
         .command('read')
         .description('Read the project-level plan envelope (exists, path, hash, refreshedAt)')
-        .requiredOption('--type <type>', 'plan type: security or perf')
-        .option('--project <path>', 'project root', process.cwd())
-        .option('--session-id <sid>', 'session id (defaults to the active session)')).action((options) => {
+        .requiredOption('--type <type>', 'plan type: security or perf'))).action((options) => {
         runPlanRead(io, options);
     });
-    addJsonOption(plan
+    addJsonOption(withPlanCommonOptions(plan
         .command('refresh')
         .description('Regenerate the plan (deterministic, idempotent; --apply to write)')
-        .requiredOption('--type <type>', 'plan type: security or perf')
-        .option('--project <path>', 'project root', process.cwd())
-        .option('--session-id <sid>', 'session id (defaults to the active session)')
-        .option('--apply', 'write the plan to disk (default is dry-run preview)')).action((options) => {
+        .requiredOption('--type <type>', 'plan type: security or perf')).option('--apply', 'write the plan to disk (default is dry-run preview)')).action((options) => {
         runPlanRefresh(io, options);
     });
-    addJsonOption(plan
+    addJsonOption(withPlanCommonOptions(plan
         .command('detect-trigger')
         .description('Detect whether a plan refresh is warranted for the slice diff')
-        .requiredOption('--rid <rid>', 'request identifier')
-        .option('--project <path>', 'project root', process.cwd())
-        .option('--session-id <sid>', 'session id (defaults to the active session)')
-        .option('--refresh', 'force triggered=true (manual override)')).action((options) => {
+        .requiredOption('--rid <rid>', 'request identifier')).option('--refresh', 'force triggered=true (manual override)')).action((options) => {
         runPlanDetectTrigger(io, options);
     });
 }

package/dist/cli/commands/workspace/clean-command.js

@@ -33,7 +33,10 @@ export function registerWorkspaceCleanCommand(workspace, _io) {
                 apply
             });
             if (opts.json === true) {
-                process.stdout.write(JSON.stringify({ ok: true, data: { dryRun: !apply, deleted: result.deleted, skipped: result.skipped } }) + '\n');
+                process.stdout.write(JSON.stringify({
+                    ok: true,
+                    data: { dryRun: !apply, deleted: result.deleted, skipped: result.skipped }
+                }) + '\n');
             }
         }
         catch (error) {

package/dist/cli/commands/workspace/helpers.js

@@ -34,7 +34,8 @@ export function readDecisionMarker(projectRoot) {
             scope: data.scope
         };
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;
     }
 }