agent-enderun 0.9.0 → 0.9.1

package/docs/getting-started.md

@@ -1,263 +1,13 @@
-# 🚀 Getting Started — Sıfırdan Agent Enderun ile Proje Kurma Rehberi / Quickstart Guide
+# Quickstart Guide for New Agent Enderun Projects
 
-[English](#english) | [Türkçe](#türkçe)
+This guide is prepared for developers who want to set up Agent Enderun in a new project from scratch.
 
----
+> **As of v0.9.1, the primary initialization command is:** `npx agent-enderun init`
 
-# English
+### Installation Steps
+- Initialize the framework with `npx agent-enderun init`.
+- Fill in the `docs/tech-stack.md` and `docs/project-docs.md` files.
+- Create the first task with `npx agent-enderun trace:new`.
+- `@manager` manages the project automatically in every session.
 
-This guide is prepared for developers and engineering teams who want to set up Agent Enderun **from scratch** on a new project. It provides a step-by-step, practical walkthrough.
-
-> **Primary recommended installation command from v0.6.6:** **`npx agent-enderun init` (generic framework setup)**
-
----
-
-## 1. Introduction
-
-Agent Enderun is a yapay zeka/AI governance framework that provides **control, discipline, and traceability** in software development processes.
-
-By completing this guide, you will:
-- Install the framework in your project
-- Configure the basic components and environment
-- Create your first tracked task and start working with specialist agents
-
----
-
-## 2. Prerequisites
-
-- **Node.js** 20+ (LTS recommended)
-- **npm** 9+
-- **Git** (must be initialized in the project directory)
-
-To check your local environment:
-
-```bash
-node --version
-npm --version
-git --version
-```
-
----
-
-## 3. Step-by-Step Installation
-
-### Step 1: Create a New Project Directory
-
-```bash
-mkdir my-new-project
-cd my-new-project
-git init
-```
-
-### Step 2: Initialize the Framework
-
-To initialize the core framework cleanly (without hardcoding any AI/adapter-specific files before installation):
-
-```bash
-npx agent-enderun init
-```
-
-This command:
-- Creates the `.enderun/` directory by default
-- Installs all core governance files (`ENDERUN.md`, `PROJECT_MEMORY.md`, agents, knowledge, etc.)
-- Adds the default framework configuration files
-
-#### 💡 Gemini Adapter (Only Supported Path)
-
-```bash
-npx agent-enderun init
-# or explicitly
-npx agent-enderun init gemini
-```
-
-This creates the `.enderun/` runtime folder + `gemini.md` shim at the root for Gemini CLI users.
-
-Other legacy adapters (`claude`, `cursor`, `codex`) may still work for editor-specific workflows.
-
----
-
-### Step 3: Install Dependencies and Build
-
-```bash
-npm install
-npm run enderun:build
-```
-
-### Step 4: Verify the Installation
-
-```bash
-npx agent-enderun check
-```
-
-Expected output:
-
-```
-✅ Framework active (v0.6.6)
-✅ MCP Server ready
-✅ Shared types compiled
-✅ Agent logs initialized
-✅ PROJECT_MEMORY.md found
-```
-
----
-
-## 4. Basic Configuration (Most Critical Step)
-
-Once initialized, you **must** update the following files to describe your project. Ajanlar (agents) learn your technology stack and target domain from here.
-
-### 4.1 `docs/tech-stack.md`
-
-This file is **mandatory**. Agents rely on it to make technical decisions.
-
-Example:
-
-```markdown
-# TECH STACK
-
-## Platform
-- Web (React + Vite)
-- Backend (Node.js + Fastify)
-
-## Database
-- PostgreSQL + Kysely
-
-## Auth
-- JWT + Refresh Token
-
-## Deployment
-- Vercel (Frontend) + Railway (Backend)
-```
-
-> **Warning:** If this file is empty, the agents will not be able to operate.
-
-### 4.2 `docs/project-docs.md`
-
-Write your project's goals, business requirements, and primary features here.
-
-### 4.3 `.enderun/PROJECT_MEMORY.md`
-
-Automatically created during initial setup inside `.enderun/PROJECT_MEMORY.md`. The Gemini adapter uses the `.enderun/` runtime folder.
-
----
-
-## 5. Creating Your First Task
-
-You are now ready to create your first real task:
-
-```bash
-npx agent-enderun trace:new "User Registration and Login System" backend P1
-```
-
-This command:
-- Generates a unique Trace ID
-- Updates the **ACTIVE TASKS** section in `PROJECT_MEMORY.md`
-- Assigns the `@manager` agent to lead the task
-
----
-
-## 6. Basics of Working with Agents
-
-### Automatic @manager Behavior
-
-At the start of every session (when a conversation begins), agents will automatically:
-
-1. Read `ENDERUN.md`
-2. Read `PROJECT_MEMORY.md`
-3. Load the active phase and current Trace ID
-
-### How to Direct Specialist Agents
-
-- Normally, **`@manager`** coordinates the process.
-- If you need to address a specialist agent directly, include their tag:
-
-```markdown
-@backend Implement the user model and auth services using Kysely.
-```
-
-### Critical Rules
-
-- Keep `docs/tech-stack.md` updated at all times.
-- When new key decisions are made, update the **CRITICAL DECISIONS** table in `PROJECT_MEMORY.md`.
-- Use a unique Trace ID for every task.
-
----
-
-## 7. First Real-World Scenario Example
-
-Try this quick workflow:
-
-1. Populate `docs/tech-stack.md`
-2. Write a simple requirement in `docs/project-docs.md`
-3. Run the following command:
-
-```bash
-npx agent-enderun trace:new "User Registration and Login" backend P1
-```
-
-4. Then write to the assistant:
-
-> @manager Please analyze this requirement and propose the backend architecture.
-
-The agents will automatically:
-- Scan your codebase
-- Propose type contracts
-- Scaffold code using blueprints if necessary
-
----
-
-## 8. Common Mistakes and Tips
-
-| Mistake | Consequence | Solution |
-| :--- | :--- | :--- |
-| Leaving `docs/tech-stack.md` empty | Agents will not know how to proceed | Ensure it is populated immediately |
-| Prompting for direct code generation | Messy and unmonitored code | Always have `@manager` plan first |
-| Not using Trace ID | Chaos and lost traceability | Use `trace:new` for every new feature |
-| Not updating `PROJECT_MEMORY.md` | Agents remember old state | Update memory with every key decision |
-
----
-
-## 9. Next Steps
-
-After completing the guide, explore:
-
-- **Contract-First Development** → Check `apps/backend/src/types`
-- **Blueprint Scaffolding** → Look inside `.enderun/blueprints/`
-- **Security & Compliance** → Run `npx agent-enderun check:security`
-- **Inter-Agent Communication** → Hermes protocol (`messages/` directory)
-
----
-
-## 10. Help and Support
-
-If you encounter issues:
-
-1. Run `npx agent-enderun status`
-2. Check `PROJECT_MEMORY.md`
-3. Inspect the error logs and the last 3 HISTORY entries
-
----
-
-**Congratulations!** You can now develop software with discipline, structure, and governance using Agent Enderun.
-
-As a next step, we recommend defining **the core contracts of your first real project**.
-
----
-
-# Türkçe
-
-Bu rehber, Agent Enderun'u **sıfırdan** yeni bir projeye kurmak isteyen geliştiriciler için hazırlanmıştır.
-
-> **v0.6.6 itibarıyla önerilen birincil başlatma komutu:** `npx agent-enderun init`
-
-Tüm teknik adımlar, ön gereksinimler, yapılandırma ve ajanlarla çalışma kuralları **İngilizce bölümde** detaylı olarak açıklanmıştır.
-
-Türkçe kısa özet:
-
-- `npx agent-enderun init` ile framework'ü kurun.
-- `docs/tech-stack.md` ve `docs/project-docs.md` dosyalarını doldurun.
-- `npx agent-enderun trace:new` ile ilk görevi oluşturun.
-- Her oturumda @manager otomatik olarak yönetir.
-
-Detaylı kurulum adımları, adaptör seçenekleri, hata önleme ipuçları ve örnek akışlar için lütfen İngilizce bölümü okuyun.
-
-**Tebrikler!** Artık Agent Enderun ile disiplinli yazılım geliştirmeye başlayabilirsiniz.
+**Congratulations!** You can now start developing professional software with Agent Enderun.

package/docs/user/README.md

@@ -0,0 +1,35 @@
+# Agent Enderun — Governance and Architecture Portal
+
+This portal is the **Central Knowledge Source** for enterprise projects developed under the Agent Enderun framework. The project's architectural decisions, standards, and governance protocols are sealed here.
+
+Unlike ordinary projects, Agent Enderun projects are built on a structure where AI agents operate autonomously but are bound by a rigid, human-authored constitution. This documentation is the **Immutable Guide** for both AI agents (Army) and human developers.
+
+### 📋 Documentation Guide
+
+#### [1. Architecture & Governance](architecture/)
+*   **[Architecture Decision Records (ADRs)](architecture/decisions/)**: Answers to "Why" and "How" questions at critical project milestones.
+*   **[Approval & High-Risk Workflows](architecture/approval-flows.md)**: Explains how tokens are generated, audited, and how high-risk actions (e.g., database deletion, privilege escalation) are sealed.
+*   **[Notification Strategy](architecture/notification-strategy.md)**: Dynamic and corporate notification patterns that do not disrupt the user experience.
+
+#### [2. Frontend Standards](frontend/)
+*   **[Component Patterns](frontend/component-patterns.md)**: Zero-UI-Library policy, guide on how all components are hand-crafted and type-safe using Panda CSS.
+*   **[Form Validations](frontend/forms.md)**: Zero-error form management systems managed with Zod and React hooks.
+*   **[Toaster Configuration](frontend/notifications.md)**: Integration of tools like Sonner with the corporate theme.
+
+#### [3. Backend Standards](backend/)
+*   **[Error Handling](backend/error-handling.md)**: Professional error management hierarchy that does not leak to the front-end and is traceable in logs.
+*   **[Audit Logging](backend/audit-logging.md)**: Contracts for how every operation is permanently processed into the database with a Trace ID.
+
+## 🛰️ Phase-Based Development Life Cycle
+All projects must pass the following 5 phases sequentially and completely:
+
+1.  **PHASE_0 (Discovery):** Tech-stack (`tech-stack.md`) sealed, risk analysis performed.
+2.  **PHASE_1 (Architecture & Contract):** First, types and API contracts are written. Contracts must be approved before a single line of application code is written.
+3.  **PHASE_2 (Core Development):** Backend and Frontend are built in parallel. Branded Types usage is mandatory.
+4.  **PHASE_3 (Integration & Test):** @quality agent takes over. 80% Test Coverage threshold must be met before proceeding to the next phase.
+5.  **PHASE_4 (Optimization & Deployment):** Security scans and performance tests are completed.
+
+> **Agent Directive:** The documents under this folder define the operational boundaries of the agents. An agent cannot deviate from a rule defined here. If a rule needs to be updated, this can only be done with @manager approval and ADR registration.
+
+**Version:** v0.9.0  
+**Status:** Active Governance

package/docs/user/action-plan-2026.md

@@ -0,0 +1,9 @@
+# Action Plan 2026 - Agent Enderun (v0.6.6+)
+
+This strategic document contains the concrete weekly action plan prepared to close critical gaps identified in the v0.6.6 Gap Analysis.
+
+**Summary:**
+- Phase 1: Reference application + Corporate CRUD Governance + Hermes proof.
+- Phase 3: @frontend and @backend professionalization + quality gates.
+
+Detailed plan and technical scope are provided in this document.

package/docs/user/getting-started.md

@@ -0,0 +1,13 @@
+# Quickstart Guide for New Agent Enderun Projects
+
+This guide is prepared for developers who want to set up Agent Enderun in a new project from scratch.
+
+> **As of v0.6.6, the primary initialization command is:** `npx agent-enderun init`
+
+### Installation Steps
+- Initialize the framework with `npx agent-enderun init`.
+- Fill in the `docs/tech-stack.md` and `docs/project-docs.md` files.
+- Create the first task with `npx agent-enderun trace:new`.
+- @manager manages the project automatically in every session.
+
+**Congratulations!** You can now start developing professional software with Agent Enderun.

package/docs/user/roadmap.md

@@ -0,0 +1,13 @@
+# Agent Enderun — Development Roadmap (v0.6.6+)
+
+**Last Updated:** May 23, 2026
+
+This document contains the development roadmap for the Agent Enderun framework post-v0.6.6.
+
+- **System Health:** 🟢 GREEN (build and test infrastructure under repair)
+- **v0.6.6 Focus:** Translating the entire framework to professional English and analyzing governance gaps honestly.
+
+## Summary
+The Agent Maturity Program is ongoing. @frontend continues to be the highest-risk agent. Live testing of the Hermes protocol and producing a reference application are the main goals for the coming period.
+
+Detailed plan and risk tracking are provided in this document.

package/eslint.config.js

@@ -21,7 +21,7 @@ export default tseslint.config(
             ".gemini/**",
             ".claude/**",
             ".cursor/**",
-            ".enderun/logs/**",
+            ".enderun/**",
             "panda.config.ts",
         ],
     },

