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

package/src/cli/{runtime-commands.ts → runtime-commands.js}

@@ -23,52 +23,52 @@ const os = require('node:os');
 const path = require('node:path');
 const {
   handleCapabilitiesCommand, handleReadinessCommand, handleEvidenceCommand,
-} = require('../runtime/cli.ts');
-// `doctor` comes from the health module rather than src/runtime/cli.ts: the health-probe report
+} = require('../runtime/cli.js');
+// `doctor` comes from the health module rather than src/runtime/cli.js: the health-probe report
 // (FR-013) supersedes the presence-check version, and one verb must have one implementation.
-const { handleDoctorCommand } = require('../runtime/health.ts');
-const { handleTraceCommand, handleStatsCommand, handleDiscoverCommand, resolveRunsLocation } = require('../runtime/trace/ledger.ts');
-const { handleIndicatorsCommand } = require('../runtime/trace/indicators.ts');
+const { handleDoctorCommand } = require('../runtime/health.js');
+const { handleTraceCommand, handleStatsCommand, handleDiscoverCommand, resolveRunsLocation } = require('../runtime/trace/ledger.js');
+const { handleIndicatorsCommand } = require('../runtime/trace/indicators.js');
 // The rest of the verb surface design §4.2 declares. `classify`, `workflow`, `route`, `claim`,
 // `context-pack`, `verify`, `recover` and `scaffold` each have exactly one implementation, in the
 // engine module named on the right; this file only dispatches to them.
-const { ReadinessEngine } = require('../runtime/readiness.ts');
-const { handleClaimCommand } = require('../runtime/claims.ts');
-const { handleClassifyCommand } = require('../runtime/task-classifier.ts');
-const { handleWorkflowCommand } = require('../runtime/workflow-engine.ts');
-const { handleOrchestrateCommand } = require('../runtime/workflow-orchestrator.ts');
-const { handleResearchRequestCommand } = require('../runtime/research-request.ts');
-const { handleTaskAttemptCommand } = require('../runtime/task-attempts.ts');
-const { handleRetrieveCommand } = require('../runtime/knowledge/retrieval.ts');
-const { handleModelRoleCommand } = require('../runtime/model-router.ts');
-const { handleRouteCommand } = require('../runtime/capability-router.ts');
-const { handleContextPackCommand } = require('../runtime/context-pack.ts');
-const { handleRetrievalPlanCommand } = require('../runtime/retrieval-plan.ts');
-const { handleOutcomeCommand } = require('../runtime/outcome.ts');
-const { handleVerifyCommand } = require('../runtime/verification/engine.ts');
-const { handleLeakScanCommand } = require('../runtime/leak-scan.ts');
-const { handleRecoverCommand } = require('../runtime/recovery.ts');
-const { handleScaffoldCommand } = require('../runtime/scaffold/generate.ts');
-const { handleDecisionCommand } = require('../runtime/decision-register.ts');
-const { handleFollowupCommand, handleLifecycleCommand, handleGoalCommand } = require('../runtime/lifecycle/cli.ts');
-const { projectRoot: lifecycleProjectRoot } = require('../runtime/lifecycle/root.ts');
-const { upkeepAfterVerb } = require('../runtime/storage/upkeep.ts');
-const { handleStorageCommand } = require('../runtime/storage/cli.ts');
+const { ReadinessEngine } = require('../runtime/readiness.js');
+const { handleClaimCommand } = require('../runtime/claims.js');
+const { handleClassifyCommand } = require('../runtime/task-classifier.js');
+const { handleWorkflowCommand } = require('../runtime/workflow-engine.js');
+const { handleOrchestrateCommand } = require('../runtime/workflow-orchestrator.js');
+const { handleResearchRequestCommand } = require('../runtime/research-request.js');
+const { handleTaskAttemptCommand } = require('../runtime/task-attempts.js');
+const { handleRetrieveCommand } = require('../runtime/knowledge/retrieval.js');
+const { handleModelRoleCommand } = require('../runtime/model-router.js');
+const { handleRouteCommand } = require('../runtime/capability-router.js');
+const { handleContextPackCommand } = require('../runtime/context-pack.js');
+const { handleRetrievalPlanCommand } = require('../runtime/retrieval-plan.js');
+const { handleOutcomeCommand } = require('../runtime/outcome.js');
+const { handleVerifyCommand } = require('../runtime/verification/engine.js');
+const { handleLeakScanCommand } = require('../runtime/leak-scan.js');
+const { handleRecoverCommand } = require('../runtime/recovery.js');
+const { handleScaffoldCommand } = require('../runtime/scaffold/generate.js');
+const { handleDecisionCommand } = require('../runtime/decision-register.js');
+const { handleFollowupCommand, handleLifecycleCommand, handleGoalCommand } = require('../runtime/lifecycle/cli.js');
+const { projectRoot: lifecycleProjectRoot } = require('../runtime/lifecycle/root.js');
+const { upkeepAfterVerb } = require('../runtime/storage/upkeep.js');
+const { handleStorageCommand } = require('../runtime/storage/cli.js');
 // Required on first use, so a CLI whose failure modules cannot be loaded still runs every other verb.
