@shahmarasy/prodo 0.1.0 → 0.1.2

package/dist/agent-command-installer.js

@@ -56,34 +56,24 @@ function renderFrontmatter(frontmatter) {
         return "";
     return `---\n${js_yaml_1.default.dump(frontmatter)}---\n`;
 }
-function resolveScriptBlock(frontmatter, argsPlaceholder) {
-    const run = frontmatter.run;
-    const runAction = typeof run?.action === "string" ? run.action.trim() : "";
-    const runMode = typeof run?.mode === "string" ? run.mode.trim() : "";
-    if (runAction) {
-        const modeSuffix = runMode ? ` (${runMode})` : "";
-        return `- Internal action: ${runAction}${modeSuffix}`;
-    }
-    const runCommand = typeof run?.command === "string" ? run.command.replace("{ARGS}", argsPlaceholder) : "";
-    if (runCommand) {
-        return `- Command: ${runCommand}`;
-    }
-    const scripts = frontmatter.scripts;
-    const sh = typeof scripts?.sh === "string" ? scripts.sh.replace("{ARGS}", argsPlaceholder) : "";
-    const ps = typeof scripts?.ps === "string" ? scripts.ps.replace("{ARGS}", argsPlaceholder) : "";
-    return [`- Bash: ${sh}`, `- PowerShell: ${ps}`].filter((line) => line.length > 8).join("\n");
+function sanitizeFrontmatter(frontmatter) {
+    const out = { ...frontmatter };
+    delete out.run;
+    delete out.scripts;
+    return out;
 }
 function toTomlPrompt(body, frontmatter, argsPlaceholder) {
     const description = String(frontmatter.description ?? "Prodo command");
-    const scriptsBlock = resolveScriptBlock(frontmatter, argsPlaceholder);
     const promptBody = body.replaceAll("$ARGUMENTS", argsPlaceholder);
     return `description = "${description.replace(/"/g, '\\"')}"
 
 prompt = """
-${promptBody}
+Important execution rule:
+- This is an agent slash command, not a shell command.
+- Do NOT run \`prodo-normalize\`, \`prodo-prd\`, or \`prodo ...\` in shell.
+- Execute the workflow directly using workspace files.
 
-Script options:
-${scriptsBlock}
+${promptBody}
 """`;
 }
 function toSkill(name, body, frontmatter) {
@@ -151,7 +141,7 @@ async function installAgentCommands(projectRoot, ai) {
         }
         const outPath = node_path_1.default.join(target, `${commandName}${cfg.extension}`);
         const replacedBody = parsed.body.replaceAll("$ARGUMENTS", cfg.argsPlaceholder);
-        await promises_1.default.writeFile(outPath, `${renderFrontmatter(parsed.frontmatter)}\n${replacedBody}`, "utf8");
+        await promises_1.default.writeFile(outPath, `${renderFrontmatter(sanitizeFrontmatter(parsed.frontmatter))}\n${replacedBody}`, "utf8");
         written.push(outPath);
     }
     return written;

package/dist/agents.js

@@ -20,28 +20,28 @@ function resolveAgent(agent) {
     return agent;
 }
 async function loadAgentCommandSet(_cwd, agent) {
-    const prefix = `prodo-${agent}`;
+    const prefix = "/prodo";
     return {
         agent,
         description: "Agent-specific command set for Prodo artifact pipeline.",
         recommended_sequence: [
             { command: "prodo init . --ai <agent> --lang <en|tr>", purpose: "Initialize Prodo scaffold and agent commands." },
-            { command: `${prefix} normalize`, purpose: "Normalize start brief into normalized brief JSON." },
-            { command: `${prefix} prd`, purpose: "Generate PRD artifact." },
-            { command: `${prefix} workflow`, purpose: "Generate workflow artifact." },
-            { 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}-normalize`, purpose: "Normalize start brief into normalized brief JSON." },
+            { command: `${prefix}-prd`, purpose: "Generate PRD artifact." },
+            { command: `${prefix}-workflow`, purpose: "Generate workflow artifact." },
+            { 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." }
         ],
         artifact_shortcuts: {
-            normalize: `${prefix} normalize`,
-            prd: `${prefix} prd`,
-            workflow: `${prefix} workflow`,
-            wireframe: `${prefix} wireframe`,
-            stories: `${prefix} stories`,
-            techspec: `${prefix} techspec`,
-            validate: `${prefix} validate`
+            normalize: `${prefix}-normalize`,
+            prd: `${prefix}-prd`,
+            workflow: `${prefix}-workflow`,
+            wireframe: `${prefix}-wireframe`,
+            stories: `${prefix}-stories`,
+            techspec: `${prefix}-techspec`,
+            validate: `${prefix}-validate`
         }
     };
 }

package/dist/artifacts.js

@@ -53,18 +53,53 @@ async function loadArtifactDoc(filePath) {
         body: parsed.content
     };
 }
+function languageProbe(body) {
+    const stripped = body
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/^\s*#{1,6}\s+.*$/gm, " ")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/\|/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .toLowerCase();
+    return ` ${stripped} `;
+}
 function hasEnglishLeak(body) {
-    const englishMarkers = [" the ", " and ", " with ", " user ", " should ", " must ", " requirement ", " flow "];
-    const normalized = ` ${body.toLowerCase().replace(/\s+/g, " ")} `;
+    const englishMarkers = [" the ", " and ", " with ", " user ", " should ", " must ", " requirement ", " flow ", " error ", " success "];
+    const normalized = languageProbe(body);
     return englishMarkers.filter((m) => normalized.includes(m)).length >= 2;
 }
+function hasTurkishLeak(body) {
+    const turkishMarkers = [
+        " ve ",
+        " ile ",
+        " kullanici ",
+        " kullanıcı ",
+        " akis ",
+        " akış ",
+        " hata ",
+        " basari ",
+        " başarı ",
+        " ekran ",
+        " islem ",
+        " işlem ",
+        " gerekli "
+    ];
+    const normalized = languageProbe(body);
+    return turkishMarkers.filter((m) => normalized.includes(m)).length >= 2;
+}
 function enforceLanguage(body, lang, artifactType) {
     const normalized = (lang || "en").toLowerCase();
-    if (!normalized.startsWith("tr"))
-        return;
-    if (hasEnglishLeak(body)) {
+    if (normalized.startsWith("tr")) {
+        if (!hasEnglishLeak(body))
+            return;
         throw new errors_1.UserError(`Language enforcement failed for ${artifactType}: output contains English fragments while language is Turkish.`);
     }
+    if (normalized.startsWith("en")) {
+        if (!hasTurkishLeak(body))
+            return;
+        throw new errors_1.UserError(`Language enforcement failed for ${artifactType}: output contains Turkish fragments while language is English.`);
+    }
 }
 function toSlug(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "screen";
@@ -75,7 +110,44 @@ function extractTurkishTitle(featureText) {
         return "Ekran";
     return base;
 }
-async function resolvePrompt(cwd, artifactType, templateContent, requiredHeadings, agent) {
+function replaceTemplateTokens(template, replacements, fallbackFromToken) {
+    let out = template;
+    for (const [key, value] of Object.entries(replacements)) {
+        out = out.replace(new RegExp(`\\{\\{\\s*${key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\}\\}`, "g"), value);
+    }
+    return out.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_match, tokenRaw) => {
+        const token = String(tokenRaw).trim();
+        return fallbackFromToken(token);
+    });
+}
+function renderWorkflowMermaidTemplate(templateContent, normalized, coverage, lang) {
+    const tr = lang.toLowerCase().startsWith("tr");
+    const primaryFeatureId = coverage.core_features[0] ?? normalized.contracts.core_features[0]?.id ?? "F1";
+    const primaryFeatureText = normalized.contracts.core_features.find((item) => item.id === primaryFeatureId)?.text ??
+        normalized.contracts.core_features[0]?.text ??
+        (tr ? "Kullanici islemi" : "User action");
+    return replaceTemplateTokens(templateContent, {
+        "Flow Name": tr ? "Ana Akis" : "Main Flow",
+        "Primary Actor": normalized.audience[0] ?? (tr ? "Kullanici" : "User"),
+        "Primary Action": `[${primaryFeatureId}] ${primaryFeatureText}`,
+        "Success State": tr ? "Basari" : "Success",
+        "Error State": tr ? "Hata" : "Error"
+    }, (token) => {
+        const key = token.toLowerCase();
+        if (key.includes("actor") || key.includes("user"))
+            return normalized.audience[0] ?? (tr ? "Kullanici" : "User");
+        if (key.includes("action") || key.includes("feature"))
+            return `[${primaryFeatureId}] ${primaryFeatureText}`;
+        if (key.includes("success"))
+            return tr ? "Basari" : "Success";
+        if (key.includes("error") || key.includes("fail"))
+            return tr ? "Hata" : "Error";
+        if (key.includes("flow"))
+            return tr ? "Ana Akis" : "Main Flow";
+        return token;
+    });
+}
+async function resolvePrompt(cwd, artifactType, templateContent, requiredHeadings, companionTemplate, 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.
@@ -89,6 +161,14 @@ Resolved template:
 \`\`\`md
 ${templateContent.trim()}
 \`\`\``;
+    const companionAuthority = companionTemplate
+        ? `Native companion template (STRICT reference):
+- Path: ${companionTemplate.path}
+- Preserve this native format and structure when generating companion artifact.
+\`\`\`${artifactType === "workflow" ? "mermaid" : "html"}
+${companionTemplate.content.trim()}
+\`\`\``
+        : "";
     const workflowPairing = artifactType === "workflow"
         ? `
 Workflow paired output contract (STRICT):
@@ -100,9 +180,19 @@ flowchart TD
 \`\`\`
 - Mermaid block is mandatory.`
         : "";
+    const wireframePairing = artifactType === "wireframe"
+        ? `
+Wireframe paired output contract (STRICT):
+- Output markdown explanation first (template headings).
+- Generate companion HTML screens based on native wireframe template.
+- HTML must stay low-fidelity and structure-first.`
+        : "";
     const withTemplate = `${base}
 
-${authority}${workflowPairing}`;
+${authority}
+${companionAuthority}
+${workflowPairing}
+${wireframePairing}`;
     if (!agent)
         return withTemplate;
     return `${withTemplate}
@@ -255,7 +345,7 @@ function splitWorkflowPair(raw) {
     }
     return { markdown, mermaid };
 }
-async function writeWireframeScreens(targetDir, baseName, normalized, coverage, lang, headings) {
+async function writeWireframeScreens(targetDir, baseName, normalized, coverage, lang, headings, htmlTemplateContent) {
     const tr = lang.toLowerCase().startsWith("tr");
     const screenContracts = normalized.contracts.core_features
         .filter((item) => coverage.core_features.includes(item.id))
@@ -268,7 +358,7 @@ async function writeWireframeScreens(targetDir, baseName, normalized, coverage,
         const screenBase = `${baseName}-${index + 1}-${toSlug(title)}`;
         const htmlPath = node_path_1.default.join(targetDir, `${screenBase}.html`);
         const mdPath = node_path_1.default.join(targetDir, `${screenBase}.md`);
-        const html = `<!doctype html>
+        const fallbackHtml = `<!doctype html>
 <html lang="${lang}">
 <head>
   <meta charset="utf-8" />
@@ -300,8 +390,39 @@ async function writeWireframeScreens(targetDir, baseName, normalized, coverage,
     </section>
   </main>
 </body>
-</html>
-`;
+</html>`;
+        const htmlTemplate = htmlTemplateContent && htmlTemplateContent.trim().length > 0 ? htmlTemplateContent : fallbackHtml;
+        const html = replaceTemplateTokens(htmlTemplate, {
+            "Screen Title": title,
+            "Primary Action": tr ? "Kaydet" : "Save",
+            "Description Label": tr ? "Aciklama" : "Description",
+            "Description Placeholder": `[${screen.id}] ${screen.text}`,
+            "Meta Label 1": tr ? "Kontrat" : "Contract",
+            "Meta Value 1": screen.id,
+            "Meta Label 2": tr ? "Aktor" : "Actor",
+            "Meta Value 2": normalized.audience[0] ?? (tr ? "Kullanici" : "User"),
+            "Field Label": tr ? "Alan" : "Field",
+            "Detailed Input Area": tr ? "Detayli Giris Alani" : "Detailed Input Area",
+            "Upload / Attachment Area": tr ? "Dosya Alani" : "Upload Area",
+            "Allowed file types / notes": tr ? "Dusuk sadakatli wireframe." : "Low-fidelity wireframe.",
+            "Consent / confirmation text": tr ? "Onay metni" : "Confirmation text"
+        }, (token) => {
+            const key = token.toLowerCase();
+            if (key.includes("screen") || key.includes("title"))
+                return title;
+            if (key.includes("action") || key.includes("button"))
+                return tr ? "Kaydet" : "Save";
+            if (key.includes("field"))
+                return tr ? "Alan" : "Field";
+            if (key.includes("description") || key.includes("summary"))
+                return `[${screen.id}] ${screen.text}`;
+            if (key.includes("actor") || key.includes("user"))
+                return normalized.audience[0] ?? (tr ? "Kullanici" : "User");
+            if (key.includes("logo"))
+                return "[ LOGO ]";
+            return token;
+        });
+        enforceLanguage(html, lang, "wireframe");
         await promises_1.default.writeFile(htmlPath, html, "utf8");
         const defaultMap = {
             purpose: [`- [${screen.id}] ${screen.text}`],
@@ -352,6 +473,7 @@ async function writeWireframeScreens(targetDir, baseName, normalized, coverage,
             mdLines.push("");
         }
         const mdBody = mdLines.join("\n").trim();
+        enforceLanguage(mdBody, lang, "wireframe");
         await promises_1.default.writeFile(mdPath, `${mdBody}\n`, "utf8");
         if (!primaryMdPath)
             primaryMdPath = mdPath;
@@ -371,9 +493,16 @@ async function generateArtifact(options) {
     const normalizedBriefRaw = await (0, utils_1.readJsonFile)(normalizedPath);
     const normalizedBrief = (0, normalized_brief_1.parseNormalizedBriefOrThrow)(normalizedBriefRaw);
     const template = await (0, template_resolver_1.resolveTemplate)({ cwd, artifactType });
+    const companionTemplate = await (0, template_resolver_1.resolveCompanionTemplate)({ cwd, artifactType });
     if (!template || template.content.trim().length === 0) {
         throw new errors_1.UserError(`Missing ${artifactType} template. Create \`.prodo/templates/${artifactType}.md\` before running \`prodo-${artifactType}\`.`);
     }
+    if (artifactType === "workflow" && !companionTemplate) {
+        throw new errors_1.UserError("Missing workflow companion template. Create `.prodo/templates/workflow.mmd` before running `prodo-workflow`.");
+    }
+    if (artifactType === "wireframe" && !companionTemplate) {
+        throw new errors_1.UserError("Missing wireframe companion template. Create `.prodo/templates/wireframe.html` before running `prodo-wireframe`.");
+    }
     const templateHeadings = template && template.content.trim().length > 0 ? (0, template_resolver_1.extractRequiredHeadingsFromTemplate)(template.content) : [];
     if (templateHeadings.length === 0) {
         throw new errors_1.UserError(`${artifactType} template has no extractable headings. Add markdown headings to \`${template.path}\`.`);
@@ -381,7 +510,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, agent);
+    const prompt = await resolvePrompt(cwd, artifactType, template?.content ?? "", computedHeadings, companionTemplate, agent);
     const provider = (0, providers_1.createProvider)();
     const upstreamArtifacts = await buildUpstreamArtifacts(cwd, artifactType, def.upstream);
     const schemaHint = {
@@ -395,6 +524,8 @@ async function generateArtifact(options) {
         contractCatalog: normalizedBrief.contracts,
         templateContent: template?.content ?? "",
         templatePath: template?.path ?? "",
+        companionTemplateContent: companionTemplate?.content ?? "",
+        companionTemplatePath: companionTemplate?.path ?? "",
         outputLanguage: settings.lang
     }, schemaHint);
     let generatedBody = generated.body.trim();
@@ -421,7 +552,13 @@ async function generateArtifact(options) {
             };
         }
     }
+    if (artifactType === "workflow" && companionTemplate?.content) {
+        workflowMermaidBody = renderWorkflowMermaidTemplate(companionTemplate.content, normalizedBrief, contractCoverage, settings.lang).trim();
+    }
     enforceLanguage(generatedBody, settings.lang, artifactType);
+    if (artifactType === "workflow" && workflowMermaidBody) {
+        enforceLanguage(workflowMermaidBody, settings.lang, artifactType);
+    }
     const uncovered = missingCoverage(def.required_contracts, normalizedBrief, contractCoverage);
     if (uncovered.length > 0) {
         const lines = uncovered
@@ -477,7 +614,7 @@ async function generateArtifact(options) {
     }
     else if (artifactType === "wireframe") {
         const base = node_path_1.default.parse(finalPath).name;
-        const wireframe = await writeWireframeScreens(node_path_1.default.dirname(finalPath), base, normalizedBrief, contractCoverage, settings.lang, schemaHint.requiredHeadings);
+        const wireframe = await writeWireframeScreens(node_path_1.default.dirname(finalPath), base, normalizedBrief, contractCoverage, settings.lang, schemaHint.requiredHeadings, companionTemplate?.content ?? null);
         doc = {
             frontmatter: doc.frontmatter,
             body: wireframe.summaryBody

package/dist/cli.js

@@ -124,7 +124,6 @@ async function runCli(options = {}) {
                 projectRoot,
                 settingsPath: result.settingsPath,
                 ai: selectedAi,
-                script: selected.script,
                 lang: selected.lang
             });
             return;
@@ -139,15 +138,13 @@ async function runCli(options = {}) {
         if (selectedAi) {
             out(`Agent command set installed for ${selectedAi}.`);
             out(`Installed ${result.installedAgentFiles.length} command files.`);
-            out("Primary workflow: run `prodo generate` after editing brief.md.");
-            out("Advanced: artifact-level slash commands remain available when needed.");
+            out("Agent workflow: edit brief.md, then run slash commands in your agent.");
         }
         else {
             out("No agent selected. Use `prodo generate` for end-to-end generation.");
-            out("Advanced commands are still available when needed.");
         }
         out(`Settings file: ${result.settingsPath}`);
-        out("Next: edit brief.md, then run `prodo generate`.");
+        out("Next: edit brief.md.");
     });
     program
         .command("generate")
@@ -182,7 +179,7 @@ async function runCli(options = {}) {
         });
     });
     program
-        .command("normalize")
+        .command("normalize", { hidden: true })
         .description("Advanced: normalize brief without full pipeline")
         .option("--brief <path>", "path to start brief markdown")
         .option("--out <path>", "output normalized brief json path")
@@ -210,7 +207,7 @@ async function runCli(options = {}) {
     });
     for (const type of artifactTypes) {
         program
-            .command(type)
+            .command(type, { hidden: true })
             .description(`Advanced: generate only ${type} artifact`)
             .option("--from <path>", "path to normalized-brief.json")
             .option("--out <path>", "output file path")
@@ -222,7 +219,7 @@ async function runCli(options = {}) {
         });
     }
     program
-        .command("agent-commands")
+        .command("agent-commands", { hidden: true })
         .requiredOption("--agent <name>", "agent profile: codex | gemini-cli | claude-cli")
         .action(async (opts) => {
         const agent = (0, agents_1.resolveAgent)(opts.agent);
@@ -246,7 +243,7 @@ async function runCli(options = {}) {
         }
     });
     program
-        .command("validate")
+        .command("validate", { hidden: true })
         .description("Advanced: run validation only")
         .option("--strict", "treat warnings as errors")
         .option("--report <path>", "report output path")

package/dist/init-tui.d.ts

@@ -15,7 +15,6 @@ export declare function finishInitInteractive(summary: {
     projectRoot: string;
     settingsPath: string;
     ai?: SupportedAi;
-    script: "sh" | "ps";
     lang: "tr" | "en";
 }): Promise<void>;
 export {};

package/dist/init-tui.js

@@ -117,18 +117,6 @@ async function gatherInitSelections(options) {
         clack.cancel("Initialization cancelled.");
         throw new errors_1.UserError("Initialization cancelled.");
     }
-    const script = await clack.select({
-        message: "Select script type",
-        initialValue: fallbackScript,
-        options: [
-            { value: "sh", label: "sh", hint: "Command profile (metadata)" },
-            { value: "ps", label: "ps", hint: "Command profile (metadata)" }
-        ]
-    });
-    if (clack.isCancel(script)) {
-        clack.cancel("Initialization cancelled.");
-        throw new errors_1.UserError("Initialization cancelled.");
-    }
     const lang = await clack.select({
         message: "Select language",
         initialValue: defaultLang,
@@ -150,12 +138,12 @@ async function gatherInitSelections(options) {
         selectedAi = detectedAi;
     return {
         ai: selectedAi,
-        script,
+        script: fallbackScript,
         lang,
         interactive: true
     };
 }
 function finishInitInteractive(summary) {
     const aiText = summary.ai ?? "none";
-    return loadClack().then((clack) => clack.outro(`Scaffold complete.\nAI: ${aiText}\nScript: ${summary.script}\nLanguage: ${summary.lang}\nSettings: ${summary.settingsPath}\nNext: edit brief.md`));
+    return loadClack().then((clack) => clack.outro(`Scaffold complete.\nAI: ${aiText}\nLanguage: ${summary.lang}\nSettings: ${summary.settingsPath}\nNext: edit brief.md`));
 }

package/dist/init.js

@@ -123,6 +123,26 @@ async function copyDirIfMissing(sourceDir, targetDir, copiedAssets) {
         });
     }
 }
+async function refreshLegacyCommandTemplates(sourceDir, targetDir) {
+    if (!(await (0, utils_1.fileExists)(sourceDir)) || !(await (0, utils_1.fileExists)(targetDir)))
+        return;
+    const entries = await promises_1.default.readdir(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        if (!entry.name.startsWith("prodo-") || !entry.name.endsWith(".md"))
+            continue;
+        const src = node_path_1.default.join(sourceDir, entry.name);
+        const dst = node_path_1.default.join(targetDir, entry.name);
+        if (!(await (0, utils_1.fileExists)(dst)))
+            continue;
+        const existing = await promises_1.default.readFile(dst, "utf8");
+        const isLegacyRunMode = /run:\s*\n\s*action:\s*[^\n]+/m.test(existing) || /mode:\s*internal-runtime/m.test(existing);
+        if (!isLegacyRunMode)
+            continue;
+        await promises_1.default.copyFile(src, dst);
+    }
+}
 async function buildAssetManifest(pairs, previous, backup) {
     const previousByTarget = new Map();
     for (const item of previous?.assets ?? []) {
@@ -264,6 +284,7 @@ async function runInit(cwd, options) {
         await writeFileIfMissing(node_path_1.default.join(root, "templates", templateFileName(artifact.name)), `${(0, templates_1.artifactTemplateTemplate)(artifact.name, options?.lang ?? "en")}\n`);
     }
     await copyDirIfMissing(node_path_1.default.join(projectScaffoldTemplates, "commands"), node_path_1.default.join(root, "commands"), copiedAssets);
+    await refreshLegacyCommandTemplates(node_path_1.default.join(projectScaffoldTemplates, "commands"), node_path_1.default.join(root, "commands"));
     for (const command of workflowCommands) {
         await writeFileIfMissing(node_path_1.default.join(root, "commands", `${command.name}.md`), `${(0, templates_1.commandTemplate)(command)}\n`);
     }

package/dist/providers/mock-provider.js

@@ -107,8 +107,15 @@ function buildArtifactBody(schemaHint, inputContext) {
     const lang = typeof inputContext.outputLanguage === "string" ? inputContext.outputLanguage.toLowerCase() : "en";
     const items = normalizeSectionItems(inputContext);
     const coverage = coverageItems(schemaHint, inputContext);
+    const localizedItems = lang === "tr" ? items.map((_, index) => `Gereksinim maddesi ${index + 1}`) : items;
+    const localizedCoverage = lang === "tr"
+        ? coverage.map((item, index) => ({
+            id: item.id,
+            text: `Kontrat kapsami ${index + 1}`
+        }))
+        : coverage;
     const fallback = lang === "tr" ? "Detay daha sonra netlestirilecek." : "To be refined.";
-    const sections = schemaHint.requiredHeadings.map((heading) => headingBlock(heading, items, fallback, coverage));
+    const sections = schemaHint.requiredHeadings.map((heading) => headingBlock(heading, localizedItems, fallback, localizedCoverage));
     const title = lang === "tr"
         ? `# ${productName} icin ${schemaHint.artifactType.toUpperCase()}`
         : `# ${schemaHint.artifactType.toUpperCase()} for ${productName}`;

package/dist/template-resolver.d.ts

@@ -7,5 +7,9 @@ export declare function resolveTemplate(options: ResolveOptions): Promise<{
     path: string;
     content: string;
 } | null>;
+export declare function resolveCompanionTemplate(options: ResolveOptions): Promise<{
+    path: string;
+    content: string;
+} | null>;
 export declare function extractRequiredHeadingsFromTemplate(content: string): string[];
 export {};

package/dist/template-resolver.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveTemplate = resolveTemplate;
+exports.resolveCompanionTemplate = resolveCompanionTemplate;
 exports.extractRequiredHeadingsFromTemplate = extractRequiredHeadingsFromTemplate;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const paths_1 = require("./paths");
@@ -23,6 +24,23 @@ async function resolveTemplate(options) {
     }
     return null;
 }
+async function resolveCompanionTemplate(options) {
+    const { cwd, artifactType } = options;
+    const nativeExt = artifactType === "workflow" ? ".mmd" : artifactType === "wireframe" ? ".html" : null;
+    if (!nativeExt)
+        return null;
+    const candidates = [
+        ...(0, paths_1.overrideTemplateCandidatePaths)(cwd, artifactType),
+        ...(0, paths_1.templateCandidatePaths)(cwd, artifactType)
+    ].filter((candidate) => candidate.toLowerCase().endsWith(nativeExt));
+    for (const filePath of candidates) {
+        if (await (0, utils_1.fileExists)(filePath)) {
+            const content = await promises_1.default.readFile(filePath, "utf8");
+            return { path: filePath, content };
+        }
+    }
+    return null;
+}
 function extractRequiredHeadingsFromTemplate(content) {
     return (0, markdown_1.extractRequiredHeadings)(content);
 }

package/dist/templates.js

@@ -350,9 +350,6 @@ handoffs:
     agent: prodo-next
     prompt: Continue with the next Prodo command in sequence.
     send: true
-run:
-  action: ${command.cliSubcommand}
-  mode: internal-runtime
 ---
 
 ## User Input
@@ -364,6 +361,8 @@ $ARGUMENTS
 Execution policy:
 - Execute-first, diagnose-second.
 - Perform only minimal prerequisite checks before execution.
+- Do not run shell commands or CLI commands from inside the agent.
+- Never run \`prodo-${command.cliSubcommand}\`, \`prodo ${command.cliSubcommand}\`, or \`prodo ...\` in shell.
 - Do not inspect hooks or internals unless command execution fails.
 - Input files are read-only; never modify or rewrite \`brief.md\`.
 
@@ -375,12 +374,14 @@ Execution policy:
 - Confirm output location is writable.
 
 2. Execute immediately:
-- Execute the \`${command.cliSubcommand}\` process through Prodo internal runtime.
+- Execute the \`${command.cliSubcommand}\` process directly using workspace files and Prodo rules.
 - Keep narration short and action-oriented.
 
 3. Verify result:
-- Confirm expected output file(s) were created/updated.
+- Confirm expected output file(s) were created/updated under \`product-docs/\` (or \`.prodo/briefs\` for normalize).
 - Confirm command success state (exit code or validation status).
+- Confirm \`brief.md\` hash/content did not change.
+- Do NOT create manual fallback files under \`.prodo/artifact\` or any ad-hoc folder.
 
 4. Diagnose only on failure:
 - Inspect \`.prodo/hooks.yml\` only after execution failure.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shahmarasy/prodo",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "CLI-first, prompt-powered product artifact kit",
   "main": "dist/cli.js",
   "types": "dist/cli.d.ts",