@caiqueoak/flow 0.7.0 → 0.8.0

package/src/commands/route.mjs

@@ -1,140 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { info } from '../shared/cli-io.mjs';
-import { projectRoot } from '../shared/project-path.mjs';
-import { readConfig } from '../shared/project-config.mjs';
-import { parseBacklog, deriveExecutionStatus } from '../artifacts/backlog.mjs';
-import { parseTasks, qualifiedTaskId } from '../artifacts/tasks.mjs';
-import { validateEngineeringDocument } from '../artifacts/engineering.mjs';
-import { validatePrdDocument } from '../artifacts/prd.mjs';
-import { validateImplementationPlan } from '../artifacts/implementation-plan.mjs';
-import { parseState } from '../artifacts/state.mjs';
-
-function step(phase, instruction, extra = {}) {
-  return { action: 'continue', phase, instruction, ...extra };
-}
-function awaitApproval(phase, instruction, extra = {}) {
-  return { action: 'stop', reason: 'consequential_decision', phase, instruction, ...extra };
-}
-function artifactApproval(file, validator, phase, draftInstruction, approvalInstruction) {
-  if (!fs.existsSync(file)) return step(phase, draftInstruction);
-  const result = validator(fs.readFileSync(file, 'utf8'));
-  if (result.errors.length) return step(phase, draftInstruction, { details: result.errors });
-  if (result.status !== 'approved') return awaitApproval(phase, approvalInstruction);
-  return null;
-}
-export function routeProject(root) {
-  const flow = path.join(root, '.flow');
-  const config = readConfig(root);
-  if (!config) return { action: 'stop', reason: 'unrecoverable_blocker', details: 'Run npx --no-install flow init.' };
-  if (config.schema_version !== 2)
-    return { action: 'stop', reason: 'unrecoverable_blocker', details: 'Run npx --no-install flow migrate.' };
-  const read = (relative) => fs.readFileSync(path.join(flow, relative), 'utf8');
-  const exists = (relative) => fs.existsSync(path.join(flow, relative));
-  const state = exists('state.yaml') ? parseState(read('state.yaml')) : null;
-  if (state?.migration.status === 'pending_reconciliation')
-    return step('migration_reconciliation', 'migration/step-01-reconcile.md', {
-      required_context: [
-        'backlog.yaml',
-        'docs/prd.md',
-        'docs/legacy-state.md',
-        'docs/legacy-decisions.md',
-        'docs/legacy-engineering.md'
-      ]
-        .filter(exists)
-        .map((file) => `.flow/${file}`)
-    });
-  if (state?.stop_reason && state.stop_reason !== 'finished')
-    return { action: 'stop', reason: state.stop_reason, phase: state.execution.phase, step: state.execution.step };
-  const productRoute = artifactApproval(
-    path.join(flow, 'docs/prd.md'),
-    validatePrdDocument,
-    'discovery',
-    'discovery/step-01-project.md',
-    'discovery/step-02-await-approval.md'
-  );
-  if (productRoute) return productRoute;
-  const engineeringRoute = artifactApproval(
-    path.join(flow, 'docs/engineering.md'),
-    validateEngineeringDocument,
-    'engineering',
-    'engineering/step-02-synthesize.md',
-    'engineering/step-05-present.md'
-  );
-  if (engineeringRoute) return engineeringRoute;
-  const engineeringText = read('docs/engineering.md');
-  const planning = () =>
-    step('backlog_planning', 'planning/step-01-plan-work-item.md', {
-      required_context: ['.flow/docs/prd.md', '.flow/docs/engineering.md']
-    });
-  if (!exists('backlog.yaml')) return planning();
-  const backlog = parseBacklog(read('backlog.yaml'));
-  for (const item of backlog.work_items) {
-    if (!exists(`work-items/${item.folder}/spec.md`) || !exists(`work-items/${item.folder}/tasks.yaml`))
-      return planning();
-    parseTasks(read(`work-items/${item.folder}/tasks.yaml`), { expectedWorkItem: item.id });
-  }
-  const byId = new Map(backlog.work_items.map((item) => [item.id, item]));
-  const active = backlog.work_items.find((item) => item.state === 'in_progress');
-  if (active && deriveExecutionStatus(active, byId).status === 'blocked')
-    return {
-      action: 'stop',
-      reason: 'dependency_blocked',
-      work_item: active.id,
-      details: deriveExecutionStatus(active, byId).reasons
-    };
-  const item =
-    active ??
-    backlog.work_items
-      .filter((item) => deriveExecutionStatus(item, byId).status === 'ready')
-      .sort((a, b) => a.priority - b.priority || Number(a.id.slice(1)) - Number(b.id.slice(1)))[0];
-  if (!item)
-    return {
-      action: 'stop',
-      reason: backlog.work_items.every((item) => item.state === 'completed') ? 'finished' : 'external_action'
-    };
-  const base = `work-items/${item.folder}`;
-  const context = [
-    '.flow/docs/prd.md',
-    '.flow/docs/engineering.md',
-    `.flow/${base}/spec.md`,
-    `.flow/${base}/tasks.yaml`
-  ];
-  const tasks = parseTasks(read(`${base}/tasks.yaml`), { expectedWorkItem: item.id });
-  const extra = { work_item: item.id, required_context: context };
-  const prepare = () => step('work_item_plan_approval', 'planning/step-02-prepare-plan.md', extra);
-  if (!exists(`${base}/implementation-plan.md`)) return prepare();
-  const plan = validateImplementationPlan(read(`${base}/implementation-plan.md`), {
-    workItem: item.id,
-    engineeringText,
-    specText: read(`${base}/spec.md`)
-  });
-  if (plan.errors.length) return prepare();
-  if (plan.status !== 'approved')
-    return awaitApproval('work_item_plan_approval', 'planning/step-03-await-approval.md', extra);
-  context.push(`.flow/${base}/implementation-plan.md`);
-  const taskById = new Map(tasks.tasks.map((task) => [task.id, task]));
-  const task =
-    tasks.tasks.find((task) => task.state === 'in_progress') ??
-    tasks.tasks
-      .filter(
-        (task) => task.state === 'pending' && task.depends_on.every((id) => taskById.get(id).state === 'completed')
-      )
-      .sort((a, b) => Number(a.id.slice(1)) - Number(b.id.slice(1)))[0];
-  if (task)
-    return step('implementation', 'build/step-01-execute-task.md', {
-      ...extra,
-      task: qualifiedTaskId(item.id, task.id)
-    });
-  if (tasks.tasks.every((task) => task.state === 'completed'))
-    return step('work_item_review', 'review/step-01-review-work-item.md', extra);
-  return step('reconcile', 'reconcile/step-01-reconcile.md', extra);
-}
-export function runRoute({ args }) {
-  const result = routeProject(projectRoot(args));
-  info(
-    args.includes('--json')
-      ? JSON.stringify(result, null, 2)
-      : `${result.action}: ${result.phase ?? result.reason}${result.work_item ? ` ${result.work_item}` : ''}`
-  );
-}

