@khoavu882/doflow 2.0.0-beta.3 → 2.0.0-beta.5

package/src/runtime/lifecycle/{fold.ts → fold.js}

@@ -17,19 +17,19 @@
 
 const SETTLE_AS = ['kept', 'dismissed', 'fix', 'done'];
 
-function byOrder(a: any, b: any): number {
+function byOrder(a     , b     )         {
   const delta = Date.parse(a.at) - Date.parse(b.at);
   if (delta !== 0) return delta;
   return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
 }
 
-function isText(value: any): boolean { return typeof value === 'string' && value.trim() !== ''; }
-function isIdList(value: any): boolean { return Array.isArray(value) && value.length > 0 && value.every(isText); }
+function isText(value     )          { return typeof value === 'string' && value.trim() !== ''; }
+function isIdList(value     )          { return Array.isArray(value) && value.length > 0 && value.every(isText); }
 
 /** DEC-045: an event dated further ahead than this stays out of the fold and is listed as a conflict. */
 const FUTURE_LIMIT_MS = 24 * 60 * 60 * 1000;
 
-function newState({ now = new Date() }: { now?: Date } = {}): any {
+function newState({ now = new Date() }                 = {})      {
   return {
     cutoff: now.getTime() + FUTURE_LIMIT_MS,
     items: new Map(),
@@ -43,15 +43,15 @@ function newState({ now = new Date() }: { now?: Date } = {}): any {
   };
 }
 
-function conflict(event: any, code: string, reason: string): { event: string; type: string; reason: string; code: string } {
+function conflict(event     , code        , reason        )                                                                {
   return { event: event.id, type: event.type, reason, code };
 }
 
-function touch(item: any, event: any): void {
+function touch(item     , event     )       {
   item.history.push({ event: event.id, type: event.type, at: event.at, by: event.by });
 }
 
-function itemFor(state: any, event: any, id: string): { item?: any; problem?: any } {
+function itemFor(state     , event     , id        )                                {
   const item = state.items.get(id);
   if (!item) return { problem: conflict(event, 'unknown-id', `${id} is not a follow-up`) };
   if (state.final.has(id)) return { problem: conflict(event, 'illegal-transition', `${id} is done and accepts no later event`) };
@@ -60,13 +60,13 @@ function itemFor(state: any, event: any, id: string): { item?: any; problem?: an
 
 // ── follow-ups ─────────────────────────────────────────────────────────────────────────────────
 
-function applyAdded(state: any, event: any): any[] {
+function applyAdded(state     , event     )        {
   const d = event.data;
   if (!isText(d.id) || !isText(d.statement) || !d.source || typeof d.source !== 'object' || !isText(d.source.kind)) {
     return [conflict(event, 'malformed', 'followup.added needs id, statement and source.kind')];
   }
   if (state.items.has(d.id)) return [conflict(event, 'illegal-transition', `${d.id} was already added`)];
-  const item: any = {
+  const item      = {
     id: d.id,
     statement: d.statement,
     source: d.source,
@@ -88,10 +88,10 @@ function applyAdded(state: any, event: any): any[] {
   return [];
 }
 
-function applyTaken(state: any, event: any): any[] {
+function applyTaken(state     , event     )        {
   const d = event.data;
   if (!isIdList(d.ids) || !isText(d.feature)) return [conflict(event, 'malformed', 'followup.taken needs ids and feature')];
-  const problems: any[] = [];
+  const problems        = [];
   for (const id of d.ids) {
     const { item, problem } = itemFor(state, event, id);
     if (problem) { problems.push(problem); continue; }
@@ -104,11 +104,11 @@ function applyTaken(state: any, event: any): any[] {
   return problems;
 }
 
-function settleOne(state: any, event: any, id: string): any {
+function settleOne(state     , event     , id        )      {
   const d = event.data;
   const { item, problem } = itemFor(state, event, id);
   if (problem) return problem;
-  const refuse = (reason: string) => conflict(event, 'illegal-transition', reason);
+  const refuse = (reason        ) => conflict(event, 'illegal-transition', reason);
   switch (d.as) {
     case 'kept':
       // IC-003: a reason is required when a taken item is released or a dismissed one reopens, not for an open one.
@@ -139,18 +139,18 @@ function settleOne(state: any, event: any, id: string): any {
   return null;
 }
 
-function applySettled(state: any, event: any): any[] {
+function applySettled(state     , event     )        {
   const d = event.data;
   // The legacy single-id shape (`id`) and the batch shape (`ids`) both fold; the verb writes one event per id.
   const ids = isText(d.id) ? [d.id] : d.ids;
   if (!isIdList(ids)) return [conflict(event, 'malformed', 'followup.settled needs an id')];
-  return ids.map((id: string) => settleOne(state, event, id)).filter(Boolean);
+  return ids.map((id        ) => settleOne(state, event, id)).filter(Boolean);
 }
 
-function applyPromoted(state: any, event: any): any[] {
+function applyPromoted(state     , event     )        {
   const d = event.data;
   if (!isIdList(d.ids) || !isText(d.intent)) return [conflict(event, 'malformed', 'followup.promoted needs ids and intent')];
-  const problems: any[] = [];
+  const problems        = [];
   for (const id of d.ids) {
     const { item, problem } = itemFor(state, event, id);
     if (problem) { problems.push(problem); continue; }
@@ -164,7 +164,7 @@ function applyPromoted(state: any, event: any): any[] {
 
 // ── features, goals, releases ──────────────────────────────────────────────────────────────────
 
-function applyTracked(state: any, event: any): any[] {
+function applyTracked(state     , event     )        {
   const slug = event.data.slug;
   if (!isText(slug)) return [conflict(event, 'malformed', 'feature.tracked needs a slug')];
   // The earliest event counts; a later one from another clone changes nothing and is no conflict.
@@ -172,19 +172,19 @@ function applyTracked(state: any, event: any): any[] {
   return [];
 }
 
-function applyMerged(state: any, event: any): any[] {
+function applyMerged(state     , event     )        {
   const { slug, reason } = event.data;
   if (!isText(slug)) return [conflict(event, 'malformed', 'feature.merged needs a slug')];
   if (!state.merged.has(slug)) state.merged.set(slug, { slug, reason: typeof reason === 'string' ? reason : '', at: event.at });
   return [];
 }
 
-function goalFor(state: any, event: any, id: string): { goal?: any; problem?: any } {
+function goalFor(state     , event     , id        )                                {
   const goal = state.goals.get(id);
   return goal ? { goal } : { problem: conflict(event, 'unknown-goal', `${id} is not a goal`) };
 }
 
-function applyGoalAdded(state: any, event: any): any[] {
+function applyGoalAdded(state     , event     )        {
   const d = event.data;
   if (!isText(d.goal) || !Array.isArray(d.items)) return [conflict(event, 'malformed', 'goal.added needs goal and items')];
   // A second `goal.added` for one id, as another clone may write, loses: the first wins.
@@ -195,26 +195,26 @@ function applyGoalAdded(state: any, event: any): any[] {
     status: 'open',
     reason: null,
     added: event.at.slice(0, 10),
-    items: d.items.filter((i: any) => i && isText(i.id)).map((i: any) => ({ id: i.id, text: String(i.text ?? ''), met: false, evidence: null })),
+    items: d.items.filter((i     ) => i && isText(i.id)).map((i     ) => ({ id: i.id, text: String(i.text ?? ''), met: false, evidence: null })),
   });
   return [];
 }
 
-function applyGoalItemAdded(state: any, event: any): any[] {
+function applyGoalItemAdded(state     , event     )        {
   const d = event.data;
   const { goal, problem } = goalFor(state, event, d.goal);
   if (problem) return [problem];
   if (!d.item || !isText(d.item.id)) return [conflict(event, 'malformed', 'goal.item-added needs item.id')];
-  if (goal.items.some((i: any) => i.id === d.item.id)) return [conflict(event, 'illegal-transition', `${d.goal} already has item ${d.item.id}`)];
+  if (goal.items.some((i     ) => i.id === d.item.id)) return [conflict(event, 'illegal-transition', `${d.goal} already has item ${d.item.id}`)];
   goal.items.push({ id: d.item.id, text: String(d.item.text ?? ''), met: false, evidence: null });
   return [];
 }
 
-function applyGoalChecked(state: any, event: any): any[] {
+function applyGoalChecked(state     , event     )        {
   const d = event.data;
   const { goal, problem } = goalFor(state, event, d.goal);
   if (problem) return [problem];
-  const item = goal.items.find((i: any) => i.id === d.item);
+  const item = goal.items.find((i     ) => i.id === d.item);
   if (!item) return [conflict(event, 'unknown-item', `${d.goal} has no item ${d.item}`)];
   if (!isText(d.evidence)) return [conflict(event, 'evidence-required', 'goal.checked needs evidence')];
   item.met = d.met === true;
@@ -222,7 +222,7 @@ function applyGoalChecked(state: any, event: any): any[] {
   return [];
 }
 
-function applyGoalLinked(state: any, event: any): any[] {
+function applyGoalLinked(state     , event     )        {
   const d = event.data;
   const { problem } = goalFor(state, event, d.goal);
   if (problem) return [problem];
@@ -235,7 +235,7 @@ function applyGoalLinked(state: any, event: any): any[] {
   return [];
 }
 
-function applyGoalDone(state: any, event: any): any[] {
+function applyGoalDone(state     , event     )        {
   const d = event.data;
   const { goal, problem } = goalFor(state, event, d.goal);
   if (problem) return [problem];
@@ -244,7 +244,7 @@ function applyGoalDone(state: any, event: any): any[] {
   return [];
 }
 
-function applyReleaseRecorded(state: any, event: any): any[] {
+function applyReleaseRecorded(state     , event     )        {
   const d = event.data;
   if (!isText(d.tag)) return [conflict(event, 'malformed', 'release.recorded needs a tag')];
   let release = state.releases.get(d.tag);
@@ -260,7 +260,7 @@ function applyReleaseRecorded(state: any, event: any): any[] {
   return [];
 }
 
-const APPLY: Record<string, (state: any, event: any) => any[]> = {
+const APPLY                                                    = {
   'followup.added': applyAdded,
   'followup.taken': applyTaken,
   'followup.settled': applySettled,
@@ -283,7 +283,7 @@ const EVENT_TYPES = Object.keys(APPLY);
  * conflicts to refuse before anything is written.
  * @returns {Array<{event:string,type:string,reason:string,code:string}>} the conflicts this event raised
  */
-function applyEvent(state: any, event: any, { checkFuture = true }: { checkFuture?: boolean } = {}): any[] {
+function applyEvent(state     , event     , { checkFuture = true }                            = {})        {
   const at = Date.parse(event.at);
   if (checkFuture && at > state.cutoff) {
     // Left out of the stamping floor and of every tracking bound: one wrong clock must not move them.
@@ -301,7 +301,7 @@ function applyEvent(state: any, event: any, { checkFuture = true }: { checkFutur
 }
 
 /** @param {Array<Object>} events IC-002 envelopes, in any order */
-function foldInto(events: any[], options: any = {}): any {
+function foldInto(events       , options      = {})      {
   const state = newState(options);
   if (options.shouldStop?.()) { state.incomplete = true; return state; }
   const ordered = [...events].sort(byOrder);
@@ -315,16 +315,16 @@ function foldInto(events: any[], options: any = {}): any {
 }
 
 /** The result of a fold, as plain data. `hasBody(item)` tells a report whose body is on this machine. */
-function finalize(state: any, { hasBody = () => false }: any = {}): any {
-  const followups = [...state.items.values()].map((item: any) => (
+function finalize(state     , { hasBody = () => false }      = {})      {
+  const followups = [...state.items.values()].map((item     ) => (
     item.source.kind === 'report' ? { ...item, body: hasBody(item) ? 'on-this-machine' : 'not-on-this-machine' } : item));
-  const releases = [...state.releases.values()].map((r: any) => {
+  const releases = [...state.releases.values()].map((r     ) => {
     const excluded = [...r.excluded];
-    return { tag: r.tag, commit: r.commit, features: [...r.features.values()].filter((f: any) => !r.excluded.has(f.slug)), excluded };
+    return { tag: r.tag, commit: r.commit, features: [...r.features.values()].filter((f     ) => !r.excluded.has(f.slug)), excluded };
   });
   return {
     followups,
-    features: [...state.tracked.values()].map((f: any) => ({ ...f })),
+    features: [...state.tracked.values()].map((f     ) => ({ ...f })),
     merged: [...state.merged.values()],
     goals: [...state.goals.values()],
     releases,
@@ -334,7 +334,7 @@ function finalize(state: any, { hasBody = () => false }: any = {}): any {
 }
 
 /** @returns {ReturnType<typeof finalize>} */
-function foldEvents(events: any[], options: any = {}): any {
+function foldEvents(events       , options      = {})      {
   return finalize(foldInto(events, options), options);
 }
 
@@ -344,9 +344,9 @@ function foldEvents(events: any[], options: any = {}): any {
  * @param {Array<Object>} followups folded items
  * @param {Object<string,string>|Map<string,string>} statuses feature slug to derived status
  */
-function withDerivedDone(followups: any[], statuses: any): any[] {
-  const statusOf = (slug: string) => (statuses instanceof Map ? statuses.get(slug) : statuses[slug]);
-  return followups.map((item: any) => (
+function withDerivedDone(followups       , statuses     )        {
+  const statusOf = (slug        ) => (statuses instanceof Map ? statuses.get(slug) : statuses[slug]);
+  return followups.map((item     ) => (
     item.state === 'taken' && statusOf(item.takenBy) === 'finished' ? { ...item, state: 'done', derived: true } : item));
 }
 

package/src/runtime/lifecycle/{followup.ts → followup.js}

@@ -17,15 +17,15 @@
 const nodeFs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { maskLine } = require('../mask.ts');
-const { STAGES: CHAIN_STAGES } = require('../decision-register.ts');
-const { isSafeSlug, invalidSlugRefusal } = require('../task-scope.ts');
-const { resolveActiveFeature } = require('../feature-resolve.ts');
-const { SETTLE_AS, withDerivedDone } = require('./fold.ts');
-const { appendEvents, readFold, byFromChannel, randomChars } = require('./event-store.ts');
-const { deriveStatuses } = require('./status.ts');
-const { writeIntent, kebabTitle } = require('./intent-writer.ts');
-const reportStore = require('./report-store.ts');
+const { maskLine } = require('../mask.js');
+const { STAGES: CHAIN_STAGES } = require('../decision-register.js');
+const { isSafeSlug, invalidSlugRefusal } = require('../task-scope.js');
+const { resolveActiveFeature } = require('../feature-resolve.js');
+const { SETTLE_AS, withDerivedDone } = require('./fold.js');
+const { appendEvents, readFold, byFromChannel, randomChars } = require('./event-store.js');
+const { deriveStatuses } = require('./status.js');
+const { writeIntent, kebabTitle } = require('./intent-writer.js');
+const reportStore = require('./report-store.js');
 
 /** The decision register's stages plus the two lifecycle stages (IC-006). */
 const STAGES = [...CHAIN_STAGES, 'release', 'maintain'];
@@ -43,16 +43,16 @@ const CONFLICT_FINDINGS = new Set(['unknown-id', 'untracked-feature', 'intent-ex
 /** A caller mistake (exit 2). */
 class FollowupUsageError extends Error {}
 
-function refusal(action: any, finding: any, message: any) { return { ok: false, action, finding, message }; }
+function refusal(action     , finding     , message     ) { return { ok: false, action, finding, message }; }
 
 /** Maps an `appendEvents` failure to a refusal result. */
-function refusalFrom(action: any, failed: any) {
+function refusalFrom(action     , failed     ) {
   const finding = failed.conflict && CONFLICT_FINDINGS.has(failed.conflict.code) ? failed.conflict.code : failed.finding;
   return refusal(action, finding, failed.message);
 }
 
 /** Masks a free-text field and checks it is one non-empty line of at most `max` characters. */
-function oneLine(raw: any, label: any, problems: any, { max = STATEMENT_MAX }: any = {}) {
+function oneLine(raw     , label     , problems     , { max = STATEMENT_MAX }      = {}) {
   // The length is checked before masking as well, so the masking patterns never see more than a bounded input.
   const rawLength = String(raw ?? '').length;
   if (rawLength > max * 4) { problems.push(`${label} is ${rawLength} characters; the limit is ${max}`); return null; }
@@ -64,20 +64,20 @@ function oneLine(raw: any, label: any, problems: any, { max = STATEMENT_MAX }: a
   return text;
 }
 
-function newFollowupId(taken: any) {
+function newFollowupId(taken     ) {
   for (;;) {
     const id = `FU-${randomChars(6)}`;
     if (!taken.has(id)) { taken.add(id); return id; }
   }
 }
 
-function channelBy(channel: any) {
+function channelBy(channel     ) {
   const by = byFromChannel(channel || 'default');
   if (!by) throw new FollowupUsageError(`unknown --channel '${channel}'. Valid: question, gate, prompt, default`);
   return by;
 }
 
-function parseIds(raw: any, label = '--ids') {
+function parseIds(raw     , label = '--ids') {
   const list = Array.isArray(raw) ? raw : String(raw ?? '').split(',');
   const ids = [...new Set(list.flatMap((entry) => String(entry).split(',')).map((id) => id.trim()).filter(Boolean))];
   if (ids.length === 0) throw new FollowupUsageError(`${label} is required: one or more follow-up ids, comma separated`);
@@ -87,18 +87,18 @@ function parseIds(raw: any, label = '--ids') {
 }
 
 /** The folded store, with a taken item shown `done` while its feature derives finished (IC-003, IC-021). */
-function loadFollowups(root: any, { hasBody, fsImpl = nodeFs, statuses, now = new Date() }: any = {}) {
+function loadFollowups(root     , { hasBody, fsImpl = nodeFs, statuses, now = new Date() }      = {}) {
   const fold = readFold(root, { hasBody: hasBody || reportStore.bodyChecker(root, { fsImpl }), fsImpl, now });
-  const needsStatus = fold.followups.some((item: any) => item.state === 'taken');
+  const needsStatus = fold.followups.some((item     ) => item.state === 'taken');
   const derived = needsStatus ? (statuses || deriveStatuses({ root, fold })) : null;
-  const followups = needsStatus ? withDerivedDone(fold.followups, Object.fromEntries(Object.entries(derived.statuses).map(([slug, s]: [string, any]) => [slug, s.status]))) : fold.followups;
+  const followups = needsStatus ? withDerivedDone(fold.followups, Object.fromEntries(Object.entries(derived.statuses).map(([slug, s]               ) => [slug, s.status]))) : fold.followups;
   return { fold, followups };
 }
 
 // ── add ────────────────────────────────────────────────────────────────────────────────────────
 
 /** The active feature slug: `--slug`, else the branch through the existing resolver; null when neither. */
-function resolveFeatureSlug({ cwd, slug }: any) {
+function resolveFeatureSlug({ cwd, slug }     ) {
   if (slug) {
     const bad = invalidSlugRefusal(slug);
     if (bad) throw new FollowupUsageError(bad.message);
@@ -118,8 +118,8 @@ function resolveFeatureSlug({ cwd, slug }: any) {
   return resolved;
 }
 
-function sourceFor(kind: any, fields: any, label: any, problems: any) {
-  const word = (value: any, name: any) => {
+function sourceFor(kind     , fields     , label     , problems     ) {
+  const word = (value     , name     ) => {
     if (typeof value === 'string' && WORD.test(value)) return value;
     problems.push(`${label}: ${name} must be letters, digits, dot, underscore or dash`);
     return null;
@@ -145,15 +145,15 @@ function sourceFor(kind: any, fields: any, label: any, problems: any) {
  * Validates every item and builds its `followup.added` data; nothing is written unless all pass.
  * @returns {Array<{statement:string, source:Object}>}
  */
-function buildItems({ cwd, items, defaults }: any) {
-  const problems: any[] = [];
-  let featureSlug: any;
+function buildItems({ cwd, items, defaults }     ) {
+  const problems        = [];
+  let featureSlug     ;
   const feature = () => {
     if (featureSlug === undefined) featureSlug = resolveFeatureSlug({ cwd, slug: defaults.slug });
     return featureSlug;
   };
-  const built: any[] = [];
-  items.forEach((raw: any, index: any) => {
+  const built        = [];
+  items.forEach((raw     , index     ) => {
     const label = items.length > 1 || defaults.batch ? `item ${index + 1}` : 'the follow-up';
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) { problems.push(`${label} must be an object`); return; }
     const statement = oneLine(raw.statement, `${label}: statement`, problems);
@@ -194,7 +194,7 @@ function buildItems({ cwd, items, defaults }: any) {
  * must be a regular file of at most 16 MiB, so a device or a FIFO is refused, never read.
  * @returns {Object[]}
  */
-function readBatchFile(file: any, fsImpl = nodeFs) {
+function readBatchFile(file     , fsImpl = nodeFs) {
   let parsed;
   let fd;
   try {
@@ -205,7 +205,7 @@ function readBatchFile(file: any, fsImpl = nodeFs) {
     if (!st.isFile()) throw new Error('not a regular file');
     if (st.size > reportStore.MAX_READ_BYTES) throw new Error('larger than 16 MiB');
     parsed = JSON.parse(fsImpl.readFileSync(fd, 'utf8'));
-  } catch (error: any) {
+  } catch (error     ) {
     throw new FollowupUsageError(`cannot read --batch ${file}: ${error.message}`);
   } finally {
     if (fd !== undefined) { try { fsImpl.closeSync(fd); } catch { /* read already done */ } }
@@ -218,18 +218,18 @@ function readBatchFile(file: any, fsImpl = nodeFs) {
  * IC-006 `add`. `items` are `{statement, stage?, source?}`; `defaults` holds the flag values
  * (`stage`, `slug`, `source`, `taskClass`, `taskId`, `release`, `batch`).
  */
-function addFollowups({ root, cwd = process.cwd(), items, defaults = {}, channel, now = new Date(), fsImpl = nodeFs }: any) {
+function addFollowups({ root, cwd = process.cwd(), items, defaults = {}, channel, now = new Date(), fsImpl = nodeFs }     ) {
   const by = channelBy(channel);
   const built = buildItems({ cwd, items, defaults });
-  const taken = new Set(readFold(root, { fsImpl, now }).followups.map((f: any) => f.id));
+  const taken = new Set(readFold(root, { fsImpl, now }).followups.map((f     ) => f.id));
   const drafts = built.map(({ statement, source }) => ({ type: 'followup.added', by, data: { id: newFollowupId(taken), statement, source } }));
   const out = appendEvents(root, drafts, { now, fsImpl });
   if (!out.ok) return refusalFrom('add', out);
   return {
     ok: true,
     action: 'add',
-    created: out.written.map(({ event }: any) => ({ id: event.data.id, statement: event.data.statement, source: event.data.source, state: 'open' })),
-    events: out.written.map((w: any) => w.file),
+    created: out.written.map(({ event }     ) => ({ id: event.data.id, statement: event.data.statement, source: event.data.source, state: 'open' })),
+    events: out.written.map((w     ) => w.file),
     next: [],
   };
 }
@@ -237,9 +237,9 @@ function addFollowups({ root, cwd = process.cwd(), items, defaults = {}, channel
 // ── report ─────────────────────────────────────────────────────────────────────────────────────
 
 /** `--release` and `--feature` of a report: letters, digits, dot, underscore or dash, as for `--source release`. */
-function reportSource({ release, feature }: any) {
+function reportSource({ release, feature }     ) {
   const problems = [];
-  const source: any = { kind: 'report' };
+  const source      = { kind: 'report' };
   if (release !== undefined && release !== null) {
     if (typeof release === 'string' && WORD.test(release)) source.release = release; else problems.push('--release must be letters, digits, dot, underscore or dash');
   }
@@ -269,21 +269,21 @@ function reportSource({ release, feature }: any) {
  * @param {string} [options.release]
  * @param {string|string[]} [options.feature]
  */
-function reportFollowup({ root, statement, input, release, feature, channel, now = new Date(), fsImpl = nodeFs, env = process.env }: any) {
+function reportFollowup({ root, statement, input, release, feature, channel, now = new Date(), fsImpl = nodeFs, env = process.env }     ) {
   const by = channelBy(channel);
   const source = reportSource({ release, feature });
-  const problems: any[] = [];
+  const problems        = [];
   const rawStatement = String(statement ?? '');
   const statementMasked = maskLine(rawStatement).masked;
   const cleanStatement = oneLine(rawStatement, '--statement', problems);
   if (problems.length) throw new FollowupUsageError(problems.join('; '));
   let raw;
-  try { raw = reportStore.readReportText(input, { fsImpl }); } catch (error: any) {
+  try { raw = reportStore.readReportText(input, { fsImpl }); } catch (error     ) {
     if (error instanceof reportStore.ReportInputError) throw new FollowupUsageError(error.message);
     throw error;
   }
   let body;
-  try { body = reportStore.prepareBody(raw, { home: env.HOME || os.homedir() }); } catch (error: any) {
+  try { body = reportStore.prepareBody(raw, { home: env.HOME || os.homedir() }); } catch (error     ) {
     if (error instanceof reportStore.ReportInputError) throw new FollowupUsageError(error.message);
     throw error;
   }
@@ -293,9 +293,9 @@ function reportFollowup({ root, statement, input, release, feature, channel, now
   // ANSI colour and title sequences were removed before masking; what is left is a real control or bidirectional character.
   if (CONTROL.test(excerpt)) throw new FollowupUsageError('the first 2 KB of the report body contain a control or bidirectional-override character; remove it and file the report again');
 
-  const taken = new Set(readFold(root, { fsImpl, now }).followups.map((f: any) => f.id));
+  const taken = new Set(readFold(root, { fsImpl, now }).followups.map((f     ) => f.id));
   let id;
-  let stored: any = { ok: false, reason: 'no-home' };
+  let stored      = { ok: false, reason: 'no-home' };
   for (let attempt = 0; attempt < 5; attempt += 1) {
     id = newFollowupId(taken);
     stored = reportStore.writeBody(root, id, body.buffer, { env, fsImpl });
@@ -309,7 +309,7 @@ function reportFollowup({ root, statement, input, release, feature, channel, now
   let out;
   try {
     out = appendEvents(root, [{ type: 'followup.added', by, data }], { now, fsImpl });
-  } catch (error: any) {
+  } catch (error     ) {
     if (kept) reportStore.removeBody(stored.file, fsImpl);
     throw error;
   }
@@ -327,7 +327,7 @@ function reportFollowup({ root, statement, input, release, feature, channel, now
       excerptBytes: Buffer.byteLength(excerpt, 'utf8'), bodyBytes: body.buffer.length,
       body: kept ? 'on-this-machine' : 'not-on-this-machine', masked: statementMasked + body.masked,
     }],
-    events: out.written.map((w: any) => w.file),
+    events: out.written.map((w     ) => w.file),
     next,
   };
 }
@@ -335,31 +335,31 @@ function reportFollowup({ root, statement, input, release, feature, channel, now
 // ── list ───────────────────────────────────────────────────────────────────────────────────────
 
 /** IC-006 `list`: `state` is open (default), taken, done, dismissed or all. */
-function listFollowups({ root, state = 'open', hasBody, fsImpl = nodeFs, statuses, now = new Date() }: any) {
+function listFollowups({ root, state = 'open', hasBody, fsImpl = nodeFs, statuses, now = new Date() }     ) {
   if (state !== 'all' && !STATES.includes(state)) throw new FollowupUsageError(`--state must be one of ${[...STATES, 'all'].join(', ')} (got '${state}')`);
   const { fold, followups } = loadFollowups(root, { hasBody, fsImpl, statuses, now });
-  const items = state === 'all' ? followups : followups.filter((item: any) => item.state === state);
+  const items = state === 'all' ? followups : followups.filter((item     ) => item.state === state);
   return { ok: true, action: 'list', state, count: items.length, items, conflicts: fold.conflicts, unreadable: fold.unreadable, unreadableReasons: fold.unreadableReasons, next: [] };
 }
 
 // ── take, settle, promote ──────────────────────────────────────────────────────────────────────
 
 /** IC-006 `take`: one `followup.taken` event; every id must be open and the feature tracked. */
-function takeFollowups({ root, ids, slug, channel, now = new Date(), fsImpl = nodeFs }: any) {
+function takeFollowups({ root, ids, slug, channel, now = new Date(), fsImpl = nodeFs }     ) {
   const list = parseIds(ids);
   if (!slug) throw new FollowupUsageError('--slug is required for --action take');
   const bad = invalidSlugRefusal(slug);
   if (bad) throw new FollowupUsageError(bad.message);
   const out = appendEvents(root, [{ type: 'followup.taken', by: channelBy(channel), data: { ids: list, feature: slug } }], { now, fsImpl });
   if (!out.ok) return refusalFrom('take', out);
-  return { ok: true, action: 'take', ids: list, feature: slug, events: out.written.map((w: any) => w.file), next: [] };
+  return { ok: true, action: 'take', ids: list, feature: slug, events: out.written.map((w     ) => w.file), next: [] };
 }
 
 /** IC-006 `settle`: one `followup.settled` event per id. Each `as` value's required field is in IC-003. */
-function settleFollowups({ root, ids, as, reason, evidence, channel, now = new Date(), fsImpl = nodeFs }: any) {
+function settleFollowups({ root, ids, as, reason, evidence, channel, now = new Date(), fsImpl = nodeFs }     ) {
   const list = parseIds(ids);
   if (!SETTLE_AS.includes(as)) throw new FollowupUsageError(`--as must be one of ${SETTLE_AS.join(', ')}${as ? ` (got '${as}')` : ''}`);
-  const problems: any[] = [];
+  const problems        = [];
   const cleanReason = reason === undefined ? null : oneLine(reason, '--reason', problems);
   const cleanEvidence = evidence === undefined ? null : oneLine(evidence, '--evidence', problems);
   // `kept` needs a reason only when it releases a taken item or reopens a dismissed one; the fold knows the state.
@@ -368,7 +368,7 @@ function settleFollowups({ root, ids, as, reason, evidence, channel, now = new D
   if (problems.length) throw new FollowupUsageError(problems.join('; '));
   const by = channelBy(channel);
   // `list` shows a taken item whose feature finished as `done`, but the fold still holds it `taken`: say what the user was shown.
-  const derivedDone = new Map(loadFollowups(root, { fsImpl, now }).followups.filter((item: any) => item.derived).map((item: any) => [item.id, item.takenBy]));
+  const derivedDone = new Map(loadFollowups(root, { fsImpl, now }).followups.filter((item     ) => item.derived).map((item     ) => [item.id, item.takenBy]));
   if (as !== 'kept') {
     const shown = list.find((id) => derivedDone.has(id));
     if (shown) {
@@ -384,7 +384,7 @@ function settleFollowups({ root, ids, as, reason, evidence, channel, now = new D
     action: 'settle',
     ids: list,
     as,
-    events: out.written.map((w: any) => w.file),
+    events: out.written.map((w     ) => w.file),
     next: reopened.map((id) => `${id} was shown as done because feature ${derivedDone.get(id)} finished; keeping it released it from that feature, so it is open again`),
   };
 }
@@ -393,9 +393,9 @@ function settleFollowups({ root, ids, as, reason, evidence, channel, now = new D
  * IC-006 `promote` (IC-024): creates a new intent that names the items, then writes one
  * `followup.promoted` event. It never adds items to an existing intent.
  */
-function promoteFollowups({ root, ids, title, channel, now = new Date(), fsImpl = nodeFs }: any) {
+function promoteFollowups({ root, ids, title, channel, now = new Date(), fsImpl = nodeFs }     ) {
   const list = parseIds(ids);
-  const problems: any[] = [];
+  const problems        = [];
   const cleanTitle = oneLine(title, '--title', problems, { max: 80 });
   if (problems.length) throw new FollowupUsageError(problems.join('; '));
   const by = channelBy(channel);
@@ -403,7 +403,7 @@ function promoteFollowups({ root, ids, title, channel, now = new Date(), fsImpl
   const { followups } = loadFollowups(root, { fsImpl, now });
   const items = [];
   for (const id of list) {
-    const item = followups.find((f: any) => f.id === id);
+    const item = followups.find((f     ) => f.id === id);
     if (!item) return refusal('promote', 'unknown-id', `${id} is not a follow-up. Nothing was written.`);
     if (item.state !== 'open') return refusal('promote', 'illegal-transition', `${id} is ${item.state}; only an open item can be promoted. Nothing was written.`);
     if (item.intent) return refusal('promote', 'intent-exists', `${id} was already promoted to ${item.intent}. Nothing was written.`);
@@ -418,7 +418,7 @@ function promoteFollowups({ root, ids, title, channel, now = new Date(), fsImpl
     const out = appendEvents(root, [{ type: 'followup.promoted', by, data: { ids: list, intent: written.path } }], { now, fsImpl });
     if (!out.ok) return refusalFrom('promote', out);
     committed = true;
-    return { ok: true, action: 'promote', intent: written.path, ids: list, events: out.written.map((w: any) => w.file), next: [] };
+    return { ok: true, action: 'promote', intent: written.path, ids: list, events: out.written.map((w     ) => w.file), next: [] };
   } finally {
     // The file is the one this call just created exclusively, so removing it undoes a half-done promotion on every failure path.
     if (!committed) { try { fsImpl.rmSync(written.file, { force: true }); } catch { /* the failure being reported stands */ } }