@dreki-gg/pi-plan-mode 0.23.0 → 0.24.1

package/extensions/plan-mode/storage/initiatives-manifest.ts

@@ -0,0 +1,154 @@
+/**
+ * `.plans/initiatives.jsonl` registry — the initiative-level sibling of
+ * `plans-manifest.ts`.
+ *
+ * An initiative groups multiple plans. Its `status` is a PROJECTION of its
+ * member plans' statuses (see `reconcileInitiativeStatus` in `../initiative.ts`
+ * for the projection wiring): `done` when every member plan is terminal,
+ * `in-progress` otherwise. Manually-set terminal statuses (`superseded` /
+ * `abandoned` via `update_initiative`) are never auto-overridden.
+ *
+ * This module is intentionally dependency-light: it knows how to read/write the
+ * registry. The projection (which must read the PLANS manifest) lives in
+ * `../initiative.ts` to keep the dependency direction one-way and cycle-free.
+ */
+
+import { Effect, Either, Option } from 'effect';
+import { FileSystem } from '../effects/filesystem.js';
+import { JsonlParseError, JsonlValidationError, PlanWriteError } from '../errors.js';
+import { decodeInitiativeManifestEntry } from '../schema.js';
+import type { InitiativeStatus } from '../types.js';
+import { withFileLock } from './file-lock.js';
+
+const MANIFEST_DIR = '.plans';
+const MANIFEST_PATH = '.plans/initiatives.jsonl';
+
+export interface InitiativeManifestEntry {
+  _type: 'initiative';
+  name: string;
+  status: InitiativeStatus;
+  title: string;
+  created_at: string;
+  completed_at: string | null;
+  reason?: string;
+}
+
+/** A status is terminal (closed) when it is anything other than in-progress. */
+export function isTerminalStatus(status: InitiativeStatus): boolean {
+  return status !== 'in-progress';
+}
+
+type ReadError = JsonlParseError | JsonlValidationError;
+
+export function readInitiativesManifest(): Effect.Effect<
+  InitiativeManifestEntry[],
+  ReadError,
+  FileSystem
+> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    // A missing or unreadable manifest is treated as "no initiatives".
+    const maybeText = yield* Effect.option(fs.readFileString(MANIFEST_PATH));
+    if (Option.isNone(maybeText)) return [];
+
+    const entries: InitiativeManifestEntry[] = [];
+    for (const [index, raw] of maybeText.value.split(/\r?\n/).entries()) {
+      if (!raw.trim()) continue;
+      const line = index + 1;
+
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(raw);
+      } catch (cause) {
+        return yield* Effect.fail(new JsonlParseError({ path: MANIFEST_PATH, line, cause }));
+      }
+
+      const decoded = decodeInitiativeManifestEntry(parsed);
+      if (Either.isLeft(decoded)) {
+        return yield* Effect.fail(
+          new JsonlValidationError({ path: MANIFEST_PATH, line, reason: decoded.left.message }),
+        );
+      }
+      entries.push(decoded.right);
+    }
+    return entries;
+  });
+}
+
+export function writeInitiativesManifest(
+  entries: InitiativeManifestEntry[],
+): Effect.Effect<void, PlanWriteError, FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    yield* fs.makeDir(MANIFEST_DIR);
+    const content =
+      entries.map((entry) => JSON.stringify(entry)).join('\n') + (entries.length ? '\n' : '');
+    yield* fs.writeFileAtomic(MANIFEST_PATH, content);
+  });
+}
+
+export interface InitiativeUpsert {
+  status: InitiativeStatus;
+  title?: string;
+  reason?: string;
+}
+
+/**
+ * Pure transform: upsert `name` into the in-memory `entries` array, preserving
+ * created_at from any existing entry. No IO — shared by the locked
+ * `upsertInitiativeEntry` and `reconcileInitiativeStatus` so both flow through
+ * one serialized read-modify-write and never nest locks.
+ */
+export function applyInitiativeUpsert(
+  entries: InitiativeManifestEntry[],
+  name: string,
+  updates: InitiativeUpsert,
+): void {
+  const now = new Date().toISOString();
+  const index = entries.findIndex((entry) => entry.name === name);
+  const existing = index === -1 ? undefined : entries[index];
+  const entry: InitiativeManifestEntry = {
+    _type: 'initiative',
+    name,
+    status: updates.status,
+    title: updates.title ?? existing?.title ?? 'Untitled initiative',
+    created_at: existing?.created_at ?? now,
+    // Terminal statuses record a completion timestamp; reopening clears it.
+    completed_at: isTerminalStatus(updates.status) ? (existing?.completed_at ?? now) : null,
+    reason: updates.reason ?? existing?.reason,
+  };
+  if (index === -1) entries.push(entry);
+  else entries[index] = entry;
+}
+
+/**
+ * Serialized read-modify-write of the initiatives registry. Holds a
+ * process-wide lock on the manifest path across the whole read → transform →
+ * write so concurrent tool calls cannot clobber each other. `transform` may run
+ * IO (e.g. read the plans manifest to project status) and mutates the entries
+ * array in place, returning `true` when it changed something.
+ */
+export function mutateInitiativesManifest<E, R>(
+  transform: (entries: InitiativeManifestEntry[]) => Effect.Effect<boolean, E, R>,
+): Effect.Effect<void, ReadError | PlanWriteError | E, FileSystem | R> {
+  return withFileLock(
+    MANIFEST_PATH,
+    Effect.gen(function* () {
+      const entries = yield* readInitiativesManifest();
+      const changed = yield* transform(entries);
+      if (changed) yield* writeInitiativesManifest(entries);
+    }),
+  );
+}
+
+export function upsertInitiativeEntry(
+  name: string,
+  updates: InitiativeUpsert,
+): Effect.Effect<void, ReadError | PlanWriteError, FileSystem> {
+  return mutateInitiativesManifest((entries) =>
+    Effect.sync(() => {
+      applyInitiativeUpsert(entries, name, updates);
+      return true;
+    }),
+  );
+}

