@dreki-gg/pi-plan-mode 0.26.0 → 0.26.2

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @dreki-gg/pi-plan-mode
 
+## 0.26.2
+
+### Patch Changes
+
+- Updated dependencies
+  - @dreki-gg/taskman@0.3.0
+
+## 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

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__/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');
 }

package/extensions/plan-mode/exec-pending.ts

@@ -0,0 +1,59 @@
+/**
+ * Exec-pending marker I/O — the pi-mode one-shot handoff from planning to
+ * execution. This is pi-workflow-specific (model + thinking preset for the
+ * execution run), so it stays in the extension rather than the engine package.
+ */
+
+import { Effect, Either, Option } from 'effect';
+import {
+  FileSystem,
+  decodeExecPendingConfig,
+  type ExecPendingConfig,
+  type PlanWriteError,
+} from '@dreki-gg/taskman';
+import { EXEC_PENDING_FILE } from './constants.js';
+
+const PLANS_DIR = '.plans';
+
+export function writeExecPending(
+  dir: string,
+  config: ExecPendingConfig,
+): Effect.Effect<void, PlanWriteError, FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    yield* fs.makeDir(dir);
+    yield* fs.writeFileString(`${dir}/${EXEC_PENDING_FILE}`, JSON.stringify(config, null, 2) + '\n');
+  });
+}
+
+export function readAndClearExecPending(): Effect.Effect<
+  { planDir: string; config: ExecPendingConfig } | undefined,
+  never,
+  FileSystem
+> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    const maybeDirs = yield* Effect.option(fs.listDirectories(PLANS_DIR));
+    if (Option.isNone(maybeDirs)) return undefined;
+
+    for (const name of maybeDirs.value) {
+      const dir = `${PLANS_DIR}/${name}`;
+      const markerPath = `${dir}/${EXEC_PENDING_FILE}`;
+      const maybeText = yield* Effect.option(fs.readFileString(markerPath));
+      if (Option.isNone(maybeText)) continue;
+
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(maybeText.value);
+      } catch {
+        continue;
+      }
+      const decoded = decodeExecPendingConfig(parsed);
+      if (Either.isLeft(decoded)) continue;
+
+      yield* Effect.ignore(fs.removeFile(markerPath));
+      return { planDir: dir, config: decoded.right };
+    }
+    return undefined;
+  });
+}

package/extensions/plan-mode/index.ts

@@ -28,19 +28,20 @@ import {
 } from './constants.js';
 import type { ThinkingLevel, TaskStatus } from './types.js';
 import { PlanModeState } from './state.js';
-import { makePlanRuntime } from './effects/runtime.js';
-import { loadHandoff, readAndClearExecPending } from './storage/plan-storage.js';
-import { readTasksJsonl, writeTasksJsonl } from './storage/task-storage.js';
-import { upsertPlanEntry, reconcilePlanStatus } from './storage/plans-manifest.js';
+import { makePlanRuntime } from '@dreki-gg/taskman';
+import { loadHandoff } from '@dreki-gg/taskman';
+import { readAndClearExecPending } from './exec-pending.js';
+import { readTasksJsonl, writeTasksJsonl } from '@dreki-gg/taskman';
+import { upsertPlanEntry, reconcilePlanStatus } from '@dreki-gg/taskman';
 import { updateUI } from './ui.js';
 import { buildPlanModePrompt, buildExecutionPrompt } from './prompts.js';
 import { filterExecutionMessages, filterStalePlanMessages } from './context-filter.js';
-import { activeTasksResolved, deferredTasks, isPlanFinalizable } from './task-status.js';
+import { activeTasksResolved, deferredTasks, isPlanFinalizable } from '@dreki-gg/taskman';
 import { enterPlanMode, exitPlanMode, switchModel } from './phase-transitions.js';
 import { resumePlan, executeInNewSession } from './resume.js';
 import { resolveActivePlan, focusActivePlan } from './resolve-plan.js';
-import { reconcileInitiativeForPlan } from './initiative.js';
-import { collectPlanDrift } from './reconcile.js';
+import { reconcileInitiativeForPlan } from '@dreki-gg/taskman';
+import { collectPlanDrift } from '@dreki-gg/taskman';
 import { registerSubmitPlanTool } from './tools/submit-plan.js';
 import { registerSubmitInitiativeTool } from './tools/submit-initiative.js';
 import { registerRevisePlanTool } from './tools/revise-plan.js';

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

@@ -10,12 +10,12 @@
 
 import { Effect } from 'effect';
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-import type { FileSystem } from '../effects/filesystem.js';
-import type { RunPlanIO } from '../effects/runtime.js';
+import type { FileSystem } from '@dreki-gg/taskman';
+import type { RunPlanIO } from '@dreki-gg/taskman';
 import type { PlanStatus, TaskRecord, TaskStatus } from '../types.js';
-import { readPlansManifest } from '../storage/plans-manifest.js';
-import { readTasksJsonl } from '../storage/task-storage.js';
-import { loadHandoff } from '../storage/plan-storage.js';
+import { readPlansManifest } from '@dreki-gg/taskman';
+import { readTasksJsonl } from '@dreki-gg/taskman';
+import { loadHandoff } from '@dreki-gg/taskman';
 import { firstPlanReference } from './tokens.js';
 
 export interface ResolvedPlanReference {