-function handleFailureCommand(options: any): any { return require('../runtime/failure/cli.ts').handleFailureCommand(options); }
-const { handleInventoryCommand } = require('../runtime/inventory/index.ts');
-const { finishRuntime, usageError } = require('../runtime/cli-result.ts');
-const { setDefaultSlug, invalidSlugRefusal, slugNamesNoFeature } = require('../runtime/task-scope.ts');
-const { listCheckouts } = require('../runtime/checkouts.ts');
-const { featureSlugFor } = require('../runtime/implementation-gate.ts');
-const { handleBriefToolsCommand } = require('../runtime/brief-tools.ts');
-const { handleAdviseCommand } = require('../runtime/advice/cli.ts');
-const { REPO_ROOT, buildAdapterRegistry } = require('./shared.ts');
+function handleFailureCommand(options     )      { return require('../runtime/failure/cli.js').handleFailureCommand(options); }
+const { handleInventoryCommand } = require('../runtime/inventory/index.js');
+const { finishRuntime, usageError } = require('../runtime/cli-result.js');
+const { setDefaultSlug, invalidSlugRefusal, slugNamesNoFeature } = require('../runtime/task-scope.js');
+const { listCheckouts } = require('../runtime/checkouts.js');
+const { featureSlugFor } = require('../runtime/implementation-gate.js');
+const { handleBriefToolsCommand } = require('../runtime/brief-tools.js');
+const { handleAdviseCommand } = require('../runtime/advice/cli.js');
+const { REPO_ROOT, buildAdapterRegistry } = require('./shared.js');
 
 /** Where `readiness`/`evidence` read and write per-task state. Mirrors scopeOf()'s rules so these
  * commands are scope-aware like the rest of the CLI, rather than defaulting to the DoFlow install
  * directory — which for an npm install is inside node_modules/. */