package/src/commands/status.mjs

@@ -1,35 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { info } from '../shared/cli-io.mjs';
-import { projectRoot } from '../shared/project-path.mjs';
-import { deriveExecutionStatus, parseBacklog } from '../artifacts/backlog.mjs';
-import { routeProject } from './route.mjs';
-
-export function runStatus({ args }) {
-  const root = projectRoot(args);
-  if (!fs.existsSync(path.join(root, '.flow', 'backlog.yaml')))
-    return info(`Next: ${routeProject(root).phase ?? 'setup'}`);
-  const backlog = parseBacklog(fs.readFileSync(path.join(root, '.flow', 'backlog.yaml'), 'utf8'));
-  const byId = new Map(backlog.work_items.map((item) => [item.id, item]));
-  const groups = new Map(['in_progress', 'ready', 'blocked', 'completed'].map((status) => [status, []]));
-  for (const item of backlog.work_items) {
-    const derived = deriveExecutionStatus(item, byId);
-    groups.get(derived.status).push({
-      ...item,
-      reasons: derived.reasons,
-      blockers: item.blockers.filter((blocker) => blocker.status === 'unresolved')
-    });
-  }
-  const lines = [];
-  for (const [status, items] of groups) {
-    if (!items.length) continue;
-    lines.push(status.replace('_', ' ').replace(/^./, (c) => c.toUpperCase()));
-    for (const item of items) {
-      const deps = item.reasons.filter((r) => r.type === 'dependency').map((r) => r.ref);
-      lines.push(`  ${item.id} — ${item.title}${deps.length ? ` ← ${deps.join(', ')}` : ''}`);
-      for (const blocker of item.blockers) lines.push(`    blocker: ${blocker.description} [${blocker.id}]`);
-    }
-    lines.push('');
-  }
-  info(lines.join('\n').trim());
-}