package/framework-mcp/dist/index.js

@@ -81,15 +81,9 @@ const TOOLS = [
         },
     },
     {
-        name: "create_app",
-        description: "Generate a new full-stack application from a natural language idea.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                idea: { type: "string", description: "The application idea or requirements" },
-            },
-            required: ["idea"],
-        },
+        name: "orchestrate_loop",
+        description: "Process the pending Hermes messages and trigger dynamic state transitions.",
+        inputSchema: { type: "object", properties: {} },
     },
     {
         name: "send_agent_message",
@@ -161,9 +155,8 @@ server.onRequest(CallToolRequestSchema, async (request) => {
                 execSync(`npx agent-enderun update_project_memory "${section}" "${safeContent}"`);
                 return { content: [{ type: "text", text: `✅ Section ${section} updated.` }] };
             }
-            case "create_app": {
-                const idea = args?.idea;
-                const output = execSync(`npx agent-enderun create-app "${idea.replace(/"/g, "\\\"")}"`).toString();
+            case "orchestrate_loop": {
+                const output = execSync("npx agent-enderun orchestrate").toString();
                 return { content: [{ type: "text", text: output }] };
             }
             case "send_agent_message": {
@@ -188,9 +181,10 @@ server.onRequest(CallToolRequestSchema, async (request) => {
         }
     }
     catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error occurred";
         return {
             isError: true,
-            content: [{ type: "text", text: error.message }],
+            content: [{ type: "text", text: message }],
         };
     }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-enderun",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "The Supreme AI Governance & Orchestration Framework for Enterprise Development",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -32,6 +32,7 @@
   },
   "files": [
     "bin",
+    "src",
     "dist",
     "framework-mcp/dist",
     "framework-mcp/package.json",
@@ -59,6 +60,7 @@
     "enderun:check": "agent-enderun check",
     "enderun:lint": "eslint .",
     "lint": "eslint .",
+    "prepublishOnly": "npm run enderun:build",
     "clean": "rm -rf node_modules apps/*/node_modules framework-mcp/node_modules apps/*/dist framework-mcp/dist"
   },
   "publishConfig": {

package/src/cli/adapters.ts

@@ -0,0 +1,208 @@
+import path from "path";
+import fs from "fs";
+
+import { findClaudeConfigPath, addMcpServerToClaude } from "./utils/claude.js";
+import { writeJsonFile, writeTextFile } from "./utils/fs.js";
+
+export const ADAPTER_IDS = ["gemini", "claude", "grok", "antigravity", "antigravity-cli"] as const;
+export type AdapterId = (typeof ADAPTER_IDS)[number];
+
+export interface AdapterConfig {
+  id: AdapterId;
+  /** Runtime framework directory created by init */
+  frameworkDir: string;
+  /** Root shim file (e.g. gemini.md) */
+  shimFile: string;
+  /** Package template copied into frameworkDir */
+  templateDir: ".enderun";
+  /** Extra directories under frameworkDir (gemini only for nested auto-scaffold) */
+  nestedDirs?: string[];
+}
+
+export const ADAPTERS: Record<AdapterId, AdapterConfig> = {
+    gemini: {
+        id: "gemini",
+        frameworkDir: ".gemini",
+        shimFile: "gemini.md",
+        templateDir: ".enderun",
+        nestedDirs: ["antigravity", "antigravity-cli"],
+    },
+    claude: {
+        id: "claude",
+        frameworkDir: ".claude",
+        shimFile: "claude.md",
+        templateDir: ".enderun",
+    },
+    grok: {
+        id: "grok",
+        frameworkDir: ".agent", // Future-proof agent-centric directory for Grok/X.ai
+        shimFile: "grok.md",
+        templateDir: ".enderun",
+    },
+    antigravity: {
+        id: "antigravity",
+        frameworkDir: ".gemini/antigravity",
+        shimFile: "agent.md",
+        templateDir: ".enderun",
+    },
+    "antigravity-cli": {
+        id: "antigravity-cli",
+        frameworkDir: ".gemini/antigravity-cli",
+        shimFile: "agent.md",
+        templateDir: ".enderun",
+    },
+};
+
+/** 
+ * All framework runtime directories (for discovery). 
+ * Verified against 2026 industry standards for Claude Code (.claude/)
+ * and internal standards for Antigravity (.gemini/antigravity/).
+ */
+export const FRAMEWORK_DIR_CANDIDATES = [
+    ".gemini",
+    ".claude",
+    ".agent",
+    ".enderun",
+] as const;
+
+const SHIM_FILES = ADAPTER_IDS.map((id) => ADAPTERS[id].shimFile);
+
+export function resolveAdapter(input?: string): AdapterConfig {
+    const normalized = (input || "gemini").toLowerCase() as AdapterId;
+    if (ADAPTER_IDS.includes(normalized)) {
+        return ADAPTERS[normalized];
+    }
+    console.warn(`⚠️  Unknown adapter "${input}". Falling back to gemini (.gemini/).`);
+    return ADAPTERS.gemini;
+}
+
+export function isAdapterShimFile(fileName: string): boolean {
+    return SHIM_FILES.includes(fileName);
+}
+
+export function remapFrameworkContent(
+    content: string,
+    frameworkDir: string,
+    adapterId: AdapterId,
+): string {
+    let result = content;
+    result = result.replace(/\{\{FRAMEWORK_DIR\}\}/g, frameworkDir);
+    result = result.replace(/\{\{ADAPTER\}\}/g, adapterId);
+    result = result.replace(/\.enderun\//g, `${frameworkDir}/`);
+    result = result.replace(/`\.enderun`/g, `\`${frameworkDir}\``);
+    result = result.replace(/\.enderun(?![\w/-])/g, frameworkDir);
+
+    // Read config paths dynamically to map directory tokens
+    let backend = "apps/backend";
+    let frontend = "apps/web";
+    let docs = "docs";
+    let tests = "tests";
+    try {
+        const configPath = path.join(process.cwd(), frameworkDir, "config.json");
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            if (config.paths) {
+                if (config.paths.backend) backend = config.paths.backend;
+                if (config.paths.frontend) frontend = config.paths.frontend;
+                if (config.paths.docs) docs = config.paths.docs;
+                if (config.paths.tests) tests = config.paths.tests;
+            }
+        }
+    } catch {
+        // ignore
+    }
+
+    result = result.replace(/\{\{BACKEND_DIR\}\}/g, backend);
+    result = result.replace(/\{\{FRONTEND_DIR\}\}/g, frontend);
+    result = result.replace(/\{\{DOCS_DIR\}\}/g, docs);
+    result = result.replace(/\{\{TESTS_DIR\}\}/g, tests);
+
+    return result;
+}
+
+export function buildMcpServerEntry(projectRoot: string) {
+    return {
+        command: "node",
+        args: [path.join(projectRoot, "framework-mcp/dist/index.js")],
+        env: {},
+    };
+}
+
+function writeAntigravityScaffold(frameworkDirPath: string): void {
+    const antigravityReadme = `# Antigravity IDE — Agent Enderun
+
+Antigravity IDE integration for the Gemini adapter.
+
+- Framework root: \`${path.basename(frameworkDirPath)}/\`
+- Nested path: \`antigravity/\`
+- Use the parent \`mcp_config.json\` and \`gemini.md\` entrypoint at the project root.
+`;
+
+    const antigravityCliReadme = `# Antigravity CLI — Agent Enderun
+
+Antigravity CLI integration for the Gemini adapter.
+
+- Framework root: \`${path.basename(frameworkDirPath)}/\`
+- Nested path: \`antigravity-cli/\`
+- Register MCP from the project root \`mcp.json\` or \`.gemini/mcp_config.json\`.
+`;
+
+    writeTextFile(path.join(frameworkDirPath, "antigravity/README.md"), antigravityReadme);
+    writeTextFile(path.join(frameworkDirPath, "antigravity-cli/README.md"), antigravityCliReadme);
+}
+
+/**
+ * Adapter-specific MCP and IDE hooks after scaffold.
+ */
+export function runAdapterPostInit(adapter: AdapterConfig, projectRoot: string): void {
+    const mcpEntry = buildMcpServerEntry(projectRoot);
+    const mcpBlock = { mcpServers: { "agent-enderun": mcpEntry } };
+
+    switch (adapter.id) {
+    case "gemini": {
+        writeJsonFile(path.join(projectRoot, adapter.frameworkDir, "mcp_config.json"), mcpBlock);
+        writeAntigravityScaffold(path.join(projectRoot, adapter.frameworkDir));
+        console.warn(`✅ Gemini MCP → ${adapter.frameworkDir}/mcp_config.json`);
+        console.warn(`✅ Antigravity → ${adapter.frameworkDir}/antigravity/ & antigravity-cli/`);
+        break;
+    }
+    case "antigravity": {
+        writeJsonFile(path.join(projectRoot, adapter.frameworkDir, "mcp_config.json"), mcpBlock);
+        console.warn(`✅ Antigravity IDE MCP → ${adapter.frameworkDir}/mcp_config.json`);
+        break;
+    }
+    case "antigravity-cli": {
+        writeJsonFile(path.join(projectRoot, adapter.frameworkDir, "mcp_config.json"), mcpBlock);
+        console.warn(`✅ Antigravity CLI MCP → ${adapter.frameworkDir}/mcp_config.json`);
+        break;
+    }
+    case "grok": {
+        writeJsonFile(path.join(projectRoot, adapter.frameworkDir, "mcp_config.json"), mcpBlock);
+        console.warn(`✅ Grok MCP → ${adapter.frameworkDir}/mcp_config.json`);
+        break;
+    }
+    case "claude": {
+        const configPath = findClaudeConfigPath();
+        if (configPath) {
+            const ok = addMcpServerToClaude(configPath, "agent-enderun", mcpEntry);
+            if (ok) {
+                console.warn(`✅ Claude MCP registered → ${configPath}`);
+            } else {
+                console.warn("⚠️  Could not patch Claude config automatically.");
+            }
+        } else {
+            console.warn("⚠️  Claude config not found. Add MCP manually (see README).");
+        }
+        writeJsonFile(path.join(projectRoot, adapter.frameworkDir, "mcp_config.json"), mcpBlock);
+        break;
+    }
+    default:
+        break;
+    }
+
+    // Keep root mcp.json in sync when missing or empty
+    const rootMcpPath = path.join(projectRoot, "mcp.json");
+    if (!fs.existsSync(rootMcpPath)) {
+        writeJsonFile(rootMcpPath, mcpBlock);
+    }
+}

package/src/cli/commands/app.ts

@@ -0,0 +1,38 @@
+import fs from "fs";
+
+import { updateMemoryForGeneratedApp, collectCreateAppDescription, inferAppSpec, createBackendFiles, createWebFiles, updateProjectDocs } from "../utils/app.js";
+import { traceNewCommand } from "./trace.js";
+import { getMemoryPath } from "../utils/memory.js";
+
+/**
+ * Generate a new application based on natural language input.
+ */
+export async function createAppCommand(args: string[]) {
+    const description = await collectCreateAppDescription(args);
+    const spec = inferAppSpec(description);
+
+    console.warn(`🚀 Generating Enterprise App: ${spec.title}...`);
+
+    createBackendFiles(spec);
+    createWebFiles(spec);
+    updateProjectDocs(spec);
+
+    const memoryPath = getMemoryPath();
+    let traceId = "01HGT8J5E2N0W0W0W0W0W0W0W0"; // default fallback
+
+    if (fs.existsSync(memoryPath)) {
+        const memory = fs.readFileSync(memoryPath, "utf8");
+        const match = memory.match(/- Trace ID: (.*)/);
+        if (match) traceId = match[1].trim();
+    }
+
+    const activeTraceId = traceNewCommand(`Generate ${spec.title} from natural language request`, "manager", "P1") || traceId;
+    updateMemoryForGeneratedApp(spec, activeTraceId);
+
+    console.warn("\n✨ Application scaffolded successfully!");
+    console.warn("📜 Updated project docs and app-local types contract");
+    console.warn("\nNext commands:");
+    console.warn("  npm install");
+    console.warn("  npm run enderun:build");
+    console.warn("  agent-enderun frontend:dev\n");
+}