-function evidenceRoot(o: any): string {
+function evidenceRoot(o     )         {
   return o.global ? os.homedir() : path.resolve(o.positional[0] || '.');
 }
 
@@ -81,7 +81,7 @@ function evidenceRoot(o: any): string {
  * The valid set comes from the readiness registry rather than a list written here, so it cannot
  * drift from the templates that actually exist.
  */
-function requireTaskClass(o: any): string {
+function requireTaskClass(o     )         {
   if (typeof o.taskClass === 'string' && o.taskClass.trim() !== '') return o.taskClass;
   let valid = '';
   try {
@@ -92,7 +92,7 @@ function requireTaskClass(o: any): string {
 }
 
 /** The task id the caller named, or exit 2. Same reasoning as requireTaskClass. */
-function requireTaskId(o: any): string {
+function requireTaskId(o     )         {
   if (typeof o.taskId === 'string' && o.taskId.trim() !== '') return o.taskId;
   usageError(o.cmd, '--task-id is required — evidence and claims belong to one task, so guessing an id would report on a different one.', o.json);
   process.exit(2);
@@ -104,8 +104,8 @@ function requireTaskId(o: any): string {
  * Absent flags stay absent. Filling a gap here with 'unknown'/'general' would move the omission out
  * of the caller's error message and into the stored record, where it reads as a measurement.
  */
-function evidenceItemFromFlags(o: any): any {
-  const item: any = {};
+function evidenceItemFromFlags(o     )      {
+  const item      = {};
   if (o.kind !== undefined) item.kind = o.kind;
   if (o.provenance !== undefined) item.provenance = o.provenance;
   if (o.locator !== undefined) item.locator = o.locator;
@@ -118,7 +118,7 @@ function evidenceItemFromFlags(o: any): any {
     if (o.observedCommand !== undefined) item.observation.command = o.observedCommand;
     if (o.observedExit !== undefined) item.observation.exitCode = o.observedExit;
   }
-  const source: any = {};
+  const source      = {};
   if (o.provider !== undefined) source.provider = o.provider;
   if (o.capability !== undefined) source.capability = o.capability;
   if (Object.keys(source).length > 0) item.source = source;
@@ -139,12 +139,12 @@ const FEATURE_STORE_VERBS = new Set(['evidence', 'claim', 'readiness']);
  * the readiness record written there is the one verify, orchestrate and the edit hook read from
  * the worktree.
  */
-function featureStoreRoot(o: any): { root: string; slug: string } | null {
+function featureStoreRoot(o     )                                        {
   if (!FEATURE_STORE_VERBS.has(o.cmd) || o.global) return null;
   const checkouts = listCheckouts({ cwd: evidenceRoot(o) });
   if (!checkouts.isLinked) return null;
   const slug = featureSlugFor({ projectRoot: checkouts.current, slug: o.slug });
-  const folder = (root: string) => path.join(root, 'agent-docs', 'doflow', slug || '');
+  const folder = (root        ) => path.join(root, 'agent-docs', 'doflow', slug || '');
   if (!slug || fs.existsSync(folder(checkouts.current)) || !fs.existsSync(folder(checkouts.main))) return null;
   return { root: checkouts.main, slug };
 }
@@ -155,7 +155,7 @@ function featureStoreRoot(o: any): { root: string; slug: string } | null {
  * validate parsed CLI arguments, which is the CLI's job, not a library's); everything else belongs
  * to the engine module each case names.
  */
-function dispatchRuntimeCommandInner(o: any, moment: any): any {
+function dispatchRuntimeCommandInner(o     , moment     )      {
   // A slug becomes a directory name and a state key, so one that could name a path is refused
   // here, once, for every verb that reads `--slug`, before any of them reads or writes state
   // (FR-013, IC-009). A well-formed slug that names no feature is the verbs' own business.
@@ -253,7 +253,7 @@ function dispatchRuntimeCommandInner(o: any, moment: any): any {
     case 'research-request': return handleResearchRequestCommand({ slug: o.slug, action: o.action === 'status' ? 'list' : o.action, taskId: requireTaskId(o), stageId: o.stageId, question: o.question, reason: o.reason, blocking: o.blocking === undefined ? undefined : o.blocking === 'true' ? true : o.blocking === 'false' ? false : o.blocking, requestId: o.requestId, outcome: o.researchOutcome, claimId: o.claimId, evidenceIds: o.evidenceIds, gap: o.gap, json: o.json, projectRoot: evidenceRoot(o) });
     // The store is shared by every linked worktree of the clone (lifecycle's main-worktree root); the
     // feature is `--slug`, else the branch's, resolved the way decision and scaffold resolve it.
-    case 'task-attempt': return handleTaskAttemptCommand({ action: o.actionGiven ? o.action : undefined, slug: o.slug, task: o.task, owner: o.owner, mode: o.mode, token: o.token, result: o.result, evidenceId: o.evidenceId, reason: o.reason, json: o.json, cwd: evidenceRoot(o), resolveSlug: (cwd: string) => featureSlugFor({ projectRoot: cwd }) });
+    case 'task-attempt': return handleTaskAttemptCommand({ action: o.actionGiven ? o.action : undefined, slug: o.slug, task: o.task, owner: o.owner, mode: o.mode, token: o.token, result: o.result, evidenceId: o.evidenceId, reason: o.reason, json: o.json, cwd: evidenceRoot(o), resolveSlug: (cwd        ) => featureSlugFor({ projectRoot: cwd }) });
     case 'retrieve': return handleRetrieveCommand({ query: o.query, top: o.top, json: o.json });
     case 'brief-tools': return handleBriefToolsCommand({ owner: o.owner, tier: o.tier, harness: o.harness, slug: o.slug, headingLevel: o.headingLevel, tasks: o.tasks, json: o.json, repoRoot: REPO_ROOT, projectRoot: storeRoot, buildAdapters: buildAdapterRegistry });
     case 'advise': return handleAdviseCommand({ action: o.action, actionGiven: o.actionGiven, kind: o.kind, server: o.server, state: o.state, stateFile: o.stateFile, staticAnswer: o.staticAnswer, questionsFile: o.questionsFile, taskId: o.taskId, pickId: o.pickId, actual: o.actual, model: o.model, endpoint: o.endpoint, off: o.off, project: o.project, force: o.force, global: o.global, json: o.json, projectRoot: evidenceRoot(o) });
@@ -271,8 +271,8 @@ function dispatchRuntimeCommandInner(o: any, moment: any): any {
 }
 
 /** Await the verb without changing its return value, output or exit code; usage exits never return. */
-async function dispatchRuntimeCommand(o: any): Promise<any> {
-  const moment: any = {};
+async function dispatchRuntimeCommand(o     )               {
+  const moment      = {};
   const result = await dispatchRuntimeCommandInner(o, moment);
   if (o.cmd !== 'storage') upkeepAfterVerb({ projectRoot: moment.projectRoot });
   return result;

package/src/cli/{shared.ts → shared.js}

@@ -9,23 +9,23 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { REPO_ROOT } = require('../helper/repo-root.ts');
-const { doflowPaths } = require('../install/paths.ts');
-const { readInstallManifest } = require('../install/manifest.ts');
-const { DEFAULT_BACKUP_RETENTION, formatBytes } = require('../install/backup.ts');
-const { stateRoot, readLedger } = require('../state/index.ts');
-const { readLock } = require('../state/lockfile.ts');
-const { acquireRunLock, RunLockTimeoutError, RunLockError, RunLockLostError } = require('../state/run-lock.ts');
-const { createAdapterRegistry } = require('../adapters/index.ts');
-const { declaredHarnessPaths } = require('../helper/harness-paths.ts');
-const claudeAdapter = require('../adapters/claude/index.ts');
-const codexAdapter = require('../adapters/codex/index.ts');
-const { createGeminiAdapter } = require('../adapters/gemini/index.ts');
-const { createOpenCodeAdapter } = require('../adapters/opencode/index.ts');
-const { createPiAdapter } = require('../adapters/pi/index.ts');
-const { createCopilotAdapter } = require('../adapters/copilot/index.ts');
-const { createKiroAdapter } = require('../adapters/kiro/index.ts');
-const { createAntigravityAdapter } = require('../adapters/antigravity/index.ts');
+const { REPO_ROOT } = require('../helper/repo-root.js');
+const { doflowPaths } = require('../install/paths.js');
+const { readInstallManifest } = require('../install/manifest.js');
+const { DEFAULT_BACKUP_RETENTION, formatBytes } = require('../install/backup.js');
+const { stateRoot, readLedger } = require('../state/index.js');
+const { readLock } = require('../state/lockfile.js');
+const { acquireRunLock, RunLockTimeoutError, RunLockError, RunLockLostError } = require('../state/run-lock.js');
+const { createAdapterRegistry } = require('../adapters/index.js');
+const { declaredHarnessPaths } = require('../helper/harness-paths.js');
+const claudeAdapter = require('../adapters/claude/index.js');
+const codexAdapter = require('../adapters/codex/index.js');
+const { createGeminiAdapter } = require('../adapters/gemini/index.js');
+const { createOpenCodeAdapter } = require('../adapters/opencode/index.js');
+const { createPiAdapter } = require('../adapters/pi/index.js');
+const { createCopilotAdapter } = require('../adapters/copilot/index.js');
+const { createKiroAdapter } = require('../adapters/kiro/index.js');
+const { createAntigravityAdapter } = require('../adapters/antigravity/index.js');
 
 // The directory of the `doflow` entrypoint. Derived from the shared package root rather than
 // __dirname so its value survives this code physically moving between directories: manifests,
@@ -36,7 +36,7 @@ const SCRIPT_DIR = path.join(REPO_ROOT, 'bin');
 // core/registry/ but no package.json — see the `runtime.*` assets in core/registry/assets.json.
 // A hard require here would make every Node-backed verb fail in an install, which is the exact
 // defect that projection exists to fix. Only version reporting depends on this.
-function loadPkg(): any {
+function loadPkg()      {
   try { return require('../../package.json'); } catch { return { version: '0.0.0-installed', name: '@khoavu882/doflow' }; }
 }
 const pkg = loadPkg();
@@ -44,13 +44,13 @@ const pkg = loadPkg();
 /**
  * The one adapter registry construction, used by install/update/remove/reconcile. There used to
  * be three inline copies of the same construction (one per mutating command); a fourth variant
- * once grew in src/lifecycle/view.ts and silently fell behind (fixed in 96006da) — which is why
+ * once grew in src/lifecycle/view.js and silently fell behind (fixed in 96006da) — which is why
  * the registry guard pins every declared harness into each call site by parsing them.
  * Build one here rather than copying the object literal again. Stage 3: each adapter factory
  * receives its harness's declared native paths from core/registry/harnesses.json, so the CLI
  * consumes exactly what the loader validates.
  */
-function buildAdapterRegistry(): any {
+function buildAdapterRegistry()      {
   const declared = declaredHarnessPaths();
   return createAdapterRegistry({
     claude: claudeAdapter.createClaudeAdapter({ declaredPaths: declared.claude }),
@@ -65,11 +65,11 @@ function buildAdapterRegistry(): any {
 }
 
 /** Resolve {global, projectRoot} scope options for src/install/targets.js#toolDirs from parsed args. */
-function scopeOf(o: any): { global: boolean; projectRoot: string } {
+function scopeOf(o     )                                           {
   return { global: o.global, projectRoot: o.positional[0] || '.' };
 }
 
-function installPaths(scope: any): any {
+function installPaths(scope     )      {
   const scopeRoot = scope.global ? os.homedir() : path.resolve(scope.projectRoot);
   return doflowPaths({ scopeRoot });
 }
@@ -77,7 +77,7 @@ function installPaths(scope: any): any {
 /** Whether two paths name the same directory. Device and inode follow symlinks (macOS reaches
  * /var through /private/var) and ignore letter case on a case-insensitive volume; a file system
  * that reports inode 0 falls back to real paths, and paths that do not exist to resolved strings. */
-function sameDirectory(a: string, b: string, { fsImpl = fs }: any = {}): boolean {
+function sameDirectory(a        , b        , { fsImpl = fs }      = {})          {
   const ra = path.resolve(a);
   const rb = path.resolve(b);
   try {
@@ -95,7 +95,7 @@ function sameDirectory(a: string, b: string, { fsImpl = fs }: any = {}): boolean
 /** A project install, update, remove or reconcile rooted at the home directory would share the
  * global install's files and records, and its remove could delete them. Refuses that run with one
  * line and exit 1 before anything is read, locked or written; `-g` and every other root pass. */
-function refuseHomeRootedProject(o: any, command: string): void {
+function refuseHomeRootedProject(o     , command        )       {
   if (o.global) return;
   const projectRoot = o.positional[0] || '.';
   if (!sameDirectory(projectRoot, os.homedir())) return;
@@ -106,40 +106,40 @@ function refuseHomeRootedProject(o: any, command: string): void {
 
 /** Takes the scope's run lock for a mutating command, or returns null under --dry-run. A run that
  * cannot take it prints the one reason line and exits 1 before it has read or changed anything. */
-function holdRunLock(o: any, scope: any, command: string): any {
+function holdRunLock(o     , scope     , command        )      {
   if (o.dryRun) return null;
   try {
     return acquireRunLock({ scopeRoot: installPaths(scope).scopeRoot, scope: scope.global ? 'global' : 'project', command });
   } catch (err) {
     if (!(err instanceof RunLockTimeoutError || err instanceof RunLockError)) throw err;
-    console.error((err as any).message);
+    console.error((err       ).message);
     process.exit(1);
   }
 }
 
 /** After the confirm prompt: renews the hold, and exits 1 before the first write if another run
  * took the lock over while the prompt waited. */
-function checkpointRunLock(hold: any): void {
+function checkpointRunLock(hold     )       {
   if (!hold) return;
   try {
     hold.checkpoint();
   } catch (err) {
     if (!(err instanceof RunLockLostError)) throw err;
-    console.error((err as any).message);
+    console.error((err       ).message);
     process.exit(1);
   }
 }
 
 /** Surface a reconciled-away MCP server rather than dropping it silently: the user picked it once,
  * so its disappearance from their config should be explained, not discovered. */
-function reportRetiredMcp(retired: string[]): void {
+function reportRetiredMcp(retired          )       {
   console.error(`[WARN]  Dropping MCP server(s) no longer in the registry: ${retired.join(', ')}`);
   console.error('        They were removed from DoFlow; your saved selection is being reconciled.');
 }
 
 /** The scope's doflow.lock, ledger and 1.18.0 manifest MCP list, as the MCP selection functions in
  * src/install/mcp.js read them. */
-function scopeSelectionState(scope: any): any {
+function scopeSelectionState(scope     )      {
   const scopeRoot = scope.global ? os.homedir() : path.resolve(scope.projectRoot);
   return {
     lock: readLock(scope.global ? { scope: 'global', homeDir: scopeRoot } : { scope: 'project', projectRoot: scopeRoot }),
@@ -148,13 +148,13 @@ function scopeSelectionState(scope: any): any {
   };
 }
 
-const MCP_SOURCE_WORDS = Object.freeze({ flag: '--mcp', prompt: 'prompt', recorded: 'recorded', kept: 'kept', manifest: 'remembered', default: 'default' } as Record<string, string>);
+const MCP_SOURCE_WORDS = Object.freeze({ flag: '--mcp', prompt: 'prompt', recorded: 'recorded', kept: 'kept', manifest: 'remembered', default: 'default' }                          );
 
 /** The one line a run names its MCP selections in, from what the plan resolved for each harness:
  * harnesses with the same servers and source share a group, groups follow target order. Prints
  * nothing when no target takes MCP servers, except that an explicit --mcp is said to do nothing. */
-function printMcpSelection(view: any, sources: any, { requested, prefix = '[INFO]' }: any = {}): void {
-  const groups: any[] = [];
+function printMcpSelection(view     , sources     , { requested, prefix = '[INFO]' }      = {})       {
+  const groups        = [];
   for (const target of view.plan.targets) {
     if (target.skipped || !Array.isArray(target.mcpSelected) || !(target.harness in sources)) continue;
     const ids = target.mcpSelected.join(', ') || 'none';
@@ -172,26 +172,26 @@ function printMcpSelection(view: any, sources: any, { requested, prefix = '[INFO
 
 /** Says which MCP entries a run with no native change recorded as DoFlow's (lifecycle
  * recordMcpOwnership), or, under --dry-run, would record. */
-function printRecordedMcpOwnership(recorded: any, { dryRun = false }: any = {}): void {
-  for (const [harness, ids] of Object.entries<any>(recorded)) {
+function printRecordedMcpOwnership(recorded     , { dryRun = false }      = {})       {
+  for (const [harness, ids] of Object.entries     (recorded)) {
     const what = `${ids.length} MCP ${ids.length === 1 ? 'entry' : 'entries'} (${ids.join(', ')})`;
     console.log(dryRun ? `[DRY]  ${harness}: would record DoFlow's ownership of ${what}` : `[INFO] ${harness}: recorded DoFlow's ownership of ${what}`);
   }
 }
 
 /** What each planned harness that takes MCP servers will hold, as doflow.lock records it. */
-function plannedMcpSelections(view: any): any {
-  return Object.fromEntries(view.plan.targets.filter((target: any) => !target.skipped && Array.isArray(target.mcpSelected))
-    .map((target: any) => [target.harness, target.mcpSelected]));
+function plannedMcpSelections(view     )      {
+  return Object.fromEntries(view.plan.targets.filter((target     ) => !target.skipped && Array.isArray(target.mcpSelected))
+    .map((target     ) => [target.harness, target.mcpSelected]));
 }
 
 /** Total size of some rows, noting when any of them could not be measured. */
-function rowsSize(rows: any[]): string {
+function rowsSize(rows       )         {
   const total = formatBytes(rows.reduce((sum, r) => sum + (r.bytes ?? 0), 0));
   return rows.some((r) => r.bytes === null) ? `${total} (some sizes unknown)` : total;
 }
 
-function printBackupTable(rows: any[], rootLabel: string): void {
+function printBackupTable(rows       , rootLabel        )       {
   if (rows.length === 0) { console.log(`[INFO] No backups found in ${rootLabel}`); return; }
   const header = `${'BACKUP ID'.padEnd(42)} ${'OPERATION'.padEnd(14)} ${'TYPE'.padEnd(9)} ${'ORIGIN'.padEnd(9)} ${'SIZE'.padEnd(11)} TIMESTAMP`;
   console.log(`\n${header}`);

package/src/helper/{bash-helper.ts → bash-helper.js}

@@ -2,12 +2,12 @@
 
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): authored as `.ts`, run directly by Node
 // native type-stripping — no build step, no runtime dependency. Body stays CommonJS so a `.js`
-// caller's `require('../helper/bash-helper.ts')` keeps working while the rest of the tree is still
+// caller's `require('../helper/bash-helper.js')` keeps working while the rest of the tree is still
 // `.js`. The `./repo-root` require stays bare while repo-root is still `.js`; it gains `.ts` in the
 // same slice that converts repo-root.
 const fs = require('node:fs');
 const path = require('node:path');
-const { REPO_ROOT } = require('./repo-root.ts');
+const { REPO_ROOT } = require('./repo-root.js');
 
 /**
  * Where a bash helper (`do-paths.sh`, `do-git-state.sh`) is: inside the package (a checkout or a
@@ -20,15 +20,15 @@ const { REPO_ROOT } = require('./repo-root.ts');
  * @param repoRoot the runtime root; only a test moves it
  */
 function resolveBashHelper(
-  name: string,
-  repoRoot: string = REPO_ROOT,
-  existsImpl: (file: string) => boolean = fs.existsSync,
-): string | null {
+  name        ,
+  repoRoot         = REPO_ROOT,
+  existsImpl                            = fs.existsSync,
+)                {
   const candidates = [
     path.join(repoRoot, 'core', 'shared', 'scripts', 'doflow', 'bash', name),
     path.resolve(repoRoot, '..', 'scripts', 'doflow', 'bash', name),
   ];
-  return candidates.find((candidate: string) => existsImpl(candidate)) || null;
+  return candidates.find((candidate        ) => existsImpl(candidate)) || null;
 }
 
 module.exports = { resolveBashHelper };

package/src/helper/{git.ts → git.js}

@@ -6,13 +6,13 @@
 // First module of the TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md). Authored as `.ts` and
 // run directly by Node's native type-stripping (process.features.typescript === 'strip', Node
 // ^22.18.0 || >=24.3.0), so no build step and no runtime dependency are added. The body stays CommonJS
-// (`module.exports`) so a `require('../helper/git.ts')` from a `.js` caller keeps working while the
+// (`module.exports`) so a `require('../helper/git.js')` from a `.js` caller keeps working while the
 // rest of the tree is still `.js`; the explicit `.ts` extension on those requires is what the
 // CommonJS resolver needs to find this file.
 const { execFileSync } = require('node:child_process');
 
 /** Short HEAD commit of the repo at `repoRoot`, or 'unknown' if not a git repo / git unavailable. */
-function sourceCommit(repoRoot: string): string {
+function sourceCommit(repoRoot        )         {
   try {
     return execFileSync('git', ['-C', repoRoot, 'rev-parse', '--short', 'HEAD'], { stdio: ['ignore', 'pipe', 'ignore'] })
       .toString().trim() || 'unknown';

package/src/helper/{guardrails.ts → guardrails.js}

@@ -11,7 +11,7 @@
 //
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): authored as `.ts`, run directly by Node
 // native type-stripping (process.features.typescript === 'strip', Node ^22.18.0 || >=24.3.0) — no build step and
-// no runtime dependency. The body stays CommonJS so a `.js` caller's `require('../helper/guardrails.ts')`
+// no runtime dependency. The body stays CommonJS so a `.js` caller's `require('../helper/guardrails.js')`
 // keeps working while the rest of the tree is still `.js`; the explicit `.ts` extension is what the
 // CommonJS resolver needs to find this file.
 
@@ -20,26 +20,26 @@ const path = require('node:path');
 
 const DENY_RULE = /^Bash\((.*):\*\)$/;
 
-interface FsReadFileSync {
-  readFileSync(file: string, encoding: 'utf8'): string;
-}
+                          
+                                                       
+ 
 
-interface DestructiveCommandGlobsOptions {
-  repoRoot: string;
-  fsImpl?: FsReadFileSync;
-}
+                                          
+                   
+                          
+ 
 
 /** Read the canonical blocklist as bare command globs, e.g. `git push --force*`. Throws when the
  * authored file is missing or malformed — a silent empty blocklist would look like success while
  * projecting no protection at all. */
-function destructiveCommandGlobs({ repoRoot, fsImpl = fs }: DestructiveCommandGlobsOptions = {} as DestructiveCommandGlobsOptions): string[] {
+function destructiveCommandGlobs({ repoRoot, fsImpl = fs }                                 = {}                                  )           {
   const file = path.join(repoRoot, 'core', 'harnesses', 'claude', 'settings', 'settings.json');
   const parsed = JSON.parse(fsImpl.readFileSync(file, 'utf8'));
   const deny = parsed?.permissions?.deny;
   if (!Array.isArray(deny) || deny.length === 0) {
     throw new Error(`guardrails: no permissions.deny list in ${file}`);
   }
-  return deny.map((rule: string) => {
+  return deny.map((rule        ) => {
     const m = DENY_RULE.exec(rule);
     if (!m) throw new Error(`guardrails: unrecognized deny rule '${rule}' in ${file}`);
     return m[1];

package/src/helper/{harness-paths.ts → harness-paths.js}

@@ -28,33 +28,33 @@
 //
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): authored as `.ts`, run directly by Node
 // native type-stripping — no build step, no runtime dependency. Body stays CommonJS so a `.js`
-// caller's `require('../helper/harness-paths.ts')` keeps working while the tree is still `.js`. The
+// caller's `require('../helper/harness-paths.js')` keeps working while the tree is still `.js`. The
 // `./repo-root` require stays bare while repo-root is still `.js`.
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { REPO_ROOT } = require('./repo-root.ts');
+const { REPO_ROOT } = require('./repo-root.js');
 
 const PATH_BASES = new Set(['root', 'home']);
 const SURFACE_NAME = /^[a-z][a-zA-Z0-9]*$/;
 const SEGMENT = /^(?!\.\.$)[^\\/]+$/;
 const SCOPES = ['project', 'user'];
 
-interface PathRule {
-  base?: string;
-  segments?: string[];
-}
+                    
+                
+                      
+ 
 
-interface ResolveInputs {
-  scope?: string;
-  scopeRoot?: string;
-  homeDir?: string;
-}
+                         
+                 
+                     
+                   
+ 
 
-function issue(errors: string[], location: string, message: string): void { errors.push(`${location}: ${message}`); }
+function issue(errors          , location        , message        )       { errors.push(`${location}: ${message}`); }
 
 /** Validate one {base, segments} rule. Returns errors via the pushed array. */
-function validateRule(rule: any, location: string, errors: string[]): void {
+function validateRule(rule     , location        , errors          )       {
   if (!rule || typeof rule !== 'object' || Array.isArray(rule)) {
     issue(errors, location, 'must be an object'); return;
   }
@@ -63,7 +63,7 @@ function validateRule(rule: any, location: string, errors: string[]): void {
   }
   if (!PATH_BASES.has(rule.base)) issue(errors, location, `base must be one of ${[...PATH_BASES].join(', ')}`);
   const segments = rule.segments;
-  if (!Array.isArray(segments) || segments.some((segment: any) => typeof segment !== 'string' || !SEGMENT.test(segment))) {
+  if (!Array.isArray(segments) || segments.some((segment     ) => typeof segment !== 'string' || !SEGMENT.test(segment))) {
     issue(errors, location, "segments must be an array of plain single path segments (no '/', no '\\', no '..')");
   }
 }
@@ -71,12 +71,12 @@ function validateRule(rule: any, location: string, errors: string[]): void {
 /** Validate one harness's whole paths section. Unknown keys and malformed rules are rejected
  * loudly: a typo'd declaration must fail the registry load, not silently fall back to whatever
  * the adapter used to hardcode. Returns an array of error messages (empty when valid). */
-function validatePathsSection(section: any, location: string): string[] {
-  const errors: string[] = [];
+function validatePathsSection(section     , location        )           {
+  const errors           = [];
   if (!section || typeof section !== 'object' || Array.isArray(section)) {
     return [`${location}: must be an object`];
   }
-  for (const [name, value] of Object.entries<any>(section)) {
+  for (const [name, value] of Object.entries     (section)) {
     const at = `${location}.${name}`;
     if (!SURFACE_NAME.test(name)) { issue(errors, at, `surface name '${name}' must be camelCase`); continue; }
     if (!value || typeof value !== 'object' || Array.isArray(value)) { issue(errors, at, 'must be an object'); continue; }
@@ -98,7 +98,7 @@ function validatePathsSection(section: any, location: string): string[] {
 }
 
 /** Resolve one rule to an absolute path. */
-function resolveRule(rule: PathRule, { root, home }: { root: string; home: string }): string {
+function resolveRule(rule          , { root, home }                                )         {
   const base = rule.base === 'home' ? home : root;
   return path.join(base, ...(rule.segments || []));
 }
@@ -109,12 +109,12 @@ function resolveRule(rule: PathRule, { root, home }: { root: string; home: strin
  * Returns { <surface>: absolutePath | null } — null when the scope has no rule for a surface —
  * plus `root`, the scope's install root itself (an input, not a declaration).
  */
-function resolveHarnessPaths(section: any, { scope, scopeRoot, homeDir }: ResolveInputs = {}): Record<string, string | null> {
+function resolveHarnessPaths(section     , { scope, scopeRoot, homeDir }                = {})                                {
   const userScope = scope === 'user' || scope === 'global';
   const home = path.resolve(homeDir || scopeRoot);
   const root = userScope ? home : path.resolve(scopeRoot);
-  const resolved: Record<string, string | null> = { root };
-  for (const [name, value] of Object.entries<any>(section || {})) {
+  const resolved                                = { root };
+  for (const [name, value] of Object.entries     (section || {})) {
     const rule = (value.base !== undefined || value.segments !== undefined)
       ? value
       : (value[userScope ? 'user' : 'project'] ?? null);
@@ -123,16 +123,16 @@ function resolveHarnessPaths(section: any, { scope, scopeRoot, homeDir }: Resolv
   return resolved;
 }
 
-let declaredCache: { repoRoot: string; paths: Record<string, any> } | undefined;
+let declaredCache                                                              ;
 /** Every harness's declared paths section, keyed by harness id, read straight from
  * core/registry/harnesses.json (memoized per process — the file ships inside the package).
  * Adapters default their factories to this, so a factory called with no arguments and the CLI
  * wiring in src/cli/shared.js#buildAdapterRegistry consume byte-identical declarations. */
-function declaredHarnessPaths(repoRoot: string = REPO_ROOT): Record<string, any> {
+function declaredHarnessPaths(repoRoot         = REPO_ROOT)                      {
   if (declaredCache && declaredCache.repoRoot === path.resolve(repoRoot)) return declaredCache.paths;
   const file = path.join(path.resolve(repoRoot), 'core', 'registry', 'harnesses.json');
   const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-  const paths = Object.fromEntries((parsed.harnesses || []).map((harness: any) => [harness.id, harness.paths ?? {}]));
+  const paths = Object.fromEntries((parsed.harnesses || []).map((harness     ) => [harness.id, harness.paths ?? {}]));
   declaredCache = { repoRoot: path.resolve(repoRoot), paths };
   return paths;
 }

package/src/helper/{marker-merge.ts → marker-merge.js}

@@ -5,7 +5,7 @@
 //
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): authored as `.ts`, run directly by Node
 // native type-stripping — no build step, no runtime dependency. Body stays CommonJS so a `.js`
-// caller's `require('../helper/marker-merge.ts')` keeps working while the tree is still `.js`.
+// caller's `require('../helper/marker-merge.js')` keeps working while the tree is still `.js`.
 const fs = require('node:fs');
 const path = require('node:path');
 
@@ -17,14 +17,14 @@ const MARKER_END = '<!-- doflow:end -->';
  * Merge `srcAbs`'s content into `dstAbs` inside a doflow-owned marker span,
  * preserving any of `dstAbs`'s own content outside that span byte-for-byte.
  */
-function mergeMarkedSection(srcAbs: string, dstAbs: string, { dryRun = false }: { dryRun?: boolean } = {}): { changed: boolean } {
+function mergeMarkedSection(srcAbs        , dstAbs        , { dryRun = false }                       = {})                       {
   const srcContent = fs.readFileSync(srcAbs, 'utf8').replace(/\s+$/, '');
   const section = `${MARKER_START}\n${srcContent}\n${MARKER_END}\n`;
 
   // Read once, reused both for parsing and for the final no-op comparison below.
   const existing = fs.existsSync(dstAbs) ? fs.readFileSync(dstAbs, 'utf8') : null;
 
-  let newContent: string;
+  let newContent        ;
   if (existing === null) {
     newContent = section;
   } else {
@@ -90,7 +90,7 @@ function mergeMarkedSection(srcAbs: string, dstAbs: string, { dryRun = false }:
  * @returns whether a managed span was found and stripped (false if the file doesn't
  *          exist or has no doflow markers — both are no-ops, not errors)
  */
-function removeMarkedSection(file: string): boolean {
+function removeMarkedSection(file        )          {
   if (!fs.existsSync(file)) return false;
   const existing = fs.readFileSync(file, 'utf8');
   const start = existing.indexOf(MARKER_START);