package/src/commands/trace.mjs

@@ -1,58 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { info, fail } from '../shared/cli-io.mjs';
-import { projectRoot } from '../shared/project-path.mjs';
-
-export function traceTask(root, qualifiedTaskId) {
-  if (!/^W\d{3,}-T\d{3,}$/.test(qualifiedTaskId))
-    fail(`invalid qualified task ID '${qualifiedTaskId}'. Expected W015-T003.`);
-  return traceTasks(root, [qualifiedTaskId]).get(qualifiedTaskId);
-}
-
-export function traceTasks(root, qualifiedTaskIds) {
-  for (const qualifiedTaskId of qualifiedTaskIds)
-    if (!/^W\d{3,}-T\d{3,}$/.test(qualifiedTaskId))
-      fail(`invalid qualified task ID '${qualifiedTaskId}'. Expected W015-T003.`);
-  const requested = new Set(qualifiedTaskIds);
-  const matches = new Map([...requested].map((task) => [task, []]));
-  let output;
-  try {
-    output = execFileSync('git', ['log', 'HEAD', '--format=%H%x1f%s%x1f%B%x1e'], {
-      cwd: root,
-      encoding: 'utf8',
-      maxBuffer: 50 * 1024 * 1024
-    });
-  } catch {
-    fail('git history is unavailable; task traceability requires a Git repository.');
-  }
-  for (const entry of output
-    .split('\x1e')
-    .filter(Boolean)
-    .map((record) => {
-      const [sha, subject, ...bodyParts] = record.replace(/^\n+|\n+$/g, '').split('\x1f');
-      return { sha, subject, body: bodyParts.join('\x1f') };
-    })) {
-    const workItems = new Set([...entry.body.matchAll(/^Flow-Work-Item:\s*(W\d{3,})\s*$/gm)].map((match) => match[1]));
-    for (const match of entry.body.matchAll(/^Flow-Task:\s*(W\d{3,}-T\d{3,})\s*$/gm)) {
-      const task = match[1];
-      if (requested.has(task) && workItems.has(task.split('-')[0])) matches.get(task).push(entry);
-    }
-  }
-  return new Map(
-    [...requested].map((task) => {
-      const commits = matches.get(task);
-      if (!commits.length) return [task, { task, commits, status: 'missing' }];
-      if (commits.length > 1) return [task, { task, commits, status: 'ambiguous' }];
-      return [task, { task, commit: commits[0], commits, status: 'resolved' }];
-    })
-  );
-}
-
-export function runTrace({ args }) {
-  const task = args.find((arg) => !arg.startsWith('--'));
-  if (!task) fail('flow trace requires a qualified task ID, e.g. W015-T003.');
-  const result = traceTask(projectRoot(args), task);
-  if (args.includes('--json')) return info(JSON.stringify(result, null, 2));
-  if (result.status === 'missing') fail(`No reachable commit declares Flow-Task: ${task}.`);
-  if (result.status === 'ambiguous') fail(`Multiple reachable commits declare Flow-Task: ${task}.`);
-  info(`${task} -> ${result.commit.sha}\n${result.commit.subject}`);
-}

package/src/commands/validate.mjs

