@akanjs/cli 2.3.9-rc.3 → 2.3.9-rc.5

package/index.js

@@ -3394,28 +3394,28 @@ class SysExecutor extends Executor {
     return scalarModules;
   }
   async getViewComponents() {
-    const viewComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.View.tsx`).exists());
+    const viewComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.View.tsx`).exists());
     return viewComponents;
   }
   async getUnitComponents() {
-    const unitComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.Unit.tsx`).exists());
+    const unitComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.Unit.tsx`).exists());
     return unitComponents;
   }
   async getTemplateComponents() {
-    const templateComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.Template.tsx`).exists());
+    const templateComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.Template.tsx`).exists());
     return templateComponents;
   }
   async getViewsSourceCode() {
     const viewComponents = await this.getViewComponents();
-    return Promise.all(viewComponents.map((viewComponent) => this.getLocalFile(`lib/${viewComponent}/${viewComponent}.View.tsx`)));
+    return Promise.all(viewComponents.map((viewComponent) => this.getLocalFile(`lib/${viewComponent}/${capitalize(viewComponent)}.View.tsx`)));
   }
   async getUnitsSourceCode() {
     const unitComponents = await this.getUnitComponents();
-    return Promise.all(unitComponents.map((unitComponent) => this.getLocalFile(`lib/${unitComponent}/${unitComponent}.Unit.tsx`)));
+    return Promise.all(unitComponents.map((unitComponent) => this.getLocalFile(`lib/${unitComponent}/${capitalize(unitComponent)}.Unit.tsx`)));
   }
   async getTemplatesSourceCode() {
     const templateComponents = await this.getTemplateComponents();
-    return Promise.all(templateComponents.map((templateComponent) => this.getLocalFile(`lib/${templateComponent}/${templateComponent}.Template.tsx`)));
+    return Promise.all(templateComponents.map((templateComponent) => this.getLocalFile(`lib/${templateComponent}/${capitalize(templateComponent)}.Template.tsx`)));
   }
   async getScalarConstantFiles() {
     const scalarModules = await this.getScalarModules();
@@ -4776,238 +4776,11 @@ class AkanAppHost {
 // pkgs/@akanjs/devkit/akanContext.ts
 import { readdir } from "fs/promises";
 import path10 from "path";
-import { capitalize as capitalize3 } from "akanjs/common";
+import { capitalize as capitalize4 } from "akanjs/common";
 
-// pkgs/@akanjs/devkit/workflow/index.ts
-import { capitalize as capitalize2 } from "akanjs/common";
+// pkgs/@akanjs/devkit/workflow/utils.ts
 var jsonText = (value, { trailingNewline = true } = {}) => `${JSON.stringify(value, null, 2)}${trailingNewline ? `
 ` : ""}`;
-var surfaceModes = new Set(["infer", "include", "skip"]);
-var parseStringList = (value) => {
-  if (Array.isArray(value)) {
-    const values = value.filter((item) => typeof item === "string" && item.trim().length > 0);
-    return values.length === value.length ? values : null;
-  }
-  if (typeof value !== "string")
-    return null;
-  return value.split(",").map((item) => item.trim()).filter(Boolean);
-};
-var normalizeInputValue = (name, spec, value) => {
-  if (spec.type === "string")
-    return typeof value === "string" && value.length > 0 ? value : null;
-  if (spec.type === "string-list") {
-    const values = parseStringList(value);
-    return values && values.length > 0 ? values : null;
-  }
-  if (typeof value === "string" && surfaceModes.has(value))
-    return value;
-  throw new Error(`Unsupported workflow input value for ${name}`);
-};
-var listWorkflowSpecs = (specs) => [...specs].sort((a, b) => a.name.localeCompare(b.name));
-var getWorkflowSpec = (specs, name) => specs.find((spec) => spec.name === name) ?? null;
-var compactWorkflowInputs = (inputs) => Object.fromEntries(Object.entries(inputs).filter(([, value]) => value !== null && value !== ""));
-var addFieldComponentForType = (typeName) => {
-  const normalizedType = normalizeFieldType(typeName);
-  if (normalizedType === "Boolean")
-    return "Field.ToggleSelect";
-  if (normalizedType === "Date")
-    return "Field.Date";
-  if (normalizedType === "Int" || normalizedType === "Float")
-    return "Field.ToggleSelect or Field.Text";
-  if (typeName.toLowerCase() === "enum")
-    return "Field.ToggleSelect";
-  return "Field.Text";
-};
-var createAddFieldRecommendations = (inputs) => {
-  const app = typeof inputs.app === "string" ? inputs.app : "<app-or-lib>";
-  const module = typeof inputs.module === "string" ? inputs.module : "<module>";
-  const field = typeof inputs.field === "string" ? inputs.field : "<field>";
-  const typeName = typeof inputs.type === "string" ? inputs.type : null;
-  if (!typeName)
-    return [];
-  const normalizedType = typeName.toLowerCase() === "enum" ? "enum" : normalizeFieldType(typeName);
-  const constantPath = `*/lib/${module}/${module}.constant.ts`;
-  const dictionaryPath = `*/lib/${module}/${module}.dictionary.ts`;
-  const templatePath = `*/lib/${module}/${capitalize2(module)}.Template.tsx`;
-  return [
-    ...normalizedType === "Int" || normalizedType === "Float" ? [
-      {
-        code: "add-field-import",
-        kind: "import",
-        target: constantPath,
-        confidence: "high",
-        message: `Import ${normalizedType} from "akanjs/base" before writing field(${normalizedType}).`
-      }
-    ] : [],
-    {
-      code: "add-field-placement-constant",
-      kind: "placement",
-      target: constantPath,
-      confidence: "high",
-      message: `Insert ${field}: field(${normalizedType}) in ${capitalize2(module)}Input.`
-    },
-    {
-      code: "add-field-placement-dictionary",
-      kind: "placement",
-      target: dictionaryPath,
-      confidence: "high",
-      message: `Add dictionary labels for ${module}.${field}.`
-    },
-    {
-      code: "add-field-component",
-      kind: "ui-component",
-      target: templatePath,
-      confidence: normalizedType === "Int" || normalizedType === "Float" ? "medium" : "high",
-      message: `Recommended UI component for ${field} (${normalizedType}): ${addFieldComponentForType(typeName)}.`
-    },
-    {
-      code: "add-field-ui-manual-review",
-      kind: "manual-action",
-      target: templatePath,
-      action: `Review ${app}:${module} Template/Unit/View/Store surfaces and add ${field} only where the existing pattern is clear.`,
-      confidence: "medium",
-      message: "UI surface edits are planned as manual-review unless a safe existing field-list pattern is detected."
-    }
-  ];
-};
-var createWorkflowPlanRecommendations = (spec, inputs) => [
-  {
-    code: "workflow-apply-first",
-    kind: "auto-apply",
-    confidence: "high",
-    action: "Call apply_workflow with the MCP planPath before editing source files directly.",
-    message: `Apply the ${spec.name} plan through apply_workflow when MCP returns planPath or next.tool=apply_workflow.`
-  },
-  {
-    code: "workflow-validate-apply-report",
-    kind: "validation",
-    confidence: "high",
-    action: "After apply_workflow, call run_validation with validationTarget when present; otherwise use applyReportPath.",
-    message: "Validate the apply report artifact so diagnostics and recommendations follow the actual apply result."
-  },
-  ...spec.name === "add-field" ? createAddFieldRecommendations(inputs) : []
-];
-var createWorkflowPlan = (spec, rawInputs) => {
-  const inputs = {};
-  const diagnostics = [];
-  for (const [name, inputSpec] of Object.entries(spec.inputs)) {
-    const rawValue = rawInputs[name];
-    if (rawValue === undefined || rawValue === null || rawValue === "") {
-      if (inputSpec.required) {
-        diagnostics.push({
-          severity: "error",
-          code: "workflow-input-missing",
-          input: name,
-          message: `Workflow ${spec.name} requires input "${name}".`
-        });
-      }
-      continue;
-    }
-    const value = normalizeInputValue(name, inputSpec, rawValue);
-    if (value === null) {
-      diagnostics.push({
-        severity: "error",
-        code: "workflow-input-invalid",
-        input: name,
-        message: `Workflow ${spec.name} input "${name}" must be ${inputSpec.type}.`
-      });
-      continue;
-    }
-    if (inputSpec.allowedValues && typeof value === "string" && !inputSpec.allowedValues.includes(value)) {
-      diagnostics.push({
-        severity: "error",
-        code: "workflow-input-not-allowed",
-        input: name,
-        message: `Workflow ${spec.name} input "${name}" must be one of: ${inputSpec.allowedValues.join(", ")}.`
-      });
-      continue;
-    }
-    inputs[name] = value;
-  }
-  const fieldType = inputs.type;
-  if (spec.name === "add-field" && typeof fieldType === "string" && (fieldType.toLowerCase() === "number" || fieldType.toLowerCase() === "numeric")) {
-    diagnostics.push({
-      severity: "error",
-      code: "primitive-field-type-unsupported",
-      input: "type",
-      message: `Field type "${fieldType}" is ambiguous in Akan. Use Int for integer fields or Float for decimal fields.`
-    });
-  }
-  return {
-    schemaVersion: 1,
-    workflow: spec.name,
-    mode: "plan",
-    inputs,
-    optionalSurfaces: spec.optionalSurfaces ?? {},
-    steps: spec.steps,
-    predictedChanges: spec.predictedChanges,
-    validation: spec.validation,
-    diagnostics,
-    recommendations: createWorkflowPlanRecommendations(spec, inputs),
-    requiresApproval: true
-  };
-};
-var renderWorkflowList = (specs) => [
-  "# Akan Workflows",
-  "",
-  ...specs.flatMap((spec) => [`- \`${spec.name}\`: ${spec.description}`, `  - When: ${spec.whenToUse}`]),
-  ""
-].join(`
-`);
-var renderWorkflowExplain = (spec) => [
-  `# Workflow: ${spec.name}`,
-  "",
-  spec.description,
-  "",
-  "## When To Use",
-  spec.whenToUse,
-  "",
-  "## Inputs",
-  ...Object.entries(spec.inputs).map(([name, input2]) => `- \`${name}\`${input2.required ? " (required)" : ""}: ${input2.description}${input2.allowedValues ? ` Allowed: ${input2.allowedValues.join(", ")}.` : ""}`),
-  "",
-  "## Optional Surfaces",
-  ...Object.entries(spec.optionalSurfaces ?? {}).map(([name, mode]) => `- \`${name}\`: ${mode}`),
-  "",
-  "## Steps",
-  ...spec.steps.map((step, index) => `${index + 1}. \`${step.id}\` (${step.tool}): ${step.description}`),
-  "",
-  "## Validation",
-  ...spec.validation.map((validation) => `- \`${validation.command}\`: ${validation.reason}`),
-  ""
-].join(`
-`);
-var renderWorkflowPlan = (plan) => [
-  `# Workflow Plan: ${plan.workflow}`,
-  "",
-  `- Mode: ${plan.mode}`,
-  `- Requires approval: ${plan.requiresApproval}`,
-  "",
-  "## Inputs",
-  ...Object.entries(plan.inputs).map(([name, value]) => `- \`${name}\`: ${Array.isArray(value) ? value.join(", ") : value}`),
-  "",
-  "## Optional Surfaces",
-  ...Object.entries(plan.optionalSurfaces).map(([name, mode]) => `- \`${name}\`: ${mode}`),
-  "",
-  "## Steps",
-  ...plan.steps.map((step, index) => `${index + 1}. \`${step.id}\` (${step.tool}): ${step.description}`),
-  "",
-  "## Predicted Changes",
-  ...plan.predictedChanges.map((change) => {
-    const scope = change.applyScope ? ` (${change.applyScope})` : "";
-    return `- \`${change.action}\`${scope} ${change.target}: ${change.reason}`;
-  }),
-  "",
-  "## Validation",
-  ...plan.validation.map((validation) => `- \`${validation.command}\`: ${validation.reason}`),
-  "",
-  "## Diagnostics",
-  ...plan.diagnostics.length ? plan.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
-  "",
-  "## Recommendations",
-  ...plan.recommendations.length ? plan.recommendations.map((recommendation) => `- [${recommendation.kind}] ${recommendation.message}`) : ["- none"],
-  ""
-].join(`
-`);
 var workflowStatus = (diagnostics) => diagnostics.some((diagnostic) => diagnostic.severity === "error") ? "failed" : "passed";
 var commandStatus = (commands) => commands.some((command) => command.status === "failed") ? "failed" : "passed";
 var uniqueBy = (values, key) => {
@@ -5020,6 +4793,9 @@ var uniqueBy = (values, key) => {
     return true;
   });
 };
+var compactDiagnostics = (diagnostics) => diagnostics.filter((diagnostic) => !!diagnostic);
+
+// pkgs/@akanjs/devkit/workflow/artifacts.ts
 var createWorkflowApplyReport = ({
   workflow,
   mode,
@@ -5102,6 +4878,66 @@ var readWorkflowRunArtifact = async (workspace, runId) => {
     throw new Error(`Workflow run artifact does not exist: ${artifactPath}`);
   return await workspace.readJson(artifactPath);
 };
+var failedCommandScopes = (commands) => commands.filter((command) => command.status === "failed").map((command) => command.failureScope ?? "unknown");
+var errorDiagnosticScopes = (diagnostics) => diagnostics.filter((diagnostic) => diagnostic.severity === "error").map((diagnostic) => diagnostic.failureScope ?? (diagnostic.scope === "baseline" ? "workspace-config" : diagnostic.scope === "workflow" ? "source-change" : "unknown"));
+var hasScopeFailure = (scopes, scope, diagnostics = []) => scopes.includes(scope) || diagnostics.some((diagnostic) => diagnostic.severity === "error" && diagnostic.failureScope === scope);
+var statusForScope = (commands, diagnostics, scopes, expectedScope) => {
+  const hasCommands = commands.length > 0 || diagnostics.length > 0;
+  if (!hasCommands)
+    return "unknown";
+  return hasScopeFailure(scopes, expectedScope, diagnostics) ? "failed" : "passed";
+};
+var statusForValidationKind = (commands, kind) => {
+  const matching = commands.filter((command) => command.kind === kind);
+  if (matching.length === 0)
+    return "unknown";
+  return matching.some((command) => command.status === "failed") ? "failed" : "passed";
+};
+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}`,
+    message: `${command.failureScope === "environment" ? "Environment" : "Workspace configuration"} blocker: ${command.command}`,
+    failureScope: command.failureScope ?? "unknown",
+    command: command.command,
+    kind: command.kind,
+    count: 1
+  }));
+  const diagnosticBlockers = diagnostics.filter((diagnostic) => diagnostic.severity === "error" && (diagnostic.failureScope === "workspace-config" || diagnostic.failureScope === "environment" || diagnostic.scope === "baseline")).map((diagnostic) => ({
+    code: diagnostic.code,
+    message: diagnostic.message,
+    failureScope: diagnostic.failureScope ?? "workspace-config",
+    command: diagnostic.command,
+    kind: diagnostic.kind,
+    count: 1
+  }));
+  const grouped = new Map;
+  for (const blocker of [...commandBlockers, ...diagnosticBlockers]) {
+    const key = `${blocker.failureScope}:${blocker.code}:${blocker.command ?? ""}:${blocker.message}`;
+    const existing = grouped.get(key);
+    if (existing)
+      existing.count += blocker.count;
+    else
+      grouped.set(key, blocker);
+  }
+  return [...grouped.values()];
+};
+var createValidationStatuses = (commands, diagnostics) => {
+  const scopes = [...failedCommandScopes(commands), ...errorDiagnosticScopes(diagnostics)];
+  const sourceStatus = statusForScope(commands, diagnostics, scopes, "source-change");
+  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";
+  return {
+    sourceStatus,
+    workspaceStatus,
+    overallStatus,
+    summary: {
+      sourceChange: sourceStatus,
+      generatedSync: statusForValidationKind(commands, "sync"),
+      workspaceConfig: statusForScope(commands, diagnostics, scopes, "workspace-config"),
+      environment: statusForScope(commands, diagnostics, scopes, "environment")
+    }
+  };
+};
 var createWorkflowValidationRunReport = async ({
   runId = createWorkflowRunId("validation"),
   workflow,
@@ -5128,15 +4964,20 @@ var createWorkflowValidationRunReport = async ({
       failureScope: result.failureScope
     }
   ] : []);
+  const reportDiagnostics = [...diagnostics, ...commandDiagnostics];
+  const scopedDiagnostics = [...reportDiagnostics, ...baselineDiagnostics, ...workflowDiagnostics];
+  const statuses = createValidationStatuses(results, scopedDiagnostics);
   return {
     schemaVersion: 1,
     runId,
     workflow,
     mode: "validate",
     source,
-    status: workflowStatus([...diagnostics, ...commandDiagnostics]) === "failed" ? "failed" : commandStatus(results),
+    status: statuses.overallStatus === "passed" ? "passed" : "failed",
+    ...statuses,
+    knownBlockers: createKnownBlockers(results, scopedDiagnostics),
     commands: results,
-    diagnostics: [...diagnostics, ...commandDiagnostics],
+    diagnostics: reportDiagnostics,
     baselineDiagnostics,
     workflowDiagnostics,
     repairActions: uniqueBy(repairActions, (action) => action.command),
@@ -5180,25 +5021,512 @@ var createDryRunWorkflowApplyReport = (plan) => {
     plan
   });
 };
-var workflowStepKey = (workflow, stepId) => `${workflow}:${stepId}`;
-var primitiveReportToWorkflowStepResult = (report) => ({
-  changedFiles: report.changedFiles,
-  generatedFiles: report.generatedFiles,
-  commands: report.validationCommands,
-  diagnostics: report.diagnostics,
-  recommendations: [],
-  nextActions: report.nextActions
+var createRepairReport = ({
+  command,
+  kind,
+  target = null,
+  diagnostics = [],
+  repairActions = [],
+  nextActions = [],
+  commands = [],
+  generatedFiles = [],
+  syncedAt
+}) => ({
+  schemaVersion: 1,
+  command,
+  kind,
+  target,
+  status: workflowStatus(diagnostics) === "failed" || commandStatus(commands) === "failed" ? "failed" : "passed",
+  diagnostics,
+  repairActions: uniqueBy(repairActions, (action) => action.command),
+  nextActions: uniqueBy(nextActions, (action) => action.command),
+  commands,
+  generatedFiles,
+  ...syncedAt ? { syncedAt } : {}
 });
-var workflowStringInput = (value) => typeof value === "string" ? value : null;
-var workflowStringListInput = (value) => Array.isArray(value) ? value.join(",") : null;
-var resolveWorkflowSys = async (workspace, target) => {
-  if (!target)
-    return null;
-  const [apps, libs] = await workspace.getSyss();
-  if (apps.includes(target))
-    return AppExecutor.from(workspace, target);
-  if (libs.includes(target))
-    return LibExecutor.from(workspace, target);
+// pkgs/@akanjs/devkit/workflow/executor.ts
+import { capitalize as capitalize2 } from "akanjs/common";
+
+// pkgs/@akanjs/devkit/workflow/primitive.ts
+var createPrimitiveWriteReport = ({
+  command,
+  status,
+  changedFiles = [],
+  generatedFiles = [],
+  validationCommands = [],
+  diagnostics = [],
+  nextActions = []
+}) => ({
+  schemaVersion: 1,
+  command,
+  status: status ?? (diagnostics.some((diagnostic) => diagnostic.severity === "error") ? "failed" : "passed"),
+  changedFiles,
+  generatedFiles,
+  validationCommands,
+  diagnostics,
+  nextActions
+});
+var renderPrimitiveWriteReport = (report) => [
+  `# Primitive Write: ${report.command}`,
+  "",
+  `- Status: ${report.status}`,
+  "",
+  "## Changed Files",
+  ...report.changedFiles.length ? report.changedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
+  "",
+  "## Generated Files",
+  ...report.generatedFiles.length ? report.generatedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
+  "",
+  "## Validation Commands",
+  ...report.validationCommands.length ? report.validationCommands.map((validation) => `- \`${validation.command}\`: ${validation.reason}`) : ["- none"],
+  "",
+  "## Diagnostics",
+  ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+  "",
+  "## Next Actions",
+  ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+  ""
+].join(`
+`);
+var renderPrimitiveReport = (report, format = "markdown") => format === "json" ? jsonText(report) : renderPrimitiveWriteReport(report);
+
+// pkgs/@akanjs/devkit/workflow/source.ts
+var getSysRoot = (sys2) => `${sys2.type}s/${sys2.name}`;
+var sourceFile = (sys2, path10, action, reason) => ({
+  path: `${getSysRoot(sys2)}/${path10}`,
+  action,
+  reason
+});
+var moduleComponentName = (moduleName) => `${moduleName.slice(0, 1).toUpperCase()}${moduleName.slice(1)}`;
+var moduleSourcePaths = (moduleName) => {
+  const componentName = moduleComponentName(moduleName);
+  return {
+    abstract: `lib/${moduleName}/${moduleName}.abstract.md`,
+    constant: `lib/${moduleName}/${moduleName}.constant.ts`,
+    dictionary: `lib/${moduleName}/${moduleName}.dictionary.ts`,
+    service: `lib/${moduleName}/${moduleName}.service.ts`,
+    signal: `lib/${moduleName}/${moduleName}.signal.ts`,
+    store: `lib/${moduleName}/${moduleName}.store.ts`,
+    template: `lib/${moduleName}/${componentName}.Template.tsx`,
+    unit: `lib/${moduleName}/${componentName}.Unit.tsx`,
+    util: `lib/${moduleName}/${componentName}.Util.tsx`,
+    view: `lib/${moduleName}/${componentName}.View.tsx`,
+    zone: `lib/${moduleName}/${componentName}.Zone.tsx`
+  };
+};
+var generatedFilesForSync = (sys2, reason = "Generated files may change after sync.") => generatedFilePathsForTarget(getSysRoot(sys2), reason);
+var validationCommandsForTarget = (target) => [
+  { command: `akan sync ${target}`, reason: "Refresh generated Akan files from source conventions." },
+  { command: `akan lint ${target}`, reason: "Validate formatting, imports, and static lint rules." }
+];
+var nextActionsForTarget = (target) => [
+  { command: `akan sync ${target}`, reason: "Refresh generated Akan files after source changes." },
+  { command: `akan lint ${target}`, reason: "Validate the target after generated files are refreshed." }
+];
+var createPassedPrimitiveReport = ({
+  command,
+  changedFiles,
+  generatedFiles,
+  target,
+  nextActions
+}) => createPrimitiveWriteReport({
+  command,
+  changedFiles,
+  generatedFiles: generatedFiles ?? [],
+  validationCommands: validationCommandsForTarget(target),
+  diagnostics: [],
+  nextActions: nextActions ?? nextActionsForTarget(target)
+});
+var scalarChangedFiles = (sys2, scalarName, files) => Object.values(files).map((file) => sourceFile(sys2, `lib/__scalar/${scalarName}/${file.filename}`, "create", "Scalar source file was created."));
+var titleize = (value) => value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+var lowerlize = (value) => `${value.slice(0, 1).toLowerCase()}${value.slice(1)}`;
+var koLabels = {
+  amount: "\uAE08\uC561",
+  budget: "\uC608\uC0B0",
+  category: "\uCE74\uD14C\uACE0\uB9AC",
+  content: "\uB0B4\uC6A9",
+  count: "\uAC1C\uC218",
+  createdAt: "\uC0DD\uC131\uC77C",
+  date: "\uB0A0\uC9DC",
+  description: "\uC124\uBA85",
+  due: "\uB9C8\uAC10\uC77C",
+  dueAt: "\uB9C8\uAC10\uC77C",
+  email: "\uC774\uBA54\uC77C",
+  enabled: "\uD65C\uC131\uD654",
+  endAt: "\uC885\uB8CC\uC77C",
+  id: "ID",
+  name: "\uC774\uB984",
+  owner: "\uB2F4\uB2F9\uC790",
+  priority: "\uC6B0\uC120\uC21C\uC704",
+  project: "\uD504\uB85C\uC81D\uD2B8",
+  rating: "\uD3C9\uC810",
+  startAt: "\uC2DC\uC791\uC77C",
+  status: "\uC0C1\uD0DC",
+  title: "\uC81C\uBAA9",
+  updatedAt: "\uC218\uC815\uC77C"
+};
+var splitFieldWords = (fieldName) => fieldName.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").split(/\s+/).map((word) => word.trim()).filter(Boolean);
+var koLabelForField = (fieldName) => {
+  if (koLabels[fieldName])
+    return koLabels[fieldName];
+  const words = splitFieldWords(fieldName);
+  const translated = words.map((word) => koLabels[word] ?? koLabels[lowerlize(word)] ?? null);
+  return translated.every(Boolean) ? translated.join(" ") : null;
+};
+var bilingualLabelForField = (fieldName) => {
+  const en = titleize(fieldName);
+  return { en, ko: koLabelForField(fieldName) ?? en };
+};
+var bilingualDescriptionForField = (fieldName) => {
+  const label = bilingualLabelForField(fieldName);
+  return {
+    en: `Enter ${label.en.toLowerCase()}.`,
+    ko: `${label.ko} \uAC12\uC744 \uC785\uB825\uD569\uB2C8\uB2E4.`
+  };
+};
+var normalizeFieldType = (typeName) => {
+  const normalizedTypes = {
+    string: "String",
+    boolean: "Boolean",
+    date: "Date",
+    int: "Int",
+    integer: "Int",
+    float: "Float",
+    double: "Float",
+    decimal: "Float"
+  };
+  return normalizedTypes[typeName.toLowerCase()] ?? typeName;
+};
+var ensureBaseTypeImport = (content, typeName) => {
+  if (typeName !== "Int" && typeName !== "Float")
+    return content;
+  if (new RegExp(`import \\{[^}]*\\b${typeName}\\b[^}]*\\} from "akanjs/base";`).test(content))
+    return content;
+  const baseImport = /import \{ ([^}]+) \} from "akanjs\/base";/.exec(content);
+  if (baseImport) {
+    const names = baseImport[1].split(",").map((name) => name.trim()).filter(Boolean);
+    return content.replace(baseImport[0], `import { ${[...names, typeName].sort().join(", ")} } from "akanjs/base";`);
+  }
+  return `import { ${typeName} } from "akanjs/base";
+${content}`;
+};
+var numericDefault = (typeName, rawDefault) => {
+  if (typeof rawDefault === "number") {
+    if (!Number.isFinite(rawDefault))
+      return null;
+    if (typeName === "Int" && !Number.isInteger(rawDefault))
+      return null;
+    return String(rawDefault);
+  }
+  if (typeof rawDefault !== "string")
+    return null;
+  const trimmed = rawDefault.trim();
+  if (!trimmed || !Number.isFinite(Number(trimmed)))
+    return null;
+  if (typeName === "Int" && !/^-?\d+$/.test(trimmed))
+    return null;
+  return trimmed;
+};
+var booleanDefault = (rawDefault) => {
+  if (typeof rawDefault === "boolean")
+    return String(rawDefault);
+  if (typeof rawDefault !== "string")
+    return null;
+  const lowered = rawDefault.trim().toLowerCase();
+  return lowered === "true" || lowered === "false" ? lowered : null;
+};
+var dateDefault = (rawDefault) => {
+  if (typeof rawDefault === "number" && Number.isFinite(rawDefault))
+    return `new Date(${rawDefault})`;
+  if (typeof rawDefault !== "string")
+    return null;
+  const trimmed = rawDefault.trim();
+  if (!trimmed)
+    return null;
+  if (trimmed === "now")
+    return "new Date()";
+  if (!Number.isNaN(Date.parse(trimmed)))
+    return `new Date(${JSON.stringify(trimmed)})`;
+  return null;
+};
+var coerceFieldDefault = (typeName, defaultValue, options = {}) => {
+  const normalizedType = typeName.toLowerCase() === "enum" ? "enum" : normalizeFieldType(typeName);
+  if (defaultValue === undefined || defaultValue === null || defaultValue === "") {
+    return { expression: null, normalized: false, normalizedType };
+  }
+  if (normalizedType === "Int" || normalizedType === "Float") {
+    const expression = numericDefault(normalizedType, defaultValue);
+    if (expression !== null)
+      return { expression, normalized: typeof defaultValue === "string", normalizedType };
+    return {
+      expression: null,
+      normalized: false,
+      normalizedType,
+      diagnostic: {
+        severity: "error",
+        code: "primitive-default-value-invalid",
+        input: "default",
+        failureScope: "source-change",
+        message: `Default value for ${normalizedType} must be a numeric literal. Received: ${JSON.stringify(defaultValue)}.`
+      }
+    };
+  }
+  if (normalizedType === "Boolean") {
+    const expression = booleanDefault(defaultValue);
+    if (expression !== null)
+      return { expression, normalized: typeof defaultValue === "string", normalizedType };
+    return {
+      expression: null,
+      normalized: false,
+      normalizedType,
+      diagnostic: {
+        severity: "error",
+        code: "primitive-default-value-invalid",
+        input: "default",
+        failureScope: "source-change",
+        message: `Default value for Boolean must be true or false. Received: ${JSON.stringify(defaultValue)}.`
+      }
+    };
+  }
+  if (normalizedType === "Date") {
+    const expression = dateDefault(defaultValue);
+    if (expression !== null)
+      return { expression, normalized: true, normalizedType };
+    return {
+      expression: null,
+      normalized: false,
+      normalizedType,
+      diagnostic: {
+        severity: "error",
+        code: "primitive-default-value-invalid",
+        input: "default",
+        failureScope: "source-change",
+        message: `Default value for Date must be "now", a timestamp, or a parseable date string. Received: ${JSON.stringify(defaultValue)}.`
+      }
+    };
+  }
+  if (normalizedType === "enum") {
+    if (typeof defaultValue === "string" && options.enumValues?.includes(defaultValue)) {
+      return { expression: JSON.stringify(defaultValue), normalized: false, normalizedType };
+    }
+    return {
+      expression: null,
+      normalized: false,
+      normalizedType,
+      diagnostic: {
+        severity: "error",
+        code: "primitive-default-value-invalid",
+        input: "default",
+        failureScope: "source-change",
+        message: `Default value for enum must be one of: ${(options.enumValues ?? []).join(", ")}. Received: ${JSON.stringify(defaultValue)}.`
+      }
+    };
+  }
+  return {
+    expression: JSON.stringify(String(defaultValue)),
+    normalized: typeof defaultValue !== "string",
+    normalizedType
+  };
+};
+var fieldExpression = (typeName, defaultValue, options = {}) => {
+  const typeExpression = normalizeFieldType(typeName);
+  const defaultExpression = coerceFieldDefault(options.enumValues ? "enum" : typeExpression, defaultValue, options).expression;
+  const defaultOption = defaultExpression ? `, { default: ${defaultExpression} }` : "";
+  return `field(${typeExpression}${defaultOption})`;
+};
+var insertIntoObject = (content, className, line) => {
+  const classIndex = content.indexOf(`export class ${className} extends via`);
+  if (classIndex < 0)
+    return null;
+  const objectEndIndex = content.indexOf("}))", classIndex);
+  if (objectEndIndex < 0)
+    return null;
+  const prefix = content.slice(0, objectEndIndex);
+  const suffix = content.slice(objectEndIndex);
+  const insertion = prefix.endsWith(`
+`) ? `  ${line}
+` : `
+  ${line}
+`;
+  return `${prefix}${insertion}${suffix}`;
+};
+var insertLightProjectionField = (content, moduleClassName, fieldName) => {
+  const classIndex = content.indexOf(`export class Light${moduleClassName} extends via`);
+  if (classIndex < 0)
+    return null;
+  const arrayMatch = /\[([\s\S]*?)\]\s+as const/.exec(content.slice(classIndex));
+  if (!arrayMatch || arrayMatch.index === undefined)
+    return null;
+  const arrayStart = classIndex + arrayMatch.index;
+  const arrayEnd = arrayStart + arrayMatch[0].length;
+  const fields = [...arrayMatch[1].matchAll(/"([^"]+)"/g)].map((match) => match[1]).filter(Boolean);
+  if (fields.includes(fieldName))
+    return content;
+  const nextFields = [...fields, fieldName];
+  const nextArray = nextFields.length === 0 ? "[] as const" : `[
+${nextFields.map((field) => `  ${JSON.stringify(field)},`).join(`
+`)}
+] as const`;
+  return `${content.slice(0, arrayStart)}${nextArray}${content.slice(arrayEnd)}`;
+};
+var insertTemplateField = ({
+  content,
+  moduleName,
+  moduleClassName,
+  fieldName,
+  component
+}) => {
+  if (content.includes(`l("${moduleName}.${fieldName}")`) || content.includes(`.${fieldName}`))
+    return content;
+  const layoutEndIndex = content.indexOf("    </Layout.Template>");
+  if (layoutEndIndex < 0)
+    return null;
+  const formName = `${moduleName}Form`;
+  if (!content.includes(`const ${formName} = st.use.${moduleName}Form();`))
+    return null;
+  const fieldSetter = `st.do.set${moduleComponentName(fieldName)}On${moduleClassName}`;
+  const fieldBlock = `      <${component}
+        label={l("${moduleName}.${fieldName}")}
+        desc={l("${moduleName}.${fieldName}.desc")}
+        value={${formName}.${fieldName}}
+        onChange={${fieldSetter}}
+      />
+`;
+  return `${content.slice(0, layoutEndIndex)}${fieldBlock}${content.slice(layoutEndIndex)}`;
+};
+var ensureEnumImport = (content) => {
+  if (content.includes("enumOf"))
+    return content;
+  const baseImport = /import \{ ([^}]+) \} from "akanjs\/base";/.exec(content);
+  if (baseImport) {
+    const names = baseImport[1]?.split(",").map((name) => name.trim()) ?? [];
+    return content.replace(baseImport[0], `import { ${[...names, "enumOf"].sort().join(", ")} } from "akanjs/base";`);
+  }
+  return `import { enumOf } from "akanjs/base";
+${content}`;
+};
+var insertEnumClass = (content, enumClassName, enumName, values) => {
+  if (content.includes(`export class ${enumClassName} extends enumOf`))
+    return content;
+  const enumClass = `export class ${enumClassName} extends enumOf("${enumName}", [
+${values.map((value) => `  ${JSON.stringify(value)},`).join(`
+`)}
+] as const) {}
+
+`;
+  const firstClassIndex = content.indexOf("export class ");
+  if (firstClassIndex < 0)
+    return `${content}
+${enumClass}`;
+  return `${content.slice(0, firstClassIndex)}${enumClass}${content.slice(firstClassIndex)}`;
+};
+var insertDictionaryModelField = (content, moduleClassName, fieldName) => {
+  if (new RegExp(`\\b${fieldName}\\s*:`).test(content))
+    return content;
+  const label = bilingualLabelForField(fieldName);
+  const desc = bilingualDescriptionForField(fieldName);
+  const modelIndex = content.indexOf(`.model<${moduleClassName}>((t) => ({`);
+  if (modelIndex < 0)
+    return null;
+  const objectEndIndex = content.indexOf("  }))", modelIndex);
+  if (objectEndIndex < 0)
+    return null;
+  return `${content.slice(0, objectEndIndex)}    ${fieldName}: t([${JSON.stringify(label.en)}, ${JSON.stringify(label.ko)}]).desc([${JSON.stringify(desc.en)}, ${JSON.stringify(desc.ko)}]),
+${content.slice(objectEndIndex)}`;
+};
+var ensureConstantTypeImport = (content, constantPath, typeName) => {
+  if (new RegExp(`import type \\{[^}]*\\b${typeName}\\b[^}]*\\} from "${constantPath}";`).test(content))
+    return content;
+  const importPattern = new RegExp(`import type \\{ ([^}]+) \\} from "${constantPath}";`);
+  const existingImport = content.match(importPattern);
+  if (existingImport !== null) {
+    const names = existingImport[1]?.split(",").map((name) => name.trim()) ?? [];
+    return content.replace(existingImport[0], `import type { ${[...names, typeName].sort().join(", ")} } from "${constantPath}";`);
+  }
+  return `import type { ${typeName} } from "${constantPath}";
+${content}`;
+};
+var insertDictionaryEnum = (content, enumClassName, enumName, values) => {
+  if (content.includes(`.enum<${enumClassName}>("${enumName}"`))
+    return content;
+  const enumBlock = `  .enum<${enumClassName}>("${enumName}", (t) => ({
+${values.map((value) => `    ${value}: t([${JSON.stringify(titleize(value))}, ${JSON.stringify(titleize(value))}]),`).join(`
+`)}
+  }))
+`;
+  const chainEndIndex = content.lastIndexOf(";");
+  const insertBeforeIndex = [content.indexOf(".error("), content.indexOf(".translate("), chainEndIndex].filter((index) => index >= 0).sort((a, b) => a - b)[0];
+  if (insertBeforeIndex === undefined)
+    return null;
+  return `${content.slice(0, insertBeforeIndex)}${enumBlock}${content.slice(insertBeforeIndex)}`;
+};
+var parseValues = (value) => value?.split(",").map((item) => item.trim()).filter(Boolean) ?? [];
+
+// pkgs/@akanjs/devkit/workflow/uiPolicy.ts
+var addFieldUiPolicyForType = (typeName) => {
+  const normalizedType = typeName.toLowerCase() === "enum" ? "enum" : normalizeFieldType(typeName);
+  if (normalizedType === "Int" || normalizedType === "Float") {
+    return {
+      normalizedType,
+      component: "Field.Number",
+      confidence: "high",
+      autoTemplateSupported: true
+    };
+  }
+  if (normalizedType === "Date") {
+    return {
+      normalizedType,
+      component: "Field.Date",
+      confidence: "high",
+      autoTemplateSupported: true
+    };
+  }
+  if (normalizedType === "Boolean" || normalizedType === "enum") {
+    return {
+      normalizedType,
+      component: "Field.ToggleSelect",
+      confidence: "medium",
+      autoTemplateSupported: false
+    };
+  }
+  if (normalizedType === "String") {
+    return {
+      normalizedType,
+      component: "Field.Text",
+      confidence: "high",
+      autoTemplateSupported: true
+    };
+  }
+  return {
+    normalizedType,
+    component: "Field.Text",
+    confidence: "low",
+    autoTemplateSupported: false
+  };
+};
+
+// pkgs/@akanjs/devkit/workflow/executor.ts
+var workflowStepKey = (workflow, stepId) => `${workflow}:${stepId}`;
+var primitiveReportToWorkflowStepResult = (report) => ({
+  changedFiles: report.changedFiles,
+  generatedFiles: report.generatedFiles,
+  commands: report.validationCommands,
+  diagnostics: report.diagnostics,
+  recommendations: [],
+  nextActions: report.nextActions
+});
+var workflowStringInput = (value) => typeof value === "string" ? value : null;
+var workflowStringListInput = (value) => Array.isArray(value) ? value.join(",") : null;
+var workflowStringArrayInput = (value) => Array.isArray(value) ? value : null;
+var workflowBooleanInput = (value) => typeof value === "boolean" ? value : null;
+var resolveWorkflowSys = async (workspace, target) => {
+  if (!target)
+    return null;
+  const [apps, libs] = await workspace.getSyss();
+  if (apps.includes(target))
+    return AppExecutor.from(workspace, target);
+  if (libs.includes(target))
+    return LibExecutor.from(workspace, target);
   return null;
 };
 var targetMissing = (input2 = "app") => ({
@@ -5220,19 +5548,24 @@ var unsupportedInput = (input2, message) => ({
   message
 });
 var addFieldUiSurfaceInspection = (plan) => {
+  const app = workflowStringInput(plan.inputs.app);
   const module = workflowStringInput(plan.inputs.module) ?? "<module>";
   const field = workflowStringInput(plan.inputs.field) ?? "<field>";
+  const typeName = workflowStringInput(plan.inputs.type);
+  const policy = addFieldUiPolicyForType(typeName ?? "String");
+  const surfaces = workflowStringArrayInput(plan.inputs.surfaces);
+  const templateRequested = surfaces?.includes("template") ?? false;
   const moduleClassName = capitalize2(module);
-  const target = `*/lib/${module}/${moduleClassName}.Template.tsx`;
+  const target = `${app ? `apps/${app}` : "*"}/${moduleSourcePaths(module).template}`;
   return {
     recommendations: [
       {
         code: "add-field-ui-surface-review",
         kind: "manual-action",
         target,
-        action: `Add ${field} to ${moduleClassName} UI surfaces only when the local Field.* pattern is clear.`,
+        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.`,
         confidence: "medium",
-        message: `Review Template/Unit/View/Store surfaces for ${module}.${field}; no UI file was modified automatically.`
+        message: `Review UI surfaces for ${module}.${field}; recommended component is ${policy.component}, with manual reasons and candidate positions in action.`
       }
     ],
     nextActions: [
@@ -5300,7 +5633,9 @@ var createWorkflowStepRegistry = ({
           module: workflowStringInput(plan.inputs.module),
           field: workflowStringInput(plan.inputs.field),
           values: workflowStringListInput(plan.inputs.values),
-          defaultValue: workflowStringInput(plan.inputs.default)
+          defaultValue: workflowStringInput(plan.inputs.default),
+          surfaces: workflowStringArrayInput(plan.inputs.surfaces),
+          includeInLight: workflowBooleanInput(plan.inputs.includeInLight)
         }));
       }
       return primitiveReportToWorkflowStepResult(await addField({
@@ -5308,7 +5643,9 @@ var createWorkflowStepRegistry = ({
         module: workflowStringInput(plan.inputs.module),
         field: workflowStringInput(plan.inputs.field),
         type: workflowStringInput(plan.inputs.type),
-        defaultValue: workflowStringInput(plan.inputs.default)
+        defaultValue: workflowStringInput(plan.inputs.default),
+        surfaces: workflowStringArrayInput(plan.inputs.surfaces),
+        includeInLight: workflowBooleanInput(plan.inputs.includeInLight)
       }));
     },
     [workflowStepKey("add-field", "update-dictionary")]: inspect,
@@ -5324,209 +5661,548 @@ var createWorkflowStepRegistry = ({
     [workflowStepKey("add-enum-field", "update-option")]: inspect
   };
 };
-var renderWorkflowApplyReport = (report) => [
-  `# Workflow Apply: ${report.workflow}`,
-  "",
-  `- Mode: ${report.mode}`,
-  `- Status: ${report.status}`,
+class WorkflowExecutor {
+  registry;
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async apply(plan) {
+    const changedFiles = [];
+    const generatedFiles = [];
+    const recommendedValidationCommands = [];
+    const diagnostics = [...plan.diagnostics];
+    const recommendations = [...plan.recommendations];
+    const nextActions = [];
+    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+      return createWorkflowApplyReport({
+        workflow: plan.workflow,
+        mode: "apply",
+        changedFiles,
+        generatedFiles,
+        recommendedValidationCommands,
+        diagnostics,
+        recommendations,
+        nextActions,
+        plan
+      });
+    }
+    recommendedValidationCommands.push(...workflowCommandsForPlan(plan));
+    nextActions.push(...workflowCommandsForPlan(plan));
+    for (const step of plan.steps) {
+      const runner = this.registry[workflowStepKey(plan.workflow, step.id)] ?? this.registry[step.tool] ?? this.registry[step.id];
+      if (!runner) {
+        diagnostics.push({
+          severity: "error",
+          code: "workflow-step-unsupported",
+          message: `Workflow ${plan.workflow} step "${step.id}" is not supported by workflow apply yet.`
+        });
+        nextActions.push({
+          command: `akan workflow explain ${plan.workflow}`,
+          reason: "Review the unsupported workflow step before retrying apply."
+        });
+        break;
+      }
+      const result = await runner(step, plan);
+      if (!result)
+        continue;
+      changedFiles.push(...result.changedFiles ?? []);
+      generatedFiles.push(...result.generatedFiles ?? []);
+      recommendedValidationCommands.push(...result.commands ?? []);
+      diagnostics.push(...result.diagnostics ?? []);
+      recommendations.push(...result.recommendations ?? []);
+      nextActions.push(...result.nextActions ?? []);
+      if (diagnostics.some((diagnostic) => diagnostic.severity === "error"))
+        break;
+    }
+    return createWorkflowApplyReport({
+      workflow: plan.workflow,
+      mode: "apply",
+      changedFiles,
+      generatedFiles,
+      recommendedValidationCommands,
+      diagnostics,
+      recommendations,
+      nextActions,
+      plan
+    });
+  }
+}
+// pkgs/@akanjs/devkit/workflow/plan.ts
+import { capitalize as capitalize3 } from "akanjs/common";
+var surfaceModes = new Set(["infer", "include", "skip"]);
+var parseStringList = (value) => {
+  if (Array.isArray(value)) {
+    const values = value.filter((item) => typeof item === "string" && item.trim().length > 0);
+    return values.length === value.length ? values : null;
+  }
+  if (typeof value !== "string")
+    return null;
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+};
+var normalizeInputValue = (name, spec, value) => {
+  if (spec.type === "string")
+    return typeof value === "string" && value.length > 0 ? value : null;
+  if (spec.type === "string-list") {
+    const values = parseStringList(value);
+    return values && values.length > 0 ? values : null;
+  }
+  if (spec.type === "boolean") {
+    if (typeof value === "boolean")
+      return value;
+    if (typeof value !== "string")
+      return null;
+    const lowered = value.trim().toLowerCase();
+    if (lowered === "true")
+      return true;
+    if (lowered === "false")
+      return false;
+    return null;
+  }
+  if (typeof value === "string" && surfaceModes.has(value))
+    return value;
+  throw new Error(`Unsupported workflow input value for ${name}`);
+};
+var listWorkflowSpecs = (specs) => [...specs].sort((a, b) => a.name.localeCompare(b.name));
+var getWorkflowSpec = (specs, name) => specs.find((spec) => spec.name === name) ?? null;
+var compactWorkflowInputs = (inputs) => Object.fromEntries(Object.entries(inputs).filter(([, value]) => value !== null && value !== ""));
+var addFieldTargetRoot = (app) => app ? `apps/${app}` : "*";
+var addFieldPaths = (inputs) => {
+  const app = typeof inputs.app === "string" ? inputs.app : null;
+  const module = typeof inputs.module === "string" ? inputs.module : "<module>";
+  const paths = moduleSourcePaths(module);
+  const root = addFieldTargetRoot(app);
+  return {
+    constant: `${root}/${paths.constant}`,
+    dictionary: `${root}/${paths.dictionary}`,
+    template: `${root}/${paths.template}`,
+    unit: `${root}/${paths.unit}`,
+    view: `${root}/${paths.view}`
+  };
+};
+var selectedAddFieldSurfaces = (inputs) => Array.isArray(inputs.surfaces) ? new Set(inputs.surfaces) : null;
+var addFieldDefaultCoercion = (inputs) => {
+  const typeName = typeof inputs.type === "string" ? inputs.type : null;
+  const defaultValue = typeof inputs.default === "string" ? inputs.default : null;
+  if (!typeName || defaultValue === null)
+    return null;
+  if (typeName.toLowerCase() === "number" || typeName.toLowerCase() === "numeric")
+    return null;
+  const enumValues = Array.isArray(inputs.values) ? inputs.values : null;
+  return coerceFieldDefault(typeName.toLowerCase() === "enum" ? "enum" : typeName, defaultValue, { enumValues });
+};
+var createAddFieldDefaultRecommendations = (inputs) => {
+  const field = typeof inputs.field === "string" ? inputs.field : "<field>";
+  const coercion = addFieldDefaultCoercion(inputs);
+  if (!coercion?.normalized || !coercion.expression)
+    return [];
+  return [
+    {
+      code: "add-field-default-normalized",
+      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."
+    }
+  ];
+};
+var createAddFieldRecommendations = (inputs) => {
+  const app = typeof inputs.app === "string" ? inputs.app : "<app-or-lib>";
+  const module = typeof inputs.module === "string" ? inputs.module : "<module>";
+  const field = typeof inputs.field === "string" ? inputs.field : "<field>";
+  const typeName = typeof inputs.type === "string" ? inputs.type : null;
+  if (!typeName)
+    return [];
+  const policy = addFieldUiPolicyForType(typeName);
+  const normalizedType = policy.normalizedType;
+  const paths = addFieldPaths(inputs);
+  const surfaces = selectedAddFieldSurfaces(inputs);
+  const templateRequested = surfaces?.has("template") ?? false;
+  const includeInLight = inputs.includeInLight === true;
+  return [
+    ...normalizedType === "Int" || normalizedType === "Float" ? [
+      {
+        code: "add-field-import",
+        kind: "import",
+        target: paths.constant,
+        confidence: "high",
+        message: `Import ${normalizedType} from "akanjs/base" before writing field(${normalizedType}).`
+      }
+    ] : [],
+    {
+      code: "add-field-placement-constant",
+      kind: "placement",
+      target: paths.constant,
+      confidence: "high",
+      message: `Insert ${field}: field(${normalizedType}) in ${capitalize3(module)}Input.`
+    },
+    {
+      code: "add-field-placement-dictionary",
+      kind: "placement",
+      target: paths.dictionary,
+      confidence: "high",
+      message: `Add dictionary labels for ${module}.${field}.`
+    },
+    {
+      code: "add-field-component",
+      kind: "ui-component",
+      target: paths.template,
+      confidence: policy.confidence,
+      action: templateRequested ? `apply_workflow will try to add ${policy.component} to Template when the existing Template has a safe generated field-list pattern.` : `Recommended component is ${policy.component}. Pass surfaces=["template"] when this field should be rendered in the Template form.`,
+      message: `Recommended UI component for ${field} (${normalizedType}): ${policy.component}.`
+    },
+    ...!surfaces ? [
+      {
+        code: "add-field-template-surface-choice",
+        kind: "manual-action",
+        target: paths.template,
+        action: `Choose whether to expose ${field} in Template by passing surfaces=["template"].`,
+        confidence: "medium",
+        message: `Template exposure for ${module}.${field} is not selected yet.`
+      }
+    ] : [],
+    ...!includeInLight ? [
+      {
+        code: "add-field-light-projection-choice",
+        kind: "manual-action",
+        target: paths.constant,
+        action: `Pass includeInLight=true when ${field} should appear in Light${capitalize3(module)} list/card projections.`,
+        confidence: "medium",
+        message: `Light projection exposure for ${module}.${field} is not selected yet.`
+      }
+    ] : [],
+    ...includeInLight ? [
+      {
+        code: "add-field-light-projection",
+        kind: "placement",
+        target: paths.constant,
+        confidence: "high",
+        message: `Add ${field} to Light${capitalize3(module)} projection fields.`
+      }
+    ] : [],
+    ...surfaces && !templateRequested ? [
+      {
+        code: "add-field-ui-surface-skip",
+        kind: "manual-action",
+        target: paths.template,
+        confidence: "medium",
+        message: `Template is not included in surfaces, so ${module}.${field} will not be auto-rendered there.`
+      }
+    ] : [],
+    {
+      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${capitalize3(module)} projection array for list data, and Unit/View card sections for display.`,
+      confidence: "medium",
+      message: "UI manual review includes the reason auto-edit may be skipped and candidate insertion positions."
+    },
+    ...createAddFieldDefaultRecommendations(inputs)
+  ];
+};
+var createWorkflowPlanPredictedChanges = (spec, inputs) => {
+  if (spec.name !== "add-field")
+    return spec.predictedChanges;
+  const paths = addFieldPaths(inputs);
+  const surfaces = selectedAddFieldSurfaces(inputs);
+  const includeInLight = inputs.includeInLight === true;
+  return [
+    {
+      target: paths.constant,
+      action: "modify",
+      applyScope: "auto",
+      reason: includeInLight ? "Field shape and Light projection are added." : "Field shape is added."
+    },
+    {
+      target: paths.dictionary,
+      action: "modify",
+      applyScope: "auto",
+      reason: "Field label is added."
+    },
+    ...!surfaces || surfaces.has("template") ? [
+      {
+        target: paths.template,
+        action: "modify",
+        applyScope: surfaces?.has("template") ? "auto" : "manual-review",
+        reason: surfaces?.has("template") ? "Template form is selected for safe-pattern auto insertion." : "Form surface may include the field."
+      }
+    ] : [],
+    {
+      target: `${addFieldTargetRoot(typeof inputs.app === "string" ? inputs.app : null)}/lib/cnst.ts`,
+      action: "sync",
+      applyScope: "generated-sync",
+      reason: "Generated constants may change after sync."
+    },
+    {
+      target: `${addFieldTargetRoot(typeof inputs.app === "string" ? inputs.app : null)}/lib/dict.ts`,
+      action: "sync",
+      applyScope: "generated-sync",
+      reason: "Generated dictionary barrel may change after sync."
+    }
+  ];
+};
+var createWorkflowPlanOptionalSurfaces = (spec, inputs) => {
+  const optionalSurfaces = spec.optionalSurfaces ?? {};
+  const surfaces = selectedAddFieldSurfaces(inputs);
+  if (spec.name !== "add-field" || !surfaces)
+    return optionalSurfaces;
+  return Object.fromEntries(Object.entries(optionalSurfaces).map(([surface, mode]) => [surface, surfaces.has(surface) ? "include" : mode]));
+};
+var createWorkflowPlanRecommendations = (spec, inputs) => [
+  {
+    code: "workflow-apply-first",
+    kind: "auto-apply",
+    confidence: "high",
+    action: "Call apply_workflow with the MCP planPath before editing source files directly.",
+    message: `Apply the ${spec.name} plan through apply_workflow when MCP returns planPath or next.tool=apply_workflow.`
+  },
+  {
+    code: "workflow-validate-apply-report",
+    kind: "validation",
+    confidence: "high",
+    action: "After apply_workflow, call run_validation with validationTarget when present; otherwise use applyReportPath.",
+    message: "Validate the apply report artifact so diagnostics and recommendations follow the actual apply result."
+  },
+  ...spec.name === "add-field" ? createAddFieldRecommendations(inputs) : []
+];
+var createWorkflowPlan = (spec, rawInputs) => {
+  const inputs = {};
+  const diagnostics = [];
+  for (const [name, inputSpec] of Object.entries(spec.inputs)) {
+    const rawValue = rawInputs[name];
+    if (rawValue === undefined || rawValue === null || rawValue === "") {
+      if (inputSpec.required) {
+        diagnostics.push({
+          severity: "error",
+          code: "workflow-input-missing",
+          input: name,
+          message: `Workflow ${spec.name} requires input "${name}".`
+        });
+      }
+      continue;
+    }
+    const value = normalizeInputValue(name, inputSpec, rawValue);
+    if (value === null) {
+      diagnostics.push({
+        severity: "error",
+        code: "workflow-input-invalid",
+        input: name,
+        message: `Workflow ${spec.name} input "${name}" must be ${inputSpec.type}.`
+      });
+      continue;
+    }
+    if (inputSpec.allowedValues && typeof value === "string" && !inputSpec.allowedValues.includes(value)) {
+      diagnostics.push({
+        severity: "error",
+        code: "workflow-input-not-allowed",
+        input: name,
+        message: `Workflow ${spec.name} input "${name}" must be one of: ${inputSpec.allowedValues.join(", ")}.`
+      });
+      continue;
+    }
+    inputs[name] = value;
+  }
+  const fieldType = inputs.type;
+  if (spec.name === "add-field" && typeof fieldType === "string" && (fieldType.toLowerCase() === "number" || fieldType.toLowerCase() === "numeric")) {
+    diagnostics.push({
+      severity: "error",
+      code: "primitive-field-type-unsupported",
+      input: "type",
+      message: `Field type "${fieldType}" is ambiguous in Akan. Use Int for integer fields or Float for decimal fields.`
+    });
+  }
+  if (spec.name === "add-field") {
+    const defaultCoercion = addFieldDefaultCoercion(inputs);
+    if (defaultCoercion?.diagnostic) {
+      diagnostics.push({
+        ...defaultCoercion.diagnostic,
+        code: "workflow-default-value-invalid",
+        message: `Plan input default is not valid for ${defaultCoercion.normalizedType}: ${defaultCoercion.diagnostic.message}`
+      });
+    } else if (defaultCoercion?.normalized && defaultCoercion.expression) {
+      diagnostics.push({
+        severity: "warning",
+        code: "workflow-default-value-normalized",
+        input: "default",
+        failureScope: "source-change",
+        message: `Plan input default will be written as ${defaultCoercion.normalizedType} literal ${defaultCoercion.expression}.`
+      });
+    }
+  }
+  return {
+    schemaVersion: 1,
+    workflow: spec.name,
+    mode: "plan",
+    inputs,
+    optionalSurfaces: createWorkflowPlanOptionalSurfaces(spec, inputs),
+    steps: spec.steps,
+    predictedChanges: createWorkflowPlanPredictedChanges(spec, inputs),
+    validation: spec.validation,
+    diagnostics,
+    recommendations: createWorkflowPlanRecommendations(spec, inputs),
+    requiresApproval: true
+  };
+};
+// pkgs/@akanjs/devkit/workflow/render.ts
+var renderWorkflowList = (specs) => [
+  "# Akan Workflows",
   "",
-  "## Changed Files",
-  ...report.changedFiles.length ? report.changedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
+  ...specs.flatMap((spec) => [`- \`${spec.name}\`: ${spec.description}`, `  - When: ${spec.whenToUse}`]),
+  ""
+].join(`
+`);
+var renderWorkflowExplain = (spec) => [
+  `# Workflow: ${spec.name}`,
   "",
-  "## Generated Files",
-  ...report.generatedFiles.length ? report.generatedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
+  spec.description,
   "",
-  "## Applied Commands",
-  ...report.appliedCommands.length ? report.appliedCommands.map((command) => `- \`${command.command}\`: ${command.reason}`) : ["- none"],
+  "## When To Use",
+  spec.whenToUse,
   "",
-  "## Recommended Validation Commands",
-  ...report.recommendedValidationCommands.length ? report.recommendedValidationCommands.map((command) => `- \`${command.command}\`: ${command.reason}`) : ["- none"],
+  "## Inputs",
+  ...Object.entries(spec.inputs).map(([name, input2]) => `- \`${name}\`${input2.required ? " (required)" : ""}: ${input2.description}${input2.allowedValues ? ` Allowed: ${input2.allowedValues.join(", ")}.` : ""}`),
   "",
-  "## Diagnostics",
-  ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+  "## Optional Surfaces",
+  ...Object.entries(spec.optionalSurfaces ?? {}).map(([name, mode]) => `- \`${name}\`: ${mode}`),
   "",
-  "## Recommendations",
-  ...report.recommendations.length ? report.recommendations.map((recommendation) => `- [${recommendation.kind}] ${recommendation.message}`) : ["- none"],
+  "## Steps",
+  ...spec.steps.map((step, index) => `${index + 1}. \`${step.id}\` (${step.tool}): ${step.description}`),
   "",
-  "## Next Actions",
-  ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+  "## Validation",
+  ...spec.validation.map((validation) => `- \`${validation.command}\`: ${validation.reason}`),
   ""
 ].join(`
 `);
-var renderWorkflowApply = (report, format = "markdown") => format === "json" ? jsonText(report) : renderWorkflowApplyReport(report);
-var renderWorkflowValidationRunReport = (report) => [
-  `# Workflow Validation: ${report.workflow}`,
+var renderWorkflowPlan = (plan) => [
+  `# Workflow Plan: ${plan.workflow}`,
   "",
-  `- Run: ${report.runId}`,
-  `- Status: ${report.status}`,
+  `- Mode: ${plan.mode}`,
+  `- Requires approval: ${plan.requiresApproval}`,
   "",
-  "## Commands",
-  ...report.commands.length ? report.commands.map((command) => {
-    const scope = command.failureScope ? ` (${command.failureScope})` : "";
-    return `- [${command.status}] \`${command.command}\`${scope}: ${command.reason}`;
-  }) : ["- none"],
+  "## Inputs",
+  ...Object.entries(plan.inputs).map(([name, value]) => `- \`${name}\`: ${Array.isArray(value) ? value.join(", ") : value}`),
   "",
-  "## Diagnostics",
-  ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+  "## Optional Surfaces",
+  ...Object.entries(plan.optionalSurfaces).map(([name, mode]) => `- \`${name}\`: ${mode}`),
   "",
-  "## Repair Actions",
-  ...report.repairActions.length ? report.repairActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+  "## Steps",
+  ...plan.steps.map((step, index) => `${index + 1}. \`${step.id}\` (${step.tool}): ${step.description}`),
   "",
-  "## Next Actions",
-  ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+  "## Predicted Changes",
+  ...plan.predictedChanges.map((change) => {
+    const scope = change.applyScope ? ` (${change.applyScope})` : "";
+    return `- \`${change.action}\`${scope} ${change.target}: ${change.reason}`;
+  }),
+  "",
+  "## Validation",
+  ...plan.validation.map((validation) => `- \`${validation.command}\`: ${validation.reason}`),
+  "",
+  "## Diagnostics",
+  ...plan.diagnostics.length ? plan.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+  "",
+  "## Recommendations",
+  ...plan.recommendations.length ? plan.recommendations.map((recommendation) => `- [${recommendation.kind}] ${recommendation.message}`) : ["- none"],
   ""
 ].join(`
 `);
-var renderWorkflowValidation = (report, format = "markdown") => format === "json" ? jsonText(report) : renderWorkflowValidationRunReport(report);
-var renderWorkflowRunArtifact = (artifact, format = "markdown") => {
-  if ("kind" in artifact)
-    return renderRepairReport(artifact, format);
-  if ("mode" in artifact && artifact.mode === "validate")
-    return renderWorkflowValidation(artifact, format);
-  if ("mode" in artifact && (artifact.mode === "apply" || artifact.mode === "dry-run")) {
-    return renderWorkflowApply(artifact, format);
-  }
-  return jsonText(artifact);
+var renderRecommendation = (recommendation) => {
+  const target = recommendation.target ? ` ${recommendation.target}` : "";
+  const action = recommendation.action ? ` Action: ${recommendation.action}` : "";
+  return `- [${recommendation.kind}]${target} ${recommendation.message}${action}`;
 };
-var createRepairReport = ({
-  command,
-  kind,
-  target = null,
-  diagnostics = [],
-  repairActions = [],
-  nextActions = [],
-  commands = [],
-  generatedFiles = [],
-  syncedAt
-}) => ({
-  schemaVersion: 1,
-  command,
-  kind,
-  target,
-  status: workflowStatus(diagnostics) === "failed" || commandStatus(commands) === "failed" ? "failed" : "passed",
-  diagnostics,
-  repairActions: uniqueBy(repairActions, (action) => action.command),
-  nextActions: uniqueBy(nextActions, (action) => action.command),
-  commands,
-  generatedFiles,
-  ...syncedAt ? { syncedAt } : {}
-});
-var renderRepairReportMarkdown = (report) => [
-  `# Akan Repair: ${report.kind}`,
+var renderDiagnostic = (diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`;
+var renderWorkflowApplyReport = (report) => {
+  const manualReviewItems = [
+    ...report.diagnostics.filter((diagnostic) => diagnostic.severity === "warning").map(renderDiagnostic),
+    ...report.recommendations.filter((recommendation) => recommendation.kind === "manual-action").map(renderRecommendation)
+  ];
+  const validationBlockers = report.diagnostics.filter((diagnostic) => diagnostic.severity === "error" && (diagnostic.failureScope === "workspace-config" || diagnostic.failureScope === "environment")).map(renderDiagnostic);
+  return [
+    `# Workflow Apply: ${report.workflow}`,
+    "",
+    `- Mode: ${report.mode}`,
+    `- Status: ${report.status}`,
+    ...report.validationTarget ? [`- Validation target: ${report.validationTarget}`] : [],
+    "",
+    "## Automatically Modified",
+    ...report.changedFiles.length ? report.changedFiles.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"],
+    "",
+    "## Applied Commands",
+    ...report.appliedCommands.length ? report.appliedCommands.map((command) => `- \`${command.command}\`: ${command.reason}`) : ["- none"],
+    "",
+    "## Recommended Validation Commands",
+    ...report.recommendedValidationCommands.length ? report.recommendedValidationCommands.map((command) => `- \`${command.command}\`: ${command.reason}`) : ["- none"],
+    "",
+    "## User Review Required",
+    ...manualReviewItems.length ? manualReviewItems : ["- none"],
+    "",
+    "## Validation Blockers",
+    ...validationBlockers.length ? validationBlockers : report.recommendedValidationCommands.length ? ["- none detected during apply; run validation with the validation target for command-level blockers."] : ["- none"],
+    "",
+    "## Diagnostics",
+    ...report.diagnostics.length ? report.diagnostics.map(renderDiagnostic) : ["- none"],
+    "",
+    "## Recommendations",
+    ...report.recommendations.length ? report.recommendations.map(renderRecommendation) : ["- none"],
+    "",
+    "## Next Actions",
+    ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+    ""
+  ].join(`
+`);
+};
+var renderWorkflowApply = (report, format = "markdown") => format === "json" ? jsonText(report) : renderWorkflowApplyReport(report);
+var renderWorkflowValidationRunReport = (report) => [
+  `# Workflow Validation: ${report.workflow}`,
   "",
+  `- Run: ${report.runId}`,
   `- Status: ${report.status}`,
-  `- Target: ${report.target ?? "none"}`,
+  `- Source status: ${report.sourceStatus}`,
+  `- Workspace status: ${report.workspaceStatus}`,
+  `- Overall status: ${report.overallStatus}`,
   "",
-  "## Commands",
-  ...report.commands.length ? report.commands.map((command) => `- [${command.status}] \`${command.command}\`: ${command.reason}`) : ["- none"],
+  "## Status Summary",
+  `- Required source-change validation: ${report.summary.sourceChange}`,
+  `- Generated sync validation: ${report.summary.generatedSync}`,
+  `- Workspace configuration validation: ${report.summary.workspaceConfig}`,
+  `- Environment validation: ${report.summary.environment}`,
   "",
-  "## Diagnostics",
-  ...report.diagnostics.length ? report.diagnostics.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"],
   "",
-  "## Next Actions",
-  ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
-  ""
-].join(`
-`);
-var renderRepairReport = (report, format = "markdown") => format === "json" ? jsonText(report) : renderRepairReportMarkdown(report);
-
-class WorkflowExecutor {
-  registry;
-  constructor(registry) {
-    this.registry = registry;
-  }
-  async apply(plan) {
-    const changedFiles = [];
-    const generatedFiles = [];
-    const recommendedValidationCommands = [];
-    const diagnostics = [...plan.diagnostics];
-    const recommendations = [...plan.recommendations];
-    const nextActions = [];
-    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-      return createWorkflowApplyReport({
-        workflow: plan.workflow,
-        mode: "apply",
-        changedFiles,
-        generatedFiles,
-        recommendedValidationCommands,
-        diagnostics,
-        recommendations,
-        nextActions,
-        plan
-      });
-    }
-    recommendedValidationCommands.push(...workflowCommandsForPlan(plan));
-    nextActions.push(...workflowCommandsForPlan(plan));
-    for (const step of plan.steps) {
-      const runner = this.registry[workflowStepKey(plan.workflow, step.id)] ?? this.registry[step.tool] ?? this.registry[step.id];
-      if (!runner) {
-        diagnostics.push({
-          severity: "error",
-          code: "workflow-step-unsupported",
-          message: `Workflow ${plan.workflow} step "${step.id}" is not supported by workflow apply yet.`
-        });
-        nextActions.push({
-          command: `akan workflow explain ${plan.workflow}`,
-          reason: "Review the unsupported workflow step before retrying apply."
-        });
-        break;
-      }
-      const result = await runner(step, plan);
-      if (!result)
-        continue;
-      changedFiles.push(...result.changedFiles ?? []);
-      generatedFiles.push(...result.generatedFiles ?? []);
-      recommendedValidationCommands.push(...result.commands ?? []);
-      diagnostics.push(...result.diagnostics ?? []);
-      recommendations.push(...result.recommendations ?? []);
-      nextActions.push(...result.nextActions ?? []);
-      if (diagnostics.some((diagnostic) => diagnostic.severity === "error"))
-        break;
-    }
-    return createWorkflowApplyReport({
-      workflow: plan.workflow,
-      mode: "apply",
-      changedFiles,
-      generatedFiles,
-      recommendedValidationCommands,
-      diagnostics,
-      recommendations,
-      nextActions,
-      plan
-    });
-  }
-}
-var createPrimitiveWriteReport = ({
-  command,
-  status,
-  changedFiles = [],
-  generatedFiles = [],
-  validationCommands = [],
-  diagnostics = [],
-  nextActions = []
-}) => ({
-  schemaVersion: 1,
-  command,
-  status: status ?? (diagnostics.some((diagnostic) => diagnostic.severity === "error") ? "failed" : "passed"),
-  changedFiles,
-  generatedFiles,
-  validationCommands,
-  diagnostics,
-  nextActions
-});
-var renderPrimitiveWriteReport = (report) => [
-  `# Primitive Write: ${report.command}`,
+  "## Commands",
+  ...report.commands.length ? report.commands.map((command) => {
+    const scope = command.failureScope ? ` (${command.failureScope})` : "";
+    return `- [${command.status}] \`${command.command}\`${scope}: ${command.reason}`;
+  }) : ["- none"],
   "",
-  `- Status: ${report.status}`,
+  "## Diagnostics",
+  ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
   "",
-  "## Changed Files",
-  ...report.changedFiles.length ? report.changedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
+  "## Repair Actions",
+  ...report.repairActions.length ? report.repairActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
   "",
-  "## Generated Files",
-  ...report.generatedFiles.length ? report.generatedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.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}`,
   "",
-  "## Validation Commands",
-  ...report.validationCommands.length ? report.validationCommands.map((validation) => `- \`${validation.command}\`: ${validation.reason}`) : ["- none"],
+  `- Status: ${report.status}`,
+  `- Target: ${report.target ?? "none"}`,
+  "",
+  "## Commands",
+  ...report.commands.length ? report.commands.map((command) => `- [${command.status}] \`${command.command}\`: ${command.reason}`) : ["- none"],
   "",
   "## Diagnostics",
   ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
@@ -5536,154 +6212,17 @@ var renderPrimitiveWriteReport = (report) => [
   ""
 ].join(`
 `);
-var renderPrimitiveReport = (report, format = "markdown") => format === "json" ? jsonText(report) : renderPrimitiveWriteReport(report);
-var getSysRoot = (sys2) => `${sys2.type}s/${sys2.name}`;
-var sourceFile = (sys2, path10, action, reason) => ({
-  path: `${getSysRoot(sys2)}/${path10}`,
-  action,
-  reason
-});
-var generatedFilesForSync = (sys2, reason = "Generated files may change after sync.") => generatedFilePathsForTarget(getSysRoot(sys2), reason);
-var validationCommandsForTarget = (target) => [
-  { command: `akan sync ${target}`, reason: "Refresh generated Akan files from source conventions." },
-  { command: `akan lint ${target}`, reason: "Validate formatting, imports, and static lint rules." }
-];
-var nextActionsForTarget = (target) => [
-  { command: `akan sync ${target}`, reason: "Refresh generated Akan files after source changes." },
-  { command: `akan lint ${target}`, reason: "Validate the target after generated files are refreshed." }
-];
-var createPassedPrimitiveReport = ({
-  command,
-  changedFiles,
-  generatedFiles,
-  target,
-  nextActions
-}) => createPrimitiveWriteReport({
-  command,
-  changedFiles,
-  generatedFiles: generatedFiles ?? [],
-  validationCommands: validationCommandsForTarget(target),
-  diagnostics: [],
-  nextActions: nextActions ?? nextActionsForTarget(target)
-});
-var scalarChangedFiles = (sys2, scalarName, files) => Object.values(files).map((file) => sourceFile(sys2, `lib/__scalar/${scalarName}/${file.filename}`, "create", "Scalar source file was created."));
-var titleize = (value) => value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
-var lowerlize = (value) => `${value.slice(0, 1).toLowerCase()}${value.slice(1)}`;
-var compactDiagnostics = (diagnostics) => diagnostics.filter((diagnostic) => !!diagnostic);
-var normalizeFieldType = (typeName) => {
-  const normalizedTypes = {
-    string: "String",
-    boolean: "Boolean",
-    date: "Date",
-    int: "Int",
-    integer: "Int",
-    float: "Float",
-    double: "Float",
-    decimal: "Float"
-  };
-  return normalizedTypes[typeName.toLowerCase()] ?? typeName;
-};
-var ensureBaseTypeImport = (content, typeName) => {
-  if (typeName !== "Int" && typeName !== "Float")
-    return content;
-  if (new RegExp(`import \\{[^}]*\\b${typeName}\\b[^}]*\\} from "akanjs/base";`).test(content))
-    return content;
-  const baseImport = /import \{ ([^}]+) \} from "akanjs\/base";/.exec(content);
-  if (baseImport) {
-    const names = baseImport[1].split(",").map((name) => name.trim()).filter(Boolean);
-    return content.replace(baseImport[0], `import { ${[...names, typeName].sort().join(", ")} } from "akanjs/base";`);
-  }
-  return `import { ${typeName} } from "akanjs/base";
-${content}`;
-};
-var fieldExpression = (typeName, defaultValue) => {
-  const typeExpression = normalizeFieldType(typeName);
-  const defaultOption = defaultValue ? `, { default: ${JSON.stringify(defaultValue)} }` : "";
-  return `field(${typeExpression}${defaultOption})`;
-};
-var insertIntoObject = (content, className, line) => {
-  const classIndex = content.indexOf(`export class ${className} extends via`);
-  if (classIndex < 0)
-    return null;
-  const objectEndIndex = content.indexOf("}))", classIndex);
-  if (objectEndIndex < 0)
-    return null;
-  const prefix = content.slice(0, objectEndIndex);
-  const suffix = content.slice(objectEndIndex);
-  const insertion = prefix.endsWith(`
-`) ? `  ${line}
-` : `
-  ${line}
-`;
-  return `${prefix}${insertion}${suffix}`;
-};
-var ensureEnumImport = (content) => {
-  if (content.includes("enumOf"))
-    return content;
-  const baseImport = /import \{ ([^}]+) \} from "akanjs\/base";/.exec(content);
-  if (baseImport) {
-    const names = baseImport[1]?.split(",").map((name) => name.trim()) ?? [];
-    return content.replace(baseImport[0], `import { ${[...names, "enumOf"].sort().join(", ")} } from "akanjs/base";`);
-  }
-  return `import { enumOf } from "akanjs/base";
-${content}`;
-};
-var insertEnumClass = (content, enumClassName, enumName, values) => {
-  if (content.includes(`export class ${enumClassName} extends enumOf`))
-    return content;
-  const enumClass = `export class ${enumClassName} extends enumOf("${enumName}", [
-${values.map((value) => `  ${JSON.stringify(value)},`).join(`
-`)}
-] as const) {}
-
-`;
-  const firstClassIndex = content.indexOf("export class ");
-  if (firstClassIndex < 0)
-    return `${content}
-${enumClass}`;
-  return `${content.slice(0, firstClassIndex)}${enumClass}${content.slice(firstClassIndex)}`;
-};
-var insertDictionaryModelField = (content, moduleClassName, fieldName) => {
-  if (new RegExp(`\\b${fieldName}\\s*:`).test(content))
-    return content;
-  const label = titleize(fieldName);
-  const modelIndex = content.indexOf(`.model<${moduleClassName}>((t) => ({`);
-  if (modelIndex < 0)
-    return null;
-  const objectEndIndex = content.indexOf("  }))", modelIndex);
-  if (objectEndIndex < 0)
-    return null;
-  return `${content.slice(0, objectEndIndex)}    ${fieldName}: t([${JSON.stringify(label)}, ${JSON.stringify(label)}]).desc([${JSON.stringify(label)}, ${JSON.stringify(label)}]),
-${content.slice(objectEndIndex)}`;
-};
-var ensureConstantTypeImport = (content, constantPath, typeName) => {
-  if (new RegExp(`import type \\{[^}]*\\b${typeName}\\b[^}]*\\} from "${constantPath}";`).test(content))
-    return content;
-  const importPattern = new RegExp(`import type \\{ ([^}]+) \\} from "${constantPath}";`);
-  const existingImport = content.match(importPattern);
-  if (existingImport !== null) {
-    const names = existingImport[1]?.split(",").map((name) => name.trim()) ?? [];
-    return content.replace(existingImport[0], `import type { ${[...names, typeName].sort().join(", ")} } from "${constantPath}";`);
+var renderRepairReport = (report, format = "markdown") => format === "json" ? jsonText(report) : renderRepairReportMarkdown(report);
+var renderWorkflowRunArtifact = (artifact, format = "markdown") => {
+  if ("kind" in artifact)
+    return renderRepairReport(artifact, format);
+  if ("mode" in artifact && artifact.mode === "validate")
+    return renderWorkflowValidation(artifact, format);
+  if ("mode" in artifact && (artifact.mode === "apply" || artifact.mode === "dry-run")) {
+    return renderWorkflowApply(artifact, format);
   }
-  return `import type { ${typeName} } from "${constantPath}";
-${content}`;
-};
-var insertDictionaryEnum = (content, enumClassName, enumName, values) => {
-  if (content.includes(`.enum<${enumClassName}>("${enumName}"`))
-    return content;
-  const enumBlock = `  .enum<${enumClassName}>("${enumName}", (t) => ({
-${values.map((value) => `    ${value}: t([${JSON.stringify(titleize(value))}, ${JSON.stringify(titleize(value))}]),`).join(`
-`)}
-  }))
-`;
-  const chainEndIndex = content.lastIndexOf(";");
-  const insertBeforeIndex = [content.indexOf(".error("), content.indexOf(".translate("), chainEndIndex].filter((index) => index >= 0).sort((a, b) => a - b)[0];
-  if (insertBeforeIndex === undefined)
-    return null;
-  return `${content.slice(0, insertBeforeIndex)}${enumBlock}${content.slice(insertBeforeIndex)}`;
+  return jsonText(artifact);
 };
-var parseValues = (value) => value?.split(",").map((item) => item.trim()).filter(Boolean) ?? [];
-
 // pkgs/@akanjs/devkit/akanContext.ts
 var resourceList = [
   { uri: "akan://docs/framework", name: "Akan framework guide", mimeType: "text/markdown" },
@@ -5819,17 +6358,17 @@ var safeReadJson = async (filePath) => {
 var isWorkflowPlan = (value) => typeof value === "object" && value !== null && ("schemaVersion" in value) && value.schemaVersion === 1 && ("mode" in value) && value.mode === "plan";
 var isWorkflowApplyReport = (value) => typeof value === "object" && value !== null && ("schemaVersion" in value) && value.schemaVersion === 1 && ("mode" in value) && (value.mode === "apply" || value.mode === "dry-run");
 var isWorkflowRunArtifact = (value) => typeof value === "object" && value !== null && ("schemaVersion" in value) && value.schemaVersion === 1;
-var planInputString = (plan, key) => {
-  const value = plan.inputs[key];
+var planInputString = (plan2, key) => {
+  const value = plan2.inputs[key];
   return typeof value === "string" ? value : "";
 };
-var expandWorkflowTarget = (target, plan) => {
-  const app = planInputString(plan, "app");
-  const module = planInputString(plan, "module");
-  const moduleClass = module ? capitalize3(module) : "<Module>";
+var expandWorkflowTarget = (target, plan2) => {
+  const app = planInputString(plan2, "app");
+  const module = planInputString(plan2, "module");
+  const moduleClass = module ? capitalize4(module) : "<Module>";
   return target.replace(/^\*\//, app ? `apps/${app}/` : "").replaceAll("<module>", module || "<module>").replaceAll("<Module>", moduleClass);
 };
-var workflowPathsForPlan = (plan) => plan.predictedChanges.map((change) => expandWorkflowTarget(change.target, plan));
+var workflowPathsForPlan = (plan2) => plan2.predictedChanges.map((change) => expandWorkflowTarget(change.target, plan2));
 var workflowPathsForArtifact = (artifact) => {
   if (isWorkflowPlan(artifact))
     return workflowPathsForPlan(artifact);
@@ -6044,7 +6583,7 @@ class AkanContextAnalyzer {
             severity: strict ? "error" : "warning",
             code: "module-abstract-missing",
             path: module.abstract.path,
-            message: `${capitalize3(module.kind)} module ${sys2.name}:${module.name} should include ${module.abstract.path}`,
+            message: `${capitalize4(module.kind)} module ${sys2.name}:${module.name} should include ${module.abstract.path}`,
             repairActions: [action]
           });
           repairActions.push(action);
@@ -6056,7 +6595,7 @@ class AkanContextAnalyzer {
             severity: "error",
             code: "module-shape-invalid",
             path: module.path,
-            message: `${capitalize3(module.kind)} module ${sys2.name}:${module.name} is missing required files: ${missingFiles.join(", ")}`,
+            message: `${capitalize4(module.kind)} module ${sys2.name}:${module.name} is missing required files: ${missingFiles.join(", ")}`,
             repairActions: [action]
           });
           repairActions.push(action);
@@ -6107,8 +6646,8 @@ class AkanContextAnalyzer {
       ...workflowPaths.length ? { baselineDiagnostics, workflowDiagnostics } : {}
     };
   }
-  static findModules(context, moduleName) {
-    const modules = [...context.apps, ...context.libs].flatMap((sys2) => sys2.modules);
+  static findModules(context, moduleName, { app = null } = {}) {
+    const modules = [...context.apps, ...context.libs].filter((sys2) => !app || sys2.name === app).flatMap((sys2) => sys2.modules);
     return moduleName ? modules.filter((module) => module.name === moduleName || module.folderName === moduleName) : modules;
   }
   static renderMarkdown(context, { module: moduleName } = {}) {
@@ -6298,7 +6837,7 @@ void st;
 ` : `const UserLayout = ({ children }) => children;
 const userLayout = {};
 `;
-  const source = opts.includeSystemProvider ? `import type { LayoutProps, PageProps } from "akanjs/client";
+  const source2 = opts.includeSystemProvider ? `import type { LayoutProps, PageProps } from "akanjs/client";
 import { loadFonts } from "akanjs/client";
 import { System } from "akanjs/ui";
 import { env } from "@apps/${opts.appName}/env/env.client";
@@ -6374,7 +6913,7 @@ export default function GeneratedLayout({ children, params, searchParams }: Layo
   return <UserLayout params={params} searchParams={searchParams}>{children}</UserLayout>;
 }
 `;
-  await Bun.write(absPath, source);
+  await Bun.write(absPath, source2);
   return absPath;
 }
 async function resolveSsrPageEntries(opts) {
@@ -6531,23 +7070,23 @@ class BarrelAnalyzer {
     if (visited.has(absFile))
       return;
     visited.add(absFile);
-    const source = await readIfExists(absFile);
-    if (source === null)
+    const source2 = await readIfExists(absFile);
+    if (source2 === null)
       return;
     const currentSubpath = this.#subpathFor(pkg, absFile);
     if (!currentSubpath)
       return;
-    const authoritative = this.#scanExports(source, absFile);
+    const authoritative = this.#scanExports(source2, absFile);
     authoritative.delete("default");
     const attributed = new Set;
     REEXPORT_RE.lastIndex = 0;
-    let m = REEXPORT_RE.exec(source);
+    let m = REEXPORT_RE.exec(source2);
     while (m !== null) {
       const star = m[1];
       const nsAs = m[2];
       const namedList = m[3];
       const spec = m[5] ?? "";
-      m = REEXPORT_RE.exec(source);
+      m = REEXPORT_RE.exec(source2);
       if (!isRelative(spec))
         continue;
       if (star) {
@@ -6583,10 +7122,10 @@ class BarrelAnalyzer {
       }
     }
     LOCAL_NAMED_RE.lastIndex = 0;
-    let n = LOCAL_NAMED_RE.exec(source);
+    let n = LOCAL_NAMED_RE.exec(source2);
     while (n !== null) {
       const body = n[1] ?? "";
-      n = LOCAL_NAMED_RE.exec(source);
+      n = LOCAL_NAMED_RE.exec(source2);
       for (const item of parseNamedList(body)) {
         if (item.isType)
           continue;
@@ -6608,10 +7147,10 @@ class BarrelAnalyzer {
       map.set(name, { subpath: currentSubpath, originalName: name });
     }
   }
-  #scanExports(source, absFile) {
+  #scanExports(source2, absFile) {
     try {
       const transpiler = [".tsx", ".jsx"].includes(path13.extname(absFile)) ? this.#tsxTranspiler : this.#tsTranspiler;
-      const { exports } = transpiler.scan(source);
+      const { exports } = transpiler.scan(source2);
       return new Set(exports);
     } catch (err) {
       this.#logger.error(`scan failed: ${err.message}`);
@@ -6723,28 +7262,28 @@ var createBarrelImportsPlugin = async (app, { skipPath = defaultSkipPath, pipeAf
           const raw = await Bun.file(realPath).text();
           return { contents: raw, loader };
         }
-        let source = await Bun.file(realPath).text();
-        const hasMacroAttr = MACRO_ATTR_RE.test(source);
+        let source2 = await Bun.file(realPath).text();
+        const hasMacroAttr = MACRO_ATTR_RE.test(source2);
         if (!hasMacroAttr && barrels.length > 0) {
           let maybe = false;
           for (const b of barrels) {
-            if (source.includes(b)) {
+            if (source2.includes(b)) {
               maybe = true;
               break;
             }
           }
           if (maybe) {
-            const rewritten = await rewriteBarrelImports(source, barrels, analyzer);
+            const rewritten = await rewriteBarrelImports(source2, barrels, analyzer);
             if (rewritten !== null)
-              source = rewritten;
+              source2 = rewritten;
           }
         }
         if (pipeAfter) {
-          const piped = await pipeAfter(source, { path: realPath });
+          const piped = await pipeAfter(source2, { path: realPath });
           if (piped !== null)
-            source = piped;
+            source2 = piped;
         }
-        return { contents: source, loader };
+        return { contents: source2, loader };
       });
     }
   };
@@ -6920,12 +7459,12 @@ var resolveFileCandidate = async (candidate) => {
   return null;
 };
 var MACRO_ATTR_RE = /with\s*\{\s*type\s*:\s*["']macro["']\s*\}/;
-var rewriteBarrelImports = async (source, barrels, analyzer) => {
-  const statements = findImportStatements(source);
+var rewriteBarrelImports = async (source2, barrels, analyzer) => {
+  const statements = findImportStatements(source2);
   if (statements.length === 0)
     return null;
   let changed = false;
-  let out = source;
+  let out = source2;
   for (let i = statements.length - 1;i >= 0; i--) {
     const stmt = statements[i];
     if (!stmt)
@@ -6943,9 +7482,9 @@ var rewriteBarrelImports = async (source, barrels, analyzer) => {
   }
   return changed ? out : null;
 };
-var findImportStatements = (source) => {
+var findImportStatements = (source2) => {
   const statements = [];
-  const sourceFile2 = ts4.createSourceFile("barrel-imports.tsx", source, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TSX);
+  const sourceFile2 = ts4.createSourceFile("barrel-imports.tsx", source2, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TSX);
   for (const statement of sourceFile2.statements) {
     if (!ts4.isImportDeclaration(statement))
       continue;
@@ -6959,10 +7498,10 @@ var findImportStatements = (source) => {
     statements.push({
       start: statementStart,
       end: statementEnd,
-      clause: source.slice(importClause.getStart(sourceFile2), importClause.end).trim(),
+      clause: source2.slice(importClause.getStart(sourceFile2), importClause.end).trim(),
       specifier: statement.moduleSpecifier.text,
-      trailingSemicolon: source.slice(statement.moduleSpecifier.end, statement.end).includes(";"),
-      raw: source.slice(statementStart, statementEnd)
+      trailingSemicolon: source2.slice(statement.moduleSpecifier.end, statement.end).includes(";"),
+      raw: source2.slice(statementStart, statementEnd)
     });
   }
   return statements;
@@ -7212,13 +7751,13 @@ class GraphClientEntryDiscovery {
     }
     return cached;
   }
-  async#getImports(file, source) {
+  async#getImports(file, source2) {
     const absPath = path15.resolve(file);
     let cached = this.#importCache.get(absPath);
     if (!cached) {
       cached = Promise.resolve().then(() => {
         try {
-          return this.#tsTranspiler.scanImports(source);
+          return this.#tsTranspiler.scanImports(source2);
         } catch {
           return [];
         }
@@ -7243,8 +7782,8 @@ class GraphClientEntryDiscovery {
       entries.add(absPath);
       return this.#finishDiscovery(absPath, visiting, entries);
     }
-    const source = await this.#getRewrittenSource(absPath, content);
-    const imports = await this.#getImports(absPath, source);
+    const source2 = await this.#getRewrittenSource(absPath, content);
+    const imports = await this.#getImports(absPath, source2);
     const importerDir = path15.dirname(absPath);
     for (const imp of imports) {
       const spec = imp.path;
@@ -7280,13 +7819,13 @@ var IMPLICIT_ROOT_LAYOUT_RE = /[/\\]\.akan[/\\]generated[/\\](?:implicit-root-la
 function toClientReferencePath(absPath, workspaceRoot) {
   return path16.relative(path16.resolve(workspaceRoot), path16.resolve(absPath)).split(path16.sep).join("/");
 }
-function transformUseClient(source, args) {
-  if (!USE_CLIENT_RE2.test(source))
+function transformUseClient(source2, args) {
+  if (!USE_CLIENT_RE2.test(source2))
     return null;
   if (IMPLICIT_ROOT_LAYOUT_RE.test(args.path))
     return null;
   const transpiler = new Bun.Transpiler({ loader: loaderFor2(args.path) });
-  const { exports } = transpiler.scan(source);
+  const { exports } = transpiler.scan(source2);
   if (exports.length === 0)
     return null;
   const referencePath = args.workspaceRoot ? toClientReferencePath(args.path, args.workspaceRoot) : args.path;
@@ -7432,9 +7971,9 @@ ${absEntry}`).toString(36);
 `;
   }
   async#scanEntryExportNames(absEntry) {
-    const source = await Bun.file(absEntry).text();
+    const source2 = await Bun.file(absEntry).text();
     const transpiler = new Bun.Transpiler({ loader: this.#loaderForEntry(absEntry) });
-    return transpiler.scan(source).exports;
+    return transpiler.scan(source2).exports;
   }
   #loaderForEntry(absPath) {
     if (absPath.endsWith(".tsx"))
@@ -7481,14 +8020,14 @@ ${absEntry}`).toString(36);
     if (Object.keys(this.#externalAliases).length === 0)
       return;
     await Promise.all(outputs.filter((output) => output.path.endsWith(".js")).map(async (output) => {
-      const source = await Bun.file(output.path).text();
-      const rewritten = ClientEntriesBundler.rewriteExternalImportSpecifiers(source, this.#externalAliases);
-      if (rewritten !== source)
+      const source2 = await Bun.file(output.path).text();
+      const rewritten = ClientEntriesBundler.rewriteExternalImportSpecifiers(source2, this.#externalAliases);
+      if (rewritten !== source2)
         await Bun.write(output.path, rewritten);
     }));
   }
-  static rewriteExternalImportSpecifiers(source, aliases) {
-    let rewritten = source;
+  static rewriteExternalImportSpecifiers(source2, aliases) {
+    let rewritten = source2;
     for (const [specifier, alias] of Object.entries(aliases)) {
       if (!alias)
         continue;
@@ -7743,9 +8282,9 @@ ${absEntry}`).toString(36);
     return { buildEntries, originalByBuildEntry };
   }
   async#scanExportNames(absEntry) {
-    const source = await Bun.file(absEntry).text();
+    const source2 = await Bun.file(absEntry).text();
     const transpiler = new Bun.Transpiler({ loader: this.#loaderFor(absEntry) });
-    return transpiler.scan(source).exports;
+    return transpiler.scan(source2).exports;
   }
   #loaderFor(absPath) {
     if (absPath.endsWith(".tsx"))
@@ -7756,10 +8295,10 @@ ${absEntry}`).toString(36);
       return "ts";
     return "js";
   }
-  static normalizeNamedDefaultFunctionForFastRefresh(source) {
+  static normalizeNamedDefaultFunctionForFastRefresh(source2) {
     let changed = false;
     const defaultNames = [];
-    const next = source.replace(/(^|\n)(\s*)export\s+default\s+(async\s+)?function\s+([A-Za-z_$][\w$]*)(?=\s*(?:<|\())/g, (match, lineStart, indent, asyncKeyword, name) => {
+    const next = source2.replace(/(^|\n)(\s*)export\s+default\s+(async\s+)?function\s+([A-Za-z_$][\w$]*)(?=\s*(?:<|\())/g, (match, lineStart, indent, asyncKeyword, name) => {
       changed = true;
       defaultNames.push(name);
       return `${lineStart}${indent}${asyncKeyword ?? ""}function ${name}`;
@@ -7987,8 +8526,8 @@ ${entries.join(`
   }
   static #hasAsyncDefaultExport(moduleAbsPath) {
     try {
-      const source = fs3.readFileSync(path21.resolve(moduleAbsPath), "utf8");
-      const sourceFile2 = ts5.createSourceFile(moduleAbsPath, source, ts5.ScriptTarget.Latest, true, PagesEntrySourceGenerator.#scriptKind(moduleAbsPath));
+      const source2 = fs3.readFileSync(path21.resolve(moduleAbsPath), "utf8");
+      const sourceFile2 = ts5.createSourceFile(moduleAbsPath, source2, ts5.ScriptTarget.Latest, true, PagesEntrySourceGenerator.#scriptKind(moduleAbsPath));
       return PagesEntrySourceGenerator.#sourceFileHasAsyncDefaultExport(sourceFile2);
     } catch {
       return false;
@@ -8248,8 +8787,8 @@ ${CsrArtifactBuilder.escapeInlineScript(await loadScript(src))}
       return html;
     return result + html.slice(lastIndex);
   }
-  static escapeInlineScript(source) {
-    return source.replace(/<\/script/gi, "<\\/script");
+  static escapeInlineScript(source2) {
+    return source2.replace(/<\/script/gi, "<\\/script");
   }
   static resolveHtmlAssetPath(htmlPath, src) {
     if (/^[a-z][a-z0-9+.-]*:/i.test(src) || src.startsWith("//")) {
@@ -8480,17 +9019,17 @@ class CssCompiler {
       } catch {
         continue;
       }
-      let source = content;
+      let source2 = content;
       if (akanConfig2.barrelImports.length > 0) {
         try {
           const rewritten = await rewriteBarrelImports(content, akanConfig2.barrelImports, analyzer);
           if (rewritten !== null)
-            source = rewritten;
+            source2 = rewritten;
         } catch {}
       }
       let imports;
       try {
-        imports = this.#transpiler.scanImports(source);
+        imports = this.#transpiler.scanImports(source2);
       } catch {
         continue;
       }
@@ -8929,7 +9468,7 @@ class DevGeneratedIndexSync {
     const rawModel = moduleSegment.startsWith("_") ? moduleSegment.slice(1) : moduleSegment;
     if (!rawModel)
       return null;
-    const modelName = capitalize4(rawModel);
+    const modelName = capitalize5(rawModel);
     const allowedTypes = isScalar ? SCALAR_UI_TYPES : moduleSegment.startsWith("_") ? SERVICE_UI_TYPES : MODULE_UI_TYPES;
     const fileTypes = [];
     for (const type of allowedTypes) {
@@ -8946,7 +9485,7 @@ export const ${modelName} = { ${fileTypes.join(", ")} };`;
   }
 }
 var exists = async (file) => stat3(file).then(() => true).catch(() => false);
-var capitalize4 = (value) => `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+var capitalize5 = (value) => `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
 var formatError = (err) => err instanceof Error ? err.message : String(err);
 // pkgs/@akanjs/devkit/frontendBuild/fontOptimizer.ts
 import { mkdir as mkdir7 } from "fs/promises";
@@ -9023,8 +9562,8 @@ class FontOptimizer {
     if (faceCss.length > 0)
       this.#cssParts.push(...faceCss, this.#buildRootVariableRule(font));
   }
-  #extractFontsExport(source, filePath) {
-    const sourceFile2 = ts6.createSourceFile(filePath, source, ts6.ScriptTarget.Latest, true, ts6.ScriptKind.TSX);
+  #extractFontsExport(source2, filePath) {
+    const sourceFile2 = ts6.createSourceFile(filePath, source2, ts6.ScriptTarget.Latest, true, ts6.ScriptKind.TSX);
     const fonts = [];
     for (const statement of sourceFile2.statements) {
       if (!ts6.isVariableStatement(statement))
@@ -9580,13 +10119,13 @@ function createUseClientBundlePlugin(options = {}) {
       build.onLoad({ filter: /\.(tsx|ts|jsx|js)$/ }, async (args) => {
         if (args.path.includes("/node_modules/"))
           return;
-        let source;
+        let source2;
         try {
-          source = await Bun.file(args.path).text();
+          source2 = await Bun.file(args.path).text();
         } catch {
           return;
         }
-        const stubbed = transformUseClient(source, {
+        const stubbed = transformUseClient(source2, {
           path: args.path,
           workspaceRoot: options.workspaceRoot
         });
@@ -9644,7 +10183,7 @@ class PagesBundleBuilder {
         PagesBundleBuilder.createServerUseClientFetchPlugin(),
         await createExternalizeFrameworkPlugin({ app: this.#app, extra: akanConfig2.externalLibs }),
         akanConfig2.barrelImports.length > 0 ? await createBarrelImportsPlugin(this.#app, {
-          pipeAfter: (source, args) => transformUseClient(source, {
+          pipeAfter: (source2, args) => transformUseClient(source2, {
             path: args.path,
             workspaceRoot
           })
@@ -9685,7 +10224,7 @@ class PagesBundleBuilder {
       ...Object.fromEntries(Object.entries(this.#app.getPublicEnv()).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]))
     };
   }
-  static createPagesEntryPlugin(source) {
+  static createPagesEntryPlugin(source2) {
     return {
       name: "akan-pages-entry",
       setup(build) {
@@ -9694,7 +10233,7 @@ class PagesBundleBuilder {
           namespace: "akan-virtual"
         }));
         build.onLoad({ filter: /^akan-pages-entry$/, namespace: "akan-virtual" }, () => ({
-          contents: source,
+          contents: source2,
           loader: "tsx"
         }));
       }
@@ -9716,19 +10255,19 @@ class PagesBundleBuilder {
       name: "akan-server-use-client-fetch",
       setup(build) {
         build.onLoad({ filter: /[/\\]lib[/\\]useClient\.(ts|tsx|js|jsx)$/ }, async (args) => {
-          const source = await Bun.file(args.path).text();
-          const transformed = PagesBundleBuilder.transformServerUseClientFetchSource(source);
-          if (transformed === source)
+          const source2 = await Bun.file(args.path).text();
+          const transformed = PagesBundleBuilder.transformServerUseClientFetchSource(source2);
+          if (transformed === source2)
             return;
           return { contents: transformed, loader: loaderFor4(args.path) };
         });
       }
     };
   }
-  static transformServerUseClientFetchSource(source) {
-    if (!source.includes(`with { type: "macro" }`) || !source.includes("FetchClient.build"))
-      return source;
-    return source.replace(/import\s+\{\s*getSerializedSignal\s*\}\s+from\s+["']\.\/sig["']\s+with\s+\{\s*type\s*:\s*["']macro["']\s*\};/, `import { fetch as serverFetch } from "./sig";`).replace(/const\s+fetchProto\s*=\s*FetchClient\.build<[^;]+;/, "const fetchProto = FetchClient.build<typeof signal>(cnst, serverFetch.serializedSignal, { Err: pageProto.Err, base: serverFetch });");
+  static transformServerUseClientFetchSource(source2) {
+    if (!source2.includes(`with { type: "macro" }`) || !source2.includes("FetchClient.build"))
+      return source2;
+    return source2.replace(/import\s+\{\s*getSerializedSignal\s*\}\s+from\s+["']\.\/sig["']\s+with\s+\{\s*type\s*:\s*["']macro["']\s*\};/, `import { fetch as serverFetch } from "./sig";`).replace(/const\s+fetchProto\s*=\s*FetchClient\.build<[^;]+;/, "const fetchProto = FetchClient.build<typeof signal>(cnst, serverFetch.serializedSignal, { Err: pageProto.Err, base: serverFetch });");
   }
 }
 function loaderFor4(absPath) {
@@ -10494,8 +11033,8 @@ class Builder {
   #executor;
   #distExecutor;
   #pkgJson;
-  constructor({ executor, distExecutor, pkgJson }) {
-    this.#executor = executor;
+  constructor({ executor: executor2, distExecutor, pkgJson }) {
+    this.#executor = executor2;
     this.#distExecutor = distExecutor;
     this.#pkgJson = pkgJson;
   }
@@ -10621,7 +11160,7 @@ import os from "os";
 import path38 from "path";
 import { select as select2 } from "@inquirer/prompts";
 import { MobileProject } from "@trapezedev/project";
-import { capitalize as capitalize5 } from "akanjs/common";
+import { capitalize as capitalize6 } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/fileEditor.ts
 class FileEditor {
@@ -11712,7 +12251,7 @@ ${error.message}`;
     this.#setPermissionsInAndroid(["POST_NOTIFICATIONS"]);
   }
   async#setPermissionInIos(permissions) {
-    const updateNs = Object.fromEntries(Object.entries(permissions).map(([key, value]) => [`NS${capitalize5(key)}`, value]));
+    const updateNs = Object.fromEntries(Object.entries(permissions).map(([key, value]) => [`NS${capitalize6(key)}`, value]));
     await Promise.all([
       this.project.ios.updateInfoPlist(this.iosTargetName, "Debug", updateNs),
       this.project.ios.updateInfoPlist(this.iosTargetName, "Release", updateNs)
@@ -11804,8 +12343,8 @@ import chalk6 from "chalk";
 import { program } from "commander";
 
 // pkgs/@akanjs/devkit/commandDecorators/dependencyBuilder.ts
-var capitalize6 = (value) => value.slice(0, 1).toUpperCase() + value.slice(1);
-var createDependencyKey = (refName, kind) => `${refName}${capitalize6(kind)}`;
+var capitalize7 = (value) => value.slice(0, 1).toUpperCase() + value.slice(1);
+var createDependencyKey = (refName, kind) => `${refName}${capitalize7(kind)}`;
 
 class CommandContainer {
   static #instances = new Map;
@@ -12285,13 +12824,13 @@ var getInternalArgumentValue = async (argMeta, value, workspace) => {
         ...libNames.map((name2) => ({ name: name2, value: { type: "lib", name: name2 } }))
       ]
     });
-    const executor = type === "app" ? AppExecutor.from(workspace, name) : LibExecutor.from(workspace, name);
-    const modules = await executor.getModules();
+    const executor2 = type === "app" ? AppExecutor.from(workspace, name) : LibExecutor.from(workspace, name);
+    const modules = await executor2.getModules();
     const moduleName = await select3({
       message: `Select the module name`,
-      choices: modules.map((name2) => ({ name: `${executor.name}:${name2}`, value: name2 }))
+      choices: modules.map((name2) => ({ name: `${executor2.name}:${name2}`, value: name2 }))
     });
-    return ModuleExecutor.from(executor, moduleName);
+    return ModuleExecutor.from(executor2, moduleName);
   } else
     throw new Error(`Invalid system type: ${argMeta.type}`);
 };
@@ -12543,6 +13082,8 @@ var NODE_NATIVE_MODULE_SET = new Set([
 ]);
 // pkgs/@akanjs/devkit/getCredentials.ts
 import yaml from "js-yaml";
+// pkgs/@akanjs/devkit/getModelFileData.ts
+import { capitalize as capitalize8 } from "akanjs/common";
 // pkgs/@akanjs/devkit/getRelatedCnsts.ts
 import { readFileSync as readFileSync4, realpathSync } from "fs";
 import ora2 from "ora";
@@ -12550,18 +13091,18 @@ import * as ts7 from "typescript";
 var tsTranspiler = new Bun.Transpiler({ loader: "ts" });
 var tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
 var getTranspiler = (filePath) => filePath.endsWith(".tsx") ? tsxTranspiler : tsTranspiler;
-var scanModuleSpecifiers = (source, filePath, includeExports) => {
-  const scannedImports = getTranspiler(filePath).scanImports(source).map((imp) => imp.path).filter(Boolean);
+var scanModuleSpecifiers = (source2, filePath, includeExports) => {
+  const scannedImports = getTranspiler(filePath).scanImports(source2).map((imp) => imp.path).filter(Boolean);
   if (includeExports) {
     const specifiers = new Set(scannedImports);
     const typeOnlyModuleRegex = /\b(?:import|export)\s+type\s+[\s\S]*?\s+from\s*["']([^"']+)["']/g;
-    for (const match of source.matchAll(typeOnlyModuleRegex)) {
+    for (const match of source2.matchAll(typeOnlyModuleRegex)) {
       const importPath = match[1];
       if (importPath)
         specifiers.add(importPath);
     }
     const exportFromRegex = /\bexport\s+(?:type\s+)?(?:\*|{[\s\S]*?})\s+from\s*["']([^"']+)["']/g;
-    for (const match of source.matchAll(exportFromRegex)) {
+    for (const match of source2.matchAll(exportFromRegex)) {
       const importPath = match[1];
       if (importPath)
         specifiers.add(importPath);
@@ -12570,7 +13111,7 @@ var scanModuleSpecifiers = (source, filePath, includeExports) => {
   }
   const importSpecifiers = new Set;
   const importDeclarationRegex = /\bimport\s+(?:type\s+)?(?:["']([^"']+)["']|[\s\S]*?\s+from\s*["']([^"']+)["'])/g;
-  for (const match of source.matchAll(importDeclarationRegex)) {
+  for (const match of source2.matchAll(importDeclarationRegex)) {
     const importPath = match[1] ?? match[2];
     if (importPath && (scannedImports.includes(importPath) || match[0].startsWith("import type"))) {
       importSpecifiers.add(importPath);
@@ -12593,8 +13134,8 @@ var collectImportedFiles = (constantFilePath, parsedConfig) => {
     if (analyzedFiles.has(filePath))
       return;
     analyzedFiles.add(filePath);
-    const source = readFileSync4(filePath, "utf-8");
-    for (const importPath of scanModuleSpecifiers(source, filePath, false)) {
+    const source2 = readFileSync4(filePath, "utf-8");
+    for (const importPath of scanModuleSpecifiers(source2, filePath, false)) {
       if (!importPath.startsWith("."))
         continue;
       const resolved = ts7.resolveModuleName(importPath, filePath, parsedConfig.options, ts7.sys).resolvedModule?.resolvedFileName;
@@ -12643,21 +13184,21 @@ var analyzeProperties = (filesToAnalyze, program2, checker) => {
     if (analyzedFiles.has(filePath))
       return;
     analyzedFiles.add(filePath);
-    const source = program2.getSourceFile(filePath);
-    if (!source)
+    const source2 = program2.getSourceFile(filePath);
+    if (!source2)
       return;
     if (!sourceLineCache.has(filePath)) {
-      sourceLineCache.set(filePath, source.getFullText().split(`
+      sourceLineCache.set(filePath, source2.getFullText().split(`
 `));
     }
     const sourceLines = sourceLineCache.get(filePath);
     function visit(node) {
-      if (!source)
+      if (!source2)
         return;
       if (ts7.isPropertyAccessExpression(node)) {
         const left = node.expression;
         const right = node.name;
-        const { line } = ts7.getLineAndCharacterOfPosition(source, node.getStart());
+        const { line } = ts7.getLineAndCharacterOfPosition(source2, node.getStart());
         if (ts7.isIdentifier(left) && sourceLines && sourceLines.length > line && sourceLines[line] && (sourceLines[line]?.includes(`@Field.Prop(() => ${left.text}.${right.text}`) || sourceLines[line].includes(`base.Filter(${left.text}.${right.text},`))) {
           const symbol = getCachedSymbol(right);
           if (symbol?.declarations && symbol.declarations.length > 0) {
@@ -12708,7 +13249,7 @@ var analyzeProperties = (filesToAnalyze, program2, checker) => {
       }
       ts7.forEachChild(node, visit);
     }
-    visit(source);
+    visit(source2);
   }
   for (const filePath of filesToAnalyze) {
     analyzeFileProperties(filePath);
@@ -14112,8 +14653,8 @@ class CloudRunner extends runner("cloud") {
   #getSshTarget(config) {
     return `${config.username ? `${config.username}@` : ""}${config.host}`;
   }
-  #getScpArgs(config, source, target) {
-    return [...config.port ? ["-P", config.port.toString()] : [], source, target];
+  #getScpArgs(config, source2, target) {
+    return [...config.port ? ["-P", config.port.toString()] : [], source2, target];
   }
   #getSshArgs(config, command3) {
     return [...config.port ? ["-p", config.port.toString()] : [], this.#getSshTarget(config), command3];
@@ -14493,7 +15034,7 @@ import path43 from "path";
 
 // pkgs/@akanjs/cli/module/module.script.ts
 import { input as input6 } from "@inquirer/prompts";
-import { capitalize as capitalize9, randomPicks } from "akanjs/common";
+import { capitalize as capitalize11, randomPicks } from "akanjs/common";
 
 // pkgs/@akanjs/cli/page/page.runner.ts
 class PageRunner extends runner("page") {
@@ -14523,7 +15064,7 @@ function pluralizeName(name) {
 }
 
 // pkgs/@akanjs/cli/module/module.request.ts
-import { capitalize as capitalize7 } from "akanjs/common";
+import { capitalize as capitalize9 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/module/module.prompt.ts
 var componentDefaultDescription = ({
@@ -14648,7 +15189,7 @@ var requestTemplate = ({
 		${componentDefaultDescription({
   sysName,
   modelName,
-  ModelName: ModelName ?? capitalize7(modelName),
+  ModelName: ModelName ?? capitalize9(modelName),
   exampleFiles,
   constant,
   properties
@@ -14705,7 +15246,7 @@ var requestView = ({
 	 ${componentDefaultDescription({
   sysName,
   modelName,
-  ModelName: ModelName ?? capitalize7(modelName),
+  ModelName: ModelName ?? capitalize9(modelName),
   exampleFiles,
   constant,
   properties
@@ -14766,7 +15307,7 @@ var requestUnit = ({
 	 ${componentDefaultDescription({
   sysName,
   modelName,
-  ModelName: ModelName ?? capitalize7(modelName),
+  ModelName: ModelName ?? capitalize9(modelName),
   exampleFiles,
   constant,
   properties
@@ -14815,7 +15356,47 @@ var requestUnit = ({
 	`;
 
 // pkgs/@akanjs/cli/module/module.runner.ts
-import { capitalize as capitalize8 } from "akanjs/common";
+import { capitalize as capitalize10 } from "akanjs/common";
+var purposeByModule = {
+  budget: "Budget represents planned or actual money allocated inside the app.",
+  project: "Project represents a project workspace or business initiative managed by the app.",
+  task: "Task represents work items that move through the app workflow."
+};
+var moduleAbstractContent = (moduleName) => {
+  const title = capitalize10(moduleName);
+  const label = bilingualLabelForField(moduleName);
+  const purpose = purposeByModule[moduleName] ?? `${title} represents ${label.en.toLowerCase()} records managed by the app.`;
+  return `# ${title} Module Abstract
+
+## Purpose
+
+${purpose}
+
+## Domain Rules
+
+- Keep ${label.en.toLowerCase()} data consistent with user-facing dictionary labels.
+
+## Data Meaning
+
+${label.en} (${label.ko}) is the primary business concept for this module.
+
+## Workflows
+
+No lifecycle workflow yet.
+
+## Agent Notes
+
+- Read this abstract before changing the module.
+- Update this file when business invariants, workflows, or public behavior change.
+- Do not update this file for formatting-only, import-only, or style-only changes.
+
+## Related Modules
+
+- None yet.
+`;
+};
+var localModuleFilename = (moduleName, pathKey2) => moduleSourcePaths(moduleName)[pathKey2].replace(`lib/${moduleName}/`, "");
+
 class ModuleRunner extends runner("module") {
   async createService(module) {
     const serviceName = module.name.replace(/^_+/, "");
@@ -14845,23 +15426,47 @@ class ModuleRunner extends runner("module") {
   async createComponentTemplate(module, type) {
     await module.sys.applyTemplate({
       basePath: `./lib/${module.name}`,
-      template: `module/__Model__.${capitalize8(type)}.tsx`,
+      template: `module/__Model__.${capitalize10(type)}.tsx`,
       dict: { model: module.name, appName: module.sys.name }
     });
     return {
       component: {
-        filename: `${module.name}.${capitalize8(type)}.tsx`,
-        content: await module.sys.readFile(`lib/${module.name}/${capitalize8(module.name)}.${capitalize8(type)}.tsx`)
+        filename: `${capitalize10(module.name)}.${capitalize10(type)}.tsx`,
+        content: await module.sys.readFile(`lib/${module.name}/${capitalize10(module.name)}.${capitalize10(type)}.tsx`)
       }
     };
   }
   async createModuleTemplate(module) {
     const names = pluralizeName(module.name);
+    const modelLabel = bilingualLabelForField(module.name);
+    const modelDescription = bilingualDescriptionForField(module.name);
+    const filenames = {
+      abstract: localModuleFilename(module.name, "abstract"),
+      constant: localModuleFilename(module.name, "constant"),
+      dictionary: localModuleFilename(module.name, "dictionary"),
+      service: localModuleFilename(module.name, "service"),
+      store: localModuleFilename(module.name, "store"),
+      signal: localModuleFilename(module.name, "signal"),
+      unit: localModuleFilename(module.name, "unit"),
+      view: localModuleFilename(module.name, "view"),
+      template: localModuleFilename(module.name, "template"),
+      zone: localModuleFilename(module.name, "zone"),
+      util: localModuleFilename(module.name, "util")
+    };
     await module.applyTemplate({
       basePath: `.`,
       template: "module",
-      dict: { model: module.name, models: names, sysName: module.sys.name }
+      dict: {
+        model: module.name,
+        models: names,
+        sysName: module.sys.name,
+        modelLabelEn: modelLabel.en,
+        modelLabelKo: modelLabel.ko,
+        modelDescEn: modelDescription.en,
+        modelDescKo: modelDescription.ko
+      }
     });
+    await module.writeFile(filenames.abstract, moduleAbstractContent(module.name));
     const [
       abstractContent,
       constantContent,
@@ -14875,30 +15480,30 @@ class ModuleRunner extends runner("module") {
       zoneContent,
       utilContent
     ] = await Promise.all([
-      module.readFile(`${module.name}.abstract.md`),
-      module.readFile(`${module.name}.constant.ts`),
-      module.readFile(`${module.name}.dictionary.ts`),
-      module.readFile(`${module.name}.service.ts`),
-      module.readFile(`${module.name}.store.ts`),
-      module.readFile(`${module.name}.signal.ts`),
-      module.readFile(`${module.name}.Unit.tsx`),
-      module.readFile(`${module.name}.View.tsx`),
-      module.readFile(`${module.name}.Template.tsx`),
-      module.readFile(`${module.name}.Zone.tsx`),
-      module.readFile(`${module.name}.Util.tsx`)
+      module.readFile(filenames.abstract),
+      module.readFile(filenames.constant),
+      module.readFile(filenames.dictionary),
+      module.readFile(filenames.service),
+      module.readFile(filenames.store),
+      module.readFile(filenames.signal),
+      module.readFile(filenames.unit),
+      module.readFile(filenames.view),
+      module.readFile(filenames.template),
+      module.readFile(filenames.zone),
+      module.readFile(filenames.util)
     ]);
     return {
-      abstract: { filename: `${module.name}.abstract.md`, content: abstractContent },
-      constant: { filename: `${module.name}.constant.ts`, content: constantContent },
-      dictionary: { filename: `${module.name}.dictionary.ts`, content: dictionaryContent },
-      service: { filename: `${module.name}.service.ts`, content: serviceContent },
-      store: { filename: `${module.name}.store.ts`, content: storeContent },
-      signal: { filename: `${module.name}.signal.ts`, content: signalContent },
-      unit: { filename: `${module.name}.Unit.tsx`, content: unitContent },
-      view: { filename: `${module.name}.View.tsx`, content: viewContent },
-      template: { filename: `${module.name}.Template.tsx`, content: templateContent },
-      zone: { filename: `${module.name}.Zone.tsx`, content: zoneContent },
-      util: { filename: `${module.name}.Util.tsx`, content: utilContent }
+      abstract: { filename: filenames.abstract, content: abstractContent },
+      constant: { filename: filenames.constant, content: constantContent },
+      dictionary: { filename: filenames.dictionary, content: dictionaryContent },
+      service: { filename: filenames.service, content: serviceContent },
+      store: { filename: filenames.store, content: storeContent },
+      signal: { filename: filenames.signal, content: signalContent },
+      unit: { filename: filenames.unit, content: unitContent },
+      view: { filename: filenames.view, content: viewContent },
+      template: { filename: filenames.template, content: templateContent },
+      zone: { filename: filenames.zone, content: zoneContent },
+      util: { filename: filenames.util, content: utilContent }
     };
   }
 }
@@ -14928,11 +15533,11 @@ class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
     const isContinued = await sys3.exists(`lib/${name}/${name}.constant.ts`);
     const session = new AiSession("createModule", { workspace: sys3.workspace, cacheKey: name, isContinued });
     const moduleConstantExampleFiles = await sys3.workspace.getConstantFiles();
-    const executor = ModuleExecutor.from(sys3, name);
-    const files = await this.moduleRunner.createModuleTemplate(executor);
+    const executor2 = ModuleExecutor.from(sys3, name);
+    const files = await this.moduleRunner.createModuleTemplate(executor2);
     const { constant, dictionary } = files;
     if (page && sys3.type === "app")
-      await this.pageScript.createCrudPage(executor, { app: sys3, basePath: null, single: false });
+      await this.pageScript.createCrudPage(executor2, { app: sys3, basePath: null, single: false });
     const modelDesc = description ?? await input6({ message: "description of module" });
     const modelSchemaDesign = schemaDescription ?? await input6({ message: "schema description of module" });
     const config = await sys3.getConfig();
@@ -15000,8 +15605,9 @@ class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
   async createTest(workspace, name) {}
   async createTemplate(mod) {
     const { component: template } = await this.moduleRunner.createComponentTemplate(mod, "template");
-    const templateExampleFiles = (await mod.sys.getTemplatesSourceCode()).filter((f) => !f.filePath.includes(`${mod.name}.Template.tsx`));
-    const Name = capitalize9(mod.name);
+    const paths = moduleSourcePaths(mod.name);
+    const templateExampleFiles = (await mod.sys.getTemplatesSourceCode()).filter((f) => !f.filePath.includes(paths.template));
+    const Name = capitalize11(mod.name);
     const relatedCnsts = getRelatedCnsts(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const constant = await FileSys.readText(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const session = new AiSession("createTemplate", { workspace: mod.sys.workspace, cacheKey: mod.name });
@@ -15027,8 +15633,9 @@ class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
   }
   async createUnit(mod) {
     const { component: unit } = await this.moduleRunner.createComponentTemplate(mod, "unit");
-    const Name = capitalize9(mod.name);
-    const unitExampleFiles = (await mod.sys.getUnitsSourceCode()).filter((f) => !f.filePath.includes(`${mod.name}.Unit.tsx`));
+    const paths = moduleSourcePaths(mod.name);
+    const Name = capitalize11(mod.name);
+    const unitExampleFiles = (await mod.sys.getUnitsSourceCode()).filter((f) => !f.filePath.includes(paths.unit));
     const relatedCnsts = getRelatedCnsts(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const constant = await FileSys.readText(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const session = new AiSession("createUnit", { workspace: mod.sys.workspace, cacheKey: mod.name });
@@ -15052,8 +15659,9 @@ class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
   }
   async createView(mod) {
     const { component: view } = await this.moduleRunner.createComponentTemplate(mod, "view");
-    const viewExampleFiles = (await mod.sys.getViewsSourceCode()).filter((f) => !f.filePath.includes(`${mod.name}.View.tsx`));
-    const Name = capitalize9(mod.name);
+    const paths = moduleSourcePaths(mod.name);
+    const viewExampleFiles = (await mod.sys.getViewsSourceCode()).filter((f) => !f.filePath.includes(paths.view));
+    const Name = capitalize11(mod.name);
     const relatedCnsts = getRelatedCnsts(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const constant = await FileSys.readText(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const session = new AiSession("createView", { workspace: mod.sys.workspace, cacheKey: mod.name });
@@ -15078,7 +15686,7 @@ class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
 }
 
 // pkgs/@akanjs/cli/primitive/primitive.script.ts
-import { capitalize as capitalize10 } from "akanjs/common";
+import { capitalize as capitalize12 } from "akanjs/common";
 class PrimitiveScript extends script("primitive", [ModuleScript]) {
   async resolveSys(workspace, target) {
     if (!target)
@@ -15126,7 +15734,7 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
   }
   async addEnumField(workspace, input7) {
     const values = parseValues(input7.values);
-    return await this.addFieldToSources(workspace, { ...input7, type: `${capitalize10(input7.field ?? "")}` }, { enumValues: values });
+    return await this.addFieldToSources(workspace, { ...input7, type: `${capitalize12(input7.field ?? "")}` }, { enumValues: values });
   }
   async addFieldToSources(workspace, input7, { enumValues }) {
     const sys3 = await this.resolveSys(workspace, input7.app);
@@ -15170,10 +15778,12 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         nextActions: []
       });
     }
-    const moduleClassName = capitalize10(input7.module);
+    const moduleClassName = capitalize12(input7.module);
     const inputClassName = `${moduleClassName}Input`;
-    const constantPath = `lib/${input7.module}/${input7.module}.constant.ts`;
-    const dictionaryPath = `lib/${input7.module}/${input7.module}.dictionary.ts`;
+    const paths = moduleSourcePaths(input7.module);
+    const constantPath = paths.constant;
+    const dictionaryPath = paths.dictionary;
+    const templatePath = paths.template;
     const changedFiles = [];
     const generatedFiles2 = generatedFilesForSync(sys3);
     const [hasConstant, hasDictionary] = await Promise.all([sys3.exists(constantPath), sys3.exists(dictionaryPath)]);
@@ -15212,8 +15822,8 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
       });
     }
     if (enumValues) {
-      const enumClassName = `${moduleClassName}${capitalize10(input7.field)}`;
-      const enumName = `${lowerlize(moduleClassName)}${capitalize10(input7.field)}`;
+      const enumClassName = `${moduleClassName}${capitalize12(input7.field)}`;
+      const enumName = `${lowerlize(moduleClassName)}${capitalize12(input7.field)}`;
       constantContent = insertEnumClass(ensureEnumImport(constantContent), enumClassName, enumName, enumValues);
       dictionaryContent = ensureConstantTypeImport(dictionaryContent, `./${input7.module}.constant`, enumClassName);
       input7.type = enumClassName;
@@ -15230,10 +15840,36 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
     }
     if (!enumValues && normalizedType) {
       input7.type = normalizedType;
+      const defaultCoercion = coerceFieldDefault(input7.type, input7.defaultValue);
+      if (defaultCoercion.diagnostic)
+        diagnostics.push(defaultCoercion.diagnostic);
       constantContent = ensureBaseTypeImport(constantContent, input7.type);
     }
-    const nextConstantContent = insertIntoObject(constantContent, inputClassName, `${input7.field}: ${fieldExpression(input7.type, input7.defaultValue)},`);
+    if (enumValues) {
+      const defaultCoercion = coerceFieldDefault("enum", input7.defaultValue, { enumValues });
+      if (defaultCoercion.diagnostic)
+        diagnostics.push(defaultCoercion.diagnostic);
+    }
+    const nextConstantContent = insertIntoObject(constantContent, inputClassName, `${input7.field}: ${fieldExpression(input7.type, input7.defaultValue, { enumValues })},`);
+    const nextConstantContentWithLight = nextConstantContent && input7.includeInLight ? insertLightProjectionField(nextConstantContent, moduleClassName, input7.field) : nextConstantContent;
     const nextDictionaryContent = insertDictionaryModelField(dictionaryContent, moduleClassName, input7.field);
+    if (nextConstantContentWithLight && (input7.type === "Int" || input7.type === "Float") && new RegExp(`\\b${input7.field}\\s*:\\s*field\\(${input7.type}, \\{ default: "`, "m").test(nextConstantContentWithLight)) {
+      diagnostics.push({
+        severity: "error",
+        code: "primitive-default-value-invalid",
+        input: "default",
+        failureScope: "source-change",
+        message: `Generated ${input7.type} default for "${input7.field}" would be a string literal; refusing to write source.`
+      });
+    }
+    if (nextConstantContentWithLight && (input7.type === "Int" || input7.type === "Float") && !new RegExp(`import \\{[^}]*\\b${input7.type}\\b[^}]*\\} from "akanjs/base";`).test(nextConstantContentWithLight)) {
+      diagnostics.push({
+        severity: "error",
+        code: "primitive-base-type-import-missing",
+        failureScope: "source-change",
+        message: `Generated source for ${input7.field} requires ${input7.type} import from "akanjs/base".`
+      });
+    }
     if (!nextConstantContent) {
       diagnostics.push({
         severity: "error",
@@ -15241,6 +15877,14 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         message: `Could not find ${inputClassName} object shape in ${constantPath}.`
       });
     }
+    if (nextConstantContent && input7.includeInLight && !nextConstantContentWithLight) {
+      diagnostics.push({
+        severity: "warning",
+        code: "primitive-light-projection-shape-unsupported",
+        failureScope: "source-change",
+        message: `Could not find a safe Light${moduleClassName} projection insertion point in ${constantPath}.`
+      });
+    }
     if (!nextDictionaryContent) {
       diagnostics.push({
         severity: "error",
@@ -15248,10 +15892,51 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         message: `Could not find ${moduleClassName} dictionary model shape in ${dictionaryPath}.`
       });
     }
-    if (!diagnostics.some((diagnostic) => diagnostic.severity === "error") && nextConstantContent && nextDictionaryContent) {
-      await sys3.writeFile(constantPath, nextConstantContent);
+    let nextTemplateContent;
+    if (input7.surfaces?.includes("template")) {
+      const policy = addFieldUiPolicyForType(enumValues ? "enum" : input7.type);
+      const hasTemplate = await sys3.exists(templatePath);
+      if (!hasTemplate) {
+        diagnostics.push({
+          severity: "warning",
+          code: "primitive-template-missing",
+          failureScope: "source-change",
+          message: `Template source file was not found: ${templatePath}. Auto-edit skipped; add the field to the Template form manually if this module renders one.`
+        });
+      } else if (!policy.autoTemplateSupported || policy.component === "Field.ToggleSelect") {
+        diagnostics.push({
+          severity: "warning",
+          code: "primitive-template-component-manual",
+          failureScope: "source-change",
+          message: `Template auto insertion for ${policy.component} is not supported because option binding must be confirmed. Candidate position: inside Layout.Template near existing Field components in ${templatePath}.`
+        });
+      } else {
+        const templateContent = await sys3.readFile(templatePath);
+        nextTemplateContent = insertTemplateField({
+          content: templateContent,
+          moduleName: input7.module,
+          moduleClassName,
+          fieldName: input7.field,
+          component: policy.component
+        });
+        if (!nextTemplateContent) {
+          diagnostics.push({
+            severity: "warning",
+            code: "primitive-template-shape-unsupported",
+            failureScope: "source-change",
+            message: `Could not find a safe Template insertion point in ${templatePath}. Expected generated ${input7.module}Form hook and Layout.Template closing tag; candidate position is the existing field list before </Layout.Template>.`
+          });
+        }
+      }
+    }
+    if (!diagnostics.some((diagnostic) => diagnostic.severity === "error") && nextConstantContentWithLight && nextDictionaryContent) {
+      await sys3.writeFile(constantPath, nextConstantContentWithLight);
       await sys3.writeFile(dictionaryPath, nextDictionaryContent);
       changedFiles.push(sourceFile(sys3, constantPath, "modify", "Field source shape was updated."), sourceFile(sys3, dictionaryPath, "modify", "Field dictionary labels were updated."));
+      if (nextTemplateContent !== undefined && nextTemplateContent !== null) {
+        await sys3.writeFile(templatePath, nextTemplateContent);
+        changedFiles.push(sourceFile(sys3, templatePath, "modify", "Template field surface was updated."));
+      }
     }
     return createPrimitiveWriteReport({
       command: enumValues ? "add-enum-field" : "add-field",
@@ -15312,8 +15997,8 @@ class RepairRunner extends runner("repair") {
     format = "markdown",
     execute
   }) {
-    const executor = execute ?? defaultExecutor(workspace);
-    const report = await this.createRepairReport(kind, { workspace, app, module, target, execute: executor });
+    const executor2 = execute ?? defaultExecutor(workspace);
+    const report = await this.createRepairReport(kind, { workspace, app, module, target, execute: executor2 });
     const { artifact: artifact2, runId } = await writeWorkflowRunArtifact(workspace, report);
     const reportWithArtifact = artifact2;
     if (kind === "generated" && reportWithArtifact.status === "passed" && reportWithArtifact.target) {
@@ -15620,6 +16305,7 @@ class ScalarScript extends script("scalar", [ScalarRunner]) {
 // pkgs/@akanjs/cli/workflow/workflow.runner.ts
 import { mkdir as mkdir12, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import path42 from "path";
+import { capitalize as capitalize13 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/workflows/shared.ts
 var sysInputs = {
@@ -15733,7 +16419,18 @@ var addFieldWorkflowSpec = {
       description: "Field type or scalar name. Use Int for integer fields or Float for decimal fields; do not use Number."
     },
     values: { type: "string-list", description: "Comma-separated enum values when type is enum." },
-    default: { type: "string", description: "Optional default value for the field." }
+    default: {
+      type: "string",
+      description: "Optional default value. plan/apply coerce by field type: Int/Float to numeric literals, Boolean to true/false, Date to new Date(...), String/scalar to string literals, and enum only when the value is in values."
+    },
+    surfaces: {
+      type: "string-list",
+      description: "Optional UI surfaces to update, comma-separated. Use template to auto-update simple generated Template forms; View/Unit stay planned as manual review."
+    },
+    includeInLight: {
+      type: "boolean",
+      description: "Whether to add the field to the Light<Model> projection used by list/card displays."
+    }
   },
   optionalSurfaces: {
     dictionary: "include",
@@ -16180,7 +16877,7 @@ var failedPlan = (workflow2, diagnostics) => ({
   recommendations: [],
   requiresApproval: true
 });
-var failedApplyReport = (workflow2, diagnostics, plan) => createWorkflowApplyReport({
+var failedApplyReport = (workflow2, diagnostics, plan2) => createWorkflowApplyReport({
   workflow: workflow2,
   mode: "apply",
   changedFiles: [],
@@ -16188,7 +16885,7 @@ var failedApplyReport = (workflow2, diagnostics, plan) => createWorkflowApplyRep
   commands: [],
   diagnostics,
   nextActions: [],
-  plan: plan ?? failedPlan(workflow2, diagnostics)
+  plan: plan2 ?? failedPlan(workflow2, diagnostics)
 });
 var commandForShell2 = (command3) => command3.startsWith("akan ") ? `bun run ${command3}` : command3;
 var inferValidationKind = (command3) => {
@@ -16248,6 +16945,61 @@ var defaultValidationExecutor = (workspace) => async (command3) => {
   }
 };
 var readJsonFile = async (filePath) => JSON.parse(await readFile2(resolvePath(filePath), "utf8"));
+var planInputString2 = (plan2, key) => {
+  const value = plan2.inputs[key];
+  return typeof value === "string" ? value : "";
+};
+var workflowPathsForPlanLike = (plan2) => {
+  const app = planInputString2(plan2, "app");
+  const module = planInputString2(plan2, "module");
+  const moduleClass = module ? capitalize13(module) : "<Module>";
+  return plan2.predictedChanges.map((change) => change.target.replace(/^\*\//, app ? `apps/${app}/` : "").replaceAll("<module>", module || "<module>").replaceAll("<Module>", moduleClass));
+};
+var workflowDiagnosticFromDoctor = (diagnostic, fallbackScope) => ({
+  severity: diagnostic.severity,
+  code: diagnostic.code,
+  message: diagnostic.message,
+  scope: diagnostic.scope ?? fallbackScope,
+  failureScope: (diagnostic.scope ?? fallbackScope) === "baseline" ? "workspace-config" : (diagnostic.scope ?? fallbackScope) === "workflow" ? "source-change" : "unknown",
+  context: diagnostic.context
+});
+var baselineBlockerCachePath = (workflow2) => `.akan/workflows/baseline/${workflow2}.json`;
+var blockerFingerprint = (blocker) => [blocker.failureScope, blocker.code, blocker.command ?? "", blocker.kind ?? "", blocker.message].join("|");
+var applyBaselineBlockerCache = async (workspace, report) => {
+  const cacheableBlockers = report.knownBlockers.filter((blocker) => blocker.failureScope === "workspace-config" || blocker.failureScope === "environment");
+  if (cacheableBlockers.length === 0)
+    return report;
+  const cachePath = baselineBlockerCachePath(report.workflow);
+  const cached = (await workspace.exists(cachePath) ? await workspace.readJson(cachePath) : null) ?? { schemaVersion: 1, workflow: report.workflow, blockers: [] };
+  const knownFingerprints = new Set(cached.blockers.map((blocker) => blocker.fingerprint));
+  const now = new Date().toISOString();
+  const blockers = new Map(cached.blockers.map((blocker) => [blocker.fingerprint, blocker]));
+  for (const blocker of cacheableBlockers) {
+    const fingerprint = blockerFingerprint(blocker);
+    blockers.set(fingerprint, {
+      fingerprint,
+      code: blocker.code,
+      message: blocker.message,
+      failureScope: blocker.failureScope,
+      command: blocker.command,
+      kind: blocker.kind,
+      lastSeenAt: now
+    });
+  }
+  await workspace.writeFile(cachePath, jsonText({ schemaVersion: 1, workflow: report.workflow, blockers: [...blockers.values()] }), { silent: true });
+  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}`
+      };
+    })
+  };
+};
 
 class WorkflowRunner extends runner("workflow") {
   list({ format = "markdown" } = {}) {
@@ -16269,13 +17021,13 @@ class WorkflowRunner extends runner("workflow") {
     const spec = getWorkflowSpec(workflowSpecs, workflow2);
     if (!spec)
       throw new Error(`Unknown workflow: ${workflow2}. Run \`akan workflow list\` to see available workflows.`);
-    const plan = createWorkflowPlan(spec, compactWorkflowInputs(inputs));
+    const plan2 = createWorkflowPlan(spec, compactWorkflowInputs(inputs));
     if (out) {
       const outPath = resolvePath(out);
       await mkdir12(path42.dirname(outPath), { recursive: true });
-      await writeFile2(outPath, jsonText(plan));
+      await writeFile2(outPath, jsonText(plan2));
     }
-    return format === "json" ? jsonText(plan) : renderWorkflowPlan(plan);
+    return format === "json" ? jsonText(plan2) : renderWorkflowPlan(plan2);
   }
   async apply(planPath, {
     dryRun = false,
@@ -16289,7 +17041,7 @@ class WorkflowRunner extends runner("workflow") {
       const { artifact: artifact2 } = await writeWorkflowRunArtifact(workspace, report);
       return renderWorkflowApply(artifact2, format);
     };
-    let plan;
+    let plan2;
     try {
       const parsed = JSON.parse(await readFile2(resolvePath(planPath), "utf8"));
       if (!isWorkflowPlan2(parsed)) {
@@ -16302,7 +17054,7 @@ class WorkflowRunner extends runner("workflow") {
         ]);
         return await renderApplyReport(report);
       }
-      plan = parsed;
+      plan2 = parsed;
     } catch (error) {
       const report = failedApplyReport("unknown", [
         {
@@ -16313,30 +17065,30 @@ class WorkflowRunner extends runner("workflow") {
       ]);
       return await renderApplyReport(report);
     }
-    const spec = getWorkflowSpec(workflowSpecs, plan.workflow);
+    const spec = getWorkflowSpec(workflowSpecs, plan2.workflow);
     if (!spec) {
-      const report = failedApplyReport(plan.workflow, [
+      const report = failedApplyReport(plan2.workflow, [
         {
           severity: "error",
           code: "workflow-unknown",
-          message: `Unknown workflow in plan: ${plan.workflow}.`
+          message: `Unknown workflow in plan: ${plan2.workflow}.`
         }
-      ], plan);
+      ], plan2);
       return await renderApplyReport(report);
     }
     if (dryRun)
-      return await renderApplyReport(createDryRunWorkflowApplyReport(plan));
+      return await renderApplyReport(createDryRunWorkflowApplyReport(plan2));
     if (!registry) {
-      const report = failedApplyReport(plan.workflow, [
+      const report = failedApplyReport(plan2.workflow, [
         {
           severity: "error",
           code: "workflow-registry-missing",
           message: "Workflow apply requires a step runner registry."
         }
-      ], plan);
+      ], plan2);
       return await renderApplyReport(report);
     }
-    return await renderApplyReport(await new WorkflowExecutor(registry).apply(plan));
+    return await renderApplyReport(await new WorkflowExecutor(registry).apply(plan2));
   }
   async validate(runIdOrPlan, {
     format = "markdown",
@@ -16344,15 +17096,22 @@ class WorkflowRunner extends runner("workflow") {
     execute
   }) {
     const loaded = await this.loadValidationTarget(runIdOrPlan, workspace);
-    const report = await createWorkflowValidationRunReport({
+    const doctor = await AkanContextAnalyzer.doctor(workspace, {
+      strict: true,
+      runIdOrPlan,
+      changedFiles: loaded.changedFiles
+    });
+    const report = await applyBaselineBlockerCache(workspace, await createWorkflowValidationRunReport({
       workflow: loaded.plan?.workflow ?? loaded.workflow,
       source: loaded.source,
       plan: loaded.plan,
       commands: loaded.commands,
       execute: execute ?? defaultValidationExecutor(workspace),
       diagnostics: loaded.diagnostics,
+      baselineDiagnostics: (doctor.baselineDiagnostics ?? []).map((diagnostic) => workflowDiagnosticFromDoctor(diagnostic, "baseline")),
+      workflowDiagnostics: (doctor.workflowDiagnostics ?? []).map((diagnostic) => workflowDiagnosticFromDoctor(diagnostic, "workflow")),
       repairActions: loaded.repairActions
-    });
+    }));
     await writeWorkflowRunArtifact(workspace, report);
     return renderWorkflowValidation(report, format);
   }
@@ -16391,6 +17150,7 @@ class WorkflowRunner extends runner("workflow") {
           plan: artifact2.plan,
           commands: artifact2.recommendedValidationCommands.length ? artifact2.recommendedValidationCommands : workflowCommandsForPlan(artifact2.plan),
           diagnostics: artifact2.diagnostics,
+          changedFiles: artifact2.changedFiles.map((file) => file.path),
           repairActions: []
         };
       }
@@ -16401,6 +17161,7 @@ class WorkflowRunner extends runner("workflow") {
           plan: artifact2.plan,
           commands: artifact2.plan ? workflowCommandsForPlan(artifact2.plan) : [],
           diagnostics: artifact2.diagnostics,
+          changedFiles: [],
           repairActions: artifact2.repairActions
         };
       }
@@ -16416,6 +17177,7 @@ class WorkflowRunner extends runner("workflow") {
             message: `Workflow validation source is not supported: ${runIdOrPlan}.`
           }
         ],
+        changedFiles: [],
         repairActions: []
       };
     };
@@ -16428,6 +17190,7 @@ class WorkflowRunner extends runner("workflow") {
           plan: parsed,
           commands: workflowCommandsForPlan(parsed),
           diagnostics: parsed.diagnostics,
+          changedFiles: workflowPathsForPlanLike(parsed),
           repairActions: []
         };
       }
@@ -16450,6 +17213,7 @@ class WorkflowRunner extends runner("workflow") {
             message: `Could not read workflow validation source: ${runIdOrPlan}. ${error instanceof Error ? error.message : ""}`.trim()
           }
         ],
+        changedFiles: [],
         repairActions: []
       };
     }
@@ -16516,7 +17280,8 @@ var readonlyMcpTools = [
   { name: "list_modules", inputSchema: emptySchema },
   {
     name: "get_module_context",
-    inputSchema: { type: "object", properties: { module: stringProperty }, required: ["module"] }
+    description: "Return module context. Pass app in monorepos to disambiguate duplicate module names.",
+    inputSchema: { type: "object", properties: { app: stringProperty, module: stringProperty }, required: ["module"] }
   },
   {
     name: "get_guideline",
@@ -16651,6 +17416,7 @@ class ContextRunner extends runner("context") {
     }
     if (name === "get_workspace_summary" || name === "list_apps" || name === "list_modules" || name === "get_module_context") {
       const context = await AkanContextAnalyzer.analyze(workspace, {
+        app: args.app ?? null,
         module: args.module ?? null,
         includeAbstractContent: name === "get_module_context"
       });
@@ -16660,7 +17426,28 @@ class ContextRunner extends runner("context") {
         return context.apps;
       if (name === "list_modules")
         return AkanContextAnalyzer.findModules(context);
-      return AkanContextAnalyzer.findModules(context, args.module);
+      const modules = AkanContextAnalyzer.findModules(context, args.module, {
+        app: args.app ?? null
+      });
+      if (name === "get_module_context" && !args.app && modules.length > 1) {
+        return {
+          diagnostics: [
+            {
+              severity: "error",
+              code: "module-context-ambiguous",
+              message: `Multiple modules match "${args.module}". Re-run get_module_context with an app argument.`,
+              input: "app"
+            }
+          ],
+          candidates: modules.map((module) => ({
+            app: module.sysName,
+            sysType: module.sysType,
+            module: module.name,
+            path: module.path
+          }))
+        };
+      }
+      return modules;
     }
     if (name === "get_guideline")
       return await Prompter.getInstruction(stringArg(args, "name"));
@@ -16689,6 +17476,16 @@ class ContextRunner extends runner("context") {
         validationFailureScopes: ["workspace-config", "environment", "source-change", "unknown"],
         artifactChainFields: ["planPath", "applyReportPath", "repairReportPath", "runId", "validationTarget", "next"],
         diagnosticScopes: ["baseline", "workflow", "unknown"],
+        validationStatuses: {
+          sourceStatus: ["passed", "failed", "unknown"],
+          workspaceStatus: ["passed", "failed", "unknown"],
+          overallStatus: ["passed", "failed", "blocked-by-workspace-config", "blocked-by-environment"],
+          knownBlockers: "Repeated workspace-config/environment failures are summarized before command output."
+        },
+        moduleContextInputs: {
+          module: "required",
+          app: "recommended in monorepos; required when module names are ambiguous"
+        },
         generatedFreshnessStatuses: ["fresh", "stale", "missing", "unknown"],
         directEditFallbackPolicy: applyFirstPolicy,
         applyReportFields: [
@@ -16714,12 +17511,12 @@ class ContextRunner extends runner("context") {
       const workflow2 = stringArg(args, "workflow");
       const inputs = workflowInputsArg(args);
       const planPath = typeof args.out === "string" && args.out ? args.out : defaultWorkflowPlanPath(workflow2, inputs);
-      const plan = parseJsonOutput(await new WorkflowRunner().plan(workflow2, inputs, {
+      const plan2 = parseJsonOutput(await new WorkflowRunner().plan(workflow2, inputs, {
         format: "json",
         out: workspacePath(workspace, planPath)
       }));
       return {
-        ...plan,
+        ...plan2,
         planPath,
         next: { tool: "apply_workflow", args: { planPath } },
         policy: applyFirstPolicy