package/extensions/plan-mode/storage/plan-storage.ts

@@ -75,3 +75,14 @@ export function loadHandoff(planDir: string): Effect.Effect<string | undefined,
     return Option.getOrUndefined(maybeText);
   });
 }
+
+export function saveInitiative(
+  initiativeDir: string,
+  content: string,
+): Effect.Effect<void, PlanWriteError, FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    yield* fs.makeDir(initiativeDir);
+    yield* fs.writeFileString(`${initiativeDir}/INITIATIVE.md`, content);
+  });
+}

package/extensions/plan-mode/storage/plans-manifest.ts

@@ -3,6 +3,7 @@ import { FileSystem } from '../effects/filesystem.js';
 import { JsonlParseError, JsonlValidationError, PlanWriteError } from '../errors.js';
 import { decodePlanManifestEntry } from '../schema.js';
 import type { PlanStatus } from '../types.js';
+import { withFileLock } from './file-lock.js';
 
 const MANIFEST_DIR = '.plans';
 const MANIFEST_PATH = '.plans/plans.jsonl';
@@ -15,6 +16,10 @@ export interface PlanManifestEntry {
   created_at: string;
   completed_at: string | null;
   reason?: string;
+  /** Parent initiative name (kebab). Absent = standalone flat plan. */
+  initiative?: string;
+  /** Plan-level dependencies (plan names). Cross-initiative allowed. */
+  depends_on?: string[];
 }
 
 /** A status is terminal (closed) when it is anything other than in-progress. */
@@ -67,28 +72,74 @@ export function writePlansManifest(
   });
 }
 