@@ -1,197 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { info, fail } from '../shared/cli-io.mjs';
-import { projectRoot } from '../shared/project-path.mjs';
-import { readConfig } from '../shared/project-config.mjs';
-import { parseBacklog, deriveExecutionStatus } from '../artifacts/backlog.mjs';
-import { parseTasks, qualifiedTaskId } from '../artifacts/tasks.mjs';
-import { parseState } from '../artifacts/state.mjs';
-import { parseGates } from '../artifacts/gates.mjs';
-import { validateEngineeringDocument } from '../artifacts/engineering.mjs';
-import { validatePrdDocument } from '../artifacts/prd.mjs';
-import { validateImplementationPlan } from '../artifacts/implementation-plan.mjs';
-import { traceTasks } from './trace.mjs';
-import { generateGraphMarkdown } from './graph.mjs';
-import { evaluateGates } from './gates.mjs';
-
-export function validateProject(
-  root,
-  { preCommitTask = null, skipTrace = false, evaluateConfiguredGates = false, onGateResults } = {}
-) {
-  const findings = [];
-  const error = (code, message) => findings.push({ level: 'error', code, message });
-  const flow = path.join(root, '.flow');
-  const exists = (relative) => fs.existsSync(path.join(flow, relative));
-  const hasExactRootEntry = (name) => fs.readdirSync(flow).includes(name);
-  const read = (relative) => fs.readFileSync(path.join(flow, relative), 'utf8');
-  let config;
-  try {
-    config = readConfig(root);
-  } catch (failure) {
-    error('CONFIG', failure.message);
-  }
-  if (!config || config.schema_version !== 2) {
-    error('CONFIG', 'Initialize Flow or migrate the existing project.');
-    return findings;
-  }
-  if (
-    config.engineering.profile !== 'flow/readability-first@1' ||
-    !['improve', 'preserve', 'not_applicable'].includes(config.engineering.existing_code_policy)
-  )
-    error('CONFIG', 'Invalid engineering bootstrap preferences.');
-  for (const name of ['STATE.md', 'DECISIONS.md', 'SUMMARY.md', 'BACKLOG.yaml', 'PRD.md', 'ENGINEERING.md', 'GRAPH.md'])
-    if (hasExactRootEntry(name)) error('LEGACY', `${name} must be migrated.`);
-  let state;
-  try {
-    state = exists('state.yaml') ? parseState(read('state.yaml')) : null;
-  } catch (failure) {
-    error('STATE', failure.message);
-  }
-  const migrationPending = state?.migration.status === 'pending_reconciliation';
-  const backlogRequired = [
-    'backlog_planning',
-    'work_item_plan_approval',
-    'implementation',
-    'work_item_review',
-    'complete'
-  ].includes(state?.execution.phase);
-  if (!exists('backlog.yaml')) {
-    if (backlogRequired) error('MISSING', 'Missing backlog.yaml.');
-    return findings;
-  }
-  let backlog;
-  try {
-    backlog = parseBacklog(read('backlog.yaml'));
-  } catch (failure) {
-    error('BACKLOG', failure.message);
-    return findings;
-  }
-  const anyStarted = backlog.work_items.some((item) => item.state !== 'pending');
-  if (!migrationPending) {
-    for (const [name, validator] of [
-      ['prd.md', validatePrdDocument],
-      ['engineering.md', validateEngineeringDocument]
-    ]) {
-      if (!exists(`docs/${name}`)) {
-        error('MISSING', `Missing docs/${name}.`);
-        continue;
-      }
-      const document = validator(read(`docs/${name}`));
-      for (const message of document.errors) error('DOCUMENT', `${name}: ${message}`);
-      if (anyStarted && document.status !== 'approved')
-        error('APPROVAL', `${name} must be approved before implementation.`);
-    }
-  }
-  const byId = new Map(backlog.work_items.map((item) => [item.id, item]));
-  let activeTasks = 0;
-  const traceCandidates = [];
-  for (const item of backlog.work_items) {
-    const base = `work-items/${item.folder}`;
-    const missing = ['spec.md', 'tasks.yaml'].filter((name) => !exists(`${base}/${name}`));
-    if (missing.length) {
-      if (!(migrationPending && item.state === 'pending'))
-        error('WORK_ITEM', `${item.id} is missing ${missing.join(', ')}.`);
-      continue;
-    }
-    let tasks;
-    try {
-      tasks = parseTasks(read(`${base}/tasks.yaml`), { expectedWorkItem: item.id });
-    } catch (failure) {
-      error('TASKS', failure.message);
-      continue;
-    }
-    const historical = tasks.tasks.length > 0 && tasks.tasks.every((task) => task.implementation === 'legacy');
-    activeTasks += tasks.tasks.filter((task) => task.state === 'in_progress').length;
-    if (tasks.tasks.some((task) => task.state === 'in_progress') && item.state !== 'in_progress')
-      error('STATE', `${item.id}: active task requires active work item.`);
-    if (item.state === 'completed' && tasks.tasks.some((task) => task.state !== 'completed'))
-      error('STATE', `${item.id}: completed work has incomplete tasks.`);
-    if (item.state === 'in_progress' && deriveExecutionStatus(item, byId).status === 'blocked')
-      error('STATE', `${item.id}: active work is blocked.`);
-    if (!historical && !migrationPending) {
-      const spec = read(`${base}/spec.md`);
-      for (const heading of [
-        '## Status',
-        '## Goal',
-        '## Scope',
-        '## Non-goals',
-        '## Requirements',
-        '## Acceptance criteria',
-        '## Decisions'
-      ])
-        if (!spec.split(/\r?\n/).includes(heading)) error('SPEC', `${item.id} missing ${heading}.`);
-      const planPath = `${base}/implementation-plan.md`;
-      if (!exists(planPath)) {
-        if (item.state !== 'pending') error('PLAN', `${item.id} requires an approved implementation plan.`);
-      } else if (exists('docs/engineering.md')) {
-        const plan = validateImplementationPlan(read(planPath), {
-          workItem: item.id,
-          engineeringText: read('docs/engineering.md'),
-          specText: spec,
-          checkRevisions: item.state !== 'completed'
-        });
-        for (const message of plan.errors) error('PLAN', `${item.id}: ${message}`);
-        if (item.state !== 'pending' && plan.status !== 'approved') error('PLAN', `${item.id}: plan is not approved.`);
-      }
-    }
-    for (const task of tasks.tasks)
-      if (task.state === 'completed' && task.implementation === 'commit' && !skipTrace) {
-        const qualified = qualifiedTaskId(item.id, task.id);
-        if (qualified !== preCommitTask) traceCandidates.push(qualified);
-      }
-  }
-  if (traceCandidates.length) {
-    try {
-      for (const [qualified, result] of traceTasks(root, traceCandidates))
-        if (result.status !== 'resolved')
-          error('TRACE', `${qualified}: expected exactly one HEAD-reachable commit with both Flow trailers.`);
-    } catch (failure) {
-      for (const qualified of traceCandidates) error('TRACE', `${qualified}: ${failure.message}`);
-    }
-  }
-  if (activeTasks > 1) error('STATE', 'Only one mutating task may be active across the project.');
-  if (exists('gates.yaml')) {
-    try {
-      parseGates(read('gates.yaml'));
-      if (!migrationPending && evaluateConfiguredGates) {
-        const gateResults = evaluateGates(root);
-        onGateResults?.(gateResults);
-        for (const gate of gateResults)
-          if (gate.blocking && ['failed', 'unsupported'].includes(gate.status))
-            error('GATE', `${gate.id}: ${gate.status}`);
-      }
-    } catch (failure) {
-      error('GATES', failure.message);
-    }
-  } else if (!migrationPending) error('MISSING', 'Missing gates.yaml.');
-  if (!exists('docs/graph.md') || read('docs/graph.md') !== generateGraphMarkdown(read('backlog.yaml')))
-    error('GRAPH', 'Graph is stale; run npx --no-install flow graph.');
-  return findings;
-}
-export function runValidate({ args }) {
-  const index = args.indexOf('--pre-commit');
-  const includeGates = args.includes('--gates');
-  let gateResults = [];
-  const findings = validateProject(projectRoot(args), {
-    preCommitTask: index < 0 ? null : args[index + 1],
-    skipTrace: args.includes('--skip-trace'),
-    evaluateConfiguredGates: includeGates,
-    onGateResults: (results) => {
-      gateResults = results;
-    }
-  });
-  if (args.includes('--json')) {
-    info(
-      JSON.stringify(
-        { valid: findings.length === 0, findings, ...(includeGates ? { gates: gateResults } : {}) },
-        null,
-        2
-      )
-    );
-    if (findings.length) process.exitCode = 1;
-    return;
-  }
-  if (!findings.length) return info('Flow project is valid.');
-  for (const finding of findings) info(`${finding.code}: ${finding.message}`);
-  fail(`${findings.length} validation finding(s).`);
-}

