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

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

@@ -16,11 +16,11 @@
  */
 
 const nodeFs = require('node:fs');
-const { isSafeSlug, invalidSlugRefusal } = require('../task-scope.ts');
-const { appendEvents, readFold } = require('./event-store.ts');
-const { deriveStatuses } = require('./status.ts');
-const { FollowupUsageError, oneLine, channelBy } = require('./followup.ts');
-const { goalView, goalConflicts, goalConflictNext } = require('./overview.ts');
+const { isSafeSlug, invalidSlugRefusal } = require('../task-scope.js');
+const { appendEvents, readFold } = require('./event-store.js');
+const { deriveStatuses } = require('./status.js');
+const { FollowupUsageError, oneLine, channelBy } = require('./followup.js');
+const { goalView, goalConflicts, goalConflictNext } = require('./overview.js');
 
 const GOAL_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const GOAL_ID_MAX = 40;
@@ -32,14 +32,14 @@ const USER_CHANNELS = ['question', 'gate', 'prompt'];
 /** Fold conflicts that are a refusal under their own name; any other conflict is an `illegal-transition`. */
 const CONFLICT_FINDINGS = new Set(['goal-exists', 'unknown-goal', 'unknown-item', 'goal-already-linked', 'untracked-feature', 'evidence-required']);
 
-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 }; }
 
-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);
 }
 
