@shahmarasy/prodo 0.1.2 → 0.1.4

package/dist/agents.js

@@ -32,7 +32,8 @@ async function loadAgentCommandSet(_cwd, agent) {
             { command: `${prefix}-wireframe`, purpose: "Generate wireframe artifact." },
             { command: `${prefix}-stories`, purpose: "Generate stories artifact." },
             { command: `${prefix}-techspec`, purpose: "Generate techspec artifact." },
-            { command: `${prefix}-validate`, purpose: "Run validation report." }
+            { command: `${prefix}-validate`, purpose: "Run validation report." },
+            { command: `${prefix}-fix`, purpose: "Fix artifacts when validation fails." }
         ],
         artifact_shortcuts: {
             normalize: `${prefix}-normalize`,
@@ -41,7 +42,8 @@ async function loadAgentCommandSet(_cwd, agent) {
             wireframe: `${prefix}-wireframe`,
             stories: `${prefix}-stories`,
             techspec: `${prefix}-techspec`,
-            validate: `${prefix}-validate`
+            validate: `${prefix}-validate`,
+            fix: `${prefix}-fix`
         }
     };
 }

package/dist/artifacts.d.ts

@@ -5,5 +5,6 @@ export type GenerateOptions = {
     normalizedBriefOverride?: string;
     outPath?: string;
     agent?: string;
+    revisionType?: "default" | "fix";
 };
 export declare function generateArtifact(options: GenerateOptions): Promise<string>;

package/dist/artifacts.js

@@ -20,11 +20,7 @@ const markdown_1 = require("./markdown");
 const utils_1 = require("./utils");
 const validator_1 = require("./validator");
 function defaultFilename(type) {
-    if (type === "workflow")
-        return `${type}-${(0, utils_1.timestampSlug)()}.md`;
-    if (type === "wireframe")
-        return `${type}-${(0, utils_1.timestampSlug)()}.md`;
-    return `${type}-${(0, utils_1.timestampSlug)()}.md`;
+    return `${type}-${(0, utils_1.artifactFileStamp)()}.md`;
 }
 function sidecarPath(filePath) {
     const parsed = node_path_1.default.parse(filePath);
@@ -147,7 +143,166 @@ function renderWorkflowMermaidTemplate(templateContent, normalized, coverage, la
         return token;
     });
 }