package/src/shared/cli-io.mjs

@@ -1,86 +0,0 @@
-import readline from 'node:readline/promises';
-import { stdin as inputStream, stdout as outputStream } from 'node:process';
-
-export class CliError extends Error {}
-export function fail(message, code = 1) {
-  const error = new CliError(message);
-  error.exitCode = code;
-  throw error;
-}
-export function info(message = '') {
-  console.log(message);
-}
-function abortedPromptError() {
-  const error = new Error('Prompt aborted.');
-  error.code = 'ABORT_ERR';
-  return error;
-}
-function question(readlineInterface, message) {
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const finish = (callback, value) => {
-      if (settled) return;
-      settled = true;
-      readlineInterface.removeListener('close', onClose);
-      callback(value);
-    };
-    const onClose = () => finish(reject, abortedPromptError());
-    readlineInterface.once('close', onClose);
-    readlineInterface.question(message).then(
-      (answer) => finish(resolve, answer),
-      (error) => finish(reject, error)
-    );
-  });
-}
-export async function promptText(message, defaultValue = '') {
-  const rl = readline.createInterface({ input: inputStream, output: outputStream });
-  try {
-    const answer = (await question(rl, `${message}${defaultValue ? ` [${defaultValue}]` : ''}: `)).trim();
-    return answer || defaultValue;
-  } finally {
-    rl.close();
-  }
-}
-export async function promptSelect({ title, options, defaultIndex = 0 }) {
-  info(title);
-  options.forEach((option, index) =>
-    info(
-      `  ${index === defaultIndex ? '›' : ' '} ${index + 1}. ${option.label}${option.description ? `\n     ${option.description}` : ''}`
-    )
-  );
-  const rl = readline.createInterface({ input: inputStream, output: outputStream });
-  try {
-    while (true) {
-      const answer = (await question(rl, `Selection [${defaultIndex + 1}]: `)).trim();
-      const index = answer ? Number.parseInt(answer, 10) - 1 : defaultIndex;
-      if (Number.isInteger(index) && index >= 0 && index < options.length) return options[index].value;
-      info('Choose a valid number.');
-    }
-  } finally {
-    rl.close();
-  }
-}
-export async function promptMultiSelect({ title, options }) {
-  info(title);
-  options.forEach((option, index) => info(`  [ ] ${index + 1}. ${option.label}`));
-  info('  (Select multiple with comma-separated numbers, e.g. 1,2)');
-  const rl = readline.createInterface({ input: inputStream, output: outputStream });
-  try {
-    while (true) {
-      const answer = (await question(rl, 'Selection: ')).trim();
-      const indices = [
-        ...new Set(
-          answer
-            .split(',')
-            .map((value) => Number.parseInt(value.trim(), 10))
-            .filter(Number.isInteger)
-        )
-      ];
-      if (indices.length && indices.every((index) => index >= 1 && index <= options.length))
-        return indices.map((index) => options[index - 1].value);
-      info('Choose one or more valid numbers.');
-    }
-  } finally {
-    rl.close();
-  }
-}