-function goalIdOf(raw: any) {
+function goalIdOf(raw     ) {
   if (raw === undefined || raw === null || raw === '') throw new FollowupUsageError('--goal is required: a kebab-case goal id of at most 40 characters');
   const id = String(raw);
   if (id.length > GOAL_ID_MAX || !GOAL_ID.test(id)) {
@@ -48,7 +48,7 @@ function goalIdOf(raw: any) {
   return id;
 }
 
-function itemIdOf(raw: any) {
+function itemIdOf(raw     ) {
   const list = Array.isArray(raw) ? raw : raw === undefined ? [] : [raw];
   if (list.length !== 1) throw new FollowupUsageError('--item takes exactly one checklist id such as C3 for --action check');
   if (!ITEM_ID.test(String(list[0]))) throw new FollowupUsageError(`--item must be a checklist id such as C3 (got '${String(list[0]).slice(0, 40)}')`);
@@ -56,25 +56,25 @@ function itemIdOf(raw: any) {
 }
 
 /** One masked, one-line, bounded text; a problem is a usage error naming the flag. */
-function textOf(raw: any, label: any) {
-  const problems: any = [];
+function textOf(raw     , label     ) {
+  const problems      = [];
   const text = raw === undefined ? null : oneLine(raw, label, problems);
   if (problems.length) throw new FollowupUsageError(problems.join('; '));
   return text;
 }
 
-function requiredText(raw: any, label: any) {
+function requiredText(raw     , label     ) {
   if (raw === undefined || raw === null) throw new FollowupUsageError(`${label} is required`);
   return textOf(raw, label);
 }
 
-function unknownGoal(action: any, fold: any, id: any) {
-  const known = fold.goals.map((g: any) => g.goal);
+function unknownGoal(action     , fold     , id     ) {
+  const known = fold.goals.map((g     ) => g.goal);
   return refusal(action, 'unknown-goal', `${id} is not a goal${known.length ? `; the goals are ${known.join(', ')}` : '; none has been added'}. Nothing was written.`);
 }
 
 /** The next free `C<n>`: one past the largest number in use, so an id is never reused. */
-function nextItemId(goal: any) {
+function nextItemId(goal     ) {
   let top = 0;
   for (const item of goal.items) {
     const m = /^C(\d+)$/.exec(item.id);
@@ -83,51 +83,51 @@ function nextItemId(goal: any) {
   return `C${top + 1}`;
 }
 
-const progressOf = (goal: any) => ({ met: goal.items.filter((i: any) => i.met).length, total: goal.items.length });
+const progressOf = (goal     ) => ({ met: goal.items.filter((i     ) => i.met).length, total: goal.items.length });
 
-function checkLine(goalId: any, item: any) {
+function checkLine(goalId     , item     ) {
   return `Record a met item with evidence: doflow-run goal --action check --goal ${goalId} --item ${item} --evidence "<what shows it>"`;
 }
 
-function doneLine(goalId: any) {
+function doneLine(goalId     ) {
   return `Every item of ${goalId} is met; ask the user, then: doflow-run goal --action done --goal ${goalId} --channel question`;
 }
 
 // ── add, item ──────────────────────────────────────────────────────────────────────────────────
 
 /** IC-022 `add`: one `goal.added` event with the outcome and the checklist, ids `C1`, `C2`, ... */
-function addGoal({ root, goal, statement, items, channel, now = new Date(), fsImpl = nodeFs }: any) {
+function addGoal({ root, goal, statement, items, channel, now = new Date(), fsImpl = nodeFs }     ) {
   const id = goalIdOf(goal);
   const outcome = requiredText(statement, '--statement');
   const list = Array.isArray(items) ? items : items === undefined ? [] : [items];
   if (list.length === 0) throw new FollowupUsageError('--item is required for --action add: at least one checklist item (repeat --item for more)');
   if (list.length > ITEMS_MAX) throw new FollowupUsageError(`--item was given ${list.length} times; a goal starts with at most ${ITEMS_MAX} items`);
-  const problems: any = [];
+  const problems      = [];
   const checklist = list.map((raw, index) => ({ id: `C${index + 1}`, text: oneLine(raw, `--item ${index + 1}`, problems) }));
   if (problems.length) throw new FollowupUsageError(problems.join('; '));
   const by = channelBy(channel);
-  if (readFold(root, { fsImpl, now }).goals.some((g: any) => g.goal === id)) return refusal('add', 'goal-exists', `${id} already exists. Nothing was written.`);
+  if (readFold(root, { fsImpl, now }).goals.some((g     ) => g.goal === id)) return refusal('add', 'goal-exists', `${id} already exists. Nothing was written.`);
   const out = appendEvents(root, [{ type: 'goal.added', by, data: { goal: id, outcome, items: checklist } }], { now, fsImpl });
   if (!out.ok) return refusalFrom('add', out);
   return {
-    ok: true, action: 'add', goal: id, outcome, items: checklist, events: out.written.map((w: any) => w.file),
+    ok: true, action: 'add', goal: id, outcome, items: checklist, events: out.written.map((w     ) => w.file),
     next: [`Link a feature that serves it: doflow-run goal --action link --goal ${id} --slug <slug>`, checkLine(id, 'C1')],
   };
 }
 
 /** IC-022 `item`: one `goal.item-added` event; the id is the next free `C<n>`. */
-function addItem({ root, goal, text, channel, now = new Date(), fsImpl = nodeFs }: any) {
+function addItem({ root, goal, text, channel, now = new Date(), fsImpl = nodeFs }     ) {
   const id = goalIdOf(goal);
   const itemText = requiredText(text, '--text');
   const by = channelBy(channel);
   // The id is chosen before the lock, so a writer that took it first makes this call refuse; a retry picks the next one.
   for (let attempt = 0; ; attempt += 1) {
     const fold = readFold(root, { fsImpl, now });
-    const found = fold.goals.find((g: any) => g.goal === id);
+    const found = fold.goals.find((g     ) => g.goal === id);
     if (!found) return unknownGoal('item', fold, id);
     const item = { id: nextItemId(found), text: itemText };
     const out = appendEvents(root, [{ type: 'goal.item-added', by, data: { goal: id, item } }], { now, fsImpl });
-    if (out.ok) return { ok: true, action: 'item', goal: id, item, events: out.written.map((w: any) => w.file), next: [checkLine(id, item.id)] };
+    if (out.ok) return { ok: true, action: 'item', goal: id, item, events: out.written.map((w     ) => w.file), next: [checkLine(id, item.id)] };
     const raced = out.conflict && out.conflict.code === 'illegal-transition' && /already has item/.test(out.conflict.reason);
     if (!raced || attempt >= 4) return refusalFrom('item', out);
   }
@@ -136,39 +136,39 @@ function addItem({ root, goal, text, channel, now = new Date(), fsImpl = nodeFs
 // ── check, link ────────────────────────────────────────────────────────────────────────────────
 
 /** IC-022 `check`: `goal.checked` with `met: true`, or `met: false` under `--unmet`; evidence either way (DEC-015). */
-function checkItem({ root, goal, item, evidence, unmet = false, channel, now = new Date(), fsImpl = nodeFs }: any) {
+function checkItem({ root, goal, item, evidence, unmet = false, channel, now = new Date(), fsImpl = nodeFs }     ) {
   const id = goalIdOf(goal);
   const itemId = itemIdOf(item);
   const proof = requiredText(evidence, '--evidence');
   const by = channelBy(channel);
   const before = readFold(root, { fsImpl, now });
-  const found = before.goals.find((g: any) => g.goal === id);
+  const found = before.goals.find((g     ) => g.goal === id);
   if (!found) return unknownGoal('check', before, id);
-  if (!found.items.some((i: any) => i.id === itemId)) {
-    return refusal('check', 'unknown-item', `${id} has no item ${itemId}; its items are ${found.items.map((i: any) => i.id).join(', ')}. Nothing was written.`);
+  if (!found.items.some((i     ) => i.id === itemId)) {
+    return refusal('check', 'unknown-item', `${id} has no item ${itemId}; its items are ${found.items.map((i     ) => i.id).join(', ')}. Nothing was written.`);
   }
   const met = !unmet;
   const out = appendEvents(root, [{ type: 'goal.checked', by, data: { goal: id, item: itemId, met, evidence: proof } }], { now, fsImpl });
   if (!out.ok) return refusalFrom('check', out);
-  const after = readFold(root, { fsImpl, now }).goals.find((g: any) => g.goal === id) || found;
+  const after = readFold(root, { fsImpl, now }).goals.find((g     ) => g.goal === id) || found;
   const progress = progressOf(after);
   const proposeDone = after.status === 'open' && progress.total > 0 && progress.met === progress.total;
-  const unchecked = after.items.find((i: any) => !i.met);
+  const unchecked = after.items.find((i     ) => !i.met);
   return {
-    ok: true, action: 'check', goal: id, item: itemId, met, evidence: proof, progress, proposeDone, events: out.written.map((w: any) => w.file),
+    ok: true, action: 'check', goal: id, item: itemId, met, evidence: proof, progress, proposeDone, events: out.written.map((w     ) => w.file),
     next: proposeDone ? [doneLine(id)] : unchecked && after.status === 'open' ? [checkLine(id, unchecked.id)] : [],
   };
 }
 
 /** IC-022 `link`: one `goal.linked` event; a feature serves one goal at most (DEC-009). */
-function linkFeature({ root, goal, slug, replace = false, channel, now = new Date(), fsImpl = nodeFs }: any) {
+function linkFeature({ root, goal, slug, replace = false, channel, now = new Date(), fsImpl = nodeFs }     ) {
   const id = goalIdOf(goal);
   if (!slug) throw new FollowupUsageError('--slug is required for --action link');
   if (!isSafeSlug(slug)) throw new FollowupUsageError(invalidSlugRefusal(slug).message);
   const by = channelBy(channel);
   const fold = readFold(root, { fsImpl, now });
-  if (!fold.goals.some((g: any) => g.goal === id)) return unknownGoal('link', fold, id);
-  const feature = fold.features.find((f: any) => f.slug === slug);
+  if (!fold.goals.some((g     ) => g.goal === id)) return unknownGoal('link', fold, id);
+  const feature = fold.features.find((f     ) => f.slug === slug);
   if (!feature) return refusal('link', 'untracked-feature', `${slug} is not a tracked feature, so no goal can link it; run doflow-run lifecycle --action init --slug ${slug} first. Nothing was written.`);
   if (feature.goal === id) return { ok: true, action: 'link', goal: id, slug, linked: 'already', replaced: null, events: [], next: [] };
   if (feature.goal && !replace) {
@@ -176,17 +176,17 @@ function linkFeature({ root, goal, slug, replace = false, channel, now = new Dat
   }
   const out = appendEvents(root, [{ type: 'goal.linked', by, data: { goal: id, slug, replace: Boolean(replace) } }], { now, fsImpl });
   if (!out.ok) return refusalFrom('link', out);
-  return { ok: true, action: 'link', goal: id, slug, linked: 'new', replaced: feature.goal || null, events: out.written.map((w: any) => w.file), next: [] };
+  return { ok: true, action: 'link', goal: id, slug, linked: 'new', replaced: feature.goal || null, events: out.written.map((w     ) => w.file), next: [] };
 }
 
 // ── list ───────────────────────────────────────────────────────────────────────────────────────
 
 /** IC-022 progress for one goal: items, `progress`, `proposeDone`, linked features by status and the nudges. */
-function progressView(goal: any, fold: any, statuses: any, conflicts = []) {
+function progressView(goal     , fold     , statuses     , conflicts = []) {
   const view = goalView(goal, fold.features, statuses, conflicts);
   return {
     goal: goal.goal, outcome: goal.outcome, status: goal.status,
-    items: goal.items.map((i: any) => ({ id: i.id, text: i.text, met: i.met, evidence: i.evidence })),
+    items: goal.items.map((i     ) => ({ id: i.id, text: i.text, met: i.met, evidence: i.evidence })),
     progress: view.items, proposeDone: view.proposeDone, features: view.features, nudges: view.nudges,
     ...(view.conflicts ? { conflicts: view.conflicts } : {}),
     ...(goal.status === 'done' ? { reason: goal.reason } : {}),
@@ -194,25 +194,25 @@ function progressView(goal: any, fold: any, statuses: any, conflicts = []) {
 }
 
 /** IC-022 `list`: every goal, or the one named, with its progress. Reads git only when a goal has a linked feature. */
-function listGoals({ root, goal, now = new Date(), fsImpl = nodeFs }: any) {
+function listGoals({ root, goal, now = new Date(), fsImpl = nodeFs }     ) {
   const id = goal === undefined ? null : goalIdOf(goal);
   const fold = readFold(root, { fsImpl, now });
-  const shown = id === null ? fold.goals : fold.goals.filter((g: any) => g.goal === id);
+  const shown = id === null ? fold.goals : fold.goals.filter((g     ) => g.goal === id);
   if (id !== null && shown.length === 0) return unknownGoal('list', fold, id);
-  const linked = new Set(fold.features.filter((f: any) => shown.some((g: any) => g.goal === f.goal)).map((f: any) => f.slug));
+  const linked = new Set(fold.features.filter((f     ) => shown.some((g     ) => g.goal === f.goal)).map((f     ) => f.slug));
   const statuses = linked.size ? deriveStatuses({ root, fold }) : { statuses: {} };
   const conflictsByGoal = goalConflicts(root, fold, fsImpl);
-  const goals = shown.map((g: any) => progressView(g, fold, statuses, conflictsByGoal.get(g.goal)));
+  const goals = shown.map((g     ) => progressView(g, fold, statuses, conflictsByGoal.get(g.goal)));
   const next = [];
-  for (const g of goals.filter((x: any) => x.status === 'open')) {
+  for (const g of goals.filter((x     ) => x.status === 'open')) {
     if (g.proposeDone) next.push(doneLine(g.goal));
     else {
-      const unchecked = g.items.find((i: any) => !i.met);
+      const unchecked = g.items.find((i     ) => !i.met);
       if (unchecked) next.push(checkLine(g.goal, unchecked.id));
     }
   }
-  for (const g of goals.filter((x: any) => x.conflicts)) next.push(...goalConflictNext(g.goal, g.conflicts));
-  const result: any = { ok: true, action: 'list', goals, conflicts: fold.conflicts, unreadable: fold.unreadable, unreadableReasons: fold.unreadableReasons, next };
+  for (const g of goals.filter((x     ) => x.conflicts)) next.push(...goalConflictNext(g.goal, g.conflicts));
+  const result      = { ok: true, action: 'list', goals, conflicts: fold.conflicts, unreadable: fold.unreadable, unreadableReasons: fold.unreadableReasons, next };
   if (statuses.reason) result.reason = statuses.reason;
   return result;
 }
@@ -223,7 +223,7 @@ function listGoals({ root, goal, now = new Date(), fsImpl = nodeFs }: any) {
  * IC-022 `done`: one `goal.done` event. Only the user closes a goal (DEC-004), so `default` is
  * refused; with unmet items it is refused unless `--reason` says why the user closes it anyway.
  */
-function doneGoal({ root, goal, reason, channel, now = new Date(), fsImpl = nodeFs }: any) {
+function doneGoal({ root, goal, reason, channel, now = new Date(), fsImpl = nodeFs }     ) {
   const id = goalIdOf(goal);
   const why = textOf(reason, '--reason');
   const by = channelBy(channel);
@@ -231,16 +231,16 @@ function doneGoal({ root, goal, reason, channel, now = new Date(), fsImpl = node
     return refusal('done', 'not-user', `only the user marks a goal done: pass --channel question, gate or prompt once the user has said so (got ${channel ? `'${channel}'` : 'no channel'}). Nothing was written.`);
   }
   const fold = readFold(root, { fsImpl, now });
-  const found = fold.goals.find((g: any) => g.goal === id);
+  const found = fold.goals.find((g     ) => g.goal === id);
   if (!found) return unknownGoal('done', fold, id);
   if (found.status === 'done') return refusal('done', 'already-done', `${id} is already done. Nothing was written.`);
-  const unmet = found.items.filter((i: any) => !i.met).map((i: any) => i.id);
+  const unmet = found.items.filter((i     ) => !i.met).map((i     ) => i.id);
   if (unmet.length && !why) {
     return refusal('done', 'items-unmet', `${id} has unmet items (${unmet.join(', ')}); check them with evidence, or pass --reason to say why the user closes it anyway. Nothing was written.`);
   }
   const out = appendEvents(root, [{ type: 'goal.done', by, data: { goal: id, reason: why } }], { now, fsImpl });
   if (!out.ok) return refusalFrom('done', out);
-  return { ok: true, action: 'done', goal: id, reason: why, unmet, events: out.written.map((w: any) => w.file), next: [] };
+  return { ok: true, action: 'done', goal: id, reason: why, unmet, events: out.written.map((w     ) => w.file), next: [] };
 }
 
 module.exports = {

package/src/runtime/lifecycle/{intent-writer.ts → intent-writer.js}

@@ -27,11 +27,11 @@ const INTENT_SECTIONS = [
 ];
 
 /** `Cart robustness!` -> `cart-robustness`; empty when the title holds no letter or digit. */
-function kebabTitle(title: any): string {
+function kebabTitle(title     )         {
   return String(title).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, SLUG_MAX).replace(/-+$/, '');
 }
 
-function sourceParts(source: any): any[] {
+function sourceParts(source     )        {
   switch (source.kind) {
     case 'stage': return [source.kind, source.feature, source.stage];
     case 'run': return [source.kind, source.taskClass, source.taskId, source.stage];
@@ -46,7 +46,7 @@ function sourceParts(source: any): any[] {
  * @param {{title:string, by:'user'|'agent', date:string, items:Array<{id:string,statement:string,source:Object}>}} intent
  * @returns {string} the file content
  */
-function renderIntent({ title, by, date, items }: { title: string; by: string; date: string; items: Array<{ id: string; statement: string; source: any }> }): string {
+function renderIntent({ title, by, date, items }                                                                                                           )         {
   const lines = [
     `# Intent: ${title}`,
     '',
@@ -65,7 +65,7 @@ function renderIntent({ title, by, date, items }: { title: string; by: string; d
  * @returns {{ok:true, file:string, path:string}|{ok:false, finding:'intent-exists'|'invalid-title', message:string}}
  *   `path` is root-relative with `/` separators.
  */
-function writeIntent(root: string, intent: any, { fsImpl = nodeFs }: any = {}): any {
+function writeIntent(root        , intent     , { fsImpl = nodeFs }      = {})      {
   const title = String(intent.title ?? '').trim();
   const name = kebabTitle(title) || intent.fallbackName || '';
   if (!name || title.length > TITLE_MAX || /[\r\n\u2028\u2029\u0085]/.test(title)) {
@@ -76,7 +76,7 @@ function writeIntent(root: string, intent: any, { fsImpl = nodeFs }: any = {}):
   fsImpl.mkdirSync(path.dirname(file), { recursive: true });
   try {
     fsImpl.writeFileSync(file, renderIntent({ ...intent, title }), { encoding: 'utf8', flag: 'wx' });
-  } catch (error: any) {
+  } catch (error     ) {
     if (error.code === 'EEXIST') return { ok: false, finding: 'intent-exists', message: `${rel.split(path.sep).join('/')} already exists and was left untouched. Nothing was written.` };
     throw error;
   }

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

@@ -11,15 +11,15 @@
 
 const nodeFs = require('node:fs');
 const path = require('node:path');
-const { isSafeSlug, invalidSlugRefusal } = require('../task-scope.ts');
-const { withDerivedDone } = require('./fold.ts');
-const { appendEvents, readFold, readEvents } = require('./event-store.ts');
-const { deriveStatuses, bucketize, behindNote } = require('./status.ts');
-const { FollowupUsageError, parseIds } = require('./followup.ts');
+const { isSafeSlug, invalidSlugRefusal } = require('../task-scope.js');
+const { withDerivedDone } = require('./fold.js');
+const { appendEvents, readFold, readEvents } = require('./event-store.js');
+const { deriveStatuses, bucketize, behindNote } = require('./status.js');
+const { FollowupUsageError, parseIds } = require('./followup.js');
 
 /** The failure store, or null when its module cannot be loaded: the overview then reports no failures. */
 function failureStoreOrNull() {
-  try { return require('../failure/store.ts'); } catch { return null; }
+  try { return require('../failure/store.js'); } catch { return null; }
 }
 
 const DISCOVERY_SHOWN = 15;
@@ -27,29 +27,29 @@ const MAINTAIN_SHOWN = 50;
 /** Slugs shown per finished or awaiting-release bucket: those lists only grow, and the overview runs on every brainstorm. */
 const FEATURES_SHOWN = 10;
 
-const refusal = (action: any, finding: any, message: any) => ({ ok: false, action, finding, message });
+const refusal = (action     , finding     , message     ) => ({ ok: false, action, finding, message });
 
-function statusMap(derived: any) {
-  return Object.fromEntries(Object.entries(derived.statuses).map(([slug, entry]: [string, any]) => [slug, entry.status]));
+function statusMap(derived     ) {
+  return Object.fromEntries(Object.entries(derived.statuses).map(([slug, entry]               ) => [slug, entry.status]));
 }
 
 /** The new and regressed failure entries inside the DoFlow repository, else null. */
-function failureEntries(root: any) {
+function failureEntries(root     ) {
   const failureStore = failureStoreOrNull();
   if (failureStore === null || !failureStore.isDoflowRepo(root)) return null;
-  return failureStore.loadEntries().entries.filter((e: any) => failureStore.SHOWN_BY_DEFAULT.has(e.status)).map(failureStore.listedEntry);
+  return failureStore.loadEntries().entries.filter((e     ) => failureStore.SHOWN_BY_DEFAULT.has(e.status)).map(failureStore.listedEntry);
 }
 
 /** Reports first, then the oldest first; the id keeps equal instants in a stable order. */
-function byDiscoveryOrder(a: any, b: any) {
+function byDiscoveryOrder(a     , b     ) {
   const report = Number(b.source.kind === 'report') - Number(a.source.kind === 'report');
   if (report !== 0) return report;
   const delta = Date.parse(a.history[0].at) - Date.parse(b.history[0].at);
   return delta !== 0 ? delta : (a.id < b.id ? -1 : 1);
 }
 
-function shownItem(item: any, pending: any) {
-  const shown: any = {
+function shownItem(item     , pending     ) {
+  const shown      = {
     id: item.id, statement: item.statement, source: item.source, state: item.state,
     promoted: Boolean(item.intent), intent: item.intent, added: item.added,
   };
@@ -58,7 +58,7 @@ function shownItem(item: any, pending: any) {
 }
 
 /** A bucket for display: the true count and the most recently tracked slugs, in tracking order. */
-function shownBucket(slugs: any) {
+function shownBucket(slugs     ) {
   const shown = slugs.slice(-FEATURES_SHOWN);
   return { count: slugs.length, shown, more: slugs.length - shown.length };
 }
@@ -70,11 +70,11 @@ function shownBucket(slugs: any) {
  * whose text the goal now holds (the user re-added it) is no longer reported.
  * @returns {Map<string, Array<Object>>}
  */
-function goalConflicts(root: any, fold: any, fsImpl = nodeFs) {
+function goalConflicts(root     , fold     , fsImpl = nodeFs) {
   const byGoal = new Map();
-  const raised = fold.conflicts.filter((c: any) => typeof c.type === 'string' && c.type.startsWith('goal.'));
+  const raised = fold.conflicts.filter((c     ) => typeof c.type === 'string' && c.type.startsWith('goal.'));
   if (raised.length === 0) return byGoal;
-  const events = new Map<any, any>(readEvents(root, { fsImpl }).events.map((e: any) => [e.id, e]));
+  const events = new Map          (readEvents(root, { fsImpl }).events.map((e     ) => [e.id, e]));
   for (const c of raised) {
     const event = events.get(c.event);
     const goal = event && event.data && event.data.goal;
@@ -82,8 +82,8 @@ function goalConflicts(root: any, fold: any, fsImpl = nodeFs) {
     const entry = { ...c };
     if (c.type === 'goal.item-added' && event.data.item) {
       // Event files are never removed, so the dropped item is resolved once the goal holds an item with that text.
-      const held = fold.goals.find((g: any) => g.goal === goal);
-      if (held && held.items.some((i: any) => i.text === String(event.data.item.text ?? ''))) continue;
+      const held = fold.goals.find((g     ) => g.goal === goal);
+      if (held && held.items.some((i     ) => i.text === String(event.data.item.text ?? ''))) continue;
       Object.assign(entry, { item: event.data.item.id, text: event.data.item.text });
     }
     if (!byGoal.has(goal)) byGoal.set(goal, []);
@@ -93,29 +93,29 @@ function goalConflicts(root: any, fold: any, fsImpl = nodeFs) {
 }
 
 /** One `next` line per kind of goal conflict, telling the user how to resolve it. */
-function goalConflictNext(goalId: any, conflicts: any) {
+function goalConflictNext(goalId     , conflicts     ) {
   const next = [];
-  if (conflicts.some((c: any) => c.type === 'goal.item-added')) {
+  if (conflicts.some((c     ) => c.type === 'goal.item-added')) {
     next.push(`An item added to ${goalId} from another clone was dropped because its id was already taken; re-add it under a new text: doflow-run goal --action item --goal ${goalId} --text "<the item>"`);
   }
-  if (conflicts.some((c: any) => c.type === 'goal.added')) {
+  if (conflicts.some((c     ) => c.type === 'goal.added')) {
     next.push(`Another clone added goal ${goalId} first and its record won; re-add yours under a different goal id: doflow-run goal --action add --goal <new-id> --statement "<outcome>"`);
   }
-  if (conflicts.some((c: any) => c.type !== 'goal.item-added' && c.type !== 'goal.added')) {
+  if (conflicts.some((c     ) => c.type !== 'goal.item-added' && c.type !== 'goal.added')) {
     next.push(`An event for ${goalId} from another clone was dropped (see conflicts); redo it with doflow-run goal --action list as the current state`);
   }
   return next;
 }
 
 /** Progress, linked features by status and the nudges of one open goal (IC-022). */
-function goalView(goal: any, features: any, statuses: any, conflicts: any = []) {
-  const linked = features.filter((f: any) => f.goal === goal.goal).map((f: any) => f.slug);
-  const buckets = bucketize(Object.fromEntries(linked.map((slug: any) => [slug, statuses.statuses[slug] || { status: 'unknown' }])), linked);
-  const met = goal.items.filter((i: any) => i.met).length;
+function goalView(goal     , features     , statuses     , conflicts      = []) {
+  const linked = features.filter((f     ) => f.goal === goal.goal).map((f     ) => f.slug);
+  const buckets = bucketize(Object.fromEntries(linked.map((slug     ) => [slug, statuses.statuses[slug] || { status: 'unknown' }])), linked);
+  const met = goal.items.filter((i     ) => i.met).length;
   const nudges = [];
   if (buckets.finished.length) {
     const who = buckets.finished.length === 1 ? `linked feature ${buckets.finished[0]} is finished` : `linked features ${buckets.finished.join(', ')} are finished`;
-    for (const item of goal.items.filter((i: any) => !i.met)) nudges.push(`${item.id} is unchecked and ${who}`);
+    for (const item of goal.items.filter((i     ) => !i.met)) nudges.push(`${item.id} is unchecked and ${who}`);
   }
   return {
     goal: goal.goal, outcome: goal.outcome,
@@ -127,7 +127,7 @@ function goalView(goal: any, features: any, statuses: any, conflicts: any = [])
   };
 }
 
-function nextLines({ shown, open, items, intents, goals, maintain, pendingItems, failures }: any) {
+function nextLines({ shown, open, items, intents, goals, maintain, pendingItems, failures }     ) {
   const next = [];
   if (shown < open) next.push('List the rest: doflow-run followup --action list');
   if (items.length) next.push(`Take items into the new feature when its folder exists: doflow-run lifecycle --action init --slug <slug> --take ${items[0].id}`);
@@ -135,10 +135,10 @@ function nextLines({ shown, open, items, intents, goals, maintain, pendingItems,
     next.push(`Start from a promoted intent: /do-brainstorm --intent ${intents[0].path}, then doflow-run lifecycle --action init --slug <slug> --intent ${intents[0].path}`);
   }
   if (goals.length) next.push(`Link the new feature to a goal: add --goal ${goals[0].goal} to the init line`);
-  for (const g of goals.filter((x: any) => x.conflicts)) next.push(...goalConflictNext(g.goal, g.conflicts));
+  for (const g of goals.filter((x     ) => x.conflicts)) next.push(...goalConflictNext(g.goal, g.conflicts));
   if (maintain && pendingItems.length) {
     const id = pendingItems[0].id;
-    const unpromoted = pendingItems.find((i: any) => !i.promoted);
+    const unpromoted = pendingItems.find((i     ) => !i.promoted);
     next.push(
       `Keep open: doflow-run followup --action settle --ids ${id} --as kept --reason "<why it stays>" --channel question`,
       `Dismiss: doflow-run followup --action settle --ids ${id} --as dismissed --reason "<why>" --channel question`,
@@ -151,7 +151,7 @@ function nextLines({ shown, open, items, intents, goals, maintain, pendingItems,
     next.push('Settle a failure entry: doflow-run failure --action settle --fp <fp> --as noise|fixed|imported --reason "<why>"');
   }
   if (maintain) {
-    for (const goal of goals.filter((g: any) => g.proposeDone)) {
+    for (const goal of goals.filter((g     ) => g.proposeDone)) {
       next.push(`Every item of ${goal.goal} is met; ask the user, then: doflow-run goal --action done --goal ${goal.goal} --channel question`);
     }
   }
@@ -165,7 +165,7 @@ function nextLines({ shown, open, items, intents, goals, maintain, pendingItems,
  * @param {boolean} [options.maintain] the `/do maintain` view: up to 50 items and `pending`
  * @param {string} [options.since] ISO time; with `maintain`, an open item with no settlement at or after it is pending
  */
-function buildOverview({ root, maintain = false, since, now = new Date(), fsImpl = nodeFs }: any) {
+function buildOverview({ root, maintain = false, since, now = new Date(), fsImpl = nodeFs }     ) {
   let sinceMs = null;
   if (since !== undefined && since !== null) {
     sinceMs = Date.parse(since);
@@ -174,25 +174,25 @@ function buildOverview({ root, maintain = false, since, now = new Date(), fsImpl
   const fold = readFold(root, { fsImpl, now });
   const derived = deriveStatuses({ root, fold });
   const followups = withDerivedDone(fold.followups, statusMap(derived));
-  const open = followups.filter((item: any) => item.state === 'open');
+  const open = followups.filter((item     ) => item.state === 'open');
   const limit = maintain ? MAINTAIN_SHOWN : DISCOVERY_SHOWN;
   // A promotion settles an item for the maintain loop as much as a settlement does: it stays open with an intent.
-  const settledSince = (item: any) => item.history.some((h: any) => (h.type === 'followup.settled' || h.type === 'followup.promoted') && (sinceMs === null || Date.parse(h.at) >= sinceMs));
-  const pendingOf = (item: any) => !settledSince(item);
+  const settledSince = (item     ) => item.history.some((h     ) => (h.type === 'followup.settled' || h.type === 'followup.promoted') && (sinceMs === null || Date.parse(h.at) >= sinceMs));
+  const pendingOf = (item     ) => !settledSince(item);
   // Maintain shows pending items first (IC-007), so a loop over more than MAINTAIN_SHOWN items reaches the rest.
   const ordered = [...open].sort((a, b) => (maintain ? Number(pendingOf(b)) - Number(pendingOf(a)) : 0) || byDiscoveryOrder(a, b));
   const items = ordered.slice(0, limit).map((item) => shownItem(item, maintain ? pendingOf(item) : undefined));
 
   const intentGroups = new Map();
-  for (const item of open.filter((i: any) => i.intent)) {
+  for (const item of open.filter((i     ) => i.intent)) {
     if (!intentGroups.has(item.intent)) intentGroups.set(item.intent, []);
     intentGroups.get(item.intent).push(item.id);
   }
   const intents = [...intentGroups].map(([intentPath, ids]) => ({ path: intentPath, items: ids }));
   const conflictsByGoal = goalConflicts(root, fold, fsImpl);
-  const goals = fold.goals.filter((g: any) => g.status === 'open').map((g: any) => goalView(g, fold.features, derived, conflictsByGoal.get(g.goal)));
+  const goals = fold.goals.filter((g     ) => g.status === 'open').map((g     ) => goalView(g, fold.features, derived, conflictsByGoal.get(g.goal)));
 
-  const result: any = {
+  const result      = {
     ok: true,
     mode: maintain ? 'maintain' : 'discovery',
     releaseMode: derived.releaseMode,
@@ -228,7 +228,7 @@ function buildOverview({ root, maintain = false, since, now = new Date(), fsImpl
  * The feature folder is looked for under the IC-001 root itself, never in the current worktree, so a
  * folder that exists only in a linked worktree is refused.
  */
-function initFeature({ root, slug, take, intent, goal, now = new Date(), fsImpl = nodeFs }: any) {
+function initFeature({ root, slug, take, intent, goal, now = new Date(), fsImpl = nodeFs }     ) {
   if (!slug) throw new FollowupUsageError('--slug is required for --action init');
   const bad = invalidSlugRefusal(slug);
   if (bad) throw new FollowupUsageError(bad.message);
@@ -240,7 +240,7 @@ function initFeature({ root, slug, take, intent, goal, now = new Date(), fsImpl
   }
   const wanted = take === undefined || take === null ? [] : parseIds(take, '--take');
   const fold = readFold(root, { fsImpl, now });
-  const tracked = fold.features.find((f: any) => f.slug === slug);
+  const tracked = fold.features.find((f     ) => f.slug === slug);
   const ids = [...wanted];
   if (intent) {
     for (const item of fold.followups) if (item.state === 'open' && item.intent === intent && !ids.includes(item.id)) ids.push(item.id);
@@ -262,7 +262,7 @@ function initFeature({ root, slug, take, intent, goal, now = new Date(), fsImpl
       const code = out.conflict && ['unknown-id', 'untracked-feature', 'goal-already-linked', 'unknown-goal'].includes(out.conflict.code) ? out.conflict.code : out.finding;
       return refusal('init', code, out.message);
     }
-    events = out.written.map((w: any) => w.file);
+    events = out.written.map((w     ) => w.file);
   }
   return { ok: true, action: 'init', slug, tracked: tracked ? 'already' : 'new', taken: ids, goal: goal || (tracked && tracked.goal) || null, events, next };
 }
@@ -270,19 +270,19 @@ function initFeature({ root, slug, take, intent, goal, now = new Date(), fsImpl
 // ── status ─────────────────────────────────────────────────────────────────────────────────────
 
 /** IC-021 `status`: the derived status of one tracked feature. */
-function featureStatus({ root, slug, now = new Date(), fsImpl = nodeFs }: any) {
+function featureStatus({ root, slug, now = new Date(), fsImpl = nodeFs }     ) {
   if (!slug) throw new FollowupUsageError('--slug is required for --action status');
   if (!isSafeSlug(slug)) throw new FollowupUsageError(invalidSlugRefusal(slug).message);
   const fold = readFold(root, { fsImpl, now });
-  if (!fold.features.some((f: any) => f.slug === slug)) {
+  if (!fold.features.some((f     ) => f.slug === slug)) {
     return refusal('status', 'untracked-feature', `${slug} is not a tracked feature, so no status is derived for it; run doflow-run lifecycle --action init --slug ${slug} first.`);
   }
   const derived = deriveStatuses({ root, fold });
   const entry = derived.statuses[slug];
-  const result: any = {
+  const result      = {
     ok: true, action: 'status', slug, status: entry.status, integrationRef: derived.integrationRef,
     evidence: entry.evidence, release: entry.release,
-    takenItems: fold.followups.filter((item: any) => item.takenBy === slug && item.state === 'taken').map((item: any) => item.id),
+    takenItems: fold.followups.filter((item     ) => item.takenBy === slug && item.state === 'taken').map((item     ) => item.id),
   };
   if (derived.reason) result.reason = derived.reason;
   if (derived.integrationBehind > 0) Object.assign(result, { integrationBehind: derived.integrationBehind, note: behindNote(derived.integrationRef, derived.integrationBehind) });