+export interface PlanUpsert {
+  status: PlanStatus;
+  title?: string;
+  reason?: string;
+  /** Parent initiative name; preserved when omitted. */
+  initiative?: string;
+  /** Plan-level dependencies (plan names); preserved when omitted. */
+  depends_on?: string[];
+}
+
+/**
+ * Pure transform: upsert `name` into the in-memory `entries` array, preserving
+ * created_at / membership / deps from any existing entry. No IO — shared by the
+ * locked `upsertPlanEntry` and `reconcilePlanStatus` so both flow through one
+ * serialized read-modify-write and never nest locks.
+ */
+export function applyPlanUpsert(
+  entries: PlanManifestEntry[],
+  name: string,
+  updates: PlanUpsert,
+): void {
+  const now = new Date().toISOString();
+  const index = entries.findIndex((entry) => entry.name === name);
+  const existing = index === -1 ? undefined : entries[index];
+  const entry: PlanManifestEntry = {
+    _type: 'plan',
+    name,
+    status: updates.status,
+    title: updates.title ?? existing?.title ?? 'Untitled plan',
+    created_at: existing?.created_at ?? now,
+    // Terminal statuses record a completion timestamp; reopening clears it.
+    completed_at: isTerminalStatus(updates.status) ? (existing?.completed_at ?? now) : null,
+    reason: updates.reason ?? existing?.reason,
+    // Membership + plan-level deps are preserved across status-only upserts.
+    initiative: updates.initiative ?? existing?.initiative,
+    depends_on: updates.depends_on ?? existing?.depends_on,
+  };
+  if (index === -1) entries.push(entry);
+  else entries[index] = entry;
+}
+
+/**
+ * Serialized read-modify-write of the plans registry. Holds a process-wide lock
+ * on the manifest path across the whole read → transform → write so concurrent
+ * tool calls cannot clobber each other (lost-update race). `transform` mutates
+ * the entries array in place and returns `true` when it changed something
+ * (return `false` to skip the rewrite).
+ */
+export function mutatePlansManifest(
+  transform: (entries: PlanManifestEntry[]) => boolean,
+): Effect.Effect<void, ReadError | PlanWriteError, FileSystem> {
+  return withFileLock(
+    MANIFEST_PATH,
+    Effect.gen(function* () {
+      const entries = yield* readPlansManifest();
+      const changed = transform(entries);
+      if (changed) yield* writePlansManifest(entries);
+    }),
+  );
+}
+
 export function upsertPlanEntry(
   name: string,
-  updates: { status: PlanStatus; title?: string; reason?: string },
+  updates: PlanUpsert,
 ): Effect.Effect<void, ReadError | PlanWriteError, FileSystem> {
-  return Effect.gen(function* () {
-    const entries = yield* readPlansManifest();
-    const now = new Date().toISOString();
-    const index = entries.findIndex((entry) => entry.name === name);
-    const existing = index === -1 ? undefined : entries[index];
-    const entry: PlanManifestEntry = {
-      _type: 'plan',
-      name,
-      status: updates.status,
-      title: updates.title ?? existing?.title ?? 'Untitled plan',
-      created_at: existing?.created_at ?? now,
-      // Terminal statuses record a completion timestamp; reopening clears it.
-      completed_at: isTerminalStatus(updates.status) ? (existing?.completed_at ?? now) : null,
-      reason: updates.reason ?? existing?.reason,
-    };
-    if (index === -1) entries.push(entry);
-    else entries[index] = entry;
-    yield* writePlansManifest(entries);
+  return mutatePlansManifest((entries) => {
+    applyPlanUpsert(entries, name, updates);
+    return true;
   });
 }
 
@@ -108,16 +159,16 @@ export function reconcilePlanStatus(
   finalizable: boolean,
   title?: string,
 ): Effect.Effect<void, ReadError | PlanWriteError, FileSystem> {
-  return Effect.gen(function* () {
-    const entries = yield* readPlansManifest();
+  return mutatePlansManifest((entries) => {
     const existing = entries.find((entry) => entry.name === name);
     // Reconcile only reflects task state for KNOWN plans; never conjure an
     // entry for an unregistered plan (orphans are surfaced, not auto-created).
-    if (!existing) return;
+    if (!existing) return false;
     // Do not resurrect / clobber an explicitly closed plan.
-    if (existing.status === 'superseded' || existing.status === 'abandoned') return;
+    if (existing.status === 'superseded' || existing.status === 'abandoned') return false;
     const status: PlanStatus = finalizable ? 'done' : 'in-progress';
-    if (existing.status === status) return; // no change
-    yield* upsertPlanEntry(name, { status, title });
+    if (existing.status === status) return false; // no change
+    applyPlanUpsert(entries, name, { status, title });
+    return true;
   });
 }

package/extensions/plan-mode/storage/task-storage.ts

@@ -11,6 +11,7 @@ import {
 } from '../errors.js';
 import { decodeTasksLine } from '../schema.js';
 import type { TaskMeta, TaskRecord } from '../types.js';
+import { withFileLock } from './file-lock.js';
 
 const TASKS_FILE = 'tasks.jsonl';
 
@@ -86,20 +87,25 @@ export function updateTask(
   ReadError | PlanWriteError | TasksFileNotFound | TaskNotFound,
   FileSystem
 > {
-  return Effect.gen(function* () {
-    const snapshot = yield* readTasksJsonl(planDir);
-    if (!snapshot) return yield* Effect.fail(new TasksFileNotFound({ planDir }));
+  // Serialize the read-modify-write so concurrent task updates to the same plan
+  // (e.g. parallel update_task / update_tasks calls) cannot clobber each other.
+  return withFileLock(
+    join(planDir, TASKS_FILE),
+    Effect.gen(function* () {
+      const snapshot = yield* readTasksJsonl(planDir);
+      if (!snapshot) return yield* Effect.fail(new TasksFileNotFound({ planDir }));
 
-    const index = snapshot.tasks.findIndex((task) => task.id === taskId);
-    if (index === -1) return yield* Effect.fail(new TaskNotFound({ planDir, taskId }));
+      const index = snapshot.tasks.findIndex((task) => task.id === taskId);
+      if (index === -1) return yield* Effect.fail(new TaskNotFound({ planDir, taskId }));
 
-    const updated: TaskRecord = {
-      ...snapshot.tasks[index],
-      ...updates,
-      updated_at: new Date().toISOString(),
-    };
-    snapshot.tasks[index] = updated;
-    yield* writeTasksJsonl(planDir, snapshot.meta, snapshot.tasks);
-    return updated;
-  });
+      const updated: TaskRecord = {
+        ...snapshot.tasks[index],
+        ...updates,
+        updated_at: new Date().toISOString(),
+      };
+      snapshot.tasks[index] = updated;
+      yield* writeTasksJsonl(planDir, snapshot.meta, snapshot.tasks);
+      return updated;
+    }),
+  );
 }

package/extensions/plan-mode/tools/initiative-status.ts

@@ -0,0 +1,191 @@
+/**
+ * initiative_status tool — read-only snapshot of an initiative.
+ *
+ * The initiative sibling of plan_status. Shows each member plan with its task
+ * progress (resolved/total), lifecycle status, and ready/blocked-by readiness
+ * derived from plan-level dependencies. This is the at-a-glance view for
+ * splitting an initiative's work across sessions or subagents: "ready" plans
+ * have all dependencies satisfied and can be picked up now.
+ */
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Text } from '@earendil-works/pi-tui';
+import { Type } from 'typebox';
+import { Effect } from 'effect';
+import type { RunPlanIO } from '../effects/runtime.js';
+import { FileSystem } from '../effects/filesystem.js';
+import { readPlansManifest, type PlanManifestEntry } from '../storage/plans-manifest.js';
+import { readInitiativesManifest } from '../storage/initiatives-manifest.js';
+import { readTasksJsonl } from '../storage/task-storage.js';
+import { initiativeRollup, membersOf, type InitiativeRollup } from '../initiative.js';
+
+/** Normalize an initiative hint (`x` or `.plans/x`) to a bare name. */
+function normalizeName(hint: string): string {
+  return hint
+    .replace(/^\.plans\//, '')
+    .replace(/\/+$/, '')
+    .trim();
+}
+
+interface TaskCount {
+  resolved: number;
+  total: number;
+}
+
+/** Load member task counts for a set of plans (resolved = done + skipped). */
+function loadTaskCounts(
+  plans: readonly PlanManifestEntry[],
+): Effect.Effect<Map<string, TaskCount>, never, FileSystem> {
+  return Effect.gen(function* () {
+    const counts = new Map<string, TaskCount>();
+    for (const plan of plans) {
+      const snapshot = yield* Effect.orElseSucceed(
+        readTasksJsonl(`.plans/${plan.name}`),
+        () => undefined,
+      );
+      const total = snapshot?.tasks.length ?? 0;
+      const resolved =
+        snapshot?.tasks.filter((t) => t.status === 'done' || t.status === 'skipped').length ?? 0;
+      counts.set(plan.name, { resolved, total });
+    }
+    return counts;
+  });
+}
+
+const STATUS_GLYPH: Record<string, string> = {
+  'in-progress': '○',
+  done: '✓',
+  superseded: '🔄',
+  abandoned: '✗',
+};
+
+export function registerInitiativeStatusTool(pi: ExtensionAPI, runPlanIO: RunPlanIO): void {
+  pi.registerTool({
+    name: 'initiative_status',
+    label: 'Initiative Status',
+    description:
+      'Read-only snapshot of an initiative: member plans with task progress, status, and ready/blocked-by. Use to see what work is unblocked and can be picked up next.',
+    promptSnippet: 'Show an initiative: member plans, progress, and ready/blocked work',
+    promptGuidelines: [
+      'Call initiative_status to see which member plans are ready (dependencies satisfied) before dispatching work across sessions or subagents.',
+      'It is read-only and never mutates state.',
+    ],
+    parameters: Type.Object({
+      initiative: Type.Optional(
+        Type.String({
+          description:
+            'Initiative name (or .plans/<name>). Omit to use the sole in-progress initiative.',
+        }),
+      ),
+    }),
+
+    async execute(_toolCallId, params) {
+      const hint = params.initiative ? normalizeName(params.initiative) : undefined;
+
+      const snapshot = await runPlanIO(
+        Effect.gen(function* () {
+          const initiatives = yield* readInitiativesManifest();
+          const plans = yield* readPlansManifest();
+          return { initiatives, plans };
+        }),
+      );
+      const { initiatives, plans } = snapshot;
+
+      // Resolve the target initiative.
+      let targetName = hint;
+      if (!targetName) {
+        const inProgress = initiatives.filter((entry) => entry.status === 'in-progress');
+        if (inProgress.length === 1) targetName = inProgress[0]!.name;
+        else {
+          // Zero or many: list in-progress initiatives with rollup progress.
+          const rows = inProgress.map((entry) => {
+            const r = initiativeRollup(entry.name, plans);
+            return `  ${r.done}/${r.total} plans  ${entry.name} — ${entry.title} (ready ${r.ready}, blocked ${r.blocked})`;
+          });
+          const text = inProgress.length
+            ? `No single active initiative — ${inProgress.length} in-progress. Pass { initiative: "<name>" }.\n${rows.join('\n')}`
+            : 'No in-progress initiative found in .plans/initiatives.jsonl.';
+          return {
+            content: [{ type: 'text' as const, text }],
+            details: {
+              active: false,
+              in_progress: inProgress.map((e) => e.name),
+            } as Record<string, unknown>,
+          };
+        }
+      }
+
+      const entry = initiatives.find((e) => e.name === targetName);
+      if (!entry) {
+        const names = initiatives.map((e) => e.name).join(', ');
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: `Initiative not found: ${targetName}. Known: ${names || '(none)'}`,
+            },
+          ],
+          details: {
+            active: false,
+            error: 'not_found',
+            initiative: targetName,
+          } as Record<string, unknown>,
+        };
+      }
+
+      const rollup: InitiativeRollup = initiativeRollup(entry.name, plans);
+      const taskCounts = await runPlanIO(loadTaskCounts(membersOf(entry.name, plans)));
+
+      const memberLines = rollup.members.map((m) => {
+        const glyph = STATUS_GLYPH[m.status] ?? '○';
+        const tc = taskCounts.get(m.name);
+        const progress = tc && tc.total > 0 ? ` ${tc.resolved}/${tc.total} tasks` : '';
+        let readiness = '';
+        if (m.status === 'in-progress') {
+          readiness = m.ready ? '  [ready]' : `  [blocked by ${m.blockedBy?.join(', ')}]`;
+        }
+        return `  ${glyph} ${m.name} [${m.status}]${progress}${readiness}`;
+      });
+
+      const text =
+        `Initiative: ${entry.title} (${entry.name}) — ${entry.status}\n` +
+        `Plans: ${rollup.done}/${rollup.total} done — in-progress ${rollup.inProgress} (ready ${rollup.ready}, blocked ${rollup.blocked})` +
+        (rollup.closed ? `, closed ${rollup.closed}` : '') +
+        '\n' +
+        (memberLines.length ? `Member plans:\n${memberLines.join('\n')}` : 'No member plans yet.');
+
+      return {
+        content: [{ type: 'text' as const, text }],
+        details: {
+          active: true,
+          initiative: entry.name,
+          status: entry.status,
+          rollup,
+          ready_plans: rollup.members.filter((m) => m.ready).map((m) => m.name),
+        } as Record<string, unknown>,
+      };
+    },
+
+    renderCall(args, theme) {
+      const name = (args as { initiative?: string }).initiative;
+      let content = theme.fg('toolTitle', theme.bold('initiative_status'));
+      if (name) content += ' ' + theme.fg('muted', name);
+      return new Text(content, 0, 0);
+    },
+
+    renderResult(result, _options, theme) {
+      const details = result.details as
+        | { active?: boolean; initiative?: string; rollup?: InitiativeRollup }
+        | undefined;
+      if (!details?.active || !details.rollup)
+        return new Text(theme.fg('dim', 'No active initiative'), 0, 0);
+      const r = details.rollup;
+      return new Text(
+        theme.fg('toolTitle', `${details.initiative ?? 'initiative'} `) +
+          theme.fg('muted', `${r.done}/${r.total} plans — ready ${r.ready}, blocked ${r.blocked}`),
+        0,
+        0,
+      );
+    },
+  });
+}

package/extensions/plan-mode/tools/reconcile-plans.ts

@@ -11,7 +11,14 @@ import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { Text } from '@earendil-works/pi-tui';
 import { Type } from 'typebox';
 import type { RunPlanIO } from '../effects/runtime.js';
-import { applyReconcile, collectPlanDrift, type PlanDriftRow } from '../reconcile.js';
+import {
+  applyInitiativeReconcile,
+  applyReconcile,
+  collectInitiativeDrift,
+  collectPlanDrift,
+  type InitiativeDriftRow,
+  type PlanDriftRow,
+} from '../reconcile.js';
 
 function describeRow(row: PlanDriftRow): string {
   const progress = row.hasTasks ? ` (${row.resolved}/${row.total})` : '';
@@ -22,6 +29,10 @@ function describeRow(row: PlanDriftRow): string {
     return `  ⚠ ${row.name}${progress} — tasks.jsonl with no registry entry (orphan)`;
   }
   if (row.drift === 'status') {
+    if (row.direction === 'downgrade') {
+      // Wrong-direction projection: do NOT auto-repair. Mark tasks done instead.
+      return `  ⚠ ${row.name}${progress} — registry ${row.registryStatus}, tasks say ${row.derivedStatus} (likely merged; mark tasks done — not auto-repaired)`;
+    }
     return `  ✗ ${row.name}${progress} — registry ${row.registryStatus}, tasks say ${row.derivedStatus}`;
   }
   return `  ✓ ${row.name}${progress} — ${row.registryStatus} (in sync)`;
@@ -37,6 +48,7 @@ export function registerReconcilePlansTool(pi: ExtensionAPI, runPlanIO: RunPlanI
     promptGuidelines: [
       'Use reconcile_plans to audit .plans/ when registry status looks stale (e.g. a fully-done plan still in-progress).',
       'Run it read-only first; pass apply:true once you have reviewed the reported drift.',
+      'apply:true only records completion (in-progress→done). It never regresses a done plan back to in-progress — if a done plan shows incomplete tasks (work merged but tasks not marked), mark those tasks done instead.',
     ],
     parameters: Type.Object({
       apply: Type.Optional(
@@ -48,38 +60,64 @@ export function registerReconcilePlansTool(pi: ExtensionAPI, runPlanIO: RunPlanI
 
     async execute(_toolCallId, params) {
       const rows = await runPlanIO(collectPlanDrift());
+      const initiativeRows = await runPlanIO(collectInitiativeDrift());
       const drifted = rows.filter((row) => row.drift);
+      const initiativeDrifted = initiativeRows.filter((row) => row.drift);
 
       let repaired: PlanDriftRow[] = [];
+      let initiativeRepaired: InitiativeDriftRow[] = [];
       if (params.apply) {
         repaired = await runPlanIO(applyReconcile(rows));
+        // Re-collect after plan repairs so initiative projection sees fresh state.
+        initiativeRepaired = await runPlanIO(
+          applyInitiativeReconcile(await runPlanIO(collectInitiativeDrift())),
+        );
       }
 
       const lines = rows.map(describeRow);
-      const statusDrift = drifted.filter((r) => r.drift === 'status').length;
+      const initiativeLines = initiativeRows.map(
+        (row) =>
+          row.drift === 'status'
+            ? `  ✗ ${row.name} (initiative, ${row.members} plans) — registry ${row.registryStatus}, plans say ${row.derivedStatus}`
+            : `  ✓ ${row.name} (initiative, ${row.members} plans) — ${row.registryStatus} (in sync)`,
+      );
+      const statusDrift = drifted.filter(
+        (r) => r.drift === 'status' && r.direction === 'upgrade',
+      ).length;
+      const downgrades = drifted.filter(
+        (r) => r.drift === 'status' && r.direction === 'downgrade',
+      ).length;
       const orphans = drifted.filter((r) => r.drift === 'orphan').length;
       const registryOnly = drifted.filter((r) => r.drift === 'registry-only').length;
 
+      const totalDrift = drifted.length + initiativeDrifted.length;
       const header = params.apply
-        ? `Reconciled ${repaired.length} plan(s).`
-        : drifted.length === 0
-          ? 'All plans in sync.'
-          : `${drifted.length} drift issue(s) found (run with apply:true to repair status drift).`;
+        ? `Reconciled ${repaired.length} plan(s) + ${initiativeRepaired.length} initiative(s).`
+        : totalDrift === 0
+          ? 'All plans and initiatives in sync.'
+          : `${totalDrift} drift issue(s) found (run with apply:true to repair status drift).`;
 
       const summary = [
         `status-drift ${statusDrift}`,
+        `needs-tasks-done ${downgrades}`,
         `orphan ${orphans}`,
         `registry-only ${registryOnly}`,
       ].join(', ');
 
-      const text = `${header}\n${summary}\n${lines.join('\n')}`;
+      const initiativeBlock = initiativeLines.length
+        ? `\nInitiatives:\n${initiativeLines.join('\n')}`
+        : '';
+      const text = `${header}\n${summary}\n${lines.join('\n')}${initiativeBlock}`;
       return {
         content: [{ type: 'text' as const, text }],
         details: {
           applied: Boolean(params.apply),
           repaired: repaired.map((r) => r.name),
-          drift: drifted.map((r) => ({ name: r.name, kind: r.drift })),
+          drift: drifted.map((r) => ({ name: r.name, kind: r.drift, direction: r.direction })),
           total: rows.length,
+          initiative_repaired: initiativeRepaired.map((r) => r.name),
+          initiative_drift: initiativeDrifted.map((r) => ({ name: r.name, kind: r.drift })),
+          initiative_total: initiativeRows.length,
         },
       };
     },