package/src/shared/profiles.mjs

@@ -1,27 +0,0 @@
-import fs from 'node:fs';
-import { parse } from 'yaml';
-const text = fs.readFileSync(
-  new URL('../../skills/flow/engineering/profiles/readability-first.md', import.meta.url),
-  'utf8'
-);
-export function parseProfileFrontmatter(text) {
-  const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
-  if (!match) throw new Error('Missing YAML frontmatter in Flow profile.');
-  return parse(match[1]);
-}
-export const READABILITY_FIRST_PROFILE = parseProfileFrontmatter(text);
-export const ENGINEERING_PROFILES = {
-  'readability-first': READABILITY_FIRST_PROFILE,
-  [READABILITY_FIRST_PROFILE.id]: READABILITY_FIRST_PROFILE
-};
-export const BROWNFIELD_POLICIES = {
-  improve: {
-    label: 'Improve existing structure — Recommended',
-    description:
-      'Preserve behavior and external contracts; recommend clearer structure where justified. Does not authorize refactoring.'
-  },
-  preserve: {
-    label: 'Keep existing structure',
-    description: 'Retain consistent conventions unless a concrete problem warrants an approved change.'
-  }
-};

package/src/shared/project-config.mjs

@@ -1,39 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { parse, stringify } from 'yaml';
-
-export function configPath(root) {
-  return path.join(root, '.flow', 'config.yaml');
-}
-
-export function defaultConfig() {
-  return {
-    schema_version: 2,
-    runtimes: [],
-    engineering: { profile: 'flow/readability-first@1', existing_code_policy: 'not_applicable' }
-  };
-}
-
-export function readConfig(root) {
-  const file = configPath(root);
-  if (!fs.existsSync(file)) return null;
-  const raw = parse(fs.readFileSync(file, 'utf8')) ?? {};
-  const config = defaultConfig();
-  config.schema_version = raw.schema_version ?? 1;
-  config.runtimes = Array.isArray(raw.runtimes) ? raw.runtimes : [];
-  config.engineering = { ...config.engineering, ...(raw.engineering ?? {}) };
-  return config;
-}
-
-export function writeConfig(root, config) {
-  const normalized = {
-    schema_version: 2,
-    runtimes: config.runtimes ?? [],
-    engineering: {
-      profile: config.engineering?.profile ?? defaultConfig().engineering.profile,
-      existing_code_policy: config.engineering?.existing_code_policy ?? 'not_applicable'
-    }
-  };
-  fs.mkdirSync(path.join(root, '.flow'), { recursive: true });
-  fs.writeFileSync(configPath(root), stringify(normalized, { lineWidth: 0 }), 'utf8');
-}

