@dreki-gg/pi-plan-mode 0.25.0 → 0.26.1

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @dreki-gg/pi-plan-mode
 
+## 0.26.1
+
+### Patch Changes
+
+- Internal refactor: the task-management engine (storage, schema, reconcile,
+  initiative projection, task-status, plan resolution) now lives in the new
+  `@dreki-gg/taskman` package, which plan-mode depends on. No behavior change —
+  the same tools, commands, and `.plans/` layout, with the engine shared so other
+  harnesses can drive the same ledger via the `taskman` CLI.
+- Updated dependencies
+  - @dreki-gg/taskman@0.2.0
+
+## 0.26.0
+
+### Minor Changes
+
+- Make plans more executable by zero-context executors. Plans now stamp the git
+  commit they were written against (`base_commit`), and the execution prompt runs
+  a drift check — if HEAD has moved, the executor is told to diff, re-read the
+  affected files, and proceed with caution. Planning guidance also now asks
+  delegation tasks to end their details with a verification gate (a concrete
+  command + expected output) and STOP conditions, so success is machine-checkable.
+  Fully backward-compatible: older plans without `base_commit` simply skip the
+  drift check.
+
 ## 0.25.0
 
 ### Minor Changes

package/extensions/plan-mode/__tests__/git.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, test } from 'bun:test';
+import { tmpdir } from 'node:os';
+import { readHeadCommit } from '../git.js';
+
+describe('readHeadCommit', () => {
+  test('returns the HEAD sha inside a git repo', async () => {
+    // This monorepo is a git repo, so cwd resolves a real commit.
+    const sha = await readHeadCommit(process.cwd());
+    expect(sha).toMatch(/^[0-9a-f]{40}$/);
+  });
+
+  test('returns undefined outside a git repo (never throws)', async () => {
+    // tmpdir is not a git repo; the helper must swallow the error.
+    const sha = await readHeadCommit(tmpdir());
+    expect(sha).toBeUndefined();
+  });
+});

package/extensions/plan-mode/__tests__/initiative-status.test.ts

@@ -4,11 +4,11 @@ import { chdir } from 'node:process';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { FileSystem, nodeFileSystemService } from '../effects/filesystem.js';
-import { makePlanRuntime } from '../effects/runtime.js';
-import { upsertPlanEntry } from '../storage/plans-manifest.js';
-import { upsertInitiativeEntry } from '../storage/initiatives-manifest.js';
-import { writeTasksJsonl } from '../storage/task-storage.js';
+import { FileSystem, nodeFileSystemService } from '@dreki-gg/taskman';
+import { makePlanRuntime } from '@dreki-gg/taskman';
+import { upsertPlanEntry } from '@dreki-gg/taskman';
+import { upsertInitiativeEntry } from '@dreki-gg/taskman';
+import { writeTasksJsonl } from '@dreki-gg/taskman';
 import type { TaskRecord } from '../types.js';
 import { registerInitiativeStatusTool } from '../tools/initiative-status.js';
 

package/extensions/plan-mode/__tests__/plan-references-context.test.ts

@@ -3,10 +3,10 @@ import { chdir } from 'node:process';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { makePlanRuntime } from '../effects/runtime.js';
-import { upsertPlanEntry } from '../storage/plans-manifest.js';
-import { writeTasksJsonl } from '../storage/task-storage.js';
-import { saveHandoff } from '../storage/plan-storage.js';
+import { makePlanRuntime } from '@dreki-gg/taskman';
+import { upsertPlanEntry } from '@dreki-gg/taskman';
+import { writeTasksJsonl } from '@dreki-gg/taskman';
+import { saveHandoff } from '@dreki-gg/taskman';
 import type { TaskMeta, TaskRecord } from '../types.js';
 import { buildPlanContextPack, resolvePlanReference } from '../references/context.js';
 

package/extensions/plan-mode/__tests__/prompts.test.ts

@@ -23,6 +23,11 @@ describe('buildPlanModePrompt', () => {
     expect(prompt).toContain('technical-options');
   });
 
