create-quiver 0.10.0 → 0.12.0

package/src/create-quiver/lib/ai/plan-review.js

@@ -0,0 +1,283 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { readPhaseApproval, resolveApprovedPlannerInput } = require('../approvals');
+const { quiverInternalPaths } = require('../init-layout');
+
+const PLAN_REVIEW_PROMPT_SOURCE = 'packaged production-readiness plan review template';
+
+function formatError(message) {
+  return `create-quiver: ${message}`;
+}
+
+function toRelativePosix(root, filePath) {
+  return path.relative(root, filePath).split(path.sep).join('/');
+}
+
+function planReviewRoot(projectRoot) {
+  return path.join(quiverInternalPaths(projectRoot).root, 'approvals', 'plan-review');
+}
+
+function planReviewPath(projectRoot) {
+  return path.join(planReviewRoot(projectRoot), 'review.md');
+}
+
+function planReviewMetaPath(projectRoot) {
+  return path.join(planReviewRoot(projectRoot), 'meta.json');
+}
+
+function readPlanReviewMeta(projectRoot) {
+  const filePath = planReviewMetaPath(projectRoot);
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (error) {
+    throw new Error(formatError(`invalid plan-review metadata at ${toRelativePosix(projectRoot, filePath)}: ${error.message}`));
+  }
+}
+
+function normalizeDrafts(meta) {
+  return Array.isArray(meta?.drafts) ? meta.drafts.filter((item) => item && typeof item === 'object') : [];
+}
+
+function resolvePath(projectRoot, relativePath) {
+  return path.resolve(projectRoot, relativePath || '');
+}
+
+function samePath(projectRoot, left, right) {
+  return Boolean(left && right && resolvePath(projectRoot, left) === resolvePath(projectRoot, right));
+}
+
+function latestTechnicalPlanDraft(approval) {
+  const version = Number(approval.meta?.draft?.version || 0);
+  if (!version) {
+    return null;
+  }
+  return normalizeDrafts(approval.meta).find((item) => Number(item.version) === version) || null;
+}
+
+function reviewMatchesTarget(projectRoot, review, target) {
+  if (review.version && target.version) {
+    return review.version === target.version;
+  }
+
+  if (!review.source) {
+    return false;
+  }
+
+  return samePath(projectRoot, review.source, target.source)
+    || samePath(projectRoot, review.source, target.artifact);
+}
+
+function resolveTechnicalPlanReviewInput(projectRoot, explicitInput) {
+  const approval = readPhaseApproval(projectRoot, 'technical-plan');
+  const latestDraft = latestTechnicalPlanDraft(approval);
+  const candidates = [];
+
+  if (latestDraft?.path) {
+    candidates.push({
+      kind: 'draft',
+      version: Number(latestDraft.version),
+      inputPath: latestDraft.path,
+      approval,
+    });
+  } else if (approval.draft?.path) {
+    candidates.push({
+      kind: 'draft',
+      version: Number(approval.meta?.draft?.version || 0) || null,
+      inputPath: approval.draft.path,
+      approval,
+    });
+  }
+
+  if (approval.approved?.path) {
+    candidates.push({
+      kind: 'approved',
+      version: Number(approval.meta?.approved?.version || 0) || null,
+      inputPath: approval.approved.path,
+      approval,
+    });
+  }
+
+  if (candidates.length === 0) {
+    throw new Error(formatError("ai review-plan requires a generated technical-plan draft. Run `npx create-quiver ai plan --phase technical-plan`."));
+  }
+
+  if (!explicitInput) {
+    return candidates[0];
+  }
+
+  const approvedSource = approval.meta?.approved?.source_file || '';
+  const draftSource = approval.meta?.draft?.source_file || '';
+  const matched = candidates.find((candidate) => samePath(projectRoot, explicitInput, candidate.inputPath))
+    || candidates.find((candidate) => candidate.kind === 'approved' && samePath(projectRoot, explicitInput, approvedSource))
+    || candidates.find((candidate) => candidate.kind === 'draft' && samePath(projectRoot, explicitInput, draftSource));
+
+  if (!matched) {
+    throw new Error(formatError(`ai review-plan input '${explicitInput}' must match the latest technical-plan draft or approved artifact.`));
+  }
+
+  return matched;
+}
+
+function readPlanReview(projectRoot) {
+  const reviewPath = planReviewPath(projectRoot);
+  const meta = readPlanReviewMeta(projectRoot);
+  if (!meta && !fs.existsSync(reviewPath)) {
+    return {
+      status: 'missing',
+      review: null,
+      meta: null,
+    };
+  }
+
+  const technicalPlan = readPhaseApproval(projectRoot, 'technical-plan');
+  const reviewedAt = meta?.reviewed_at ? new Date(meta.reviewed_at).getTime() : 0;
+  const approvedAt = technicalPlan.meta?.approved?.approved_at ? new Date(technicalPlan.meta.approved.approved_at).getTime() : 0;
+  const reviewedVersion = Number(meta?.source_version || 0) || null;
+  const approvedVersion = Number(technicalPlan.meta?.approved?.version || 0) || null;
+  const reviewedSource = meta?.source_file || '';
+  const approvedSource = technicalPlan.meta?.approved?.source_file || '';
+  const approvedArtifact = technicalPlan.approved?.path || '';
+  const reviewIdentity = {
+    source: reviewedSource,
+    version: reviewedVersion,
+  };
+  let status = 'unapproved';
+
+  if (technicalPlan.status === 'approved') {
+    const matchesApproved = reviewMatchesTarget(projectRoot, reviewIdentity, {
+      artifact: approvedArtifact,
+      source: approvedSource,
+      version: approvedVersion,
+    });
+    const staleByTime = !reviewedVersion && !matchesApproved && approvedAt > 0 && reviewedAt > 0 && approvedAt > reviewedAt;
+    status = matchesApproved && !staleByTime ? 'reviewed' : 'stale';
+  } else if (technicalPlan.status === 'draft' || technicalPlan.status === 'stale') {
+    const latestDraft = latestTechnicalPlanDraft(technicalPlan);
+    const matchesLatestDraft = reviewMatchesTarget(projectRoot, reviewIdentity, {
+      artifact: latestDraft?.path || technicalPlan.draft?.path || '',
+      source: technicalPlan.meta?.draft?.source_file || '',
+      version: Number(latestDraft?.version || technicalPlan.meta?.draft?.version || 0) || null,
+    });
+    status = matchesLatestDraft ? 'unapproved' : 'stale';
+  }
+
+  return {
+    status,
+    review: fs.existsSync(reviewPath)
+      ? {
+          path: toRelativePosix(projectRoot, reviewPath),
+          contents: fs.readFileSync(reviewPath, 'utf8'),
+        }
+      : null,
+    meta,
+  };
+}
+
+function savePlanReview(projectRoot, options = {}) {
+  const root = planReviewRoot(projectRoot);
+  fs.mkdirSync(root, { recursive: true });
+  const reviewPath = planReviewPath(projectRoot);
+  const now = new Date().toISOString();
+  const contents = String(options.contents || '');
+  const inputPath = options.inputPath || '';
+
+  fs.writeFileSync(reviewPath, contents);
+  const meta = {
+    phase: 'plan-review',
+    source_file: inputPath,
+    source_kind: options.inputKind || null,
+    source_version: options.inputVersion || null,
+    path: toRelativePosix(projectRoot, reviewPath),
+    reviewed_at: now,
+  };
+  fs.writeFileSync(planReviewMetaPath(projectRoot), `${JSON.stringify(meta, null, 2)}\n`);
+
+  return {
+    filePath: reviewPath,
+    metaPath: planReviewMetaPath(projectRoot),
+    reviewedAt: now,
+  };
+}
+
+function assertPlanReviewed(projectRoot) {
+  const review = readPlanReview(projectRoot);
+  if (review.status !== 'reviewed') {
+    const nextCommand = review.status === 'unapproved'
+      ? 'npx create-quiver ai approve --phase technical-plan --version <n>'
+      : 'npx create-quiver ai review-plan';
+    throw new Error(formatError(`ai plan phase 'spec' requires a reviewed and approved technical-plan input; current review status: ${review.status}. Run \`${nextCommand}\`.`));
+  }
+  return review;
+}
+
+function resolveReviewedTechnicalPlanInput(projectRoot, explicitInput) {
+  const resolved = resolveApprovedPlannerInput(projectRoot, 'spec', explicitInput);
+  const review = assertPlanReviewed(projectRoot);
+  return {
+    ...resolved,
+    review,
+  };
+}
+
+function buildPlanReviewPrompt({ pack, inputText, inputPath }) {
+  const sections = [
+    pack.prompt,
+    'Task: review the technical plan as if it will be implemented and tested in production.',
+    'Do not question the approved scope.',
+    'Do not implement code, create specs, or modify files.',
+    'Focus on avoiding partial fixes.',
+    'Report:',
+    '- fragile assumptions',
+    '- uncovered cases',
+    '- ambiguous criteria',
+    '- validation gaps',
+    '- operational risks',
+    '- recommended fixes to the plan',
+    'If ambiguity is not blocking, state the safest assumption and continue.',
+  ];
+
+  if (inputPath) {
+    sections.push(`Input file: ${inputPath}`);
+  }
+
+  if (inputText) {
+    sections.push('Technical plan:', inputText.trimEnd());
+  }
+
+  return {
+    promptSource: PLAN_REVIEW_PROMPT_SOURCE,
+    prompt: sections.join('\n\n'),
+  };
+}
+
+function summarizePlanReview(projectRoot) {
+  const review = readPlanReview(projectRoot);
+  const lines = [
+    'Phase: plan-review',
+    `Status: ${review.status}`,
+  ];
+  if (review.review?.path) {
+    lines.push(`Review: ${review.review.path}`);
+  }
+  if (review.meta?.source_file) {
+    lines.push(`Source file: ${review.meta.source_file}`);
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+module.exports = {
+  PLAN_REVIEW_PROMPT_SOURCE,
+  assertPlanReviewed,
+  buildPlanReviewPrompt,
+  planReviewMetaPath,
+  planReviewPath,
+  readPlanReview,
+  resolveTechnicalPlanReviewInput,
+  resolveReviewedTechnicalPlanInput,
+  savePlanReview,
+  summarizePlanReview,
+};

package/src/create-quiver/lib/ai/providers.js

@@ -309,6 +309,7 @@ module.exports = {
   ProviderRunnerError,
   assertSupportedProvider,
   buildProviderInvocation,
+  formatProviderList,
   getProviderDefinition,
   runProvider,
 };

package/src/create-quiver/lib/ai/safety.js

@@ -2,6 +2,7 @@ const path = require('node:path');
 
 const SENSITIVE_SEGMENTS = [
   '.ssh',
+  '.quiver',
   'node_modules',
   'dist',
   'build',
@@ -95,6 +96,10 @@ function getContextPathExclusionReason(filePath) {
     return 'empty-path';
   }
 
+  if (normalized === '.quiver/scans/PROJECT_SCAN.json') {
+    return null;
+  }
+
   if (segments.some((segment) => SENSITIVE_SEGMENTS.includes(segment))) {
     const matchedSegment = segments.find((segment) => SENSITIVE_SEGMENTS.includes(segment));
     return `unsafe-segment:${matchedSegment}`;

package/src/create-quiver/lib/ai/spec-templates.js

@@ -273,7 +273,7 @@ function buildPrMarkdown(manifest) {
     '',
     '```bash',
     `cd <repo-root>`,
-    `npx create-quiver ai plan --phase spec --input <approved-input> --spec ${manifest.slug}`,
+    `npx create-quiver spec create --input <approved-input> --spec ${manifest.slug}`,
     '```',
     '',
     '### Run the Project',
@@ -289,7 +289,7 @@ function buildPrMarkdown(manifest) {
     '',
     '**Prerequisite:** approved input is available.',
     '',
-    '1. Run the spec phase.',
+    '1. Run `spec create`.',
     '2. Inspect the generated spec directory.',
     '',
     '**Expected result:** all generated files exist and every JSON file parses.',

package/src/create-quiver/lib/approvals.js

@@ -0,0 +1,350 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { quiverInternalPaths } = require('./init-layout');
+
+const PLANNER_APPROVAL_PHASES = Object.freeze(['acceptance', 'technical-plan']);
+const APPROVAL_DEPENDENCIES = Object.freeze({
+  acceptance: null,
+  'technical-plan': 'acceptance',
+  spec: 'technical-plan',
+});
+
+function formatError(message) {
+  return `create-quiver: ${message}`;
+}
+
+function normalizePhase(phase) {
+  const normalized = String(phase || '').trim().toLowerCase();
+  if (!Object.prototype.hasOwnProperty.call(APPROVAL_DEPENDENCIES, normalized)) {
+    throw new Error(formatError(`unsupported approval phase '${phase}'`));
+  }
+  return normalized;
+}
+
+function approvalRoot(projectRoot, phase) {
+  return path.join(quiverInternalPaths(projectRoot).root, 'approvals', normalizePhase(phase));
+}
+
+function approvalDraftPath(projectRoot, phase) {
+  return path.join(approvalRoot(projectRoot, phase), 'draft.md');
+}
+
+function approvalDraftsDir(projectRoot, phase) {
+  return path.join(approvalRoot(projectRoot, phase), 'drafts');
+}
+
+function approvalDraftVersionPath(projectRoot, phase, version) {
+  const padded = String(version).padStart(3, '0');
+  return path.join(approvalDraftsDir(projectRoot, phase), `${padded}.md`);
+}
+
+function approvalApprovedPath(projectRoot, phase) {
+  return path.join(approvalRoot(projectRoot, phase), 'approved.md');
+}
+
+function approvalMetaPath(projectRoot, phase) {
+  return path.join(approvalRoot(projectRoot, phase), 'meta.json');
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function toRelativePosix(root, filePath) {
+  return path.relative(root, filePath).split(path.sep).join('/');
+}
+
+function readTextFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(formatError(`missing approval input file: ${filePath}`));
+  }
+
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function readApprovalMeta(projectRoot, phase) {
+  const metaPath = approvalMetaPath(projectRoot, phase);
+  if (!fs.existsSync(metaPath)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+  } catch (error) {
+    throw new Error(formatError(`invalid approval metadata at ${toRelativePosix(projectRoot, metaPath)}: ${error.message}`));
+  }
+}
+
+function normalizeDrafts(meta) {
+  return Array.isArray(meta?.drafts) ? meta.drafts.filter((item) => item && typeof item === 'object') : [];
+}
+
+function nextDraftVersion(meta) {
+  const versions = normalizeDrafts(meta)
+    .map((item) => Number(item.version))
+    .filter((value) => Number.isInteger(value) && value > 0);
+  return versions.length > 0 ? Math.max(...versions) + 1 : 1;
+}
+
+function findDraftVersion(meta, version) {
+  const parsed = Number(version);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(formatError(`invalid draft version: ${version}`));
+  }
+  return normalizeDrafts(meta).find((item) => Number(item.version) === parsed) || null;
+}
+
+function readPhaseApproval(projectRoot, phase) {
+  const normalizedPhase = normalizePhase(phase);
+  const draftPath = approvalDraftPath(projectRoot, normalizedPhase);
+  const approvedPath = approvalApprovedPath(projectRoot, normalizedPhase);
+  const meta = readApprovalMeta(projectRoot, normalizedPhase);
+
+  if (!meta && !fs.existsSync(draftPath) && !fs.existsSync(approvedPath)) {
+    return {
+      phase: normalizedPhase,
+      status: 'missing',
+      draft: null,
+      approved: null,
+      meta: null,
+    };
+  }
+
+  const draft = fs.existsSync(draftPath)
+    ? {
+        path: toRelativePosix(projectRoot, draftPath),
+        contents: fs.readFileSync(draftPath, 'utf8'),
+      }
+    : null;
+  const approved = fs.existsSync(approvedPath)
+    ? {
+        path: toRelativePosix(projectRoot, approvedPath),
+        contents: fs.readFileSync(approvedPath, 'utf8'),
+      }
+    : null;
+
+  const approvedSource = meta?.approved || null;
+  const draftSource = meta?.draft || null;
+  const stale = Boolean(
+    approvedSource
+    && approvedSource.source_file
+    && !fs.existsSync(path.resolve(projectRoot, approvedSource.source_file))
+    && !approvedSource.source_file.startsWith('.quiver/approvals/'),
+  ) || Boolean(
+    draftSource?.created_at
+    && approvedSource?.approved_at
+    && new Date(draftSource.created_at).getTime() > new Date(approvedSource.approved_at).getTime(),
+  ) || Boolean(
+    draftSource?.version
+    && approvedSource?.version
+    && Number(draftSource.version) > Number(approvedSource.version),
+  );
+
+  let status = 'missing';
+  if (approved) {
+    status = stale ? 'stale' : 'approved';
+  } else if (draft) {
+    status = 'draft';
+  }
+
+  return {
+    phase: normalizedPhase,
+    status,
+    draft,
+    approved,
+    meta,
+  };
+}
+
+function renderApprovalStatus(report) {
+  if (!report || report.status === 'missing') {
+    return `missing ${report ? report.phase : 'approval'} approval`;
+  }
+
+  if (report.status === 'draft') {
+    return `draft ready for ${report.phase}`;
+  }
+
+  if (report.status === 'stale') {
+    return `stale ${report.phase} approval`;
+  }
+
+  return `approved ${report.phase}`;
+}
+
+function writeApprovalArtifacts(projectRoot, phase, kind, sourceFile, contents, options = {}) {
+  const normalizedPhase = normalizePhase(phase);
+  const root = approvalRoot(projectRoot, normalizedPhase);
+  ensureDir(root);
+
+  const filePath = kind === 'approved'
+    ? approvalApprovedPath(projectRoot, normalizedPhase)
+    : approvalDraftPath(projectRoot, normalizedPhase);
+  const now = new Date().toISOString();
+  const current = readApprovalMeta(projectRoot, normalizedPhase) || {};
+  const nextMeta = {
+    phase: normalizedPhase,
+    drafts: normalizeDrafts(current),
+    draft: current.draft || null,
+    approved: current.approved || null,
+  };
+  let finalContents = `${contents}`;
+  let version = null;
+
+  if (kind === 'approved' && options.version) {
+    const selectedDraft = findDraftVersion(current, options.version);
+    if (!selectedDraft) {
+      throw new Error(formatError(`missing ${normalizedPhase} draft version ${options.version}`));
+    }
+    const draftPath = path.resolve(projectRoot, selectedDraft.path);
+    if (!fs.existsSync(draftPath)) {
+      throw new Error(formatError(`missing ${normalizedPhase} draft artifact: ${selectedDraft.path}`));
+    }
+    finalContents = fs.readFileSync(draftPath, 'utf8');
+    sourceFile = selectedDraft.path;
+    version = Number(selectedDraft.version);
+  } else if (kind === 'approved' && current.draft?.version) {
+    version = Number(current.draft.version);
+  }
+
+  if (kind === 'draft') {
+    version = nextDraftVersion(current);
+    const versionPath = approvalDraftVersionPath(projectRoot, normalizedPhase, version);
+    ensureDir(path.dirname(versionPath));
+    fs.writeFileSync(versionPath, finalContents);
+
+    nextMeta.drafts = nextMeta.drafts.concat({
+      version,
+      phase: normalizedPhase,
+      source_file: toRelativePosix(projectRoot, path.resolve(projectRoot, sourceFile)),
+      path: toRelativePosix(projectRoot, versionPath),
+      created_at: now,
+    });
+  }
+
+  fs.writeFileSync(filePath, finalContents);
+
+  nextMeta[kind] = {
+    phase: normalizedPhase,
+    source_file: toRelativePosix(projectRoot, path.resolve(projectRoot, sourceFile)),
+    path: toRelativePosix(projectRoot, filePath),
+    version,
+    created_at: now,
+    ...(kind === 'approved' ? { approved_at: now } : {}),
+  };
+
+  if (kind === 'draft' && nextMeta.approved && nextMeta.approved.approved_at) {
+    nextMeta.approved = {
+      ...nextMeta.approved,
+    };
+  }
+
+  fs.writeFileSync(approvalMetaPath(projectRoot, normalizedPhase), `${JSON.stringify(nextMeta, null, 2)}\n`);
+
+  return {
+    phase: normalizedPhase,
+    kind,
+    filePath,
+    metaPath: approvalMetaPath(projectRoot, normalizedPhase),
+    createdAt: now,
+    version,
+  };
+}
+
+function savePlannerDraft(projectRoot, phase, sourceFile, contents) {
+  return writeApprovalArtifacts(projectRoot, phase, 'draft', sourceFile, contents);
+}
+
+function approvePlannerPhase(projectRoot, phase, sourceFile, contents, options = {}) {
+  return writeApprovalArtifacts(projectRoot, phase, 'approved', sourceFile, contents, options);
+}
+
+function resolveApprovedPlannerInput(projectRoot, phase, explicitInput) {
+  const normalizedPhase = normalizePhase(phase);
+  const dependencyPhase = APPROVAL_DEPENDENCIES[normalizedPhase];
+
+  if (!dependencyPhase) {
+    return {
+      phase: normalizedPhase,
+      inputPath: explicitInput || null,
+      approval: null,
+    };
+  }
+
+  const approval = readPhaseApproval(projectRoot, dependencyPhase);
+  if (approval.status !== 'approved') {
+    throw new Error(formatError(`ai plan phase '${normalizedPhase}' requires approved ${dependencyPhase} input; current status: ${approval.status}. Run \`npx create-quiver ai approve --phase ${dependencyPhase} --input <file>\`.`));
+  }
+
+  const approvedPath = approval.approved?.path ? path.resolve(projectRoot, approval.approved.path) : '';
+  const approvedSource = approval.meta?.approved?.source_file ? path.resolve(projectRoot, approval.meta.approved.source_file) : '';
+
+  if (!explicitInput) {
+    return {
+      phase: normalizedPhase,
+      inputPath: approval.approved.path,
+      approval,
+    };
+  }
+
+  const resolvedExplicit = path.resolve(projectRoot, explicitInput);
+  const matchesApprovedArtifact = approvedPath && resolvedExplicit === approvedPath;
+  const matchesApprovedSource = approvedSource && resolvedExplicit === approvedSource;
+
+  if (!matchesApprovedArtifact && !matchesApprovedSource) {
+    throw new Error(formatError(`ai plan phase '${normalizedPhase}' requires approved ${dependencyPhase} input; '${explicitInput}' is not the approved source.`));
+  }
+
+  return {
+    phase: normalizedPhase,
+    inputPath: approval.approved.path,
+    approval,
+  };
+}
+
+function summarizePlannerApproval(projectRoot, phase) {
+  const report = readPhaseApproval(projectRoot, phase);
+  const lines = [`Phase: ${report.phase}`, `Status: ${report.status}`];
+
+  if (report.draft) {
+    const version = report.meta?.draft?.version ? ` v${report.meta.draft.version}` : '';
+    lines.push(`Draft${version}: ${report.draft.path}`);
+  }
+  const drafts = normalizeDrafts(report.meta);
+  if (drafts.length > 0) {
+    lines.push('Draft history:');
+    for (const draft of drafts) {
+      lines.push(`- v${draft.version}: ${draft.path}`);
+    }
+  }
+  if (report.approved) {
+    const version = report.meta?.approved?.version ? ` v${report.meta.approved.version}` : '';
+    lines.push(`Approved${version}: ${report.approved.path}`);
+  }
+  if (report.meta?.approved?.source_file) {
+    lines.push(`Source file: ${report.meta.approved.source_file}`);
+  } else if (report.meta?.draft?.source_file) {
+    lines.push(`Source file: ${report.meta.draft.source_file}`);
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+module.exports = {
+  APPROVAL_DEPENDENCIES,
+  PLANNER_APPROVAL_PHASES,
+  approvalApprovedPath,
+  approvalDraftPath,
+  approvalDraftsDir,
+  approvalDraftVersionPath,
+  approvalMetaPath,
+  approvePlannerPhase,
+  findDraftVersion,
+  normalizePhase,
+  readPhaseApproval,
+  renderApprovalStatus,
+  resolveApprovedPlannerInput,
+  savePlannerDraft,
+  summarizePlannerApproval,
+};