package/src/shared/project-path.mjs

@@ -1,10 +0,0 @@
-import path from 'node:path';
-
-export function valueAfter(args, name) {
-  const index = args.indexOf(name);
-  return index >= 0 ? args[index + 1] : undefined;
-}
-
-export function projectRoot(args) {
-  return path.resolve(valueAfter(args, '--path') || process.cwd());
-}

package/src/shared/skill-installer.mjs

@@ -1,34 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-function copyDirectory(source, target) {
-  fs.mkdirSync(target, { recursive: true });
-  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
-    const sourcePath = path.join(source, entry.name);
-    const targetPath = path.join(target, entry.name);
-    if (entry.isDirectory()) copyDirectory(sourcePath, targetPath);
-    else fs.copyFileSync(sourcePath, targetPath);
-  }
-}
-
-export function installRuntimeSkill(root, runtime, packageRoot) {
-  if (
-    typeof runtime.skills_path !== 'string' ||
-    !runtime.skills_path ||
-    path.isAbsolute(runtime.skills_path) ||
-    runtime.skills_path.split(/[\\/]/).includes('..')
-  )
-    throw new Error('Runtime skills_path must remain project-local.');
-  const target = path.join(root, runtime.skills_path, 'flow');
-  let ancestor = root;
-  for (const segment of path.relative(root, target).split(path.sep)) {
-    ancestor = path.join(ancestor, segment);
-    if (fs.existsSync(ancestor) && fs.lstatSync(ancestor).isSymbolicLink())
-      throw new Error('Refusing a symlinked runtime path.');
-  }
-  if (fs.existsSync(target) && fs.lstatSync(target).isSymbolicLink())
-    throw new Error('Refusing to overwrite a symlinked skill.');
-  fs.rmSync(target, { recursive: true, force: true });
-  copyDirectory(path.join(packageRoot, 'skills', 'flow'), target);
-  return target;
-}