+  test('instructs delegation tasks to include a verification gate', () => {
+    expect(prompt).toContain('verification gate');
+    expect(prompt).toContain('STOP conditions');
+  });
+
   test('mentions handoff instead of context and risks', () => {
     expect(prompt).toContain('handoff');
     expect(prompt).not.toContain('- risks:');
@@ -72,6 +77,24 @@ describe('buildExecutionPrompt', () => {
     expect(prompt).toContain('Details: Full instructions here');
   });
 
+  test('includes a drift check when base_commit is present', () => {
+    const plan: PlanData = {
+      title: 'Test',
+      planName: 'test',
+      handoff: '# H',
+      tasks: [makeTask()],
+      base_commit: 'deadbeef',
+    };
+    const prompt = buildExecutionPrompt(plan)!;
+    expect(prompt).toContain('Drift check');
+    expect(prompt).toContain('deadbeef');
+  });
+
+  test('omits the drift check when base_commit is absent', () => {
+    const plan: PlanData = { title: 'Test', planName: 'test', handoff: '# H', tasks: [makeTask()] };
+    expect(buildExecutionPrompt(plan)!).not.toContain('Drift check');
+  });
+
   test('returns undefined when no pending tasks', () => {
     const plan: PlanData = {
       title: 'Test',

package/extensions/plan-mode/__tests__/reconcile-plans.test.ts

@@ -3,9 +3,9 @@ import { chdir } from 'node:process';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { makePlanRuntime } from '../effects/runtime.js';
-import { writeTasksJsonl } from '../storage/task-storage.js';
-import { readPlansManifest, upsertPlanEntry } from '../storage/plans-manifest.js';
+import { makePlanRuntime } from '@dreki-gg/taskman';
+import { writeTasksJsonl } from '@dreki-gg/taskman';
+import { readPlansManifest, upsertPlanEntry } from '@dreki-gg/taskman';
 import { registerReconcilePlansTool } from '../tools/reconcile-plans.js';
 import type { TaskMeta, TaskRecord } from '../types.js';
 

package/extensions/plan-mode/__tests__/resolve-plan.test.ts

@@ -3,10 +3,10 @@ import { chdir } from 'node:process';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { makePlanRuntime } from '../effects/runtime.js';
-import { writeTasksJsonl } from '../storage/task-storage.js';
-import { upsertPlanEntry } from '../storage/plans-manifest.js';
-import { saveHandoff } from '../storage/plan-storage.js';
+import { makePlanRuntime } from '@dreki-gg/taskman';
+import { writeTasksJsonl } from '@dreki-gg/taskman';
+import { upsertPlanEntry } from '@dreki-gg/taskman';
+import { saveHandoff } from '@dreki-gg/taskman';
 import { PlanModeState } from '../state.js';
 import { resolveActivePlan } from '../resolve-plan.js';
 import type { TaskMeta, TaskRecord } from '../types.js';

package/extensions/plan-mode/__tests__/revise-plan.test.ts

@@ -3,11 +3,11 @@ import { chdir } from 'node:process';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { makePlanRuntime } from '../effects/runtime.js';
+import { makePlanRuntime } from '@dreki-gg/taskman';
 import { registerRevisePlanTool } from '../tools/revise-plan.js';
-import { readTasksJsonl, writeTasksJsonl } from '../storage/task-storage.js';
-import { saveHandoff, loadHandoff } from '../storage/plan-storage.js';
-import { readPlansManifest, upsertPlanEntry } from '../storage/plans-manifest.js';
+import { readTasksJsonl, writeTasksJsonl } from '@dreki-gg/taskman';
+import { saveHandoff, loadHandoff } from '@dreki-gg/taskman';
+import { readPlansManifest, upsertPlanEntry } from '@dreki-gg/taskman';
 import type { PlanData, TaskRecord } from '../types.js';
 
 const runPlanIO = makePlanRuntime();

package/extensions/plan-mode/__tests__/submit-initiative.test.ts

@@ -3,8 +3,8 @@ import { chdir } from 'node:process';
 import { mkdtemp, readFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { makePlanRuntime } from '../effects/runtime.js';
-import { readInitiativesManifest } from '../storage/initiatives-manifest.js';
+import { makePlanRuntime } from '@dreki-gg/taskman';
+import { readInitiativesManifest } from '@dreki-gg/taskman';
 import { registerSubmitInitiativeTool } from '../tools/submit-initiative.js';
 
 const runPlanIO = makePlanRuntime();

package/extensions/plan-mode/__tests__/submit-plan.test.ts

@@ -3,12 +3,12 @@ import { chdir } from 'node:process';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { makePlanRuntime } from '../effects/runtime.js';
-import { readPlansManifest } from '../storage/plans-manifest.js';
+import { makePlanRuntime } from '@dreki-gg/taskman';
+import { readPlansManifest } from '@dreki-gg/taskman';
 import {
   readInitiativesManifest,
   upsertInitiativeEntry,
-} from '../storage/initiatives-manifest.js';
+} from '@dreki-gg/taskman';
 import { registerSubmitPlanTool } from '../tools/submit-plan.js';
 
 const runPlanIO = makePlanRuntime();

package/extensions/plan-mode/__tests__/update-initiative.test.ts

@@ -3,11 +3,11 @@ import { chdir } from 'node:process';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { makePlanRuntime } from '../effects/runtime.js';
+import { makePlanRuntime } from '@dreki-gg/taskman';
 import {
   readInitiativesManifest,
   upsertInitiativeEntry,
-} from '../storage/initiatives-manifest.js';
+} from '@dreki-gg/taskman';
 import { registerUpdateInitiativeTool } from '../tools/update-initiative.js';
 
 const runPlanIO = makePlanRuntime();

package/extensions/plan-mode/__tests__/update-plan.test.ts

@@ -3,8 +3,8 @@ import { chdir } from 'node:process';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { makePlanRuntime } from '../effects/runtime.js';
-import { readPlansManifest, upsertPlanEntry } from '../storage/plans-manifest.js';
+import { makePlanRuntime } from '@dreki-gg/taskman';
+import { readPlansManifest, upsertPlanEntry } from '@dreki-gg/taskman';
 import { registerUpdatePlanTool } from '../tools/update-plan.js';
 
 const runPlanIO = makePlanRuntime();

package/extensions/plan-mode/__tests__/utils.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from 'bun:test';
-import { isSafeCommand, isPlanPath, nextTaskId } from '../utils.js';
+import { isSafeCommand, isPlanPath } from '../utils.js';
+import { nextTaskId } from '@dreki-gg/taskman';
 
 describe('nextTaskId', () => {
   test('increments the max numeric suffix', () => {

package/extensions/plan-mode/commands/list-initiatives.ts

@@ -1,121 +1,29 @@
 /**
  * /initiatives command — list, filter, and sort initiatives interactively.
  *
- * The initiative sibling of /plans. Reads the initiatives registry plus the
- * plans manifest to roll up member-plan progress (done/total, ready/blocked).
+ * The pure listing logic lives in `@dreki-gg/taskman`; this file is the
+ * pi-interactive shell around it.
  */
 
-import { Effect } from 'effect';
 import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
-import type { RunPlanIO } from '../effects/runtime.js';
-import { FileSystem } from '../effects/filesystem.js';
-import { readPlansManifest, type PlanManifestEntry } from '../storage/plans-manifest.js';
-import {
-  readInitiativesManifest,
-  type InitiativeManifestEntry,
-} from '../storage/initiatives-manifest.js';
-import { initiativeRollup } from '../initiative.js';
-import type { InitiativeStatus } from '../types.js';
-
-export type StatusFilter = 'all' | InitiativeStatus;
-
-export interface InitiativeListItem {
-  name: string;
-  title: string;
-  status: InitiativeStatus;
-  created_at: string;
-  totalPlans: number;
-  donePlans: number;
-  ready: number;
-  blocked: number;
-}
-
-export function filterInitiatives(
-  items: InitiativeListItem[],
-  filter: StatusFilter,
-): InitiativeListItem[] {
-  if (filter === 'all') return items;
-  return items.filter((i) => i.status === filter);
-}
-
-const STATUS_ICON: Record<InitiativeStatus, string> = {
-  'in-progress': '🔵',
-  done: '✅',
-  superseded: '🔄',
-  abandoned: '❌',
-};
-
-export function formatInitiativeList(items: InitiativeListItem[], filter: StatusFilter): string {
-  if (items.length === 0) {
-    return filter === 'all'
-      ? 'No initiatives found in .plans/initiatives.jsonl'
-      : `No initiatives with status "${filter}"`;
-  }
-  const header =
-    filter === 'all'
-      ? `All initiatives (${items.length})`
-      : `Initiatives: ${filter} (${items.length})`;
-  const lines = items.map((i) => {
-    const icon = STATUS_ICON[i.status];
-    const progress =
-      i.totalPlans > 0
-        ? ` [${i.donePlans}/${i.totalPlans} plans, ready ${i.ready}, blocked ${i.blocked}]`
-        : ' [no plans]';
-    const date = i.created_at.slice(0, 10);
-    return `  ${icon} ${i.name} — ${i.title}${progress}  (${date})`;
-  });
-  return `${header}\n${lines.join('\n')}`;
-}
-
-export function loadInitiativeListItems(): Effect.Effect<InitiativeListItem[], never, FileSystem> {
-  return Effect.gen(function* () {
-    const initiatives = yield* Effect.orElseSucceed(
-      readInitiativesManifest(),
-      () => [] as InitiativeManifestEntry[],
-    );
-    const plans = yield* Effect.orElseSucceed(
-      readPlansManifest(),
-      () => [] as PlanManifestEntry[],
-    );
-    return initiatives.map((entry): InitiativeListItem => {
-      const r = initiativeRollup(entry.name, plans);
-      return {
-        name: entry.name,
-        title: entry.title,
-        status: entry.status,
-        created_at: entry.created_at,
-        totalPlans: r.total,
-        donePlans: r.done,
-        ready: r.ready,
-        blocked: r.blocked,
-      };
-    });
-  });
-}
-
-const FILTER_ALIASES: Record<string, StatusFilter> = {
-  all: 'all',
-  'in-progress': 'in-progress',
-  active: 'in-progress',
-  done: 'done',
-  completed: 'done',
-  superseded: 'superseded',
-  abandoned: 'abandoned',
-};
-
-export function parseFilter(raw: string): StatusFilter {
-  for (const token of raw.toLowerCase().split(/\s+/)) {
-    if (FILTER_ALIASES[token]) return FILTER_ALIASES[token];
-  }
-  return 'all';
-}
+import type { RunPlanIO } from '@dreki-gg/taskman';
+import { InitiativeListing } from '@dreki-gg/taskman';
+
+export type StatusFilter = InitiativeListing.StatusFilter;
+export type InitiativeListItem = InitiativeListing.InitiativeListItem;
+export const {
+  filterInitiatives,
+  formatInitiativeList,
+  loadInitiativeListItems,
+  parseInitiativeFilter: parseFilter,
+} = InitiativeListing;
 
 export async function handleListInitiatives(
   ctx: ExtensionCommandContext,
   runPlanIO: RunPlanIO,
   args?: string,
 ): Promise<void> {
-  const items = await runPlanIO(loadInitiativeListItems());
+  const items = await runPlanIO(InitiativeListing.loadInitiativeListItems());
   if (items.length === 0) {
     ctx.ui.notify('No initiatives found in .plans/initiatives.jsonl', 'info');
     return;
@@ -123,7 +31,7 @@ export async function handleListInitiatives(
 
   let filter: StatusFilter = 'all';
   if (args?.trim()) {
-    filter = parseFilter(args.trim());
+    filter = InitiativeListing.parseInitiativeFilter(args.trim());
   } else {
     const choice = await ctx.ui.select('Filter initiatives by status:', [
       'All',
@@ -143,6 +51,8 @@ export async function handleListInitiatives(
     filter = map[choice] ?? 'all';
   }
 
-  const filtered = filterInitiatives(items, filter);
-  ctx.ui.notify(formatInitiativeList(filtered, filter), 'info');
+  ctx.ui.notify(
+    InitiativeListing.formatInitiativeList(InitiativeListing.filterInitiatives(items, filter), filter),
+    'info',
+  );
 }

package/extensions/plan-mode/commands/list-plans.ts

@@ -1,155 +1,47 @@
 /**
  * /plans command — list, filter, and sort plans interactively.
  *
- * Reads from the plans manifest AND task snapshots to build a rich table
- * with status, task counts, and dates. The user can filter by status and
- * sort by different criteria via interactive selectors.
+ * The pure listing logic (filter / sort / format / load) lives in
+ * `@dreki-gg/taskman`; this file is the pi-interactive shell around it.
  */
 
-import { Effect } from 'effect';
 import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
-import type { RunPlanIO } from '../effects/runtime.js';
-import { FileSystem } from '../effects/filesystem.js';
-import { readPlansManifest, type PlanManifestEntry } from '../storage/plans-manifest.js';
-import { readTasksJsonl } from '../storage/task-storage.js';
-import type { PlanStatus } from '../types.js';
-
-// ── Types ────────────────────────────────────────────────────────────────────
-
-export type SortField = 'name' | 'date-asc' | 'date-desc' | 'tasks';
-export type StatusFilter = 'all' | PlanStatus;
-
-export interface PlanListItem {
-  name: string;
-  title: string;
-  status: PlanStatus;
-  created_at: string;
-  completed_at: string | null;
-  totalTasks: number;
-  doneTasks: number;
-  pendingTasks: number;
-}
-
-// ── Core logic (pure, testable) ──────────────────────────────────────────────
-
-export function filterPlans(plans: PlanListItem[], filter: StatusFilter): PlanListItem[] {
-  if (filter === 'all') return plans;
-  return plans.filter((p) => p.status === filter);
-}
-
-export function sortPlans(plans: PlanListItem[], sort: SortField): PlanListItem[] {
-  const sorted = [...plans];
-  switch (sort) {
-    case 'name':
-      sorted.sort((a, b) => a.name.localeCompare(b.name));
-      break;
-    case 'date-asc':
-      sorted.sort((a, b) => a.created_at.localeCompare(b.created_at));
-      break;
-    case 'date-desc':
-      sorted.sort((a, b) => b.created_at.localeCompare(a.created_at));
-      break;
-    case 'tasks':
-      sorted.sort((a, b) => b.totalTasks - a.totalTasks);
-      break;
-  }
-  return sorted;
-}
-
-const STATUS_ICON: Record<PlanStatus, string> = {
-  'in-progress': '🔵',
-  done: '✅',
-  superseded: '🔄',
-  abandoned: '❌',
-};
-
-export function formatPlanList(plans: PlanListItem[], filter: StatusFilter, sort: SortField): string {
-  if (plans.length === 0) {
-    return filter === 'all'
-      ? 'No plans found in .plans/plans.jsonl'
-      : `No plans with status "${filter}"`;
-  }
-
-  const sortLabel: Record<SortField, string> = {
-    name: 'name',
-    'date-asc': 'oldest first',
-    'date-desc': 'newest first',
-    tasks: 'most tasks first',
-  };
-
-  const header =
-    filter === 'all'
-      ? `All plans (${plans.length}) — sorted by ${sortLabel[sort]}`
-      : `Plans: ${filter} (${plans.length}) — sorted by ${sortLabel[sort]}`;
-
-  const lines = plans.map((p) => {
-    const icon = STATUS_ICON[p.status];
-    const progress =
-      p.totalTasks > 0 ? ` [${p.doneTasks}/${p.totalTasks} tasks]` : ' [no tasks]';
-    const date = p.created_at.slice(0, 10);
-    return `  ${icon} ${p.name} — ${p.title}${progress}  (${date})`;
-  });
-
-  return `${header}\n${lines.join('\n')}`;
-}
-
-// ── Data loading (Effect-based) ──────────────────────────────────────────────
-
-export function loadPlanListItems(): Effect.Effect<PlanListItem[], never, FileSystem> {
-  return Effect.gen(function* () {
-    const manifest = yield* Effect.orElseSucceed(readPlansManifest(), () => [] as PlanManifestEntry[]);
-    const items: PlanListItem[] = [];
-
-    for (const entry of manifest) {
-      const dir = `.plans/${entry.name}`;
-      const snapshot = yield* Effect.orElseSucceed(readTasksJsonl(dir), () => undefined);
-      const totalTasks = snapshot?.tasks.length ?? 0;
-      const doneTasks = snapshot?.tasks.filter(
-        (t) => t.status === 'done' || t.status === 'skipped',
-      ).length ?? 0;
-      const pendingTasks = snapshot?.tasks.filter((t) => t.status === 'pending').length ?? 0;
-
-      items.push({
-        name: entry.name,
-        title: entry.title,
-        status: entry.status,
-        created_at: entry.created_at,
-        completed_at: entry.completed_at,
-        totalTasks,
-        doneTasks,
-        pendingTasks,
-      });
-    }
-
-    return items;
-  });
-}
-
-// ── Interactive command handler ──────────────────────────────────────────────
+import type { RunPlanIO } from '@dreki-gg/taskman';
+import { PlanListing } from '@dreki-gg/taskman';
+
+// Re-export the engine listing types/helpers for the rest of the extension.
+export type SortField = PlanListing.SortField;
+export type StatusFilter = PlanListing.StatusFilter;
+export type PlanListItem = PlanListing.PlanListItem;
+export const {
+  filterPlans,
+  sortPlans,
+  formatPlanList,
+  loadPlanListItems,
+  parseListArgs: parseArgs,
+} = PlanListing;
 
 export async function handleListPlans(
   ctx: ExtensionCommandContext,
   runPlanIO: RunPlanIO,
   args?: string,
 ): Promise<void> {
-  const allItems = await runPlanIO(loadPlanListItems());
+  const allItems = await runPlanIO(PlanListing.loadPlanListItems());
 
   if (allItems.length === 0) {
     ctx.ui.notify('No plans found in .plans/plans.jsonl', 'info');
     return;
   }
 
-  // Parse inline args: /plans [filter] [sort]
-  // e.g. /plans done tasks, /plans in-progress date-asc
+  // Parse inline args: /plans [filter] [sort] — e.g. /plans done tasks
   let filter: StatusFilter = 'all';
   let sort: SortField = 'date-desc';
 
   if (args?.trim()) {
-    const parsed = parseArgs(args.trim());
+    const parsed = PlanListing.parseListArgs(args.trim());
     filter = parsed.filter;
     sort = parsed.sort;
   } else {
-    // Interactive mode: ask the user
     const filterChoice = await ctx.ui.select('Filter plans by status:', [
       'All',
       'In-progress',
@@ -185,45 +77,6 @@ export async function handleListPlans(
     sort = sortMap[sortChoice] ?? 'date-desc';
   }
 
-  const filtered = filterPlans(allItems, filter);
-  const sorted = sortPlans(filtered, sort);
-  const output = formatPlanList(sorted, filter, sort);
-
-  ctx.ui.notify(output, 'info');
-}
-
-// ── Arg parsing ──────────────────────────────────────────────────────────────
-
-const FILTER_ALIASES: Record<string, StatusFilter> = {
-  all: 'all',
-  'in-progress': 'in-progress',
-  pending: 'in-progress',
-  active: 'in-progress',
-  done: 'done',
-  completed: 'done',
-  superseded: 'superseded',
-  abandoned: 'abandoned',
-};
-
-const SORT_ALIASES: Record<string, SortField> = {
-  name: 'name',
-  'date-asc': 'date-asc',
-  oldest: 'date-asc',
-  'date-desc': 'date-desc',
-  newest: 'date-desc',
-  tasks: 'tasks',
-  'task-count': 'tasks',
-};
-
-export function parseArgs(raw: string): { filter: StatusFilter; sort: SortField } {
-  const tokens = raw.toLowerCase().split(/\s+/);
-  let filter: StatusFilter = 'all';
-  let sort: SortField = 'date-desc';
-
-  for (const token of tokens) {
-    if (FILTER_ALIASES[token]) filter = FILTER_ALIASES[token];
-    else if (SORT_ALIASES[token]) sort = SORT_ALIASES[token];
-  }
-
-  return { filter, sort };
+  const sorted = PlanListing.sortPlans(PlanListing.filterPlans(allItems, filter), sort);
+  ctx.ui.notify(PlanListing.formatPlanList(sorted, filter, sort), 'info');
 }