-async function resolvePrompt(cwd, artifactType, templateContent, requiredHeadings, companionTemplate, agent) {
+function normalizeAuthor(author) {
+    if (!author)
+        return undefined;
+    const normalized = author.trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function replaceAuthorPlaceholders(body, author) {
+    const safeAuthor = normalizeAuthor(author);
+    if (!safeAuthor)
+        return body;
+    return body.replace(/\{\{\s*author\s*\}\}/gi, safeAuthor);
+}
+function todayYmd() {
+    const now = new Date();
+    const y = now.getFullYear();
+    const m = String(now.getMonth() + 1).padStart(2, "0");
+    const d = String(now.getDate()).padStart(2, "0");
+    return `${y}-${m}-${d}`;
+}
+function headingKey(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, " ")
+        .trim();
+}
+function defaultDocumentControlValues(lang, revisionType, version, author) {
+    const tr = lang.toLowerCase().startsWith("tr");
+    const safeAuthor = normalizeAuthor(author) ?? (tr ? "Prodo" : "Prodo");
+    const description = revisionType === "fix"
+        ? (tr ? "Dogrulama sonrasi duzeltme revizyonu" : "Post-validation fix revision")
+        : (tr ? "Ilk surum" : "Initial version");
+    return {
+        version,
+        date: todayYmd(),
+        author: safeAuthor,
+        description
+    };
+}
+function applyDocumentControlDefaults(body, options) {
+    const defaults = defaultDocumentControlValues(options.lang, options.revisionType, options.version, options.author);
+    let out = body
+        .replace(/\{\{\s*date\s*\}\}/gi, defaults.date)
+        .replace(/\{\{\s*description\s*\}\}/gi, defaults.description)
+        .replace(/\{\{\s*version\s*\}\}/gi, defaults.version);
+    const lines = out.split(/\r?\n/);
+    const headingIndex = lines.findIndex((line) => {
+        const match = line.match(/^\s*##+\s+(.+?)\s*$/);
+        if (!match)
+            return false;
+        const key = headingKey(match[1]);
+        return key.includes("document control") || key.includes("belge kontrol");
+    });
+    if (headingIndex === -1)
+        return out;
+    const row = `| ${defaults.version} | ${defaults.date} | ${defaults.author} | ${defaults.description} |`;
+    let tableSeparatorIndex = -1;
+    let tableDataIndex = -1;
+    for (let i = headingIndex + 1; i < lines.length; i += 1) {
+        if (/^\s*##+\s+/.test(lines[i]))
+            break;
+        if (tableSeparatorIndex === -1 && /\|/.test(lines[i]) && /-/.test(lines[i])) {
+            tableSeparatorIndex = i;
+            continue;
+        }
+        if (tableSeparatorIndex !== -1 && /^\s*\|/.test(lines[i])) {
+            tableDataIndex = i;
+            break;
+        }
+    }
+    if (tableDataIndex !== -1) {
+        lines[tableDataIndex] = row;
+    }
+    else if (tableSeparatorIndex !== -1) {
+        lines.splice(tableSeparatorIndex + 1, 0, row);
+    }
+    else {
+        lines.splice(headingIndex + 1, 0, "", "| Version | Date | Author | Description |", "|--------|------|--------|-------------|", row, "");
+    }
+    out = lines.join("\n");
+    return out;
+}
+function parseVersionToken(input) {
+    const match = input.match(/v?\s*(\d+)(?:\.(\d+))?/i);
+    if (!match)
+        return null;
+    const major = Number(match[1]);
+    const minor = Number(match[2] ?? "0");
+    if (!Number.isFinite(major) || !Number.isFinite(minor))
+        return null;
+    return { major, minor };
+}
+function extractDocumentControlVersion(body) {
+    const tableMatch = body.match(/\|\s*(v?\d+(?:\.\d+)?)\s*\|/i);
+    if (tableMatch?.[1])
+        return tableMatch[1].trim().startsWith("v") ? tableMatch[1].trim() : `v${tableMatch[1].trim()}`;
+    const looseMatch = body.match(/\bv?\d+\.\d+\b/i);
+    if (looseMatch?.[0])
+        return looseMatch[0].startsWith("v") ? looseMatch[0] : `v${looseMatch[0]}`;
+    return undefined;
+}
+async function resolveDocumentControlVersion(cwd, artifactType, revisionType) {
+    if (revisionType !== "fix")
+        return "v1.0";
+    const activePath = await (0, output_index_1.getActiveArtifactPath)(cwd, artifactType);
+    const fallbackPath = activePath ?? (await loadLatestArtifactPath(cwd, artifactType));
+    if (!fallbackPath || !(await (0, utils_1.fileExists)(fallbackPath))) {
+        return "v1.1";
+    }
+    try {
+        const previous = await loadArtifactDoc(fallbackPath);
+        const previousVersion = extractDocumentControlVersion(previous.body) ?? String(previous.frontmatter.version ?? "");
+        const parsed = parseVersionToken(previousVersion);
+        if (!parsed)
+            return "v1.1";
+        return `v${parsed.major}.${parsed.minor + 1}`;
+    }
+    catch {
+        return "v1.1";
+    }
+}
+function enforceAuthorInControlTables(body, author) {
+    const safeAuthor = normalizeAuthor(author);
+    if (!safeAuthor)
+        return body;
+    return body.replace(/(\|\s*v?[0-9.]+\s*\|\s*[^|]*\|\s*)([^|]*)(\|\s*[^|]*\|)/gi, (_match, left, _current, right) => `${left}${safeAuthor} ${right}`);
+}
+async function resolveUniqueOutputPath(targetDir, fileName) {
+    const parsed = node_path_1.default.parse(fileName);
+    let candidate = node_path_1.default.join(targetDir, fileName);
+    let index = 2;
+    while (await (0, utils_1.fileExists)(candidate)) {
+        candidate = node_path_1.default.join(targetDir, `${parsed.name}-${String(index).padStart(2, "0")}${parsed.ext}`);
+        index += 1;
+    }
+    return candidate;
+}
+function workflowFeatureTargets(normalized, coverage) {
+    const byId = new Map(normalized.contracts.core_features.map((item) => [item.id, item]));
+    const explicit = coverage.core_features
+        .map((id) => byId.get(id))
+        .filter((item) => Boolean(item));
+    if (explicit.length > 1)
+        return explicit;
+    if (normalized.contracts.core_features.length > 1)
+        return normalized.contracts.core_features.slice(0, 6);
+    if (explicit.length === 1)
+        return explicit;
+    return normalized.contracts.core_features.slice(0, 1);
+}
+function renderWorkflowMarkdownForFeature(markdown, feature, lang) {
+    const tr = lang.toLowerCase().startsWith("tr");
+    const noteHeading = tr ? "## Akis Odagi" : "## Flow Focus";
+    const noteLine = tr
+        ? `- [${feature.id}] Bu akis ${feature.text} ihtiyacina odaklanir.`
+        : `- [${feature.id}] This flow focuses on ${feature.text}.`;
+    if (markdown.includes(noteHeading))
+        return markdown;
+    return `${markdown.trim()}\n\n${noteHeading}\n${noteLine}`.trim();
+}
+async function resolvePrompt(cwd, artifactType, templateContent, requiredHeadings, companionTemplate, outputAuthor, agent) {
     const base = await promises_1.default.readFile((0, paths_1.promptPath)(cwd, artifactType), "utf8");
     const authority = `Template authority (STRICT):
 - Treat this template as the single output structure source.
@@ -187,12 +342,19 @@ Wireframe paired output contract (STRICT):
 - Generate companion HTML screens based on native wireframe template.
 - HTML must stay low-fidelity and structure-first.`
         : "";
+    const authorPolicy = outputAuthor && outputAuthor.trim().length > 0
+        ? `
+Author policy (STRICT):
+- Use this exact author name wherever author is required: ${outputAuthor.trim()}
+- Do not invent random author names.`
+        : "";
     const withTemplate = `${base}
 
 ${authority}
 ${companionAuthority}
 ${workflowPairing}
-${wireframePairing}`;
+${wireframePairing}
+${authorPolicy}`;
     if (!agent)
         return withTemplate;
     return `${withTemplate}
@@ -345,12 +507,59 @@ function splitWorkflowPair(raw) {
     }
     return { markdown, mermaid };
 }
+async function writeWorkflowFlows(targetDir, baseName, normalized, coverage, lang, markdownBody, mermaidBody, mermaidTemplateContent) {
+    const targets = workflowFeatureTargets(normalized, coverage);
+    const fallbackFeature = normalized.contracts.core_features[0] ?? { id: "F1", text: "Primary flow" };
+    const flows = targets.length > 0 ? targets : [fallbackFeature];
+    const summaryBodies = [];
+    const renderedArtifacts = [];
+    let primaryMdPath = "";
+    for (const [index, flowFeature] of flows.entries()) {
+        const flowBase = flows.length === 1
+            ? baseName
+            : (index === 0
+                ? baseName
+                : `${baseName}-${index + 1}-${toSlug(extractTurkishTitle(flowFeature.text))}`);
+        const mdPath = node_path_1.default.join(targetDir, `${flowBase}.md`);
+        const mmdPath = node_path_1.default.join(targetDir, `${flowBase}.mmd`);
+        const featureCoverage = {
+            ...coverage,
+            core_features: [flowFeature.id]
+        };
+        const renderedMarkdown = renderWorkflowMarkdownForFeature(markdownBody, flowFeature, lang);
+        const renderedMermaid = (mermaidTemplateContent && mermaidTemplateContent.trim().length > 0)
+            ? renderWorkflowMermaidTemplate(mermaidTemplateContent, normalized, featureCoverage, lang).trim()
+            : (mermaidBody ?? "").trim();
+        if (!/(^|\n)\s*(flowchart|graph)\s+/i.test(renderedMermaid)) {
+            throw new errors_1.UserError("Workflow Mermaid output is invalid.");
+        }
+        enforceLanguage(renderedMarkdown, lang, "workflow");
+        enforceLanguage(renderedMermaid, lang, "workflow");
+        await promises_1.default.writeFile(mdPath, `${renderedMarkdown}\n`, "utf8");
+        await promises_1.default.writeFile(mmdPath, `${renderedMermaid}\n`, "utf8");
+        if (!primaryMdPath)
+            primaryMdPath = mdPath;
+        summaryBodies.push(renderedMarkdown);
+        renderedArtifacts.push({ mdPath, body: renderedMarkdown });
+    }
+    return {
+        primaryPath: primaryMdPath,
+        summaryBody: summaryBodies.join("\n\n"),
+        rendered: renderedArtifacts
+    };
+}
 async function writeWireframeScreens(targetDir, baseName, normalized, coverage, lang, headings, htmlTemplateContent) {
     const tr = lang.toLowerCase().startsWith("tr");
-    const screenContracts = normalized.contracts.core_features
+    const explicitScreens = normalized.contracts.core_features
         .filter((item) => coverage.core_features.includes(item.id))
         .slice(0, 6);
-    const screens = screenContracts.length > 0 ? screenContracts : normalized.contracts.core_features.slice(0, 3);
+    const screens = explicitScreens.length > 1
+        ? explicitScreens
+        : (normalized.contracts.core_features.length > 1
+            ? normalized.contracts.core_features.slice(0, 6)
+            : (explicitScreens.length === 1
+                ? explicitScreens
+                : normalized.contracts.core_features.slice(0, 1)));
     const summaryBodies = [];
     let primaryMdPath = "";
     for (const [index, screen] of screens.entries()) {
@@ -486,9 +695,11 @@ async function writeWireframeScreens(targetDir, baseName, normalized, coverage,
 }
 async function generateArtifact(options) {
     const { cwd, artifactType, outPath, agent } = options;
+    const revisionType = options.revisionType ?? "default";
     const def = await (0, artifact_registry_1.getArtifactDefinition)(cwd, artifactType);
     const normalizedPath = options.normalizedBriefOverride ?? (0, paths_1.normalizedBriefPath)(cwd);
     await ensurePipelinePrereqs(cwd, normalizedPath);
+    const documentControlVersion = await resolveDocumentControlVersion(cwd, artifactType, revisionType);
     const settings = await (0, settings_1.readSettings)(cwd);
     const normalizedBriefRaw = await (0, utils_1.readJsonFile)(normalizedPath);
     const normalizedBrief = (0, normalized_brief_1.parseNormalizedBriefOrThrow)(normalizedBriefRaw);
@@ -510,7 +721,7 @@ async function generateArtifact(options) {
     const computedHeadings = templateHeadings.length > 0
         ? templateHeadings
         : (def.required_headings.length > 0 ? def.required_headings : (0, constants_1.defaultRequiredHeadings)(artifactType));
-    const prompt = await resolvePrompt(cwd, artifactType, template?.content ?? "", computedHeadings, companionTemplate, agent);
+    const prompt = await resolvePrompt(cwd, artifactType, template?.content ?? "", computedHeadings, companionTemplate, settings.author, agent);
     const provider = (0, providers_1.createProvider)();
     const upstreamArtifacts = await buildUpstreamArtifacts(cwd, artifactType, def.upstream);
     const schemaHint = {
@@ -526,14 +737,15 @@ async function generateArtifact(options) {
         templatePath: template?.path ?? "",
         companionTemplateContent: companionTemplate?.content ?? "",
         companionTemplatePath: companionTemplate?.path ?? "",
-        outputLanguage: settings.lang
+        outputLanguage: settings.lang,
+        outputAuthor: settings.author
     }, schemaHint);
-    let generatedBody = generated.body.trim();
+    let generatedBody = enforceAuthorInControlTables(replaceAuthorPlaceholders(generated.body.trim(), settings.author), settings.author);
     let workflowMermaidBody = null;
     if (artifactType === "workflow") {
         const paired = splitWorkflowPair(generatedBody);
-        generatedBody = paired.markdown;
-        workflowMermaidBody = paired.mermaid;
+        generatedBody = enforceAuthorInControlTables(replaceAuthorPlaceholders(paired.markdown, settings.author), settings.author);
+        workflowMermaidBody = replaceAuthorPlaceholders(paired.mermaid, settings.author);
     }
     let contractCoverage = extractCoverageFromBody(generatedBody);
     if (artifactType === "workflow") {
@@ -552,8 +764,15 @@ async function generateArtifact(options) {
             };
         }
     }
+    generatedBody = applyDocumentControlDefaults(generatedBody, {
+        lang: settings.lang,
+        revisionType,
+        version: documentControlVersion,
+        author: settings.author
+    });
     if (artifactType === "workflow" && companionTemplate?.content) {
         workflowMermaidBody = renderWorkflowMermaidTemplate(companionTemplate.content, normalizedBrief, contractCoverage, settings.lang).trim();
+        workflowMermaidBody = replaceAuthorPlaceholders(workflowMermaidBody, settings.author);
     }
     enforceLanguage(generatedBody, settings.lang, artifactType);
     if (artifactType === "workflow" && workflowMermaidBody) {
@@ -574,9 +793,13 @@ async function generateArtifact(options) {
         status: constants_1.DEFAULT_STATUS,
         upstream_artifacts: upstreamArtifacts.map((item) => item.file),
         contract_coverage: contractCoverage,
-        language: settings.lang
+        language: settings.lang,
+        ...(normalizeAuthor(settings.author) ? { author: normalizeAuthor(settings.author) } : {})
     };
     const mergedFrontmatter = { ...frontmatter, ...(generated.frontmatter ?? {}) };
+    if (normalizeAuthor(settings.author)) {
+        mergedFrontmatter.author = normalizeAuthor(settings.author);
+    }
     let doc = {
         frontmatter: mergedFrontmatter,
         body: generatedBody
@@ -588,29 +811,40 @@ async function generateArtifact(options) {
         throw new errors_1.UserError(`Artifact failed schema checks:\n${details}`);
     }
     const targetDir = (0, paths_1.outputDirPath)(cwd, artifactType, def.output_dir);
-    const finalPath = outPath ? node_path_1.default.resolve(cwd, outPath) : node_path_1.default.join(targetDir, defaultFilename(artifactType));
+    const finalPath = outPath
+        ? node_path_1.default.resolve(cwd, outPath)
+        : await resolveUniqueOutputPath(targetDir, defaultFilename(artifactType));
     if (!(0, utils_1.isPathInside)(node_path_1.default.join(cwd, "product-docs"), finalPath)) {
         throw new errors_1.UserError("Artifact output must be inside `product-docs/`.");
     }
     await promises_1.default.mkdir(node_path_1.default.dirname(finalPath), { recursive: true });
     if (artifactType === "workflow") {
         const basePath = node_path_1.default.join(node_path_1.default.dirname(finalPath), node_path_1.default.parse(finalPath).name);
-        const mdPath = `${basePath}.md`;
-        const mmdPath = `${basePath}.mmd`;
-        await promises_1.default.writeFile(mdPath, gray_matter_1.default.stringify(doc.body, doc.frontmatter), "utf8");
-        await promises_1.default.writeFile(mmdPath, `${(workflowMermaidBody ?? "").trim()}\n`, "utf8");
-        await writeSidecar(mdPath, doc);
-        const derivedContext = {
-            artifact_type: artifactType,
-            artifact_file: mdPath,
-            generated_at: new Date().toISOString(),
-            contract_coverage: contractCoverage,
-            ...deriveStructuredContext(artifactType, doc.body, schemaHint.requiredHeadings)
-        };
+        const workflow = await writeWorkflowFlows(node_path_1.default.dirname(basePath), node_path_1.default.parse(basePath).name, normalizedBrief, contractCoverage, settings.lang, doc.body, workflowMermaidBody, companionTemplate?.content ?? null);
         await promises_1.default.mkdir((0, paths_1.outputContextDirPath)(cwd), { recursive: true });
-        await promises_1.default.writeFile(contextFilePath(cwd, mdPath), `${JSON.stringify(derivedContext, null, 2)}\n`, "utf8");
-        await (0, output_index_1.setActiveArtifact)(cwd, artifactType, mdPath);
-        return mdPath;
+        for (const rendered of workflow.rendered) {
+            const renderedDoc = {
+                frontmatter: doc.frontmatter,
+                body: rendered.body
+            };
+            await promises_1.default.writeFile(rendered.mdPath, gray_matter_1.default.stringify(renderedDoc.body, renderedDoc.frontmatter), "utf8");
+            await writeSidecar(rendered.mdPath, renderedDoc);
+            const renderedContext = {
+                artifact_type: artifactType,
+                artifact_file: rendered.mdPath,
+                generated_at: new Date().toISOString(),
+                contract_coverage: contractCoverage,
+                ...deriveStructuredContext(artifactType, renderedDoc.body, schemaHint.requiredHeadings)
+            };
+            await promises_1.default.writeFile(contextFilePath(cwd, rendered.mdPath), `${JSON.stringify(renderedContext, null, 2)}\n`, "utf8");
+        }
+        const primaryRendered = workflow.rendered.find((item) => item.mdPath === workflow.primaryPath) ?? workflow.rendered[0];
+        doc = {
+            frontmatter: doc.frontmatter,
+            body: primaryRendered?.body ?? doc.body
+        };
+        await (0, output_index_1.setActiveArtifact)(cwd, artifactType, workflow.primaryPath);
+        return workflow.primaryPath;
     }
     else if (artifactType === "wireframe") {
         const base = node_path_1.default.parse(finalPath).name;

package/dist/cli.js

@@ -29,6 +29,8 @@ function mapForcedCommand(forcedCommand) {
         return "validate";
     if (forcedCommand === "prodo-normalize")
         return "normalize";
+    if (forcedCommand === "prodo-fix")
+        return "fix";
     if (forcedCommand === "prodo-prd")
         return "prd";
     if (forcedCommand === "prodo-workflow")
@@ -49,7 +51,8 @@ async function runArtifactCommand(type, opts, cwd, log, options) {
         cwd,
         normalizedBriefOverride: opts.from,
         outPath: opts.out,
-        agent
+        agent,
+        revisionType: opts.revisionType
     });
     const agentMsg = agent ? ` [agent=${agent}]` : "";
     log(`${type.toUpperCase()} generated${agentMsg}: ${file}`);
@@ -100,13 +103,15 @@ async function runCli(options = {}) {
         .command("init [target]")
         .option("--ai <name>", "agent integration: codex | gemini-cli | claude-cli")
         .option("--lang <code>", "document language (e.g. en, tr)")
+        .option("--author <name>", "document author name")
         .option("--preset <name>", "preset to install during initialization")
         .action(async (target, opts) => {
         const projectRoot = node_path_1.default.resolve(cwd, target ?? ".");
         const selected = await (0, init_tui_1.gatherInitSelections)({
             projectRoot,
             aiInput: opts.ai,
-            langInput: opts.lang
+            langInput: opts.lang,
+            authorInput: opts.author
         });
         const selectedAi = selected.ai;
         if (selected.interactive) {
@@ -116,6 +121,7 @@ async function runCli(options = {}) {
             const result = await (0, init_1.runInit)(projectRoot, {
                 ai: selectedAi,
                 lang: selected.lang,
+                author: selected.author,
                 preset: opts.preset,
                 script: selected.script
             });
@@ -124,13 +130,15 @@ async function runCli(options = {}) {
                 projectRoot,
                 settingsPath: result.settingsPath,
                 ai: selectedAi,
-                lang: selected.lang
+                lang: selected.lang,
+                author: selected.author
             });
             return;
         }
         const result = await (0, init_1.runInit)(projectRoot, {
             ai: selectedAi,
             lang: selected.lang,
+            author: selected.author,
             preset: opts.preset,
             script: selected.script
         });
@@ -144,6 +152,7 @@ async function runCli(options = {}) {
             out("No agent selected. Use `prodo generate` for end-to-end generation.");
         }
         out(`Settings file: ${result.settingsPath}`);
+        out(`Author: ${selected.author}`);
         out("Next: edit brief.md.");
     });
     program
@@ -178,6 +187,51 @@ async function runCli(options = {}) {
             await (0, hook_executor_1.runHookPhase)(cwd, "after_validate", out);
         });
     });
+    program
+        .command("fix", { hidden: true })
+        .description("Advanced: auto-regenerate affected artifacts from validation findings")
+        .option("--agent <name>", "agent profile: codex | gemini-cli | claude-cli")
+        .option("--strict", "treat validation warnings as errors")
+        .option("--report <path>", "validation report output path")
+        .action(async (opts) => {
+        if (opts.agent)
+            (0, agents_1.resolveAgent)(opts.agent);
+        await withBriefReadOnlyGuard(cwd, async () => {
+            await (0, hook_executor_1.runHookPhase)(cwd, "before_validate", out);
+            const initial = await (0, validate_1.runValidate)(cwd, {
+                strict: Boolean(opts.strict),
+                report: opts.report
+            });
+            out(`Validation report written to: ${initial.reportPath}`);
+            await (0, hook_executor_1.runHookPhase)(cwd, "after_validate", out);
+            if (initial.pass) {
+                out("No blocking issues found. Nothing to fix.");
+                return;
+            }
+            const targets = await resolveFixTargets(cwd, artifactTypes, initial.issues);
+            out(`Validation failed. Regenerating impacted artifacts: ${targets.join(", ")}`);
+            await (0, hook_executor_1.runHookPhase)(cwd, "before_normalize", out);
+            const normalizedPath = await (0, normalize_1.runNormalize)({ cwd });
+            out(`Normalized brief refreshed: ${normalizedPath}`);
+            await (0, hook_executor_1.runHookPhase)(cwd, "after_normalize", out);
+            for (const type of targets) {
+                await runArtifactCommand(type, { from: normalizedPath, agent: opts.agent, revisionType: "fix" }, cwd, out, {
+                    suggestValidate: false
+                });
+            }
+            await (0, hook_executor_1.runHookPhase)(cwd, "before_validate", out);
+            const final = await (0, validate_1.runValidate)(cwd, {
+                strict: Boolean(opts.strict),
+                report: opts.report
+            });
+            out(`Validation report written to: ${final.reportPath}`);
+            if (!final.pass) {
+                throw new errors_1.UserError("Fix completed but validation is still failing. Review report and retry.");
+            }
+            out("Fix pipeline completed. Validation passed.");
+            await (0, hook_executor_1.runHookPhase)(cwd, "after_validate", out);
+        });
+    });
     program
         .command("normalize", { hidden: true })
         .description("Advanced: normalize brief without full pipeline")
@@ -276,6 +330,9 @@ async function runCli(options = {}) {
             else if (forced === "validate") {
                 await program.parseAsync(["node", "prodo", "validate", ...argv.slice(2)]);
             }
+            else if (forced === "fix") {
+                await program.parseAsync(["node", "prodo", "fix", ...argv.slice(2)]);
+            }
             else {
                 await program.parseAsync(["node", "prodo", forced, ...argv.slice(2)]);
             }
@@ -300,3 +357,23 @@ if (require.main === module) {
         process.exitCode = code;
     });
 }
+async function resolveFixTargets(cwd, artifactTypes, issues) {
+    const direct = new Set(issues
+        .map((issue) => issue.artifactType)
+        .filter((artifactType) => typeof artifactType === "string" && artifactTypes.includes(artifactType)));
+    if (direct.size === 0)
+        return artifactTypes;
+    const defs = await (0, artifact_registry_1.listArtifactDefinitions)(cwd);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const def of defs) {
+            const needsRefresh = def.upstream.some((upstream) => direct.has(upstream));
+            if (needsRefresh && !direct.has(def.name)) {
+                direct.add(def.name);
+                changed = true;
+            }
+        }
+    }
+    return artifactTypes.filter((artifactType) => direct.has(artifactType));
+}

package/dist/init-tui.d.ts

@@ -3,12 +3,14 @@ export type InitSelections = {
     ai?: SupportedAi;
     script: "sh" | "ps";
     lang: "tr" | "en";
+    author: string;
     interactive: boolean;
 };
 type GatherInitUiOptions = {
     projectRoot: string;
     aiInput?: string;
     langInput?: string;
+    authorInput?: string;
 };
 export declare function gatherInitSelections(options: GatherInitUiOptions): Promise<InitSelections>;
 export declare function finishInitInteractive(summary: {
@@ -16,5 +18,6 @@ export declare function finishInitInteractive(summary: {
     settingsPath: string;
     ai?: SupportedAi;
     lang: "tr" | "en";
+    author: string;
 }): Promise<void>;
 export {};

package/dist/init-tui.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.gatherInitSelections = gatherInitSelections;
 exports.finishInitInteractive = finishInitInteractive;
 const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
 const agent_command_installer_1 = require("./agent-command-installer");
 const errors_1 = require("./errors");
 const utils_1 = require("./utils");
@@ -75,16 +76,32 @@ function modelChoiceFromAi(ai) {
         return "gemini";
     return "auto-detect";
 }
+function defaultAuthorName(authorInput) {
+    const explicit = (authorInput ?? "").trim();
+    if (explicit.length > 0)
+        return explicit;
+    try {
+        const username = node_os_1.default.userInfo().username.trim();
+        if (username.length > 0)
+            return username;
+    }
+    catch {
+        // ignore lookup errors and continue with fallback
+    }
+    return "Product Author";
+}
 async function gatherInitSelections(options) {
     const clack = await loadClack();
     const defaultLang = normalizeLang(options.langInput);
     const fallbackScript = process.platform === "win32" ? "ps" : "sh";
     const parsedAi = (0, agent_command_installer_1.resolveAi)(options.aiInput);
+    const defaultAuthor = defaultAuthorName(options.authorInput);
     if (!isInteractiveTerminal()) {
         return {
             ai: parsedAi,
             script: fallbackScript,
             lang: defaultLang,
+            author: defaultAuthor,
             interactive: false
         };
     }
@@ -129,6 +146,15 @@ async function gatherInitSelections(options) {
         clack.cancel("Initialization cancelled.");
         throw new errors_1.UserError("Initialization cancelled.");
     }
+    const author = await clack.text({
+        message: "Author name",
+        placeholder: "Shahmarasy",
+        defaultValue: defaultAuthor
+    });
+    if (clack.isCancel(author)) {
+        clack.cancel("Initialization cancelled.");
+        throw new errors_1.UserError("Initialization cancelled.");
+    }
     let selectedAi;
     if (model === "codex")
         selectedAi = "codex";
@@ -140,10 +166,11 @@ async function gatherInitSelections(options) {
         ai: selectedAi,
         script: fallbackScript,
         lang,
+        author: String(author).trim() || defaultAuthor,
         interactive: true
     };
 }
 function finishInitInteractive(summary) {
     const aiText = summary.ai ?? "none";
-    return loadClack().then((clack) => clack.outro(`Scaffold complete.\nAI: ${aiText}\nLanguage: ${summary.lang}\nSettings: ${summary.settingsPath}\nNext: edit brief.md`));
+    return loadClack().then((clack) => clack.outro(`Scaffold complete.\nAI: ${aiText}\nLanguage: ${summary.lang}\nAuthor: ${summary.author}\nSettings: ${summary.settingsPath}\nNext: edit brief.md`));
 }

package/dist/init.d.ts

@@ -2,6 +2,7 @@ import { type SupportedAi } from "./agent-command-installer";
 export declare function runInit(cwd: string, options?: {
     ai?: SupportedAi;
     lang?: string;
+    author?: string;
     preset?: string;
     script?: "sh" | "ps";
 }): Promise<{