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

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

@@ -23,52 +23,54 @@ 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');
+const { loadRegistry } = require('../registry/index.js');
+const { enforcementFor, UnknownEnforcementTarget } = require('../lifecycle/coverage.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, resolveFeature } = 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 +83,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 +94,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,13 +106,16 @@ 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;
   if (o.content !== undefined) item.content = o.content;
   if (o.establishes !== undefined) item.establishes = o.establishes;
+  if (o.need !== undefined) item.need = o.need;
+  if (o.result !== undefined) item.result = o.result;
+  if (o.absence !== undefined) item.absence = o.absence;
   // Both halves of an observation travel together; a lone half must reach the write boundary as
   // the partial object it is, so the refusal names the missing field instead of dropping the pair.
   if (o.observedCommand !== undefined || o.observedExit !== undefined) {
@@ -118,7 +123,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;
@@ -128,9 +133,9 @@ function evidenceItemFromFlags(o: any): any {
 /** Verbs that read or write per-task records, and so accept `--slug` (IC-002). */
 const TASK_STORE_VERBS = new Set(['evidence', 'claim', 'readiness', 'context-pack', 'research-request', 'outcome', 'retrieval-plan']);
 
-/** Verbs that build a task's readiness: run from a linked worktree whose feature folder lives only
- * in the main checkout, they keep the task's records there, beside the folder their evidence names. */
-const FEATURE_STORE_VERBS = new Set(['evidence', 'claim', 'readiness']);
+/** Verbs whose task records live beside the feature folder when run from a linked worktree that
+ * does not contain it. */
+const FEATURE_STORE_VERBS = new Set(['evidence', 'claim', 'readiness', 'retrieval-plan']);
 
 /**
  * The main checkout, when `o` runs one of FEATURE_STORE_VERBS in a linked worktree that lacks the
@@ -139,12 +144,17 @@ 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     , checkouts     )                                        {
   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 || '');
+  let slug = o.slug || null;
+  if (!slug) {
+    try {
+      const feature = resolveFeature({ projectRoot: checkouts.current });
+      slug = !feature.error && feature.paths ? feature.paths.feature_slug : null;
+    } catch { /* a failed branch lookup cannot route state to a guessed feature */ }
+  }
+  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 +165,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.
@@ -169,8 +179,11 @@ function dispatchRuntimeCommandInner(o: any, moment: any): any {
   // here so the verbs whose handlers build their own ledger (readiness, evidence) route the same
   // way as the ones that take `slug` directly. The orchestration journal is keyed by slug already.
   // Reset on every dispatch, so one invocation's slug can never carry into the next in-process call.
-  const featureStore = featureStoreRoot(o);
+  const checkouts = FEATURE_STORE_VERBS.has(o.cmd) && !o.global
+    ? listCheckouts({ cwd: evidenceRoot(o) }) : null;
+  const featureStore = featureStoreRoot(o, checkouts);
   const storeRoot = featureStore ? featureStore.root : evidenceRoot(o);
+  const attemptRoot = checkouts?.ok && !checkouts.sandbox ? (checkouts.main || checkouts.current || null) : null;
   // Use the same root resolver as the handler: task redirection, the nearest run ledger,
   // and lifecycle's shared main-worktree store are deliberately different scopes.
   try {
@@ -197,6 +210,7 @@ function dispatchRuntimeCommandInner(o: any, moment: any): any {
     // REPO_ROOT locates the capability registry; projectRoot is the tree whose index freshness
     // and build/test commands are being reported on, which follows the usual scope rules.
     case 'capabilities': return handleCapabilitiesCommand({ json: o.json, check: o.check, repoRoot: REPO_ROOT });
+    case 'enforcement': return handleEnforcementCommand(o);
     case 'doctor': return handleDoctorCommand({ json: o.json, repoRoot: REPO_ROOT, projectRoot: evidenceRoot(o), adapters: buildAdapterRegistry() });
     // REPO_ROOT locates the registry (templates ship with the package); stateRoot locates the
     // caller's evidence, which follows the same scope rules as every other command: -g means
@@ -211,8 +225,8 @@ function dispatchRuntimeCommandInner(o: any, moment: any): any {
     // than from evidence, so the gate had one reachable answer for every task. Forwarding is
     // all this does: the handler names them back under `callerAsserted` so a stated input is
     // never mistaken for a measured one.
-    case 'readiness': return handleReadinessCommand({ taskClass: requireTaskClass(o), taskId: requireTaskId(o), verificationPlan: o.verificationPlan, scopeClear: o.scope, invariants: o.invariants, userDecisionPending: o.userDecisionPending, mode: o.mode, slug: storeSlug, json: o.json, repoRoot: REPO_ROOT, stateRoot: storeRoot });
-    case 'evidence': return handleEvidenceCommand({ taskId: requireTaskId(o), action: o.action, item: evidenceItemFromFlags(o), batchPath: o.batchPath, evidenceId: o.evidenceId, replacedBy: o.replacedBy, json: o.json, repoRoot: REPO_ROOT, stateRoot: storeRoot });
+    case 'readiness': return handleReadinessCommand({ taskClass: requireTaskClass(o), taskId: requireTaskId(o), verificationPlan: o.verificationPlan, scopeClear: o.scope, invariants: o.invariants, userDecisionPending: o.userDecisionPending, mode: o.mode, slug: storeSlug, json: o.json, repoRoot: REPO_ROOT, stateRoot: storeRoot, sourceRoot: evidenceRoot(o) });
+    case 'evidence': return handleEvidenceCommand({ taskId: requireTaskId(o), action: o.action, item: evidenceItemFromFlags(o), batchPath: o.batchPath, evidenceId: o.evidenceId, replacedBy: o.replacedBy, json: o.json, repoRoot: REPO_ROOT, stateRoot: storeRoot, slug: storeSlug, sourceRoot: evidenceRoot(o), attemptRoot });
     // Run-ledger views. They resolve their own ledger the way the dispatcher does (nearest
     // `.doflow` walking up, or the global one) rather than assuming cwd is the project root, so
     // a view invoked from a subdirectory reads the runs that were actually recorded.
@@ -253,15 +267,15 @@ 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) });
     case 'model-role': return handleModelRoleCommand({ role: o.role, exclude: o.exclude, json: o.json, repoRoot: REPO_ROOT });
     case 'route': return handleRouteCommand({ intent: o.intent, query: o.query, check: o.check, json: o.json, projectRoot: evidenceRoot(o) });
     case 'claim': return handleClaimCommand({ slug: storeSlug, taskId: requireTaskId(o), action: o.action, statement: o.statement, claimId: o.claimId, evidenceId: o.evidenceId, replacedBy: o.replacedBy, relation: o.relation, role: o.role, json: o.json, stateRoot: storeRoot });
-    case 'context-pack': return handleContextPackCommand({ taskId: requireTaskId(o), taskClass: o.taskClass, objective: o.objective, json: o.json, stateRoot: evidenceRoot(o), slug: o.slug });
-    case 'retrieval-plan': return handleRetrievalPlanCommand({ slug: o.slug, taskId: requireTaskId(o), action: o.action, need: o.need, stage: o.stage, json: o.json, repoRoot: REPO_ROOT, stateRoot: evidenceRoot(o) });
+    case 'context-pack': return handleContextPackCommand({ taskId: requireTaskId(o), taskClass: o.taskClass, objective: o.objective, json: o.json, stateRoot: evidenceRoot(o), slug: o.slug, mandatoryFile: o.mandatoryFile, harness: o.harness, maxBytes: o.maxBytes, bare: o.bare, noRecord: o.noRecord, reason: o.reason, since: o.since, expand: o.expand });
+    case 'retrieval-plan': return handleRetrievalPlanCommand({ slug: storeSlug, taskId: requireTaskId(o), action: o.action, need: o.need, stage: o.stage, provider: o.provider, attemptStatus: o.attemptStatus, reason: o.reason, note: o.note, json: o.json, repoRoot: REPO_ROOT, stateRoot: storeRoot, sourceRoot: evidenceRoot(o) });
     case 'outcome': return handleOutcomeCommand({ slug: o.slug, taskId: requireTaskId(o), action: o.action, state: o.state, taskClass: o.taskClass, stage: o.stage, readiness: o.readiness, verification: o.verification, json: o.json, repoRoot: REPO_ROOT, stateRoot: evidenceRoot(o) });
     case 'verify': return handleVerifyCommand({ slug: o.slug, taskId: requireTaskId(o), action: o.action, risk: o.risk, planPath: o.planPath, scope: o.scope, verificationInput: o.verificationInput, verificationPhase: o.verificationPhase, baselineRef: o.baselineRef, json: o.json, projectRoot: evidenceRoot(o) });
     case 'leak-scan': return handleLeakScanCommand({ paths: o.paths, exclude: o.exclude, json: o.json, repoRoot: evidenceRoot(o) });
@@ -271,11 +285,36 @@ 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;
 }
 
+function handleEnforcementCommand(o     )         {
+  const fail = (error        , detail        )         => {
+    if (o.json) console.log(JSON.stringify({ error, detail }));
+    else console.error(`doflow enforcement: ${detail}`);
+    process.exitCode = 2;
+    return 2;
+  };
+  if (typeof o.harness !== 'string' || !o.harness || typeof o.policy !== 'string' || !o.policy || (o.profile !== undefined && typeof o.profile !== 'string')) return fail('usage', 'requires --harness <id> --policy <id> [--profile <id>]');
+  try {
+    const registry = loadRegistry({ repoRoot: REPO_ROOT });
+    const answer = enforcementFor(registry.coverage, { harness: o.harness, policy: o.policy, ...(o.profile ? { profile: o.profile } : {}) });
+    if (o.json) console.log(JSON.stringify(answer));
+    else {
+      console.log(`${answer.harness} ${answer.policy}: ${answer.enforced ? 'enforced' : 'not enforced'} (${answer.class}, ${answer.verification})`);
+      for (const item of answer.doesNotCover) console.log(`does not cover: ${item}`);
+      for (const item of answer.prerequisites) console.log(`prerequisite: ${item}`);
+    }
+    process.exitCode = answer.enforced ? 0 : 1;
+    return process.exitCode;
+  } catch (error     ) {
+    if (error instanceof UnknownEnforcementTarget) return fail(error.code, error.message);
+    return fail('usage', error.message);
+  }
+}
+
 module.exports = { dispatchRuntimeCommand };

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];