@akanjs/cli 2.3.9-rc.8 → 2.3.9

package/index.js

@@ -4797,6 +4797,11 @@ var compactDiagnostics = (diagnostics) => diagnostics.filter((diagnostic) => !!d
 
 // pkgs/@akanjs/devkit/workflow/artifacts.ts
 var sourceChangeBlocked = (diagnostics) => diagnostics.some((diagnostic) => diagnostic.severity === "error" && (diagnostic.failureScope === "source-change" || !diagnostic.failureScope || diagnostic.failureScope === "unknown"));
+var workflowPlanApproval = {
+  required: true,
+  meaning: "Review this read-only plan before apply_workflow mutates files.",
+  applyTool: "apply_workflow"
+};
 var inferNextActionCode = (action, diagnostics) => {
   if (action.action)
     return action.action;
@@ -4841,13 +4846,19 @@ var createWorkflowApplyReport = ({
     });
   }
   const orderedNextActions = uniqueBy(nextActionsWithIntent, (action) => action.command).sort((left, right) => nextActionPriority(left, diagnostics) - nextActionPriority(right, diagnostics));
+  const sourceFilesChanged = uniqueBy(changedFiles, (file) => `${file.action}:${file.path}:${file.reason}`);
+  const generatedFilesSynced = uniqueBy(generatedFiles, (file) => `${file.action}:${file.path}:${file.reason}`);
   return {
     schemaVersion: 1,
     workflow,
     mode,
     status: workflowStatus(diagnostics),
-    changedFiles: uniqueBy(changedFiles, (file) => `${file.action}:${file.path}:${file.reason}`),
-    generatedFiles: uniqueBy(generatedFiles, (file) => `${file.action}:${file.path}:${file.reason}`),
+    summary: {
+      sourceFilesChanged,
+      generatedFilesSynced
+    },
+    changedFiles: sourceFilesChanged,
+    generatedFiles: generatedFilesSynced,
     appliedCommands: uniqueBy(appliedCommands, (command) => command.command),
     recommendedValidationCommands: uniqueBy(validationCommands, (command) => command.command),
     commands: uniqueBy(validationCommands, (command) => command.command),
@@ -4925,6 +4936,52 @@ var statusForValidationKind = (commands, kind) => {
     return "unknown";
   return matching.some((command) => command.status === "failed") ? "failed" : "passed";
 };
+var statusForCommands = (commands) => {
+  if (commands.length === 0)
+    return "unknown";
+  return commandStatus(commands) === "failed" ? "failed" : "passed";
+};
+var statusForDiagnostics = (diagnostics) => {
+  if (diagnostics.length === 0)
+    return "unknown";
+  return workflowStatus(diagnostics) === "failed" ? "failed" : "passed";
+};
+var workflowDiagnosticContextPaths = (diagnostics) => uniqueBy(diagnostics.flatMap((diagnostic) => diagnostic.context?.paths ?? []), (filePath) => filePath);
+var createWorkflowBaselineSummary = (diagnostics, { detailsIncluded = true, knownBlockerCount = 0 } = {}) => {
+  const grouped = new Map;
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  for (const diagnostic of diagnostics) {
+    if (diagnostic.severity === "error")
+      totalErrors += 1;
+    else
+      totalWarnings += 1;
+    const existing = grouped.get(diagnostic.code);
+    if (existing) {
+      existing.count += 1;
+      if (existing.severity !== diagnostic.severity)
+        existing.severity = "mixed";
+    } else {
+      grouped.set(diagnostic.code, {
+        code: diagnostic.code,
+        severity: diagnostic.severity,
+        count: 1,
+        sampleMessage: diagnostic.message
+      });
+    }
+  }
+  const contextPaths = workflowDiagnosticContextPaths(diagnostics);
+  return {
+    status: totalErrors > 0 ? "failed" : diagnostics.length > 0 ? "passed" : "unknown",
+    total: diagnostics.length,
+    totalErrors,
+    totalWarnings,
+    detailsIncluded,
+    knownBlockerCount,
+    byCode: [...grouped.values()],
+    ...contextPaths.length ? { contextPaths } : {}
+  };
+};
 var createKnownBlockers = (commands, diagnostics) => {
   const commandBlockers = commands.filter((command) => command.status === "failed" && (command.failureScope === "workspace-config" || command.failureScope === "environment")).map((command) => ({
     code: `workflow-validation-${command.failureScope}`,
@@ -4953,18 +5010,28 @@ var createKnownBlockers = (commands, diagnostics) => {
   }
   return [...grouped.values()];
 };
-var createValidationStatuses = (commands, diagnostics) => {
+var createValidationStatuses = (commands, reportDiagnostics, baselineDiagnostics, workflowDiagnostics) => {
+  const diagnostics = [...reportDiagnostics, ...baselineDiagnostics, ...workflowDiagnostics];
   const scopes = [...failedCommandScopes(commands), ...errorDiagnosticScopes(diagnostics)];
-  const sourceStatus = statusForScope(commands, diagnostics, scopes, "source-change");
+  const sourceDiagnostics = [...reportDiagnostics, ...workflowDiagnostics].filter((diagnostic) => diagnostic.failureScope === "source-change" || diagnostic.scope === "workflow" || !diagnostic.failureScope && diagnostic.scope !== "baseline");
+  const sourceScopes = [...failedCommandScopes(commands), ...errorDiagnosticScopes(sourceDiagnostics)];
+  const sourceStatus = statusForScope(commands, sourceDiagnostics, sourceScopes, "source-change");
+  const validationCommandsStatus = statusForCommands(commands);
+  const baselineStatus = statusForDiagnostics(baselineDiagnostics);
+  const nonBaselineDiagnostics = [...reportDiagnostics, ...workflowDiagnostics];
   const workspaceStatus = hasScopeFailure(scopes, "workspace-config", diagnostics) || hasScopeFailure(scopes, "environment", diagnostics) ? "failed" : commands.length || diagnostics.length ? "passed" : "unknown";
-  const overallStatus = hasScopeFailure(scopes, "source-change", diagnostics) ? "failed" : hasScopeFailure(scopes, "workspace-config", diagnostics) ? "blocked-by-workspace-config" : hasScopeFailure(scopes, "environment", diagnostics) ? "blocked-by-environment" : workflowStatus(diagnostics) === "failed" || commandStatus(commands) === "failed" ? "failed" : "passed";
+  const overallStatus = hasScopeFailure(scopes, "source-change", diagnostics) ? "failed" : validationCommandsStatus === "passed" && baselineStatus === "failed" && workflowStatus(nonBaselineDiagnostics) !== "failed" ? "passed-with-baseline-blockers" : hasScopeFailure(scopes, "workspace-config", diagnostics) ? "blocked-by-workspace-config" : hasScopeFailure(scopes, "environment", diagnostics) ? "blocked-by-environment" : workflowStatus(diagnostics) === "failed" || commandStatus(commands) === "failed" ? "failed" : "passed";
   return {
     sourceStatus,
     workspaceStatus,
+    validationCommandsStatus,
+    baselineStatus,
     overallStatus,
     summary: {
       sourceChange: sourceStatus,
       generatedSync: statusForValidationKind(commands, "sync"),
+      validationCommands: validationCommandsStatus,
+      baseline: baselineStatus,
       workspaceConfig: statusForScope(commands, diagnostics, scopes, "workspace-config"),
       environment: statusForScope(commands, diagnostics, scopes, "environment")
     }
@@ -4998,7 +5065,8 @@ var createWorkflowValidationRunReport = async ({
   ] : []);
   const reportDiagnostics = [...diagnostics, ...commandDiagnostics];
   const scopedDiagnostics = [...reportDiagnostics, ...baselineDiagnostics, ...workflowDiagnostics];
-  const statuses = createValidationStatuses(results, scopedDiagnostics);
+  const knownBlockers = createKnownBlockers(results, scopedDiagnostics);
+  const statuses = createValidationStatuses(results, reportDiagnostics, baselineDiagnostics, workflowDiagnostics);
   return {
     schemaVersion: 1,
     runId,
@@ -5007,9 +5075,12 @@ var createWorkflowValidationRunReport = async ({
     source,
     status: statuses.overallStatus === "passed" ? "passed" : "failed",
     ...statuses,
-    knownBlockers: createKnownBlockers(results, scopedDiagnostics),
+    knownBlockers,
     commands: results,
     diagnostics: reportDiagnostics,
+    baselineSummary: createWorkflowBaselineSummary(baselineDiagnostics, {
+      knownBlockerCount: knownBlockers.filter((blocker) => blocker.failureScope === "workspace-config").length
+    }),
     baselineDiagnostics,
     workflowDiagnostics,
     repairActions: uniqueBy(repairActions, (action) => action.command),
@@ -6325,7 +6396,7 @@ var checkTypeScriptSyntax = async (workspace, filePath) => {
     return null;
   const content = await workspace.readFile(filePath);
   const source = ts6.createSourceFile(filePath, content, ts6.ScriptTarget.Latest, true, scriptKind);
-  const diagnostic = source.parseDiagnostics[0];
+  const diagnostic = (source.parseDiagnostics ?? [])[0];
   if (!diagnostic)
     return null;
   const position = diagnostic.file?.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
@@ -6523,9 +6594,9 @@ var addFieldUiSurfaceInspection = (plan) => {
         code: "add-field-ui-surface-review",
         kind: "manual-action",
         target,
-        action: templateRequested ? `Template was requested for ${field}. If no Template file changed, auto-edit was skipped because the file was missing, the generated ${module}Form/Layout.Template pattern was not found, or ${policy.component} needs option binding. Candidate position: inside Layout.Template near the existing Field components.` : `Template was not selected, so UI files are intentionally left unchanged. Candidate positions if you expose it later: Layout.Template field list for editing, Light${moduleClassName} projection for list/card data, and Unit/View card sections for display.`,
+        action: templateRequested ? `Template was requested for ${field}. If no Template file changed, users will not see the field in the form yet because the file was missing, the generated ${module}Form/Layout.Template pattern was not found, or ${policy.component} needs option binding. Add it inside Layout.Template near existing Field components.` : `Template was not selected, so users will not see ${field} in the form from this apply. If list/card display is needed, include ${field} in Light${moduleClassName} projection data and place it in the local Unit/View card layout.`,
         confidence: "medium",
-        message: `Review UI surfaces for ${module}.${field}; recommended component is ${policy.component}, with manual reasons and candidate positions in action.`
+        message: `Review user-visible UI for ${module}.${field}; recommended component is ${policy.component}.`
       }
     ],
     nextActions: [
@@ -6780,10 +6851,48 @@ var createAddFieldDefaultRecommendations = (inputs) => {
       kind: "manual-action",
       confidence: "high",
       message: `Default for ${field} will be normalized to ${coercion.normalizedType} literal ${coercion.expression}.`,
-      action: "Review the normalized default in the apply report if this value should stay unset."
+      action: "Review the normalized default in the apply report. To leave the field without a default, omit the default input."
     }
   ];
 };
+var moneyLikeFieldPattern = /(budget|price|amount|cost|rate|fee|salary|balance)/i;
+var wholeNumberFieldPattern = /(count|quantity|total|number|index|rank|order|age)/i;
+var createAddFieldInputRecommendations = (inputs) => {
+  const field = typeof inputs.field === "string" ? inputs.field : "<field>";
+  const typeName = typeof inputs.type === "string" ? inputs.type : null;
+  const recommendations = [];
+  if (!typeName)
+    return recommendations;
+  if (typeName.toLowerCase() === "number" || typeName.toLowerCase() === "numeric") {
+    const recommendedType = moneyLikeFieldPattern.test(field) ? "Float" : wholeNumberFieldPattern.test(field) ? "Int" : null;
+    recommendations.push({
+      code: "add-field-type-choice",
+      kind: "input-guidance",
+      confidence: recommendedType ? "high" : "medium",
+      message: recommendedType ? `Use ${recommendedType} for ${field}; Float is recommended for money-like decimal values and Int for whole-number values.` : `Choose Int for whole-number ${field} values or Float for decimal ${field} values.`,
+      action: recommendedType ? `Re-run plan_workflow with type="${recommendedType}".` : 'Re-run plan_workflow with type="Int" or type="Float".'
+    });
+  }
+  if (typeName.toLowerCase() === "enum" && !Array.isArray(inputs.values)) {
+    recommendations.push({
+      code: "add-field-enum-values",
+      kind: "input-guidance",
+      confidence: "high",
+      message: `Enum field ${field} needs values before apply can choose valid dictionary and default behavior.`,
+      action: 'Pass values as an array or comma-separated string, for example values=["draft","done"].'
+    });
+  }
+  if (inputs.default === undefined) {
+    recommendations.push({
+      code: "add-field-default-optional",
+      kind: "input-guidance",
+      confidence: "medium",
+      message: `No default will be written for ${field} because default is omitted.`,
+      action: "Keep default omitted when the field should have no default value."
+    });
+  }
+  return recommendations;
+};
 var createAddFieldRecommendations = (inputs) => {
   const app = typeof inputs.app === "string" ? inputs.app : "<app-or-lib>";
   const module = typeof inputs.module === "string" ? inputs.module : "<module>";
@@ -6844,9 +6953,9 @@ var createAddFieldRecommendations = (inputs) => {
         code: "add-field-light-projection-choice",
         kind: "manual-action",
         target: paths.constant,
-        action: `Pass includeInLight=true when ${field} should appear in Light${capitalize2(module)} list/card projections.`,
+        action: `Pass includeInLight=true when users should see ${field} in list/card data. Without it, the field can exist on ${capitalize2(module)}Input but stay absent from Light${capitalize2(module)} projections.`,
         confidence: "medium",
-        message: `Light projection exposure for ${module}.${field} is not selected yet.`
+        message: `${module}.${field} is not selected for list/card projection data.`
       }
     ] : [],
     ...includeInLight ? [
@@ -6864,18 +6973,20 @@ var createAddFieldRecommendations = (inputs) => {
         kind: "manual-action",
         target: paths.template,
         confidence: "medium",
-        message: `Template is not included in surfaces, so ${module}.${field} will not be auto-rendered there.`
+        message: `Template form auto-edit is skipped for ${module}.${field} because surfaces does not include "template".`,
+        action: `Pass surfaces=["template"] when users should enter ${field} in the Template form.`
       }
     ] : [],
     {
       code: "add-field-ui-manual-review",
       kind: "manual-action",
       target: paths.template,
-      action: `Review ${app}:${module} UI after apply. Template auto-edit requires a generated ${module}Form hook and Layout.Template field list; Unit/View are not auto-edited because list/card placement depends on local layout. Candidate positions: Layout.Template before the closing tag, Light${capitalize2(module)} projection array for list data, and Unit/View card sections for display.`,
+      action: `After apply, verify what users can see: Template form auto-edit only runs when a generated ${module}Form hook and Layout.Template field list are present. Unit/View cards are not auto-edited, so ${field} may be stored on ${capitalize2(module)} but not shown in list/card UI until you place it in the local card layout.`,
       confidence: "medium",
-      message: "UI manual review includes the reason auto-edit may be skipped and candidate insertion positions."
+      message: `${app}:${module}.${field} may need UI review for user-visible Template, Unit, and View behavior.`
     },
-    ...createAddFieldDefaultRecommendations(inputs)
+    ...createAddFieldDefaultRecommendations(inputs),
+    ...createAddFieldInputRecommendations(inputs)
   ];
 };
 var createWorkflowPlanPredictedChanges = (spec, inputs) => {
@@ -7018,7 +7129,8 @@ var createWorkflowPlan = (spec, rawInputs) => {
     validation: spec.validation,
     diagnostics,
     recommendations: createWorkflowPlanRecommendations(spec, inputs),
-    requiresApproval: true
+    requiresApproval: true,
+    approval: workflowPlanApproval
   };
 };
 // pkgs/@akanjs/devkit/workflow/render.ts
@@ -7056,6 +7168,7 @@ var renderWorkflowPlan = (plan) => [
   "",
   `- Mode: ${plan.mode}`,
   `- Requires approval: ${plan.requiresApproval}`,
+  `- Approval: ${plan.approval?.meaning ?? "Review this read-only plan before applying workflow mutations."}`,
   "",
   "## Inputs",
   ...Object.entries(plan.inputs).map(([name, value]) => `- \`${name}\`: ${Array.isArray(value) ? value.join(", ") : value}`),
@@ -7092,6 +7205,10 @@ var renderDiagnostic = (diagnostic) => `- [${diagnostic.severity}] ${diagnostic.
 var renderNextAction = (action) => `- \`${action.command}\`: ${action.reason}`;
 var applySourceStatus = (report) => report.diagnostics.some((diagnostic) => diagnostic.severity === "error" && (diagnostic.failureScope === "source-change" || !diagnostic.failureScope || diagnostic.failureScope === "unknown")) ? "failed" : "passed";
 var renderWorkflowApplyReport = (report) => {
+  const applySummary = {
+    sourceFilesChanged: report.summary?.sourceFilesChanged ?? report.changedFiles,
+    generatedFilesSynced: report.summary?.generatedFilesSynced ?? report.generatedFiles
+  };
   const manualReviewItems = [
     ...report.diagnostics.filter((diagnostic) => diagnostic.severity === "warning").map(renderDiagnostic),
     ...report.recommendations.filter((recommendation) => recommendation.kind === "manual-action").map(renderRecommendation)
@@ -7105,6 +7222,8 @@ var renderWorkflowApplyReport = (report) => {
     `- Status: ${report.status}`,
     `- Source-change status: ${applySourceStatus(report)}`,
     `- Workspace status: ${validationBlockers.length ? "blocked" : "not blocked during apply"}`,
+    `- Source files changed: ${applySummary.sourceFilesChanged.length}`,
+    `- Generated files queued for sync: ${applySummary.generatedFilesSynced.length}`,
     ...report.validationTarget ? [`- Validation target: ${report.validationTarget}`] : [],
     "",
     "## Apply Checks",
@@ -7114,10 +7233,10 @@ var renderWorkflowApplyReport = (report) => {
     ...sourceBlockers.length ? sourceBlockers : ["- none"],
     "",
     "## Automatically Modified",
-    ...report.changedFiles.length ? report.changedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
+    ...applySummary.sourceFilesChanged.length ? applySummary.sourceFilesChanged.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
     "",
     "## Generated Sync",
-    ...report.generatedFiles.length ? report.generatedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
+    ...applySummary.generatedFilesSynced.length ? applySummary.generatedFilesSynced.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
     "",
     "## Applied Commands",
     ...report.appliedCommands.length ? report.appliedCommands.map((command) => `- \`${command.command}\`: ${command.reason}`) : ["- none"],
@@ -7144,52 +7263,76 @@ var renderWorkflowApplyReport = (report) => {
 `);
 };
 var renderWorkflowApply = (report, format = "markdown") => format === "json" ? jsonText(report) : renderWorkflowApplyReport(report);
-var renderWorkflowValidationRunReport = (report) => [
-  `# Workflow Validation: ${report.workflow}`,
-  "",
-  `- Run: ${report.runId}`,
-  `- Status: ${report.status}`,
-  `- Source status: ${report.sourceStatus}`,
-  `- Workspace status: ${report.workspaceStatus}`,
-  `- Overall status: ${report.overallStatus}`,
-  "",
-  "## Status Summary",
-  `- Source-change: ${report.summary.sourceChange}`,
-  `- Generated sync: ${report.summary.generatedSync}`,
-  `- Workspace config: ${report.summary.workspaceConfig}`,
-  `- Environment: ${report.summary.environment}`,
-  "",
-  "## Source Change Diagnostics",
-  ...report.workflowDiagnostics?.length ? report.workflowDiagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
-  "",
-  "## Existing Workspace Blockers",
-  ...report.baselineDiagnostics?.length ? report.baselineDiagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
-  "",
-  "## Known Blockers",
-  ...report.knownBlockers.length ? report.knownBlockers.map((blocker) => {
-    const command = blocker.command ? ` \`${blocker.command}\`` : "";
-    const count = blocker.count > 1 ? ` (${blocker.count}x)` : "";
-    const known = blocker.known ? " known" : "";
-    return `- [${blocker.failureScope}${known}]${command}${count}: ${blocker.message}`;
-  }) : ["- none"],
-  "",
-  "## Commands",
-  ...report.commands.length ? report.commands.map((command) => {
-    const scope = command.failureScope ? ` (${command.failureScope})` : "";
-    return `- [${command.status}] \`${command.command}\`${scope}: ${command.reason}`;
-  }) : ["- none"],
-  "",
-  "## Diagnostics",
-  ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
-  "",
-  "## Repair Actions",
-  ...report.repairActions.length ? report.repairActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
-  "",
-  "## Next Actions",
-  ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
-  ""
-].join(`
+var renderWorkflowValidationRunReport = (report) => {
+  const baselineSummary = report.baselineSummary ?? {
+    status: report.baselineDiagnostics?.some((diagnostic) => diagnostic.severity === "error") ? "failed" : "unknown",
+    total: report.baselineDiagnostics?.length ?? 0,
+    totalErrors: report.baselineDiagnostics?.filter((diagnostic) => diagnostic.severity === "error").length ?? 0,
+    totalWarnings: report.baselineDiagnostics?.filter((diagnostic) => diagnostic.severity === "warning").length ?? 0,
+    detailsIncluded: true,
+    knownBlockerCount: report.knownBlockers.filter((blocker) => blocker.known).length,
+    byCode: []
+  };
+  return [
+    `# Workflow Validation: ${report.workflow}`,
+    "",
+    `- Run: ${report.runId}`,
+    `- Status: ${report.status}`,
+    `- Source status: ${report.sourceStatus}`,
+    `- Workspace status: ${report.workspaceStatus}`,
+    `- Validation commands status: ${report.validationCommandsStatus ?? "unknown"}`,
+    `- Baseline status: ${report.baselineStatus ?? baselineSummary.status}`,
+    `- Overall status: ${report.overallStatus}`,
+    "",
+    "## Status Summary",
+    `- Source-change: ${report.summary.sourceChange}`,
+    `- Generated sync: ${report.summary.generatedSync}`,
+    `- Validation commands: ${report.summary.validationCommands ?? "unknown"}`,
+    `- Baseline: ${report.summary.baseline ?? baselineSummary.status}`,
+    `- Workspace config: ${report.summary.workspaceConfig}`,
+    `- Environment: ${report.summary.environment}`,
+    "",
+    "## Source Change Diagnostics",
+    ...report.workflowDiagnostics?.length ? report.workflowDiagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+    "",
+    "## Existing Workspace Blockers",
+    `- Status: ${baselineSummary.status}`,
+    `- Errors: ${baselineSummary.totalErrors}`,
+    `- Warnings: ${baselineSummary.totalWarnings}`,
+    ...baselineSummary.byCode.length ? baselineSummary.byCode.map((item) => `- [${item.severity}] ${item.code} (${item.count}x): ${item.sampleMessage}`) : ["- none"],
+    ...baselineSummary.detailsIncluded ? [] : [
+      "- Baseline details are summarized by default. Re-run validation with includeBaselineDetails=true for full baselineDiagnostics."
+    ],
+    "",
+    "## Existing Workspace Blocker Details",
+    ...report.baselineDiagnostics?.length ? report.baselineDiagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : baselineSummary.detailsIncluded ? ["- none"] : ["- omitted"],
+    "",
+    "## Known Blockers",
+    ...report.knownBlockers.length ? report.knownBlockers.map((blocker) => {
+      const command = blocker.command ? ` \`${blocker.command}\`` : "";
+      const count = blocker.count > 1 ? ` (${blocker.count}x)` : "";
+      const known = blocker.known ? " known" : "";
+      return `- [${blocker.failureScope}${known}]${command}${count}: ${blocker.message}`;
+    }) : ["- none"],
+    "",
+    "## Commands",
+    ...report.commands.length ? report.commands.map((command) => {
+      const scope = command.failureScope ? ` (${command.failureScope})` : "";
+      return `- [${command.status}] \`${command.command}\`${scope}: ${command.reason}`;
+    }) : ["- none"],
+    "",
+    "## Diagnostics",
+    ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+    "",
+    "## Repair Actions",
+    ...report.repairActions.length ? report.repairActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+    "",
+    "## Next Actions",
+    ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+    ""
+  ].join(`
 `);
+};
 var renderWorkflowValidation = (report, format = "markdown") => format === "json" ? jsonText(report) : renderWorkflowValidationRunReport(report);
 var renderRepairReportMarkdown = (report) => [
   `# Akan Repair: ${report.kind}`,
@@ -7278,7 +7421,11 @@ var toolingRolloutGate = {
   candidates: toolingRolloutCandidates
 };
 var isRestrictedCandidate = (candidate) => candidate.status !== "allowed";
-var restrictedCandidates = new Map(toolingRolloutCandidates.filter(isRestrictedCandidate).map((candidate) => [candidate.packageName, candidate]));
+var restrictedCandidates = new Map;
+for (const candidate of toolingRolloutCandidates) {
+  if (isRestrictedCandidate(candidate))
+    restrictedCandidates.set(candidate.packageName, candidate);
+}
 // pkgs/@akanjs/devkit/akanContext.ts
 var resourceList = [
   { uri: "akan://docs/framework", name: "Akan framework guide", mimeType: "text/markdown" },
@@ -7847,6 +7994,7 @@ var applyFirstPolicy = {
   mode: "apply-first",
   directSourceEdits: "fallback-only",
   applyRequiredWhen: ["plan_workflow returns planPath", "plan_workflow returns next.tool=apply_workflow"],
+  approvalMeaning: "requiresApproval is an agent/user review signal before apply_workflow mutates files; it is not a separate MCP permission gate.",
   validationRequiredAfterApply: ["validationTarget", "applyReportPath"],
   fallbackAllowedWhen: [
     "list_workflows and explain_workflow show no matching workflow",
@@ -7982,7 +8130,12 @@ var readonlyMcpTools = [
     description: "Report workspace diagnostics, optionally split into baseline and workflow scopes.",
     inputSchema: {
       type: "object",
-      properties: { strict: booleanProperty, runIdOrPlan: stringProperty, changedFiles: stringArrayProperty }
+      properties: {
+        strict: booleanProperty,
+        runIdOrPlan: stringProperty,
+        changedFiles: stringArrayProperty,
+        includeBaselineDetails: booleanProperty
+      }
     }
   },
   {
@@ -8027,7 +8180,7 @@ var applyMcpTools = [
     description: "Validate a plan, apply report, validationTarget, or run artifact.",
     inputSchema: {
       type: "object",
-      properties: { runIdOrPlan: stringProperty },
+      properties: { runIdOrPlan: stringProperty, includeBaselineDetails: booleanProperty },
       required: ["runIdOrPlan"]
     }
   },
@@ -8077,7 +8230,16 @@ var createAkanValidationContract = (listTools = listAkanMcpTools) => ({
   validationStatuses: {
     sourceStatus: ["passed", "failed", "unknown"],
     workspaceStatus: ["passed", "failed", "unknown"],
-    overallStatus: ["passed", "failed", "blocked-by-workspace-config", "blocked-by-environment"],
+    validationCommandsStatus: ["passed", "failed", "unknown"],
+    baselineStatus: ["passed", "failed", "unknown"],
+    overallStatus: [
+      "passed",
+      "failed",
+      "passed-with-baseline-blockers",
+      "blocked-by-workspace-config",
+      "blocked-by-environment"
+    ],
+    baselineSummary: "Default MCP validation output summarizes baseline diagnostics; pass includeBaselineDetails=true for full baselineDiagnostics.",
     knownBlockers: "Repeated workspace-config/environment failures are summarized before command output."
   },
   moduleContextInputs: {
@@ -8088,6 +8250,7 @@ var createAkanValidationContract = (listTools = listAkanMcpTools) => ({
   toolingRolloutGate,
   directEditFallbackPolicy: applyFirstPolicy,
   applyReportFields: [
+    "summary",
     "appliedCommands",
     "recommendedValidationCommands",
     "commands",
@@ -8129,7 +8292,14 @@ var inspectAkanContext = async (workspace, args) => {
       strict: true,
       runIdOrPlan: workspacePath(workspace, props.request.runIdOrPlan)
     });
-    diagnostics.push(...doctor.diagnostics.map((diagnostic) => ({
+    const baselineSummary = createWorkflowBaselineSummary((doctor.baselineDiagnostics ?? []).map((diagnostic) => ({
+      severity: diagnostic.severity,
+      code: diagnostic.code,
+      message: diagnostic.message,
+      scope: diagnostic.scope,
+      context: diagnostic.context
+    })), { detailsIncluded: false });
+    diagnostics.push(...(doctor.workflowDiagnostics ?? doctor.diagnostics).map((diagnostic) => ({
       severity: diagnostic.severity,
       code: diagnostic.code,
       message: diagnostic.message,
@@ -8150,7 +8320,8 @@ var inspectAkanContext = async (workspace, args) => {
       reason: doctor.status === "passed" ? "No strict workspace diagnostics were found for the workflow context." : "Review diagnostics before applying or manually editing source files."
     }, {
       status: doctor.status,
-      baselineDiagnostics: doctor.baselineDiagnostics?.length ?? 0,
+      baselineSummary,
+      baselineDiagnostics: 0,
       workflowDiagnostics: doctor.workflowDiagnostics?.length ?? 0
     });
   }
@@ -12331,6 +12502,7 @@ void run().catch((error) => {
 }
 // pkgs/@akanjs/devkit/applicationReleasePackager.ts
 import { cp, mkdir as mkdir9, rm as rm4 } from "fs/promises";
+import path38 from "path";
 
 // pkgs/@akanjs/devkit/uploadRelease.ts
 import { HttpClient as HttpClient2, Logger as Logger9 } from "akanjs/common";
@@ -12446,13 +12618,9 @@ class ApplicationReleasePackager {
     await cp(`${this.#app.dist.cwdPath}/backend`, `${buildPath}/backend`, { recursive: true });
     await cp(this.#app.dist.cwdPath, buildRoot, { recursive: true });
     await rm4(`${buildRoot}/frontend/.next`, { recursive: true, force: true });
-    await this.#app.workspace.spawn("tar", [
-      "-zcf",
-      `${this.#app.workspace.workspaceRoot}/releases/builds/${this.#app.name}-release.tar.gz`,
-      "-C",
-      buildRoot,
-      "./"
-    ]);
+    const releaseRoot = this.#app.workspace.workspaceRoot;
+    const releaseArchivePath = path38.relative(releaseRoot, `${releaseRoot}/releases/builds/${this.#app.name}-release.tar.gz`).split(path38.sep).join("/");
+    await this.#app.workspace.spawn("tar", ["-zcf", releaseArchivePath, "-C", buildRoot, "./"], { cwd: releaseRoot });
     await this.#writeCsrZipIfPresent();
     return { platformVersion };
   }
@@ -12473,22 +12641,18 @@ class ApplicationReleasePackager {
     await cp(this.#app.dist.cwdPath, `${sourceRoot}/apps/${this.#app.name}`, { recursive: true });
     const libDeps = ["social", "shared", "platform", "util"];
     await Promise.all(libDeps.map((lib) => cp(`${this.#app.workspace.cwdPath}/libs/${lib}`, `${sourceRoot}/libs/${lib}`, { recursive: true })));
-    await Promise.all([".next", "ios", "android", "public/libs"].map(async (path38) => {
-      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path38}`;
+    await Promise.all([".next", "ios", "android", "public/libs"].map(async (path39) => {
+      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path39}`;
       if (await FileSys.dirExists(targetPath))
         await rm4(targetPath, { recursive: true, force: true });
     }));
     const syncPaths = [".husky", ".gitignore", "package.json"];
-    await Promise.all(syncPaths.map((path38) => cp(`${this.#app.workspace.cwdPath}/${path38}`, `${sourceRoot}/${path38}`, { recursive: true })));
+    await Promise.all(syncPaths.map((path39) => cp(`${this.#app.workspace.cwdPath}/${path39}`, `${sourceRoot}/${path39}`, { recursive: true })));
     await this.#writeSourceTsconfig(sourceRoot, libDeps);
     await Bun.write(`${sourceRoot}/README.md`, readme);
-    await this.#app.workspace.spawn("tar", [
-      "-zcf",
-      `${this.#app.workspace.cwdPath}/releases/sources/${this.#app.name}-source.tar.gz`,
-      "-C",
-      sourceRoot,
-      "./"
-    ]);
+    const sourceCwd = this.#app.workspace.cwdPath;
+    const sourceArchivePath = path38.relative(sourceCwd, `${sourceCwd}/releases/sources/${this.#app.name}-source.tar.gz`).split(path38.sep).join("/");
+    await this.#app.workspace.spawn("tar", ["-zcf", sourceArchivePath, "-C", sourceRoot, "./"], { cwd: sourceCwd });
   }
   async#resetSourceRoot(sourceRoot) {
     if (await FileSys.dirExists(sourceRoot)) {
@@ -12570,20 +12734,20 @@ class ApplicationReleasePackager {
   }
 }
 // pkgs/@akanjs/devkit/applicationTestPreload.ts
-import path38 from "path";
+import path39 from "path";
 var SIGNAL_TEST_PRELOAD_PATH = "test/signalTest.preload.ts";
 async function resolveSignalTestPreloadPath(target) {
   const candidates = [];
   const addResolvedPackageCandidate = (basePath2) => {
     try {
-      candidates.push(path38.join(path38.dirname(Bun.resolveSync("akanjs/package.json", basePath2)), SIGNAL_TEST_PRELOAD_PATH));
+      candidates.push(path39.join(path39.dirname(Bun.resolveSync("akanjs/package.json", basePath2)), SIGNAL_TEST_PRELOAD_PATH));
     } catch {}
   };
   addResolvedPackageCandidate(target.cwdPath);
   addResolvedPackageCandidate(process.cwd());
-  addResolvedPackageCandidate(path38.dirname(Bun.main));
+  addResolvedPackageCandidate(path39.dirname(Bun.main));
   addResolvedPackageCandidate(import.meta.dir);
-  candidates.push(path38.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.join(path38.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
+  candidates.push(path39.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.join(path39.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
   for (const candidate of [...new Set(candidates)]) {
     if (await Bun.file(candidate).exists())
       return candidate;
@@ -12593,7 +12757,7 @@ async function resolveSignalTestPreloadPath(target) {
 // pkgs/@akanjs/devkit/builder.ts
 import { existsSync as existsSync2 } from "fs";
 import { mkdir as mkdir10 } from "fs/promises";
-import path39 from "path";
+import path40 from "path";
 var SKIP_ENTRY_DIR_SET = new Set(["node_modules", "dist", "build", ".git", ".next"]);
 var assetExtensions = [".css", ".md", ".js", ".png", ".ico", ".svg", ".json", ".template"];
 var assetLoader = Object.fromEntries(assetExtensions.map((ext) => [ext, "file"]));
@@ -12610,14 +12774,14 @@ class Builder {
   #globEntrypoints(cwd, pattern) {
     const glob = new Bun.Glob(pattern);
     return Array.from(glob.scanSync({ cwd, onlyFiles: true })).filter((relativePath) => {
-      const segments = relativePath.split(path39.sep);
+      const segments = relativePath.split(path40.sep);
       return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
-    }).map((rel) => path39.join(cwd, rel));
+    }).map((rel) => path40.join(cwd, rel));
   }
   #globFiles(cwd, pattern = "**/*.*") {
     const glob = new Bun.Glob(pattern);
     return Array.from(glob.scanSync({ cwd, onlyFiles: true })).filter((relativePath) => {
-      const segments = relativePath.split(path39.sep);
+      const segments = relativePath.split(path40.sep);
       return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
     });
   }
@@ -12625,17 +12789,17 @@ class Builder {
     const out = [];
     for (const p of additionalEntryPoints) {
       if (p.includes("*")) {
-        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path39.sep}`) ? p.slice(cwd.length + 1) : p;
+        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path40.sep}`) ? p.slice(cwd.length + 1) : p;
         out.push(...this.#globEntrypoints(cwd, rel));
       } else
-        out.push(path39.isAbsolute(p) ? p : path39.join(cwd, p));
+        out.push(path40.isAbsolute(p) ? p : path40.join(cwd, p));
     }
     return out;
   }
   #getBuildOptions({ bundle = false, additionalEntryPoints = [] } = {}) {
     const cwd = this.#executor.cwdPath;
     const entrypoints = [
-      ...bundle ? [path39.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}"),
+      ...bundle ? [path40.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}"),
       ...this.#resolveAdditionalEntrypoints(cwd, additionalEntryPoints)
     ];
     return {
@@ -12656,9 +12820,9 @@ class Builder {
     for (const relativePath of this.#globFiles(cwd)) {
       if (relativePath === "package.json")
         continue;
-      const sourcePath = path39.join(cwd, relativePath);
-      const targetPath = path39.join(this.#distExecutor.cwdPath, relativePath);
-      await mkdir10(path39.dirname(targetPath), { recursive: true });
+      const sourcePath = path40.join(cwd, relativePath);
+      const targetPath = path40.join(this.#distExecutor.cwdPath, relativePath);
+      await mkdir10(path40.dirname(targetPath), { recursive: true });
       await Bun.write(targetPath, Bun.file(sourcePath));
     }
   }
@@ -12669,13 +12833,13 @@ class Builder {
       return withoutFormatDir;
     if (!hasDotSlash && withoutFormatDir === publishedPath)
       return publishedPath;
-    const parsed = path39.posix.parse(withoutFormatDir);
+    const parsed = path40.posix.parse(withoutFormatDir);
     if (![".js", ".mjs", ".cjs"].includes(parsed.ext))
       return withoutFormatDir;
-    const withoutExt = path39.posix.join(parsed.dir, parsed.name);
+    const withoutExt = path40.posix.join(parsed.dir, parsed.name);
     const sourcePath = withoutExt.startsWith("./") ? withoutExt.slice(2) : withoutExt;
     const sourceCandidates = [`${sourcePath}.ts`, `${sourcePath}.tsx`];
-    const matchedSource = sourceCandidates.find((candidate) => existsSync2(path39.join(this.#executor.cwdPath, candidate)));
+    const matchedSource = sourceCandidates.find((candidate) => existsSync2(path40.join(this.#executor.cwdPath, candidate)));
     if (!matchedSource)
       return withoutFormatDir;
     return hasDotSlash ? `./${matchedSource}` : matchedSource;
@@ -12726,7 +12890,7 @@ class Builder {
 // pkgs/@akanjs/devkit/capacitorApp.ts
 import { cp as cp2, mkdir as mkdir11, rm as rm5 } from "fs/promises";
 import os from "os";
-import path40 from "path";
+import path41 from "path";
 import { select as select2 } from "@inquirer/prompts";
 import { MobileProject } from "@trapezedev/project";
 import { capitalize as capitalize5 } from "akanjs/common";
@@ -12933,13 +13097,13 @@ var rootCapacitorConfigFilenames = [
   "capacitor.config.js",
   "capacitor.config.json"
 ];
-var rootCapacitorConfigPaths = (appRoot) => rootCapacitorConfigFilenames.map((file) => path40.join(appRoot, file));
+var rootCapacitorConfigPaths = (appRoot) => rootCapacitorConfigFilenames.map((file) => path41.join(appRoot, file));
 async function clearRootCapacitorConfigs(appRoot) {
   await Promise.all(rootCapacitorConfigPaths(appRoot).map((file) => rm5(file, { force: true })));
 }
 async function writeRootCapacitorConfig(appRoot, content) {
   await clearRootCapacitorConfigs(appRoot);
-  await Bun.write(path40.join(appRoot, "capacitor.config.json"), content);
+  await Bun.write(path41.join(appRoot, "capacitor.config.json"), content);
 }
 var getLocalIP = () => {
   const interfaces = os.networkInterfaces();
@@ -13048,13 +13212,13 @@ function buildIosNativeRunCommand({
   scheme = "App",
   configuration = "Debug"
 }) {
-  const derivedDataPath = path40.join(appRoot, "ios/DerivedData", device.id);
+  const derivedDataPath = path41.join(appRoot, "ios/DerivedData", device.id);
   const productPlatform = device.kind === "device" ? "iphoneos" : "iphonesimulator";
   const destination = device.kind === "device" ? `id=${device.xcodebuildId ?? device.id}` : `platform=iOS Simulator,id=${device.id}`;
   return {
     configuration,
     derivedDataPath,
-    appPath: path40.join(derivedDataPath, "Build/Products", `${configuration}-${productPlatform}`, "App.app"),
+    appPath: path41.join(derivedDataPath, "Build/Products", `${configuration}-${productPlatform}`, "App.app"),
     xcodebuildArgs: [
       "-project",
       "App.xcodeproj",
@@ -13264,7 +13428,7 @@ function materializeCapacitorConfig(target, { operation, localServerUrl, localIp
     ...capacitorConfig,
     appId,
     appName,
-    webDir: path40.posix.join(".akan", "mobile", name, "www"),
+    webDir: path41.posix.join(".akan", "mobile", name, "www"),
     plugins: {
       CapacitorCookies: { enabled: true },
       ...pluginsConfig,
@@ -13321,10 +13485,10 @@ class CapacitorApp {
   constructor(app, target) {
     this.app = app;
     this.target = target;
-    this.targetRootPath = path40.posix.join(".akan", "mobile", this.target.name);
-    this.targetRoot = path40.join(this.app.cwdPath, this.targetRootPath);
-    this.targetWebRoot = path40.join(this.targetRoot, "www");
-    this.targetAssetRoot = path40.join(this.targetRoot, "assets");
+    this.targetRootPath = path41.posix.join(".akan", "mobile", this.target.name);
+    this.targetRoot = path41.join(this.app.cwdPath, this.targetRootPath);
+    this.targetWebRoot = path41.join(this.targetRoot, "www");
+    this.targetAssetRoot = path41.join(this.targetRoot, "assets");
     this.project = new MobileProject(this.app.cwdPath, {
       android: { path: this.androidRootPath },
       ios: { path: this.iosProjectPath }
@@ -13339,9 +13503,9 @@ class CapacitorApp {
     await mkdir11(this.targetRoot, { recursive: true });
     if (regenerate) {
       if (!platform || platform === "ios")
-        await rm5(path40.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
+        await rm5(path41.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
       if (!platform || platform === "android")
-        await rm5(path40.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
+        await rm5(path41.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
     }
     const project = this.project;
     await this.project.load();
@@ -13464,7 +13628,7 @@ ${textError instanceof Error ? textError.message : ""}`);
     const xcodebuildArgs = noAllowProvisioningUpdates ? command.xcodebuildArgs : [...command.xcodebuildArgs.slice(0, -1), "-allowProvisioningUpdates", ...command.xcodebuildArgs.slice(-1)];
     try {
       await this.#spawn("xcodebuild", xcodebuildArgs, {
-        cwd: path40.join(this.app.cwdPath, this.iosProjectPath),
+        cwd: path41.join(this.app.cwdPath, this.iosProjectPath),
         env: mobileEnv
       });
       const devicectlId = runTarget.devicectlId ?? runTarget.id;
@@ -13489,7 +13653,7 @@ ${textError instanceof Error ? textError.message : ""}`);
     return isRecord2(this.target.ios) && typeof this.target.ios.scheme === "string" ? this.target.ios.scheme : "App";
   }
   async#getIosDevelopmentTeam() {
-    const pbxprojPath = path40.join(this.app.cwdPath, this.iosProjectPath, "App.xcodeproj/project.pbxproj");
+    const pbxprojPath = path41.join(this.app.cwdPath, this.iosProjectPath, "App.xcodeproj/project.pbxproj");
     if (!await Bun.file(pbxprojPath).exists())
       return;
     return (await Bun.file(pbxprojPath).text()).match(/DEVELOPMENT_TEAM = ([^;]+);/)?.[1]?.trim();
@@ -13515,7 +13679,7 @@ ${error.message}`;
     await this.#spawnMobile("npx", ["cap", "sync", "android"], { operation, env });
   }
   async#updateAndroidBuildTypes() {
-    const appGradle = await FileEditor.create(path40.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
+    const appGradle = await FileEditor.create(path41.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
     const buildTypesBlock = `
       debug {
         applicationIdSuffix ".debug"
@@ -13559,7 +13723,7 @@ ${error.message}`;
     const gradleCommand = isWindows ? "gradlew.bat" : "./gradlew";
     await this.app.spawn(gradleCommand, [assembleType === "apk" ? "assembleRelease" : "bundleRelease"], {
       stdio: "inherit",
-      cwd: path40.join(this.app.cwdPath, this.androidRootPath),
+      cwd: path41.join(this.app.cwdPath, this.androidRootPath),
       env: await this.#commandEnv("release", env)
     });
   }
@@ -13567,10 +13731,10 @@ ${error.message}`;
     await this.#spawnMobile("npx", ["cap", "open", "android"], { operation: "local", env: "local" });
   }
   async#ensureAndroidAssetsDir() {
-    await mkdir11(path40.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
+    await mkdir11(path41.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
   }
   async#ensureAndroidDebugKeystore() {
-    const keystorePath = path40.join(this.app.cwdPath, this.androidRootPath, "app/debug.keystore");
+    const keystorePath = path41.join(this.app.cwdPath, this.androidRootPath, "app/debug.keystore");
     if (await Bun.file(keystorePath).exists())
       return;
     await this.#spawn("keytool", [
@@ -13609,7 +13773,7 @@ ${error.message}`;
     await this.#spawnMobile("npx", args, { operation, env }, { stdio: "inherit" });
   }
   async#assertAndroidReleaseSigningConfig() {
-    const gradlePropertiesPath = path40.join(this.app.cwdPath, this.androidRootPath, "gradle.properties");
+    const gradlePropertiesPath = path41.join(this.app.cwdPath, this.androidRootPath, "gradle.properties");
     const gradleProperties = await Bun.file(gradlePropertiesPath).exists() ? await Bun.file(gradlePropertiesPath).text() : "";
     const missingKeys = getMissingAndroidReleaseSigningKeys({ gradleProperties });
     if (missingKeys.length > 0)
@@ -13636,12 +13800,12 @@ ${error.message}`;
     await this.#prepareAndroid({ operation: "release", env: "main" });
   }
   async prepareWww() {
-    const htmlSource = path40.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
+    const htmlSource = path41.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
     if (!await Bun.file(htmlSource).exists())
       throw new Error(`CSR html for mobile target '${this.target.name}' not found: ${htmlSource}`);
     await rm5(this.targetWebRoot, { recursive: true, force: true });
     await mkdir11(this.targetWebRoot, { recursive: true });
-    await Bun.write(path40.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
+    await Bun.write(path41.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
   }
   #injectMobileTargetMeta(html) {
     const basePath2 = this.target.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
@@ -13661,7 +13825,7 @@ ${error.message}`;
     });
     const content = `${JSON.stringify(config, null, 2)}
 `;
-    await Bun.write(path40.join(this.targetRoot, "capacitor.config.json"), content);
+    await Bun.write(path41.join(this.targetRoot, "capacitor.config.json"), content);
     return content;
   }
   async#prepareTargetAssets() {
@@ -13669,11 +13833,11 @@ ${error.message}`;
       return;
     await mkdir11(this.targetAssetRoot, { recursive: true });
     if (this.target.assets.icon)
-      await cp2(path40.join(this.app.cwdPath, this.target.assets.icon), path40.join(this.targetAssetRoot, "icon.png"), {
+      await cp2(path41.join(this.app.cwdPath, this.target.assets.icon), path41.join(this.targetAssetRoot, "icon.png"), {
         force: true
       });
     if (this.target.assets.splash)
-      await cp2(path40.join(this.app.cwdPath, this.target.assets.splash), path40.join(this.targetAssetRoot, "splash.png"), {
+      await cp2(path41.join(this.app.cwdPath, this.target.assets.splash), path41.join(this.targetAssetRoot, "splash.png"), {
         force: true
       });
   }
@@ -13681,11 +13845,11 @@ ${error.message}`;
     const files = this.target.files?.[platform];
     if (!files)
       return;
-    const platformRoot = path40.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
+    const platformRoot = path41.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
     await Promise.all(Object.entries(files).map(async ([to, from]) => {
-      const targetPath = path40.join(platformRoot, to);
-      await mkdir11(path40.dirname(targetPath), { recursive: true });
-      await cp2(path40.join(this.app.cwdPath, from), targetPath, { force: true });
+      const targetPath = path41.join(platformRoot, to);
+      await mkdir11(path41.dirname(targetPath), { recursive: true });
+      await cp2(path41.join(this.app.cwdPath, from), targetPath, { force: true });
     }));
   }
   async#generateAssets({ operation, env }) {
@@ -13695,7 +13859,7 @@ ${error.message}`;
       "@capacitor/assets",
       "generate",
       "--assetPath",
-      path40.posix.join(this.targetRootPath, "assets"),
+      path41.posix.join(this.targetRootPath, "assets"),
       "--iosProject",
       this.iosProjectPath,
       "--androidProject",
@@ -13905,7 +14069,7 @@ var Pkg = createInternalArgToken("Pkg");
 var Module = createInternalArgToken("Module");
 var Workspace = createInternalArgToken("Workspace");
 // pkgs/@akanjs/devkit/commandDecorators/command.ts
-import path41 from "path";
+import path42 from "path";
 import { confirm, input as input2, select as select3 } from "@inquirer/prompts";
 import { Logger as Logger10 } from "akanjs/common";
 import chalk6 from "chalk";
@@ -14409,7 +14573,7 @@ var runCommands = async (...commands) => {
     process.exit(1);
   });
   const __dirname2 = getDirname(import.meta.url);
-  const packageJsonCandidates = [`${path41.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
+  const packageJsonCandidates = [`${path42.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
   let cliPackageJson = null;
   for (const packageJsonPath of packageJsonCandidates) {
     if (!await FileSys.fileExists(packageJsonPath))
@@ -14689,8 +14853,8 @@ var scanModuleSpecifiers = (source2, filePath, includeExports) => {
   return importSpecifiers;
 };
 var parseTsConfig = (tsConfigPath = "./tsconfig.json") => {
-  const configFile = ts10.readConfigFile(tsConfigPath, (path42) => {
-    return ts10.sys.readFile(path42);
+  const configFile = ts10.readConfigFile(tsConfigPath, (path43) => {
+    return ts10.sys.readFile(path43);
   });
   return ts10.parseJsonConfigFileContent(configFile.config, ts10.sys, realpathSync(tsConfigPath).replace(/[^/\\]+$/, ""));
 };
@@ -14906,6 +15070,571 @@ ${document}
 `;
   }
 }
+// pkgs/@akanjs/devkit/qualityScanner.ts
+import { createHash } from "crypto";
+import { readdir as readdir3, readFile as readFile2, stat as stat4 } from "fs/promises";
+import path43 from "path";
+import ignore2 from "ignore";
+import ts11 from "typescript";
+var MAX_FILE_LINES = 2000;
+var PLACEHOLDER_EXPORT_NAMES = new Set([
+  "aa",
+  "dumb",
+  "dumb2",
+  "someBaseLogic",
+  "someCommonLogic",
+  "someFrontendLogic",
+  "someBackendLogic"
+]);
+var SUGGESTED_RULES = [
+  "Keep generated scanSync index files out of hand-written changes; generated indexes should only contain one-depth export statements.",
+  "Generated Akan index files should not contain placeholder exports such as aa, dumb, dumb2, or some*Logic.",
+  "Dictionary text should not contain scaffold wording, misspellings, or stale copied domain nouns.",
+  "Warn earlier on very long Akan files: 500 lines for services, 800 lines for Template/Zone files, and 1000 lines for Util files.",
+  "Global declarations, Window augmentation, and prototype mutation should stay in explicitly approved low-level integration files.",
+  "Keep app root folders small and conventional: application code belongs under common, env, lib, page, private, public, script, srvkit, ui, or webkit.",
+  "Keep apps/*/lib and libs/*/lib root files limited to generated support facets such as cnst.ts, db.ts, dict.ts, sig.ts, srv.ts, st.ts, useClient.ts, and useServer.ts.",
+  "Use domain module folders consistently: lib/<model> for database modules, lib/_<service> for service modules, and lib/__scalar/<scalar> for scalar modules.",
+  "Keep module UI filenames predictable: database modules use <Model>.Template/Unit/Util/View/Zone.tsx, service modules use <Service>.Util/Zone.tsx, and scalar modules use <Scalar>.Template/Unit.tsx.",
+  "Move shared app utilities to apps/*/common instead of creating apps/*/base.",
+  "Avoid large mixed-purpose class files; class export files should import helpers from neighboring utility files instead of declaring them inline."
+];
+var APP_ROOT_FILES = new Set([
+  "akan.app.json",
+  "akan.config.ts",
+  "capacitor.config.ts",
+  "client.ts",
+  "main.ts",
+  "package.json",
+  "server.ts",
+  "tsconfig.json"
+]);
+var LIB_ROOT_FILES = new Set([
+  "cnst.ts",
+  "db.ts",
+  "dict.ts",
+  "option.ts",
+  "sig.ts",
+  "srv.ts",
+  "st.ts",
+  "useClient.ts",
+  "useServer.ts"
+]);
+var CONVENTION_SUFFIXES = [
+  ".constant.ts",
+  ".dictionary.ts",
+  ".document.ts",
+  ".service.ts",
+  ".signal.ts",
+  ".store.ts"
+];
+
+class AkanQualityScanner {
+  async scan(workspaceRoot) {
+    const targetFiles = await this.#collectTargetFiles(workspaceRoot);
+    const sourceFiles = await Promise.all(targetFiles.map((file) => this.#readSourceFile(workspaceRoot, file)));
+    const warnings = [
+      ...this.#scanGlobalQuality(sourceFiles),
+      ...sourceFiles.flatMap((sourceFile2) => this.#scanSingleFileQuality(sourceFile2)),
+      ...sourceFiles.flatMap((sourceFile2) => this.#scanConventionQuality(sourceFile2)),
+      ...sourceFiles.flatMap((sourceFile2) => this.#scanLayoutQuality(sourceFile2))
+    ];
+    return {
+      workspaceRoot,
+      scannedFiles: sourceFiles.length,
+      warnings: warnings.sort(compareWarnings),
+      suggestedRules: SUGGESTED_RULES
+    };
+  }
+  async#collectTargetFiles(workspaceRoot) {
+    const ignoreFilter = ignore2().add(await this.#readGitIgnore(workspaceRoot));
+    const files = [];
+    for (const targetRoot of ["apps", "libs"]) {
+      const absoluteTargetRoot = path43.join(workspaceRoot, targetRoot);
+      if (!await isDirectory(absoluteTargetRoot))
+        continue;
+      await this.#walkTargetFiles(workspaceRoot, absoluteTargetRoot, ignoreFilter, files);
+    }
+    return files.sort();
+  }
+  async#readGitIgnore(workspaceRoot) {
+    const gitIgnorePath = path43.join(workspaceRoot, ".gitignore");
+    if (!await Bun.file(gitIgnorePath).exists())
+      return [];
+    return (await readFile2(gitIgnorePath, "utf8")).split(/\r?\n/);
+  }
+  async#walkTargetFiles(workspaceRoot, currentPath, ignoreFilter, files) {
+    const entries = await readdir3(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = path43.join(currentPath, entry.name);
+      const relativePath = toPosix(path43.relative(workspaceRoot, absolutePath));
+      if (shouldSkipPath(relativePath, entry.isDirectory(), ignoreFilter))
+        continue;
+      if (entry.isDirectory()) {
+        await this.#walkTargetFiles(workspaceRoot, absolutePath, ignoreFilter, files);
+        continue;
+      }
+      if ((relativePath.endsWith(".ts") || relativePath.endsWith(".tsx")) && !relativePath.endsWith(".d.ts")) {
+        files.push(relativePath);
+      }
+    }
+  }
+  async#readSourceFile(workspaceRoot, file) {
+    const absolutePath = path43.join(workspaceRoot, file);
+    const content = await readFile2(absolutePath, "utf8");
+    return {
+      file,
+      absolutePath,
+      content,
+      sourceFile: ts11.createSourceFile(file, content, ts11.ScriptTarget.Latest, true, getScriptKind(file))
+    };
+  }
+  #scanGlobalQuality(sourceFiles) {
+    const exportedFunctionLikes = sourceFiles.flatMap((sourceFile2) => getExportedFunctionLikes(sourceFile2));
+    const warnings = [];
+    for (const [name, declarations] of groupBy(exportedFunctionLikes, (declaration) => declaration.name)) {
+      if (declarations.length < 2)
+        continue;
+      warnings.push({
+        rule: "akan.global.duplicate-exported-function-name",
+        scope: "global",
+        severity: "warning",
+        message: `Exported function or class name "${name}" is declared in ${declarations.length} files.`,
+        locations: declarations.map(({ file, line }) => ({ file, line }))
+      });
+    }
+    const declarationsWithBody = exportedFunctionLikes.filter((declaration) => declaration.bodyFingerprint);
+    for (const [fingerprint, declarations] of groupBy(declarationsWithBody, (declaration) => declaration.bodyFingerprint ?? "")) {
+      const uniqueNames = new Set(declarations.map((declaration) => declaration.name));
+      if (declarations.length < 2 || uniqueNames.size < 2 || fingerprint === "")
+        continue;
+      warnings.push({
+        rule: "akan.global.duplicate-exported-function-body",
+        scope: "global",
+        severity: "warning",
+        message: `Exported functions/classes share the same implementation body: ${declarations.map((declaration) => declaration.name).join(", ")}.`,
+        locations: declarations.map(({ file, line }) => ({ file, line }))
+      });
+    }
+    return warnings;
+  }
+  #scanSingleFileQuality(sourceFile2) {
+    const warnings = [];
+    const lineCount = sourceFile2.content.split(/\r?\n/).length;
+    const recommendedLineLimit = getRecommendedLineLimit(sourceFile2.file);
+    if (recommendedLineLimit && lineCount > recommendedLineLimit) {
+      warnings.push({
+        rule: "akan.file.recommended-max-lines",
+        scope: "file",
+        severity: "warning",
+        file: sourceFile2.file,
+        message: `File has ${lineCount} lines. Recommended limit for this file type is ${recommendedLineLimit} lines.`
+      });
+    }
+    if (lineCount > MAX_FILE_LINES) {
+      warnings.push({
+        rule: "akan.file.max-lines",
+        scope: "file",
+        severity: "warning",
+        file: sourceFile2.file,
+        message: `File has ${lineCount} lines. Keep single files under ${MAX_FILE_LINES} lines.`
+      });
+    }
+    warnings.push(...getPlaceholderExportWarnings(sourceFile2));
+    warnings.push(...getDictionaryTextWarnings(sourceFile2));
+    warnings.push(...getGlobalMutationWarnings(sourceFile2));
+    const exportedClassNames = getExportedClassNames(sourceFile2.sourceFile);
+    if (exportedClassNames.length === 0)
+      return warnings;
+    const allowedInterfaceNames = new Set(exportedClassNames.map((name) => `${name}Options`));
+    for (const declaration of getTopLevelDeclarations(sourceFile2)) {
+      if (declaration.kind === "class" && exportedClassNames.includes(declaration.name))
+        continue;
+      if (declaration.kind === "interface" && allowedInterfaceNames.has(declaration.name))
+        continue;
+      warnings.push({
+        rule: "akan.file.class-export-global-declaration",
+        scope: "file",
+        severity: "warning",
+        file: sourceFile2.file,
+        line: declaration.line,
+        message: `Class export files should not declare top-level ${declaration.kind} "${declaration.name}". Move helpers to another file and import them.`
+      });
+    }
+    return warnings;
+  }
+  #scanConventionQuality(sourceFile2) {
+    const suffix = CONVENTION_SUFFIXES.find((candidate) => sourceFile2.file.endsWith(candidate));
+    if (!suffix)
+      return [];
+    const modelName = toPascalCase(path43.basename(sourceFile2.file, suffix));
+    const warnings = [];
+    for (const declaration of getTopLevelDeclarations(sourceFile2)) {
+      if (isAllowedConventionDeclaration(suffix, modelName, declaration))
+        continue;
+      warnings.push({
+        rule: `akan.convention${suffix.replace(".ts", "")}`,
+        scope: "convention",
+        severity: "warning",
+        file: sourceFile2.file,
+        line: declaration.line,
+        message: `${path43.basename(sourceFile2.file)} should not declare top-level ${declaration.kind} "${declaration.name}". Allowed declarations: ${getConventionDescription(suffix, modelName)}.`
+      });
+    }
+    return warnings;
+  }
+  #scanLayoutQuality(sourceFile2) {
+    const segments = sourceFile2.file.split("/");
+    const warnings = [];
+    if (segments[0] === "apps" && segments.length === 3 && !APP_ROOT_FILES.has(segments[2])) {
+      warnings.push({
+        rule: "akan.layout.app-root-file",
+        scope: "layout",
+        severity: "warning",
+        file: sourceFile2.file,
+        message: `Unexpected app root file "${segments[2]}". Keep application code in conventional app folders.`
+      });
+    }
+    const libRootFile = getLibRootFile(sourceFile2.file);
+    if (libRootFile && !LIB_ROOT_FILES.has(libRootFile)) {
+      warnings.push({
+        rule: "akan.layout.lib-root-file",
+        scope: "layout",
+        severity: "warning",
+        file: sourceFile2.file,
+        message: `Unexpected lib root file "${libRootFile}". Keep direct lib root files limited to generated support facets.`
+      });
+    }
+    const moduleUiWarning = getModuleUiWarning(sourceFile2.file);
+    if (moduleUiWarning)
+      warnings.push(moduleUiWarning);
+    return warnings;
+  }
+}
+function formatQualityScanResult(result) {
+  const sections = [
+    "Akan Code Quality Scan",
+    `workspace: ${result.workspaceRoot}`,
+    `scanned files: ${result.scannedFiles}`,
+    `warnings: ${result.warnings.length}`,
+    "",
+    "Warnings:",
+    "",
+    ...formatQualityWarnings(result.warnings),
+    "",
+    "Suggested quality rules:",
+    "",
+    ...result.suggestedRules.map((rule) => `  - ${rule}`)
+  ];
+  return sections.join(`
+`);
+}
+function formatQualityWarnings(warnings) {
+  if (warnings.length === 0)
+    return ["No warnings found."];
+  return warnings.flatMap((warning) => {
+    const location = formatQualityLocation(warning.file, warning.line);
+    const lines = [`${location} - warning ${warning.rule}: ${warning.message}`];
+    if (warning.locations?.length) {
+      lines.push(...warning.locations.map(({ file, line }) => `  note: related location ${formatQualityLocation(file, line)}`));
+    }
+    return lines;
+  });
+}
+function formatQualityLocation(file, line) {
+  return `${file ?? "<global>"}:${line ?? 1}:1`;
+}
+function getExportedFunctionLikes(sourceFile2) {
+  const declarations = [];
+  for (const statement of sourceFile2.sourceFile.statements) {
+    if (ts11.isFunctionDeclaration(statement) && statement.name && isExported(statement)) {
+      declarations.push({
+        name: statement.name.text,
+        kind: "function",
+        file: sourceFile2.file,
+        line: getLine(sourceFile2.sourceFile, statement),
+        bodyFingerprint: getBodyFingerprint(sourceFile2.sourceFile, statement.body)
+      });
+    }
+    if (ts11.isClassDeclaration(statement) && statement.name && isExported(statement)) {
+      declarations.push({
+        name: statement.name.text,
+        kind: "class",
+        file: sourceFile2.file,
+        line: getLine(sourceFile2.sourceFile, statement),
+        bodyFingerprint: getBodyFingerprint(sourceFile2.sourceFile, statement)
+      });
+    }
+    if (ts11.isVariableStatement(statement) && isExported(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (!ts11.isIdentifier(declaration.name) || !isFunctionLikeInitializer(declaration.initializer))
+          continue;
+        declarations.push({
+          name: declaration.name.text,
+          kind: "function-variable",
+          file: sourceFile2.file,
+          line: getLine(sourceFile2.sourceFile, declaration),
+          bodyFingerprint: getBodyFingerprint(sourceFile2.sourceFile, declaration.initializer)
+        });
+      }
+    }
+  }
+  return declarations;
+}
+function getExportedClassNames(sourceFile2) {
+  return sourceFile2.statements.filter((statement) => ts11.isClassDeclaration(statement) && !!statement.name).filter((statement) => isExported(statement)).map((statement) => statement.name.text);
+}
+function getPlaceholderExportWarnings(sourceFile2) {
+  if (!sourceFile2.file.endsWith("/index.ts") && !sourceFile2.file.endsWith("/index.tsx"))
+    return [];
+  return getTopLevelDeclarations(sourceFile2).filter((declaration) => declaration.exported && PLACEHOLDER_EXPORT_NAMES.has(declaration.name)).map((declaration) => ({
+    rule: "akan.file.placeholder-export",
+    scope: "file",
+    severity: "warning",
+    file: sourceFile2.file,
+    line: declaration.line,
+    message: `Generated or barrel index file should not export placeholder "${declaration.name}".`
+  }));
+}
+function getDictionaryTextWarnings(sourceFile2) {
+  if (!sourceFile2.file.endsWith(".dictionary.ts"))
+    return [];
+  const stalePatterns = [
+    { pattern: /\b[A-Z][A-Za-z0-9]* description\b/, label: "scaffold description text" },
+    { pattern: /settting/, label: "misspelling: settting" },
+    { pattern: /\uBC30\uB108 \uC218/, label: "stale copied Korean domain noun: \uBC30\uB108 \uC218" }
+  ];
+  return stalePatterns.flatMap(({ pattern, label }) => findPatternLines(sourceFile2.content, pattern).map((line) => ({
+    rule: "akan.file.dictionary-stale-text",
+    scope: "file",
+    severity: "warning",
+    file: sourceFile2.file,
+    line,
+    message: `Dictionary text appears to contain ${label}.`
+  })));
+}
+function getGlobalMutationWarnings(sourceFile2) {
+  const warnings = [];
+  for (const statement of sourceFile2.sourceFile.statements) {
+    if (ts11.isModuleDeclaration(statement) && statement.name.getText(sourceFile2.sourceFile) === "global") {
+      warnings.push({
+        rule: "akan.file.global-declaration",
+        scope: "file",
+        severity: "warning",
+        file: sourceFile2.file,
+        line: getLine(sourceFile2.sourceFile, statement),
+        message: "Global declarations require an explicit low-level integration allowlist."
+      });
+    }
+    if (ts11.isInterfaceDeclaration(statement) && statement.name.text === "Window") {
+      warnings.push({
+        rule: "akan.file.window-augmentation",
+        scope: "file",
+        severity: "warning",
+        file: sourceFile2.file,
+        line: getLine(sourceFile2.sourceFile, statement),
+        message: "Window augmentation should be isolated to approved browser integration files."
+      });
+    }
+    if (ts11.isExpressionStatement(statement) && statement.expression.getText(sourceFile2.sourceFile).includes(".prototype.")) {
+      warnings.push({
+        rule: "akan.file.prototype-mutation",
+        scope: "file",
+        severity: "warning",
+        file: sourceFile2.file,
+        line: getLine(sourceFile2.sourceFile, statement),
+        message: "Prototype mutation should be avoided or isolated to approved low-level integration files."
+      });
+    }
+  }
+  return warnings;
+}
+function getTopLevelDeclarations(sourceFile2) {
+  return sourceFile2.sourceFile.statements.flatMap((statement) => getTopLevelDeclaration(sourceFile2.sourceFile, statement));
+}
+function getTopLevelDeclaration(sourceFile2, statement) {
+  const line = getLine(sourceFile2, statement);
+  if (ts11.isClassDeclaration(statement) && statement.name) {
+    return [{ name: statement.name.text, kind: "class", line, exported: isExported(statement), node: statement }];
+  }
+  if (ts11.isFunctionDeclaration(statement) && statement.name) {
+    return [{ name: statement.name.text, kind: "function", line, exported: isExported(statement), node: statement }];
+  }
+  if (ts11.isInterfaceDeclaration(statement)) {
+    return [{ name: statement.name.text, kind: "interface", line, exported: isExported(statement), node: statement }];
+  }
+  if (ts11.isTypeAliasDeclaration(statement)) {
+    return [{ name: statement.name.text, kind: "type", line, exported: isExported(statement), node: statement }];
+  }
+  if (ts11.isEnumDeclaration(statement)) {
+    return [{ name: statement.name.text, kind: "enum", line, exported: isExported(statement), node: statement }];
+  }
+  if (ts11.isVariableStatement(statement)) {
+    return statement.declarationList.declarations.filter((declaration) => ts11.isIdentifier(declaration.name)).map((declaration) => ({
+      name: declaration.name.text,
+      kind: "variable",
+      line: getLine(sourceFile2, declaration),
+      exported: isExported(statement),
+      node: statement
+    }));
+  }
+  if (ts11.isExportDeclaration(statement)) {
+    return [{ name: "export declaration", kind: "export", line, exported: true, node: statement }];
+  }
+  return [];
+}
+function isAllowedConventionDeclaration(suffix, modelName, declaration) {
+  if (suffix === ".dictionary.ts")
+    return isExportedConst(declaration) && declaration.name === "dictionary";
+  if (suffix === ".constant.ts")
+    return isAllowedConstantDeclaration(modelName, declaration);
+  if (suffix === ".document.ts")
+    return declaration.kind === "class" && [`${modelName}Filter`, modelName, `${modelName}Model`].includes(declaration.name);
+  if (suffix === ".service.ts")
+    return declaration.kind === "class" && declaration.name === `${modelName}Service`;
+  if (suffix === ".signal.ts")
+    return declaration.kind === "class" && [`${modelName}Internal`, `${modelName}Slice`, `${modelName}Endpoint`].includes(declaration.name);
+  if (suffix === ".store.ts")
+    return declaration.kind === "class" && declaration.name === `${modelName}Store`;
+  return false;
+}
+function isAllowedConstantDeclaration(modelName, declaration) {
+  if (declaration.kind !== "class")
+    return false;
+  if ([`${modelName}Input`, `${modelName}Object`, modelName, `Light${modelName}`, `${modelName}Insight`].includes(declaration.name))
+    return true;
+  if (!ts11.isClassDeclaration(declaration.node))
+    return false;
+  const heritageClause = declaration.node.heritageClauses?.find((clause) => clause.token === ts11.SyntaxKind.ExtendsKeyword);
+  const expression = heritageClause?.types[0]?.expression;
+  return !!expression && expression.getText().startsWith("enumOf(");
+}
+function getConventionDescription(suffix, modelName) {
+  if (suffix === ".dictionary.ts")
+    return "export const dictionary";
+  if (suffix === ".constant.ts")
+    return `${modelName}Input, ${modelName}Object, ${modelName}, Light${modelName}, ${modelName}Insight, or enumOf classes`;
+  if (suffix === ".document.ts")
+    return `${modelName}Filter, ${modelName}, or ${modelName}Model`;
+  if (suffix === ".service.ts")
+    return `${modelName}Service`;
+  if (suffix === ".signal.ts")
+    return `${modelName}Internal, ${modelName}Slice, or ${modelName}Endpoint`;
+  return `${modelName}Store`;
+}
+function getLibRootFile(file) {
+  const segments = file.split("/");
+  if (segments[0] === "libs" && segments.length === 4 && segments[2] === "lib")
+    return segments[3];
+  if (segments[0] === "apps" && segments.length === 5 && segments[2] === "lib")
+    return segments[4];
+  return null;
+}
+function getModuleUiWarning(file) {
+  if (!file.endsWith(".tsx"))
+    return null;
+  const moduleInfo = getModuleInfo(file);
+  if (!moduleInfo)
+    return null;
+  const { moduleName, fileName, kind } = moduleInfo;
+  const pascalName = toPascalCase(moduleName.replace(/^_+/, ""));
+  const allowedSuffixes = kind === "database" ? ["Template", "Unit", "Util", "View", "Zone"] : kind === "service" ? ["Util", "Zone"] : ["Template", "Unit"];
+  const allowedFileNames = new Set(allowedSuffixes.map((suffix) => `${pascalName}.${suffix}.tsx`));
+  if (allowedFileNames.has(fileName) || fileName.endsWith(".test.tsx") || fileName.endsWith(".spec.tsx"))
+    return null;
+  return {
+    rule: "akan.layout.module-ui-file",
+    scope: "layout",
+    severity: "warning",
+    file,
+    message: `Unexpected ${kind} module UI filename "${fileName}". Expected one of: ${[...allowedFileNames].join(", ")}.`
+  };
+}
+function getModuleInfo(file) {
+  const segments = file.split("/");
+  const libIndex = segments.indexOf("lib");
+  if (libIndex < 0)
+    return null;
+  const moduleName = segments[libIndex + 1];
+  if (moduleName === "__scalar") {
+    if (segments.length !== libIndex + 4)
+      return null;
+    return { moduleName: segments[libIndex + 2], fileName: segments[libIndex + 3], kind: "scalar" };
+  }
+  if (segments.length !== libIndex + 3)
+    return null;
+  const fileName = segments[libIndex + 2];
+  if (moduleName.startsWith("__")) {
+    const scalarName = moduleName === "__scalar" ? segments[libIndex + 2] : moduleName;
+    return { moduleName: scalarName, fileName, kind: "scalar" };
+  }
+  if (moduleName.startsWith("_"))
+    return { moduleName, fileName, kind: "service" };
+  return { moduleName, fileName, kind: "database" };
+}
+function isExportedConst(declaration) {
+  return declaration.exported && ts11.isVariableStatement(declaration.node) && (declaration.node.declarationList.flags & ts11.NodeFlags.Const) !== 0;
+}
+function isExported(node) {
+  return !!ts11.getCombinedModifierFlags(node) && !!(ts11.getCombinedModifierFlags(node) & ts11.ModifierFlags.Export);
+}
+function isFunctionLikeInitializer(node) {
+  return !!node && (ts11.isArrowFunction(node) || ts11.isFunctionExpression(node));
+}
+function getBodyFingerprint(sourceFile2, node) {
+  if (!node)
+    return;
+  const normalizedBody = node.getText(sourceFile2).replace(/\s+/g, " ").trim();
+  if (normalizedBody.length < 80)
+    return;
+  return createHash("sha256").update(normalizedBody).digest("hex");
+}
+function shouldSkipPath(relativePath, isDirectory, ignoreFilter) {
+  const ignorePath = isDirectory ? `${relativePath}/` : relativePath;
+  return relativePath === ".git" || relativePath.includes("/.git/") || relativePath.includes("/node_modules/") || ignoreFilter.ignores(relativePath) || ignoreFilter.ignores(ignorePath);
+}
+async function isDirectory(absolutePath) {
+  try {
+    return (await stat4(absolutePath)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function getScriptKind(file) {
+  return file.endsWith(".tsx") ? ts11.ScriptKind.TSX : ts11.ScriptKind.TS;
+}
+function getLine(sourceFile2, node) {
+  return sourceFile2.getLineAndCharacterOfPosition(node.getStart(sourceFile2)).line + 1;
+}
+function getRecommendedLineLimit(file) {
+  if (file.endsWith(".service.ts"))
+    return 500;
+  if (file.endsWith(".Template.tsx") || file.endsWith(".Zone.tsx"))
+    return 800;
+  if (file.endsWith(".Util.tsx"))
+    return 1000;
+  return null;
+}
+function findPatternLines(content, pattern) {
+  return content.split(/\r?\n/).flatMap((line, index) => pattern.test(line) ? [index + 1] : []);
+}
+function toPascalCase(value) {
+  return value.replace(/(^|[-_./])([a-zA-Z0-9])/g, (_, __, char) => char.toUpperCase()).replace(/[-_./]/g, "");
+}
+function toPosix(value) {
+  return value.split(path43.sep).join("/");
+}
+function groupBy(items, getKey) {
+  const grouped = new Map;
+  for (const item of items) {
+    const key = getKey(item);
+    grouped.set(key, [...grouped.get(key) ?? [], item]);
+  }
+  return grouped;
+}
+function compareWarnings(a, b) {
+  return a.scope.localeCompare(b.scope) || (a.file ?? "").localeCompare(b.file ?? "") || (a.line ?? 0) - (b.line ?? 0) || a.rule.localeCompare(b.rule);
+}
 // pkgs/@akanjs/devkit/selectModel.ts
 import { select as select5 } from "@inquirer/prompts";
 // pkgs/@akanjs/devkit/streamAi.ts
@@ -15867,7 +16596,7 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
 import { Logger as Logger16 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/package/package.runner.ts
-import path42 from "path";
+import path44 from "path";
 import { Logger as Logger14 } from "akanjs/common";
 var {$: $2 } = globalThis.Bun;
 
@@ -15887,11 +16616,11 @@ class PackageRunner extends runner("package") {
   }
   async#getInstalledPackageJson() {
     const packageJsonCandidates = [
-      `${path42.dirname(Bun.main)}/package.json`,
+      `${path44.dirname(Bun.main)}/package.json`,
       `${process.cwd()}/node_modules/akanjs/package.json`
     ];
     try {
-      packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", path42.dirname(Bun.main)));
+      packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", path44.dirname(Bun.main)));
     } catch {}
     for (const packageJsonPath of packageJsonCandidates) {
       if (!await Bun.file(packageJsonPath).exists())
@@ -15900,7 +16629,7 @@ class PackageRunner extends runner("package") {
       if (packageJson.name === "akanjs" || packageJson.name === "@akanjs/cli")
         return packageJson;
     }
-    throw new Error(`[package] failed to locate akanjs package.json from ${path42.dirname(Bun.main)}`);
+    throw new Error(`[package] failed to locate akanjs package.json from ${path44.dirname(Bun.main)}`);
   }
   async createPackage(workspace, pkgName) {
     await workspace.applyTemplate({ basePath: `pkgs/${pkgName}`, template: "pkgRoot", dict: { pkgName } });
@@ -16075,7 +16804,7 @@ class PackageScript extends script("package", [PackageRunner]) {
 }
 
 // pkgs/@akanjs/cli/cloud/cloud.runner.ts
-import path43 from "path";
+import path45 from "path";
 import { confirm as confirm4, input as input5, select as select8 } from "@inquirer/prompts";
 import { Logger as Logger15, sleep } from "akanjs/common";
 import chalk7 from "chalk";
@@ -16346,7 +17075,7 @@ ${chalk7.green("\u27A4")} Authentication Required`));
     await Promise.all(akanPkgs.map(async (library) => {
       Logger15.info(`Publishing ${library}@${nextVersion} to ${registry ?? "npm"}...`);
       await workspace.spawn("npm", ["publish", "--tag", tag, ...this.#getRegistryArgs(registry), ...this.#getLocalRegistryAuthArgs(registry)], {
-        cwd: path43.join(workspace.workspaceRoot, "dist/pkgs", library),
+        cwd: path45.join(workspace.workspaceRoot, "dist/pkgs", library),
         env: this.#getRegistryEnv(registry),
         stdio: "inherit"
       });
@@ -16400,11 +17129,12 @@ ${chalk7.green("\u27A4")} Authentication Required`));
   async downloadEnv(cloudApi2, workspace, workspaceId) {
     await workspace.mkdir("local");
     const localPath = await cloudApi2.downloadEnv(workspaceId);
-    await workspace.spawn("tar", ["-xf", localPath], { cwd: workspace.workspaceRoot });
+    const relativePath = path45.relative(workspace.workspaceRoot, localPath).split(path45.sep).join("/");
+    await workspace.spawn("tar", ["-xf", relativePath], { cwd: workspace.workspaceRoot });
     await workspace.remove(localPath);
   }
   async uploadEnv(cloudApi2, workspaceId, filePath) {
-    const file = new File([Bun.file(filePath)], path43.basename(filePath));
+    const file = new File([Bun.file(filePath)], path45.basename(filePath));
     await cloudApi2.uploadEnv(workspaceId, file);
   }
   async downloadEnvByScp(workspace) {
@@ -16496,14 +17226,14 @@ class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, Packa
   }
   async uploadEnv(workspace) {
     const workspaceId = workspace.getWorkspaceId({ allowEmpty: true });
-    const { path: path44 } = await this.cloudRunner.gatherEnvFiles(workspace);
+    const { path: path46 } = await this.cloudRunner.gatherEnvFiles(workspace);
     if (workspaceId) {
       await this.login(workspace);
       const cloudApi2 = await CloudApi.fromHost(workspace);
-      await this.cloudRunner.uploadEnv(cloudApi2, workspaceId, path44);
+      await this.cloudRunner.uploadEnv(cloudApi2, workspaceId, path46);
       return;
     }
-    await this.cloudRunner.uploadEnvByScp(workspace, path44);
+    await this.cloudRunner.uploadEnvByScp(workspace, path46);
   }
   async deployAkan(workspace, { test = true, registryUrl } = {}) {
     const akanPkgs = await this.cloudRunner.getAkanPkgs(workspace);
@@ -16744,8 +17474,8 @@ class RepairRunner extends runner("repair") {
 }
 
 // pkgs/@akanjs/cli/workflow/workflow.runner.ts
-import { mkdir as mkdir12, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import path44 from "path";
+import { mkdir as mkdir12, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import path46 from "path";
 import { capitalize as capitalize8 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/workflows/shared.ts
@@ -17288,7 +18018,7 @@ var workflowSpecs = [
 ];
 
 // pkgs/@akanjs/cli/workflow/workflow.runner.ts
-var resolvePath = (filePath) => path44.isAbsolute(filePath) ? filePath : path44.join(process.cwd(), filePath);
+var resolvePath = (filePath) => path46.isAbsolute(filePath) ? filePath : path46.join(process.cwd(), filePath);
 var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isWorkflowPlan2 = (value) => {
   if (!isRecord3(value))
@@ -17316,7 +18046,8 @@ var failedPlan = (workflow2, diagnostics) => ({
   validation: [],
   diagnostics,
   recommendations: [],
-  requiresApproval: true
+  requiresApproval: true,
+  approval: workflowPlanApproval
 });
 var failedApplyReport = (workflow2, diagnostics, plan2) => createWorkflowApplyReport({
   workflow: workflow2,
@@ -17385,7 +18116,7 @@ var defaultValidationExecutor = (workspace) => async (command3) => {
     };
   }
 };
-var readJsonFile = async (filePath) => JSON.parse(await readFile2(resolvePath(filePath), "utf8"));
+var readJsonFile = async (filePath) => JSON.parse(await readFile3(resolvePath(filePath), "utf8"));
 var planInputString2 = (plan2, key) => {
   const value = plan2.inputs[key];
   return typeof value === "string" ? value : "";
@@ -17428,17 +18159,33 @@ var applyBaselineBlockerCache = async (workspace, report) => {
     });
   }
   await workspace.writeFile(cachePath, jsonText({ schemaVersion: 1, workflow: report.workflow, blockers: [...blockers.values()] }), { silent: true });
+  const knownBlockers = report.knownBlockers.map((blocker) => {
+    if (!knownFingerprints.has(blockerFingerprint(blocker)))
+      return blocker;
+    return {
+      ...blocker,
+      known: true,
+      message: `Known baseline blocker, unrelated to this source change: ${blocker.message}`
+    };
+  });
   return {
     ...report,
-    knownBlockers: report.knownBlockers.map((blocker) => {
-      if (!knownFingerprints.has(blockerFingerprint(blocker)))
-        return blocker;
-      return {
-        ...blocker,
-        known: true,
-        message: `Known baseline blocker, unrelated to this source change: ${blocker.message}`
-      };
-    })
+    knownBlockers,
+    baselineSummary: {
+      ...report.baselineSummary,
+      knownBlockerCount: knownBlockers.filter((blocker) => blocker.known).length
+    }
+  };
+};
+var withBaselineDetailsPolicy = (report, includeBaselineDetails) => {
+  const baselineDiagnostics = report.baselineDiagnostics ?? [];
+  return {
+    ...report,
+    baselineSummary: createWorkflowBaselineSummary(baselineDiagnostics, {
+      detailsIncluded: includeBaselineDetails,
+      knownBlockerCount: report.knownBlockers.filter((blocker) => blocker.known).length
+    }),
+    baselineDiagnostics: includeBaselineDetails ? baselineDiagnostics : []
   };
 };
 
@@ -17465,7 +18212,7 @@ class WorkflowRunner extends runner("workflow") {
     const plan2 = createWorkflowPlan(spec, compactWorkflowInputs(inputs));
     if (out) {
       const outPath = resolvePath(out);
-      await mkdir12(path44.dirname(outPath), { recursive: true });
+      await mkdir12(path46.dirname(outPath), { recursive: true });
       await writeFile2(outPath, jsonText(plan2));
     }
     return format === "json" ? jsonText(plan2) : renderWorkflowPlan(plan2);
@@ -17484,7 +18231,7 @@ class WorkflowRunner extends runner("workflow") {
     };
     let plan2;
     try {
-      const parsed = JSON.parse(await readFile2(resolvePath(planPath), "utf8"));
+      const parsed = JSON.parse(await readFile3(resolvePath(planPath), "utf8"));
       if (!isWorkflowPlan2(parsed)) {
         const report = failedApplyReport("unknown", [
           {
@@ -17534,7 +18281,8 @@ class WorkflowRunner extends runner("workflow") {
   async validate(runIdOrPlan, {
     format = "markdown",
     workspace,
-    execute
+    execute,
+    includeBaselineDetails = false
   }) {
     const loaded = await this.loadValidationTarget(runIdOrPlan, workspace);
     const doctor = await AkanContextAnalyzer.doctor(workspace, {
@@ -17542,7 +18290,7 @@ class WorkflowRunner extends runner("workflow") {
       runIdOrPlan,
       changedFiles: loaded.changedFiles
     });
-    const report = await applyBaselineBlockerCache(workspace, await createWorkflowValidationRunReport({
+    const report = withBaselineDetailsPolicy(await applyBaselineBlockerCache(workspace, await createWorkflowValidationRunReport({
       workflow: loaded.plan?.workflow ?? loaded.workflow,
       source: loaded.source,
       plan: loaded.plan,
@@ -17552,7 +18300,7 @@ class WorkflowRunner extends runner("workflow") {
       baselineDiagnostics: (doctor.baselineDiagnostics ?? []).map((diagnostic) => workflowDiagnosticFromDoctor(diagnostic, "baseline")),
       workflowDiagnostics: (doctor.workflowDiagnostics ?? []).map((diagnostic) => workflowDiagnosticFromDoctor(diagnostic, "workflow")),
       repairActions: loaded.repairActions
-    }));
+    })), includeBaselineDetails);
     await writeWorkflowRunArtifact(workspace, report);
     return renderWorkflowValidation(report, format);
   }
@@ -18814,6 +19562,32 @@ var createCliWorkflowStepRegistry = (workspace) => createWorkflowStepRegistry({
 });
 
 // pkgs/@akanjs/cli/context/context.runner.ts
+var workflowDiagnosticFromContext = (diagnostic) => ({
+  severity: diagnostic.severity,
+  code: diagnostic.code,
+  message: diagnostic.message,
+  scope: diagnostic.scope,
+  context: diagnostic.context
+});
+var compactDoctorWorkspaceResult = (result, includeBaselineDetails) => {
+  const baselineDiagnostics = result.baselineDiagnostics ?? [];
+  if (baselineDiagnostics.length === 0) {
+    return {
+      ...result,
+      baselineSummary: createWorkflowBaselineSummary([], { detailsIncluded: includeBaselineDetails })
+    };
+  }
+  const baselineSummary = createWorkflowBaselineSummary(baselineDiagnostics.map(workflowDiagnosticFromContext), {
+    detailsIncluded: includeBaselineDetails
+  });
+  return {
+    ...result,
+    baselineSummary,
+    diagnostics: includeBaselineDetails ? result.diagnostics : result.diagnostics.filter((diagnostic) => diagnostic.scope !== "baseline"),
+    baselineDiagnostics: includeBaselineDetails ? baselineDiagnostics : []
+  };
+};
+
 class ContextRunner extends runner("context") {
   async getContext(workspace, {
     format = "markdown",
@@ -18903,11 +19677,11 @@ class ContextRunner extends runner("context") {
     if (name === "get_guideline")
       return await Prompter.getInstruction(stringArg(args, "name"));
     if (name === "doctor_workspace")
-      return await AkanContextAnalyzer.doctor(workspace, {
+      return compactDoctorWorkspaceResult(await AkanContextAnalyzer.doctor(workspace, {
         strict: !!args.strict,
         runIdOrPlan: typeof args.runIdOrPlan === "string" ? workspacePath(workspace, args.runIdOrPlan) : null,
         changedFiles: Array.isArray(args.changedFiles) ? args.changedFiles.filter((file) => typeof file === "string") : []
-      });
+      }), !!args.includeBaselineDetails);
     if (name === "explain_command")
       return this.explainCommand(stringArg(args, "command"));
     if (name === "get_validation_contract")
@@ -18927,6 +19701,7 @@ class ContextRunner extends runner("context") {
       return {
         ...plan2,
         planPath,
+        approval: typeof plan2 === "object" && plan2 && "approval" in plan2 ? { ...plan2.approval, canApplyWith: { planPath } } : undefined,
         next: { tool: "apply_workflow", args: { planPath } },
         policy: applyFirstPolicy
       };
@@ -18949,7 +19724,8 @@ class ContextRunner extends runner("context") {
     if (name === "run_validation")
       return parseJsonOutput(await new WorkflowRunner().validate(workspacePath(workspace, stringArg(args, "runIdOrPlan")), {
         format: "json",
-        workspace
+        workspace,
+        includeBaselineDetails: !!args.includeBaselineDetails
       }));
     if (name === "repair_generated") {
       const report = parseJsonOutput(await new RepairRunner().repair("generated", { workspace, app: stringArg(args, "app"), format: "json" }));
@@ -19260,14 +20036,14 @@ class GuidelinePrompt extends Prompter {
   async#getScanFilePaths(matchPattern, { avoidDirs = ["node_modules", ".next"], filterText } = {}) {
     const glob = new Bun.Glob(matchPattern);
     const paths = [];
-    for await (const path45 of glob.scan({ cwd: this.workspace.workspaceRoot, absolute: true })) {
-      if (avoidDirs.some((dir) => path45.includes(dir)))
+    for await (const path47 of glob.scan({ cwd: this.workspace.workspaceRoot, absolute: true })) {
+      if (avoidDirs.some((dir) => path47.includes(dir)))
         continue;
-      const fileContent = await FileSys.readText(path45);
+      const fileContent = await FileSys.readText(path47);
       const textFilter = filterText ? new RegExp(filterText) : null;
       if (filterText && !textFilter?.test(fileContent))
         continue;
-      paths.push(path45);
+      paths.push(path47);
     }
     return paths;
   }
@@ -19587,7 +20363,7 @@ class LibraryCommand extends command("library", [LibraryScript], ({ public: targ
 
 // pkgs/@akanjs/cli/localRegistry/localRegistry.runner.ts
 import { mkdir as mkdir13, rm as rm6 } from "fs/promises";
-import path45 from "path";
+import path47 from "path";
 import { Logger as Logger19 } from "akanjs/common";
 var defaultLocalRegistryUrl = "http://127.0.0.1:4873";
 var containerName = "akan-verdaccio";
@@ -19605,8 +20381,8 @@ class LocalRegistryRunner extends runner("localRegistry") {
       Logger19.info(`Local registry is already running at ${registry}`);
       return registry;
     } catch {}
-    const configPath2 = path45.join(workspace.workspaceRoot, "pkgs/@akanjs/cli/localRegistry/verdaccio.yaml");
-    const storagePath = path45.join(workspace.workspaceRoot, ".akan/verdaccio/storage");
+    const configPath2 = path47.join(workspace.workspaceRoot, "pkgs/@akanjs/cli/localRegistry/verdaccio.yaml");
+    const storagePath = path47.join(workspace.workspaceRoot, ".akan/verdaccio/storage");
     await mkdir13(storagePath, { recursive: true });
     await workspace.spawn("docker", [
       "run",
@@ -19629,13 +20405,13 @@ class LocalRegistryRunner extends runner("localRegistry") {
     try {
       await workspace.spawn("docker", ["rm", "-f", containerName], { stdio: "inherit" });
     } catch {}
-    await rm6(path45.join(workspace.workspaceRoot, ".akan/verdaccio"), { recursive: true, force: true });
+    await rm6(path47.join(workspace.workspaceRoot, ".akan/verdaccio"), { recursive: true, force: true });
     Logger19.info("Local registry storage has been reset");
   }
   async smoke(workspace, { registryUrl } = {}) {
     const registry = this.getRegistryUrl(registryUrl);
-    const smokeRoot = path45.join(workspace.workspaceRoot, ".akan/e2e");
-    await rm6(path45.join(smokeRoot, smokeRepoName), { recursive: true, force: true });
+    const smokeRoot = path47.join(workspace.workspaceRoot, ".akan/e2e");
+    await rm6(path47.join(smokeRoot, smokeRepoName), { recursive: true, force: true });
     await workspace.spawn(process.execPath, [
       "dist/pkgs/create-akan-workspace/index.js",
       smokeRepoName,
@@ -19652,12 +20428,12 @@ class LocalRegistryRunner extends runner("localRegistry") {
       stdio: "inherit"
     });
     await workspace.spawn("akan", ["typecheck", smokeAppName], {
-      cwd: path45.join(smokeRoot, smokeRepoName),
+      cwd: path47.join(smokeRoot, smokeRepoName),
       env: { ...process.env, AKAN_NPM_REGISTRY: registry, NPM_CONFIG_REGISTRY: registry },
       stdio: "inherit"
     });
     await workspace.spawn("akan", ["build", smokeAppName], {
-      cwd: path45.join(smokeRoot, smokeRepoName),
+      cwd: path47.join(smokeRoot, smokeRepoName),
       env: { ...process.env, AKAN_NPM_REGISTRY: registry, NPM_CONFIG_REGISTRY: registry },
       stdio: "inherit"
     });
@@ -19836,8 +20612,46 @@ class PrimitiveCommand extends command("primitive", [PrimitiveScript], ({ public
 })) {
 }
 
-// pkgs/@akanjs/cli/repair/repair.script.ts
+// pkgs/@akanjs/cli/quality/quality.script.ts
 import { Logger as Logger22 } from "akanjs/common";
+
+// pkgs/@akanjs/cli/quality/quality.runner.ts
+class QualityRunner extends runner("quality") {
+  async scan(workspace) {
+    return await new AkanQualityScanner().scan(workspace.workspaceRoot);
+  }
+}
+
+// pkgs/@akanjs/cli/quality/quality.script.ts
+class QualityScript extends script("quality", [QualityRunner]) {
+  async scan(workspace, format = "text") {
+    const spinner2 = workspace.spinning("Scanning Akan code quality...");
+    const result = await this.qualityRunner.scan(workspace);
+    spinner2.succeed(`Quality scan completed (${result.scannedFiles} files, ${result.warnings.length} warnings)`);
+    Logger22.rawLog(format === "json" ? JSON.stringify(result, null, 2) : formatQualityScanResult(result));
+  }
+}
+
+// pkgs/@akanjs/cli/quality/quality.command.ts
+class QualityCommand extends command("quality", [QualityScript], ({ public: target }) => ({
+  quality: target({ desc: "Scan apps and libs for Akan code quality warnings" }).arg("action", String, {
+    desc: "quality action",
+    default: "scan",
+    enum: ["scan"]
+  }).option("format", String, {
+    desc: "output format",
+    default: "text",
+    enum: ["text", "json"]
+  }).with(Workspace).exec(async function(action, format, workspace) {
+    if (action !== "scan")
+      throw new Error(`Unknown quality action: ${action}. Use "scan".`);
+    await this.qualityScript.scan(workspace, format);
+  })
+})) {
+}
+
+// pkgs/@akanjs/cli/repair/repair.script.ts
+import { Logger as Logger23 } from "akanjs/common";
 class RepairScript extends script("repair", [RepairRunner]) {
   async repair(kind, {
     workspace,
@@ -19846,7 +20660,7 @@ class RepairScript extends script("repair", [RepairRunner]) {
     target = null,
     format = "markdown"
   }) {
-    Logger22.rawLog(await this.repairRunner.repair(kind, {
+    Logger23.rawLog(await this.repairRunner.repair(kind, {
       workspace,
       app,
       module,
@@ -19886,12 +20700,12 @@ class RepairCommand extends command("repair", [RepairScript], ({ public: target
 }
 
 // pkgs/@akanjs/cli/scalar/scalar.command.ts
-import { Logger as Logger23, lowerlize as lowerlize3 } from "akanjs/common";
+import { Logger as Logger24, lowerlize as lowerlize3 } from "akanjs/common";
 class ScalarCommand extends command("scalar", [ScalarScript], ({ public: target }) => ({
   createScalar: target({ desc: "Create a new scalar type (simple data model without DB)" }).arg("scalarName", String, { desc: "name of scalar" }).with(Sys).option("ai", Boolean, { default: false, desc: "use ai to create scalar" }).option("format", String, { flag: "o", desc: "output format", default: "markdown", enum: ["markdown", "json"] }).exec(async function(scalarName, sys3, ai, format) {
     const name = lowerlize3(scalarName.replace(/ /g, ""));
     const report = ai ? await this.scalarScript.createScalarWithAi(sys3, name) : await this.scalarScript.createScalar(sys3, name);
-    Logger23.rawLog(renderPrimitiveReport(report, format));
+    Logger24.rawLog(renderPrimitiveReport(report, format));
   }),
   removeScalar: target({ desc: "Remove a scalar type from an app or library" }).arg("scalarName", String, { desc: "name of scalar" }).with(Sys).exec(async function(scalarName, sys3) {
     await this.scalarScript.removeScalar(sys3, scalarName);
@@ -19900,7 +20714,7 @@ class ScalarCommand extends command("scalar", [ScalarScript], ({ public: target
 }
 
 // pkgs/@akanjs/cli/workflow/workflow.script.ts
-import { Logger as Logger24 } from "akanjs/common";
+import { Logger as Logger25 } from "akanjs/common";
 class WorkflowScript extends script("workflow", [WorkflowRunner, ModuleScript, ScalarScript, PrimitiveScript]) {
   async workflow(action, workflow2, inputs, {
     format = "markdown",
@@ -19909,23 +20723,23 @@ class WorkflowScript extends script("workflow", [WorkflowRunner, ModuleScript, S
     workspace
   } = {}) {
     if (action === "list") {
-      Logger24.rawLog(this.workflowRunner.list({ format }));
+      Logger25.rawLog(this.workflowRunner.list({ format }));
       return;
     }
     if (!workflow2)
       throw new Error(`Workflow name is required for "${action}".`);
     if (action === "explain") {
-      Logger24.rawLog(this.workflowRunner.explain(workflow2, { format }));
+      Logger25.rawLog(this.workflowRunner.explain(workflow2, { format }));
       return;
     }
     if (action === "plan") {
-      Logger24.rawLog(await this.workflowRunner.plan(workflow2, inputs, { format, out }));
+      Logger25.rawLog(await this.workflowRunner.plan(workflow2, inputs, { format, out }));
       return;
     }
     if (action === "apply") {
       if (!workspace)
         throw new Error("Workspace is required for workflow apply.");
-      Logger24.rawLog(await this.workflowRunner.apply(workflow2, {
+      Logger25.rawLog(await this.workflowRunner.apply(workflow2, {
         dryRun,
         format,
         workspace,
@@ -19943,13 +20757,13 @@ class WorkflowScript extends script("workflow", [WorkflowRunner, ModuleScript, S
     if (action === "validate") {
       if (!workspace)
         throw new Error("Workspace is required for workflow validate.");
-      Logger24.rawLog(await this.workflowRunner.validate(workflow2, { format, workspace }));
+      Logger25.rawLog(await this.workflowRunner.validate(workflow2, { format, workspace }));
       return;
     }
     if (action === "report") {
       if (!workspace)
         throw new Error("Workspace is required for workflow report.");
-      Logger24.rawLog(await this.workflowRunner.report(workflow2, { format, workspace }));
+      Logger25.rawLog(await this.workflowRunner.report(workflow2, { format, workspace }));
       return;
     }
     throw new Error(`Unknown workflow action: ${action}. Use list, explain, plan, apply, validate, or report.`);
@@ -19973,11 +20787,11 @@ class WorkflowCommand extends command("workflow", [WorkflowScript], ({ public: t
 }
 
 // pkgs/@akanjs/cli/workspace/workspace.script.ts
-import path47 from "path";
-import { Logger as Logger25 } from "akanjs/common";
+import path49 from "path";
+import { Logger as Logger26 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/workspace/workspace.runner.ts
-import path46 from "path";
+import path48 from "path";
 var defaultWorkspacePeerDependencies = new Set([
   "@react-spring/web",
   "@use-gesture/react",
@@ -20028,7 +20842,7 @@ class WorkspaceRunner extends runner("workspace") {
     owner = ""
   }) {
     const cwdPath = process.cwd();
-    const workspaceRoot = path46.join(cwdPath, dirname2, repoName);
+    const workspaceRoot = path48.join(cwdPath, dirname2, repoName);
     const normalizedRegistryUrl = registryUrl ? getNpmRegistryUrl(registryUrl) : undefined;
     const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot, repoName });
     const templateSpinner = workspace.spinning(`Creating workspace template files in ${dirname2}/${repoName}...`);
@@ -20084,9 +20898,9 @@ class WorkspaceRunner extends runner("workspace") {
   }
   async#getCliPackageJson() {
     const packageJsonCandidates = [
-      path46.join(import.meta.dir, "../package.json"),
-      path46.join(import.meta.dir, "package.json"),
-      path46.join(path46.dirname(Bun.main), "package.json")
+      path48.join(import.meta.dir, "../package.json"),
+      path48.join(import.meta.dir, "package.json"),
+      path48.join(path48.dirname(Bun.main), "package.json")
     ];
     try {
       packageJsonCandidates.unshift(Bun.resolveSync("@akanjs/cli/package.json", import.meta.dir));
@@ -20102,9 +20916,9 @@ class WorkspaceRunner extends runner("workspace") {
   }
   async#getAkanPackageJson() {
     const packageJsonCandidates = [
-      path46.join(import.meta.dir, "../../../akanjs/package.json"),
-      path46.join(process.cwd(), "pkgs/akanjs/package.json"),
-      path46.join(path46.dirname(Bun.main), "node_modules/akanjs/package.json")
+      path48.join(import.meta.dir, "../../../akanjs/package.json"),
+      path48.join(process.cwd(), "pkgs/akanjs/package.json"),
+      path48.join(path48.dirname(Bun.main), "node_modules/akanjs/package.json")
     ];
     try {
       packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", import.meta.dir));
@@ -20118,13 +20932,13 @@ class WorkspaceRunner extends runner("workspace") {
     }
     let current = import.meta.dir;
     for (let depth = 0;depth < 6; depth++) {
-      const packageJsonPath = path46.join(current, "package.json");
+      const packageJsonPath = path48.join(current, "package.json");
       if (await Bun.file(packageJsonPath).exists()) {
         const packageJson = await FileSys.readJson(packageJsonPath);
         if (packageJson.name === "akanjs")
           return packageJson;
       }
-      const parent = path46.dirname(current);
+      const parent = path48.dirname(current);
       if (parent === current)
         break;
       current = parent;
@@ -20201,11 +21015,11 @@ class WorkspaceScript extends script("workspace", [
     } catch (_) {
       gitSpinner.fail("Git repository initialization failed. It's not fatal, you can commit manually");
     }
-    const workspacePath2 = path47.join(dirname2, repoName);
-    Logger25.rawLog(`
+    const workspacePath2 = path49.join(dirname2, repoName);
+    Logger26.rawLog(`
 \uD83C\uDF89 Welcome aboard! Workspace created in ${dirname2}/${repoName}`);
-    Logger25.rawLog(`\uD83D\uDE80 Run \`cd ${workspacePath2} && akan start ${appName}\` to start the development server.`);
-    Logger25.rawLog(`
+    Logger26.rawLog(`\uD83D\uDE80 Run \`cd ${workspacePath2} && akan start ${appName}\` to start the development server.`);
+    Logger26.rawLog(`
 \uD83D\uDC4B Happy coding!`);
   }
   async generateAgentRules(workspace, { overwrite = false, cursorRules = true } = {}) {
@@ -20321,4 +21135,4 @@ class WorkspaceCommand extends command("workspace", [WorkspaceScript], ({ public
 }
 
 // pkgs/@akanjs/cli/index.ts
-runCommands(WorkspaceCommand, AgentCommand, ApplicationCommand, LibraryCommand, LocalRegistryCommand, PackageCommand, ModuleCommand, PageCommand, ContextCommand, CloudCommand, GuidelineCommand, ScalarCommand, PrimitiveCommand, RepairCommand, WorkflowCommand);
+runCommands(WorkspaceCommand, AgentCommand, ApplicationCommand, LibraryCommand, LocalRegistryCommand, PackageCommand, ModuleCommand, PageCommand, ContextCommand, CloudCommand, GuidelineCommand, ScalarCommand, PrimitiveCommand, QualityCommand, RepairCommand, WorkflowCommand);