cf-claw 3.0.0

package/dist/factory.js

@@ -0,0 +1,2010 @@
+import Database from "better-sqlite3";
+import path from "node:path";
+import fs from "node:fs";
+import { chatCompletionWithFallback } from "./llm/index.js";
+import { getTool, tools } from "./tools/index.js";
+import { logUsage, estimateCost } from "./usage.js";
+import { getActiveModel } from "./llm/index.js";
+import { getAgent, listAgents } from "./agents.js";
+import { sendToTelegram } from "./bot.js";
+import { config } from "./config.js";
+import { getDataDir, getProjectsDir } from "./paths.js";
+const DATA_DIR = getDataDir();
+const PROJECTS_DIR = getProjectsDir();
+const DB_PATH = path.join(DATA_DIR, "cf-claw.db");
+const db = new Database(DB_PATH);
+db.pragma("journal_mode = WAL");
+db.exec(`
+  CREATE TABLE IF NOT EXISTS factory_projects (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    title TEXT NOT NULL,
+    description TEXT DEFAULT '',
+    status TEXT DEFAULT 'planning' CHECK(status IN ('planning','running','paused','completed','failed')),
+    workspace_path TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS factory_tasks (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    project_id INTEGER NOT NULL,
+    title TEXT NOT NULL,
+    description TEXT DEFAULT '',
+    assigned_agent TEXT NOT NULL,
+    reviewer_agent TEXT,
+    status TEXT DEFAULT 'backlog' CHECK(status IN ('backlog','in_progress','review','done','failed','human_intervention')),
+    dependencies TEXT DEFAULT '[]',
+    retry_count INTEGER DEFAULT 0,
+    max_retries INTEGER DEFAULT 10,
+    context_payload TEXT DEFAULT '{}',
+    result TEXT,
+    started_at TEXT,
+    completed_at TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    FOREIGN KEY (project_id) REFERENCES factory_projects(id) ON DELETE CASCADE
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_factory_tasks_project ON factory_tasks(project_id);
+  CREATE INDEX IF NOT EXISTS idx_factory_tasks_status ON factory_tasks(status);
+`);
+const projectTableInfo = db.prepare("PRAGMA table_info(factory_projects)").all();
+const hasWorkspaceCol = projectTableInfo.some((c) => c.name === "workspace_path");
+if (!hasWorkspaceCol) {
+    db.exec("ALTER TABLE factory_projects ADD COLUMN workspace_path TEXT");
+}
+const taskTableInfo = db.prepare("PRAGMA table_info(factory_tasks)").all();
+const hasPhaseCol = taskTableInfo.some((c) => c.name === "phase");
+if (!hasPhaseCol) {
+    db.exec("ALTER TABLE factory_tasks ADD COLUMN phase TEXT DEFAULT NULL");
+}
+const insertProject = db.prepare("INSERT INTO factory_projects (title, description, status) VALUES (?, ?, ?)");
+const getProjectById = db.prepare("SELECT * FROM factory_projects WHERE id = ?");
+const getAllProjects = db.prepare("SELECT * FROM factory_projects ORDER BY updated_at DESC");
+const updateProjectStatus = db.prepare("UPDATE factory_projects SET status = ?, updated_at = datetime('now') WHERE id = ?");
+const updateProjectWorkspacePath = db.prepare("UPDATE factory_projects SET workspace_path = ?, updated_at = datetime('now') WHERE id = ?");
+const insertTask = db.prepare("INSERT INTO factory_tasks (project_id, title, description, assigned_agent, reviewer_agent, dependencies, max_retries, context_payload, phase) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
+const getTasksByProject = db.prepare("SELECT * FROM factory_tasks WHERE project_id = ? ORDER BY id");
+const getTaskById = db.prepare("SELECT * FROM factory_tasks WHERE id = ?");
+const updateTaskStatus = db.prepare("UPDATE factory_tasks SET status = ?, updated_at = datetime('now') WHERE id = ?");
+const updateTaskResult = db.prepare("UPDATE factory_tasks SET status = ?, result = ?, context_payload = ?, completed_at = datetime('now'), updated_at = datetime('now') WHERE id = ?");
+const updateTaskRetry = db.prepare("UPDATE factory_tasks SET status = ?, retry_count = ?, context_payload = ?, result = NULL, started_at = NULL, completed_at = NULL, updated_at = datetime('now') WHERE id = ?");
+const updateTaskDependencies = db.prepare("UPDATE factory_tasks SET dependencies = ?, updated_at = datetime('now') WHERE id = ?");
+const updateProjectUpdatedAt = db.prepare("UPDATE factory_projects SET updated_at = datetime('now') WHERE id = ?");
+const updateProjectTaskMaxRetries = db.prepare("UPDATE factory_tasks SET max_retries = ?, updated_at = datetime('now') WHERE project_id = ? AND (max_retries IS NULL OR max_retries <= 0)");
+const resetProjectTasksPartial = db.prepare("UPDATE factory_tasks SET status = 'backlog', retry_count = 0, context_payload = '{}', result = NULL, started_at = NULL, completed_at = NULL, updated_at = datetime('now') WHERE project_id = ? AND status != 'done'");
+const resetProjectTasksFull = db.prepare("UPDATE factory_tasks SET status = 'backlog', retry_count = 0, context_payload = '{}', result = NULL, started_at = NULL, completed_at = NULL, updated_at = datetime('now') WHERE project_id = ?");
+const setTaskStarted = db.prepare("UPDATE factory_tasks SET status = 'in_progress', started_at = datetime('now'), updated_at = datetime('now') WHERE id = ?");
+const getBacklogTasks = db.prepare("SELECT * FROM factory_tasks WHERE status = 'backlog'");
+const getReviewTasks = db.prepare("SELECT * FROM factory_tasks WHERE status = 'review'");
+const getStaleInProgressTasks = db.prepare("SELECT * FROM factory_tasks WHERE status = 'in_progress' AND started_at IS NOT NULL AND started_at <= datetime('now', ?)");
+const getTaskCounts = db.prepare("SELECT COUNT(*) as total, SUM(CASE WHEN status = 'done' THEN 1 ELSE 0 END) as completed FROM factory_tasks WHERE project_id = ?");
+const DEFAULT_MAX_RETRIES = 10;
+const AGENT_PHASES = {
+    Fredrix: "ideation",
+    Stoffe: "blueprint",
+    ulla: "design",
+    fia: "implementation",
+    benny: "implementation",
+    ivan: "integration",
+    sara: "security",
+    tess: "qa",
+    chris: "code-review",
+    dan: "deployment",
+    stig: "release",
+    sune: "feedback",
+};
+const PHASE_ORDER = [
+    "ideation", "blueprint", "design", "implementation",
+    "integration", "security", "qa", "code-review",
+    "deployment", "release", "feedback",
+];
+export { AGENT_PHASES, PHASE_ORDER };
+function asStringArray(input) {
+    if (!Array.isArray(input))
+        return [];
+    return input
+        .map((v) => (typeof v === "string" ? v.trim() : ""))
+        .filter((v) => v.length > 0);
+}
+function normalizeArchitectureContract(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const obj = raw;
+    const stackType = typeof obj.stack_type === "string"
+        ? obj.stack_type.trim()
+        : typeof obj.stackType === "string"
+            ? obj.stackType.trim()
+            : typeof obj.framework === "string"
+                ? obj.framework.trim()
+                : "";
+    const language = typeof obj.language === "string" ? obj.language.trim() : "";
+    const notes = typeof obj.notes === "string" ? obj.notes.trim() : "";
+    const requiredArtifacts = asStringArray(obj.required_artifacts ?? obj.requiredArtifacts ?? obj.required_files ?? obj.requiredFiles);
+    const forbiddenArtifacts = asStringArray(obj.forbidden_artifacts ?? obj.forbiddenArtifacts ?? obj.forbidden_files ?? obj.forbiddenFiles);
+    const reviewerFocus = asStringArray(obj.reviewer_focus ?? obj.reviewerFocus ?? obj.review_checks ?? obj.reviewChecks);
+    if (!stackType && !language && !notes && requiredArtifacts.length === 0 && forbiddenArtifacts.length === 0 && reviewerFocus.length === 0) {
+        return null;
+    }
+    return {
+        stackType: stackType || null,
+        language: language || null,
+        requiredArtifacts,
+        forbiddenArtifacts,
+        reviewerFocus,
+        notes: notes || null,
+    };
+}
+function inferArchitectureContract(task) {
+    const blob = `${task.title} ${task.description}`.toLowerCase();
+    if (/\b(no framework|without framework|vanilla|static html|plain html|plain javascript)\b/.test(blob)) {
+        return {
+            stackType: "vanilla-web",
+            language: "javascript",
+            requiredArtifacts: ["index.html"],
+            forbiddenArtifacts: [
+                "src/main.tsx",
+                "src/main.jsx",
+                "vite.config.ts",
+                "vite.config.js",
+                "tailwind.config.ts",
+                "tailwind.config.js",
+            ],
+            reviewerFocus: ["No framework artifacts", "Static shell requirement honored"],
+            notes: "Inferred from task wording",
+        };
+    }
+    if (/\b(next\.js|nextjs|react|vite|tsx|spa)\b/.test(blob) || task.assignedAgent === "fia") {
+        return {
+            stackType: "react-vite",
+            language: "typescript",
+            requiredArtifacts: ["package.json", "src/**"],
+            forbiddenArtifacts: [],
+            reviewerFocus: ["Component architecture", "Client behavior aligns with task"],
+            notes: "Inferred from task wording/agent specialization",
+        };
+    }
+    if (/\b(c\+\+|cpp|game engine|render loop|unreal|opengl|vulkan)\b/.test(blob)) {
+        return {
+            stackType: "cpp-engine",
+            language: "c++",
+            requiredArtifacts: ["**/*.cpp", "**/*.h"],
+            forbiddenArtifacts: [],
+            reviewerFocus: ["Buildability", "Engine loop correctness"],
+            notes: "Inferred from task wording",
+        };
+    }
+    return null;
+}
+function resolveTaskArchitectureContract(task, contextPayload) {
+    const fromContext = normalizeArchitectureContract(contextPayload.architecture_contract);
+    if (fromContext)
+        return fromContext;
+    return inferArchitectureContract(task);
+}
+function toPathRegex(pattern) {
+    const normalized = pattern.replace(/\\/g, "/");
+    let escaped = normalized.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    escaped = escaped.replace(/\*\*/g, "__DOUBLE_STAR__");
+    escaped = escaped.replace(/\*/g, "[^/]*");
+    escaped = escaped.replace(/__DOUBLE_STAR__/g, ".*");
+    return new RegExp(`^${escaped}$`);
+}
+function matchesArtifact(pattern, relPath) {
+    const normalizedPattern = pattern.replace(/\\/g, "/").trim();
+    const normalizedPath = relPath.replace(/\\/g, "/");
+    if (!normalizedPattern)
+        return false;
+    if (!normalizedPattern.includes("/") && !normalizedPattern.includes("*")) {
+        return path.basename(normalizedPath) === normalizedPattern;
+    }
+    return toPathRegex(normalizedPattern).test(normalizedPath);
+}
+function validateWorkspaceAgainstContract(workspacePath, contract) {
+    if (!workspacePath || !contract) {
+        return { ok: true, violations: [] };
+    }
+    const workspaceAbs = absoluteWorkspacePath(workspacePath);
+    if (!fs.existsSync(workspaceAbs)) {
+        return { ok: false, violations: [`Workspace does not exist: ${workspacePath}`] };
+    }
+    const files = collectFiles(workspaceAbs, 1200).map((f) => path.relative(workspaceAbs, f).replace(/\\/g, "/"));
+    const violations = [];
+    for (const required of contract.requiredArtifacts) {
+        const found = files.some((f) => matchesArtifact(required, f));
+        if (!found) {
+            violations.push(`Missing required artifact pattern: ${required}`);
+        }
+    }
+    for (const forbidden of contract.forbiddenArtifacts) {
+        const matches = files.filter((f) => matchesArtifact(forbidden, f));
+        if (matches.length > 0) {
+            const sample = matches.slice(0, 3).join(", ");
+            violations.push(`Forbidden artifact present (${forbidden}): ${sample}`);
+        }
+    }
+    return { ok: violations.length === 0, violations };
+}
+function formatArchitectureContract(contract) {
+    const lines = [];
+    if (contract.stackType)
+        lines.push(`- Stack: ${contract.stackType}`);
+    if (contract.language)
+        lines.push(`- Language: ${contract.language}`);
+    if (contract.requiredArtifacts.length > 0) {
+        lines.push(`- Required artifacts: ${contract.requiredArtifacts.join(", ")}`);
+    }
+    if (contract.forbiddenArtifacts.length > 0) {
+        lines.push(`- Forbidden artifacts: ${contract.forbiddenArtifacts.join(", ")}`);
+    }
+    if (contract.reviewerFocus.length > 0) {
+        lines.push(`- Reviewer focus: ${contract.reviewerFocus.join(" | ")}`);
+    }
+    if (contract.notes)
+        lines.push(`- Notes: ${contract.notes}`);
+    return lines.join("\n");
+}
+function getAgentByNameFromList(agentName, allAgents) {
+    const normalized = agentName.toLowerCase();
+    return allAgents.find((a) => a.name.toLowerCase() === normalized) || null;
+}
+function hasAnyTag(agent, tags) {
+    const tagSet = new Set((agent.tags || []).map((t) => t.toLowerCase()));
+    return tags.some((tag) => tagSet.has(tag));
+}
+function supportsCodeTools(agent) {
+    const toolSet = new Set((agent.tools || []).map((t) => t.toLowerCase()));
+    const hasFileTool = toolSet.has("file_write") || toolSet.has("file_create");
+    return hasFileTool && toolSet.has("shell");
+}
+function isQaAgent(agent) {
+    const phase = AGENT_PHASES[agent.name.toLowerCase()];
+    if (phase === "qa")
+        return true;
+    if (agent.team === "quality")
+        return true;
+    if (hasAnyTag(agent, ["qa", "testing", "test", "quality"]))
+        return true;
+    return false;
+}
+function isReviewAgent(agent) {
+    const phase = AGENT_PHASES[agent.name.toLowerCase()];
+    if (phase === "code-review")
+        return true;
+    if (hasAnyTag(agent, ["code-review", "review", "reviewer"]))
+        return true;
+    if (agent.role.toLowerCase().includes("review"))
+        return true;
+    return false;
+}
+function isSecurityAgent(agent) {
+    const phase = AGENT_PHASES[agent.name.toLowerCase()];
+    if (phase === "security")
+        return true;
+    if (hasAnyTag(agent, ["security", "audit", "secops"]))
+        return true;
+    return agent.role.toLowerCase().includes("security");
+}
+function isCodeAgent(agent) {
+    const phase = AGENT_PHASES[agent.name.toLowerCase()];
+    if (phase === "implementation" || phase === "integration")
+        return true;
+    if (agent.team === "development")
+        return true;
+    if (hasAnyTag(agent, ["frontend", "backend", "fullstack", "api", "integration", "mobile", "cpp", "engine", "developer"])) {
+        return true;
+    }
+    return supportsCodeTools(agent);
+}
+export function getAgentPipelineRoles(agentName) {
+    const agent = getAgent(agentName.toLowerCase());
+    if (!agent)
+        return [];
+    const roles = [];
+    if (isCodeAgent(agent))
+        roles.push("code");
+    if (isQaAgent(agent))
+        roles.push("qa");
+    if (isReviewAgent(agent))
+        roles.push("review");
+    if (isSecurityAgent(agent))
+        roles.push("security");
+    const phase = AGENT_PHASES[agent.name.toLowerCase()];
+    if (phase && !roles.includes(phase)) {
+        roles.push(phase);
+    }
+    return roles;
+}
+function preferredAgentsForContract(contract, allAgents) {
+    const stack = contract?.stackType?.toLowerCase() || "";
+    const language = contract?.language?.toLowerCase() || "";
+    const candidates = allAgents.filter((agent) => {
+        if (!isCodeAgent(agent))
+            return false;
+        const blob = `${agent.role} ${agent.description} ${(agent.tags || []).join(" ")}`.toLowerCase();
+        if (!stack && !language)
+            return true;
+        if (stack && (blob.includes(stack) || stack.split(/[^a-z0-9+.-]+/).some((token) => token.length > 2 && blob.includes(token)))) {
+            return true;
+        }
+        if (language && blob.includes(language))
+            return true;
+        return false;
+    });
+    if (candidates.length > 0) {
+        return candidates.map((a) => a.name.toLowerCase());
+    }
+    const genericCodeAgents = allAgents.filter((a) => isCodeAgent(a)).map((a) => a.name.toLowerCase());
+    if (genericCodeAgents.length > 0)
+        return genericCodeAgents;
+    return ["chris"];
+}
+function rowToTask(row) {
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        title: row.title,
+        description: row.description || "",
+        assignedAgent: row.assigned_agent,
+        reviewerAgent: row.reviewer_agent || null,
+        status: row.status,
+        phase: row.phase || AGENT_PHASES[row.assigned_agent?.toLowerCase()] || null,
+        dependencies: JSON.parse(row.dependencies || "[]"),
+        retryCount: row.retry_count || 0,
+        maxRetries: row.max_retries || DEFAULT_MAX_RETRIES,
+        contextPayload: JSON.parse(row.context_payload || "{}"),
+        result: row.result || null,
+        startedAt: row.started_at || null,
+        completedAt: row.completed_at || null,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function slugifyProjectTitle(input) {
+    const slug = input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48);
+    return slug || "project";
+}
+function buildDefaultWorkspacePath(projectId, title) {
+    return path.join("projects", `${slugifyProjectTitle(title)}-${projectId}`);
+}
+function absoluteWorkspacePath(workspacePath) {
+    return path.resolve(workspacePath);
+}
+function ensureWorkspaceDir(workspacePath) {
+    const abs = absoluteWorkspacePath(workspacePath);
+    fs.mkdirSync(abs, { recursive: true });
+}
+function ensureProjectWorkspace(row) {
+    const workspacePath = row.workspace_path || buildDefaultWorkspacePath(row.id, row.title || "project");
+    if (!row.workspace_path) {
+        updateProjectWorkspacePath.run(workspacePath, row.id);
+    }
+    ensureWorkspaceDir(workspacePath);
+    return workspacePath;
+}
+function rowToProject(row) {
+    const counts = getTaskCounts.get(row.id);
+    const workspacePath = ensureProjectWorkspace(row);
+    return {
+        id: row.id,
+        title: row.title,
+        description: row.description || "",
+        status: row.status,
+        workspacePath,
+        taskCount: counts?.total || 0,
+        completedTasks: counts?.completed || 0,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export function createFactoryProject(title, description) {
+    const result = insertProject.run(title, description, "planning");
+    const projectId = Number(result.lastInsertRowid);
+    const workspacePath = buildDefaultWorkspacePath(projectId, title);
+    ensureWorkspaceDir(workspacePath);
+    updateProjectWorkspacePath.run(workspacePath, projectId);
+    const row = getProjectById.get(projectId);
+    return rowToProject(row);
+}
+export function listFactoryProjects() {
+    return getAllProjects.all().map(rowToProject);
+}
+export function getFactoryProject(id) {
+    const row = getProjectById.get(id);
+    if (!row)
+        return null;
+    return rowToProject(row);
+}
+export function setProjectStatus(id, status) {
+    return updateProjectStatus.run(status, id).changes > 0;
+}
+export function getFactoryTasks(projectId) {
+    return getTasksByProject.all(projectId).map(rowToTask);
+}
+export function getFactoryTask(taskId) {
+    const row = getTaskById.get(taskId);
+    if (!row)
+        return null;
+    return rowToTask(row);
+}
+export function forceRetryTask(taskId) {
+    const task = getFactoryTask(taskId);
+    if (!task || task.status !== "human_intervention")
+        return false;
+    updateTaskRetry.run("backlog", 0, JSON.stringify({}), taskId);
+    return true;
+}
+export function switchProjectProfile(projectId, newProfile) {
+    const project = getFactoryProject(projectId);
+    if (!project)
+        return { ok: false, message: `Project ${projectId} not found.`, injectedTasks: 0 };
+    const profiles = config.factoryOrchestration.profiles;
+    const profile = profiles[newProfile];
+    if (!profile) {
+        const available = Object.keys(profiles).join(", ");
+        return { ok: false, message: `Unknown profile "${newProfile}". Available: ${available}`, injectedTasks: 0 };
+    }
+    const allAgents = listAgents();
+    const tasks = getFactoryTasks(projectId);
+    const existingStages = new Set(tasks.map((t) => {
+        const stageId = normalizeStageId(typeof t.contextPayload?.stage_id === "string" ? t.contextPayload.stage_id : null);
+        return stageId;
+    }));
+    const mandatoryStages = (profile.mandatoryStages || []).map((s) => normalizeStageId(s)).filter((s) => !!s);
+    const stageOrder = Object.fromEntries(Object.entries(config.factoryOrchestration.stageCatalog).map(([id, def]) => [id, def.order || 999]));
+    mandatoryStages.sort((a, b) => (stageOrder[a] || 999) - (stageOrder[b] || 999));
+    let injectedCount = 0;
+    for (const stageId of mandatoryStages) {
+        if (existingStages.has(stageId))
+            continue;
+        const stagePolicy = config.factoryOrchestration.stageCatalog[stageId];
+        const stageMaxRetries = stagePolicy?.retryPolicy?.maxRetries ?? DEFAULT_MAX_RETRIES;
+        const fallbackAgent = stageId === "qa-testing" ? "tess" :
+            stageId === "code-review" ? "chris" :
+                stageId === "security-audit" ? "sara" :
+                    stageId === "ideation" || stageId === "final-review" ? "Fredrix" :
+                        stageId === "blueprint" ? "Stoffe" :
+                            stageId === "ui-ux-design" ? "ulla" :
+                                stageId === "implementation" ? "chris" :
+                                    stageId === "integration" ? "ivan" :
+                                        stageId === "deployment" ? "dan" :
+                                            stageId === "release" ? "stig" :
+                                                stageId === "feedback" ? "sune" : "chris";
+        const selectedAgent = findAgentForStage(stageId, allAgents, fallbackAgent);
+        const deps = tasks
+            .filter((t) => {
+            const tid = normalizeStageId(typeof t.contextPayload?.stage_id === "string" ? t.contextPayload.stage_id : null);
+            const tidOrder = stageOrder[tid || ""] || 999;
+            return tidOrder < (stageOrder[stageId] || 999);
+        })
+            .map((t) => t.id);
+        const contextPayload = {
+            stage_id: stageId,
+            pipeline_profile: newProfile,
+        };
+        insertTask.run(projectId, `${stageId} (injected)`, `Stage task for "${stageId}" injected when switching profile to "${newProfile}".`, selectedAgent, null, JSON.stringify(deps), Math.max(1, stageMaxRetries), JSON.stringify(contextPayload), AGENT_PHASES[selectedAgent] || null);
+        injectedCount++;
+        console.log(`🏭 Profile switch: injected stage ${stageId} → ${selectedAgent} for project ${projectId}`);
+    }
+    updateProjectUpdatedAt.run(projectId);
+    return { ok: true, message: `Switched to profile "${newProfile}". Injected ${injectedCount} missing stage tasks.`, injectedTasks: injectedCount };
+}
+export function listFactoryProfiles() {
+    return Object.entries(config.factoryOrchestration.profiles).map(([id, def]) => ({
+        id,
+        mandatoryStages: def.mandatoryStages,
+        optionalStages: def.optionalStages,
+    }));
+}
+export function restartFactoryProject(projectId, mode = "partial") {
+    const row = getProjectById.get(projectId);
+    if (!row) {
+        return {
+            ok: false,
+            projectId,
+            mode,
+            resetTasks: 0,
+            workspacePath: "",
+            message: `Project ${projectId} not found.`,
+        };
+    }
+    const project = rowToProject(row);
+    const workspaceAbs = absoluteWorkspacePath(project.workspacePath);
+    const projectsRootAbs = path.resolve(PROJECTS_DIR);
+    if (mode === "full") {
+        if (workspaceAbs === projectsRootAbs || !workspaceAbs.startsWith(projectsRootAbs + path.sep)) {
+            return {
+                ok: false,
+                projectId,
+                mode,
+                resetTasks: 0,
+                workspacePath: project.workspacePath,
+                message: `Refusing to delete unsafe workspace path: ${project.workspacePath}`,
+            };
+        }
+        if (fs.existsSync(workspaceAbs)) {
+            fs.rmSync(workspaceAbs, { recursive: true, force: true });
+        }
+        fs.mkdirSync(workspaceAbs, { recursive: true });
+    }
+    else {
+        ensureWorkspaceDir(project.workspacePath);
+    }
+    setProjectStatus(projectId, "paused");
+    const resetResult = mode === "full"
+        ? resetProjectTasksFull.run(projectId)
+        : resetProjectTasksPartial.run(projectId);
+    setProjectStatus(projectId, "running");
+    return {
+        ok: true,
+        projectId,
+        mode,
+        resetTasks: resetResult.changes,
+        workspacePath: project.workspacePath,
+        message: mode === "full"
+            ? `Project ${projectId} fully restarted. Workspace reset at ${project.workspacePath}.`
+            : `Project ${projectId} restarted. Non-done tasks moved back to backlog.`,
+    };
+}
+function toolsToDefinitions(toolNames) {
+    return toolNames
+        .map((name) => {
+        const t = tools.find((tool) => tool.name === name);
+        if (!t)
+            return null;
+        return { name: t.name, description: t.description, parameters: t.input_schema };
+    })
+        .filter((t) => t !== null);
+}
+function isWithinDir(targetPath, rootPath) {
+    const resolvedTarget = path.resolve(targetPath);
+    const resolvedRoot = path.resolve(rootPath);
+    return resolvedTarget === resolvedRoot || resolvedTarget.startsWith(resolvedRoot + path.sep);
+}
+function resolveWorkspacePath(inputPath, workspaceAbs) {
+    const maybeAbsolute = path.isAbsolute(inputPath)
+        ? path.resolve(inputPath)
+        : path.resolve(workspaceAbs, inputPath);
+    if (!isWithinDir(maybeAbsolute, workspaceAbs)) {
+        throw new Error(`Path escapes project workspace: ${inputPath}`);
+    }
+    return maybeAbsolute;
+}
+function quoteForShell(value) {
+    return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+}
+function normalizeAgentRelativePath(inputPath, workspacePath) {
+    if (path.isAbsolute(inputPath))
+        return inputPath;
+    const normalizedInput = inputPath.replace(/\\/g, "/").replace(/^\.\//, "");
+    const normalizedWorkspace = workspacePath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+    if (normalizedInput === normalizedWorkspace)
+        return ".";
+    if (normalizedInput.startsWith(normalizedWorkspace + "/")) {
+        return normalizedInput.slice(normalizedWorkspace.length + 1);
+    }
+    if (normalizedInput.startsWith("projects/")) {
+        throw new Error("Use workspace-relative paths only (do not prefix with projects/...).");
+    }
+    return inputPath;
+}
+function scopeToolInput(toolName, rawArgs, workspacePath) {
+    if (!workspacePath)
+        return rawArgs;
+    const workspaceAbs = absoluteWorkspacePath(workspacePath);
+    const scoped = { ...rawArgs };
+    const pathTools = new Set(["file_read", "file_write", "file_create", "file_delete", "file_list", "file_search"]);
+    if (pathTools.has(toolName)) {
+        const rawPath = typeof scoped.path === "string" ? scoped.path : ".";
+        const normalizedInput = normalizeAgentRelativePath(rawPath, workspacePath);
+        scoped.path = resolveWorkspacePath(normalizedInput, workspaceAbs);
+        return scoped;
+    }
+    if (toolName === "shell_exec" && typeof scoped.command === "string") {
+        const workspaceQuoted = quoteForShell(workspaceAbs);
+        scoped.command = `cd ${workspaceQuoted} && ${scoped.command}`;
+        return scoped;
+    }
+    return scoped;
+}
+async function runFactoryAgent(agentDef, task, contextPayload, maxIterations = 12, workspacePath = null) {
+    const systemPrompt = agentDef.systemPrompt +
+        (agentDef.rules.length > 0
+            ? `\n\n## Special Rules\n${agentDef.rules.map((r) => `- ${r}`).join("\n")}`
+            : "");
+    const toolDefs = toolsToDefinitions(agentDef.tools);
+    const contextStr = Object.keys(contextPayload).length > 0
+        ? `\n\n## Context from previous tasks\n${JSON.stringify(contextPayload, null, 2)}`
+        : "";
+    const workspaceStr = workspacePath
+        ? `\n\n## Workspace\nYou must read/write files only inside this project workspace: ${workspacePath}\nUse this path as your base directory for code changes.`
+        : "";
+    const messages = [
+        { role: "system", content: systemPrompt + contextStr + workspaceStr },
+        { role: "user", content: task },
+    ];
+    const agentModel = agentDef.model || undefined;
+    const agentFallback = agentDef.fallbackModel || undefined;
+    const agentChat = (opts) => chatCompletionWithFallback(agentModel, agentFallback, opts);
+    const modelLabel = agentModel || getActiveModel();
+    let totalToolCalls = 0;
+    let totalFileWriteCalls = 0;
+    for (let i = 0; i < maxIterations; i++) {
+        const iterStart = Date.now();
+        const response = await agentChat({
+            messages,
+            tools: toolDefs.length > 0 ? toolDefs : undefined,
+        });
+        const iterLatency = Date.now() - iterStart;
+        const usage = response.usage;
+        if (usage) {
+            logUsage({
+                model: modelLabel,
+                promptTokens: usage.promptTokens,
+                completionTokens: usage.completionTokens,
+                totalTokens: usage.promptTokens + usage.completionTokens,
+                costUsd: estimateCost(modelLabel, usage.promptTokens, usage.completionTokens),
+                latencyMs: iterLatency,
+                toolCalls: 0,
+                source: `factory:${agentDef.name}`,
+            });
+        }
+        if (!response.toolCalls || response.toolCalls.length === 0) {
+            return {
+                content: response.content || "(no response)",
+                toolCalls: totalToolCalls,
+                fileWriteCalls: totalFileWriteCalls,
+            };
+        }
+        totalToolCalls += response.toolCalls.length;
+        messages.push({
+            role: "assistant",
+            content: response.content || null,
+            tool_calls: response.toolCalls.map((tc) => ({
+                id: tc.id,
+                function: { name: tc.name, arguments: tc.arguments },
+            })),
+        });
+        for (const tc of response.toolCalls) {
+            if (tc.name === "file_write" || tc.name === "file_create") {
+                totalFileWriteCalls++;
+            }
+            const tool = getTool(tc.name);
+            if (!tool) {
+                messages.push({ role: "tool", tool_call_id: tc.id, content: `Unknown tool: ${tc.name}` });
+                continue;
+            }
+            try {
+                const args = JSON.parse(tc.arguments);
+                const scopedArgs = scopeToolInput(tc.name, args, workspacePath);
+                const result = await tool.execute(scopedArgs);
+                messages.push({ role: "tool", tool_call_id: tc.id, content: result });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                messages.push({ role: "tool", tool_call_id: tc.id, content: `Error: ${msg}` });
+            }
+        }
+    }
+    try {
+        const forcedFinalize = await agentChat({
+            messages: [
+                ...messages,
+                {
+                    role: "user",
+                    content: "Stop using tools. Return your final deliverable now using only the information already gathered in this conversation.",
+                },
+            ],
+        });
+        if (forcedFinalize.content && forcedFinalize.content.trim().length > 0) {
+            return {
+                content: forcedFinalize.content,
+                toolCalls: totalToolCalls,
+                fileWriteCalls: totalFileWriteCalls,
+            };
+        }
+    }
+    catch {
+        // Ignore finalize errors and fall back to sentinel below.
+    }
+    return {
+        content: "Max iterations reached.",
+        toolCalls: totalToolCalls,
+        fileWriteCalls: totalFileWriteCalls,
+    };
+}
+const Fredrix_DECOMPOSE_PROMPT = `You are Fredrix, Product Manager. Given a project description, create a product specification.
+
+Define clear User Stories, MoSCoW prioritization (Must/Should/Could/Won't), and Acceptance Criteria.
+
+Available teams and agents:
+{agents}
+
+Project: {description}
+
+Return ONLY a JSON object with:
+{
+  "title": "Project title",
+  "user_stories": [
+    {
+      "id": "US-1",
+      "title": "Short title",
+      "description": "As a user I want X so that Y",
+      "priority": "must|should|could|wont",
+      "acceptance_criteria": ["AC1", "AC2"]
+    }
+  ]
+}`;
+const Stoffe_DECOMPOSE_PROMPT = `You are Stoffe, Systems Architect. Given Fredrix's product spec, break it into concrete technical tasks for the development team.
+
+Available agents:
+{agents}
+
+Fredrix's Product Spec:
+{Fredrix_spec}
+
+Available orchestration profiles:
+{profiles}
+
+Recommended project profile for this project: {selected_profile}
+
+## CODE AGENTS (for implementation/integration tasks):
+{code_agents}
+
+## QA AGENTS (for testing tasks):
+{qa_agents}
+
+## REVIEW AGENTS (for code review tasks):
+{review_agents}
+
+## SECURITY AGENTS (for security audit tasks):
+{security_agents}
+
+MANDATORY RULES FOR CODE TASKS:
+- Split implementation across MULTIPLE code agents listed above when the project has distinct areas (frontend, backend, integrations, mobile, etc.).
+- Each coding task should be independently deployable (no circular dependencies between code tasks).
+- All code tasks that can run in parallel MUST share the same dependency set (e.g. all depend on the architecture task).
+- Assign reviewer_agent to every code task using a QA agent from the list above. NEVER leave reviewer_agent null for code tasks.
+
+MANDATORY PIPELINE STAGES:
+- Every project with code tasks MUST include a QA Testing task assigned to a QA agent that depends on ALL code tasks.
+- Every project with code tasks MUST include a Code Review task assigned to a review agent that depends on the QA task.
+- Security-sensitive tasks (auth, payments, user data, API keys) MUST have reviewer_agent set to a security agent.
+
+Define dependencies between tasks (0-indexed task IDs). Tasks with no dependencies run first. Tasks that depend on others wait.
+
+Provide a Mermaid flow diagram showing the task dependencies.
+
+Return ONLY JSON in one of these formats:
+
+Option A (preferred):
+{
+  "pipeline_profile": "one of the available profiles",
+  "tasks": [
+    {
+      "title": "Short task title",
+      "description": "Detailed technical description including what the agent should produce",
+      "assigned_agent": "agent_name_lowercase",
+      "reviewer_agent": "agent_name_lowercase" | null,
+      "dependencies": [0, 1],
+      "max_retries": 10,
+      "stage_id": "optional stage id from stage catalog",
+      "architecture_contract": {
+        "stack_type": "optional stack",
+        "language": "optional language",
+        "required_artifacts": ["optional patterns"],
+        "forbidden_artifacts": ["optional patterns"],
+        "reviewer_focus": ["optional checks"],
+        "notes": "optional"
+      }
+    }
+  ]
+}
+
+Option B (legacy fallback): JSON array of tasks only.`;
+function inferProjectProfile(description) {
+    const text = description.toLowerCase();
+    if (/\b(game|engine|unreal|unity|opengl|vulkan|render)\b/.test(text))
+        return "game-engine-cpp";
+    if (/\b(ios|android|mobile|react native|flutter|swift|kotlin)\b/.test(text))
+        return "mobile-app";
+    if (/\b(marketing|campaign|seo|social media|ads|funnel|growth)\b/.test(text))
+        return "marketing-campaign";
+    if (/\b(code review|review only|audit existing code|refactor audit)\b/.test(text))
+        return "code-review-only";
+    if (/\b(publish|publishing|newsletter|editorial|content pipeline|release notes)\b/.test(text))
+        return "publishing-workflow";
+    return config.factoryOrchestration.selection.defaultProfile;
+}
+function resolveProjectProfile(description, requestedProfile) {
+    const profiles = config.factoryOrchestration.profiles || {};
+    if (requestedProfile && profiles[requestedProfile])
+        return requestedProfile;
+    const inferred = inferProjectProfile(description);
+    if (profiles[inferred])
+        return inferred;
+    return config.factoryOrchestration.selection.defaultProfile;
+}
+function formatProfilesForPrompt() {
+    const profiles = config.factoryOrchestration.profiles || {};
+    return Object.entries(profiles)
+        .map(([key, value]) => `- ${key}: mandatory=[${value.mandatoryStages.join(", ")}], optional=[${value.optionalStages.join(", ")}]`)
+        .join("\n");
+}
+function normalizeStageId(input) {
+    if (!input)
+        return null;
+    const normalized = input.toLowerCase().trim().replace(/_/g, "-");
+    const aliasMap = {
+        qa: "qa-testing",
+        security: "security-audit",
+        "final review": "final-review",
+        review: "code-review",
+    };
+    return aliasMap[normalized] || normalized;
+}
+function agentMatchesSelectors(agent, selectors) {
+    if (!selectors)
+        return false;
+    const phase = AGENT_PHASES[agent.name.toLowerCase()] || "";
+    const team = (agent.team || "").toLowerCase();
+    const tags = new Set((agent.tags || []).map((t) => t.toLowerCase()));
+    const tools = new Set((agent.tools || []).map((t) => t.toLowerCase()));
+    const phaseMatch = Array.isArray(selectors.phase)
+        ? selectors.phase.some((p) => String(p).toLowerCase() === phase)
+        : false;
+    const teamMatch = Array.isArray(selectors.team)
+        ? selectors.team.some((t) => String(t).toLowerCase() === team)
+        : false;
+    const tagMatch = Array.isArray(selectors.tags)
+        ? selectors.tags.some((t) => tags.has(String(t).toLowerCase()))
+        : false;
+    const toolsMatch = Array.isArray(selectors.toolsAny)
+        ? selectors.toolsAny.some((t) => tools.has(String(t).toLowerCase()))
+        : false;
+    return phaseMatch || teamMatch || tagMatch || toolsMatch;
+}
+function findAgentForStage(stageId, allAgents, fallback) {
+    const stageDef = config.factoryOrchestration.stageCatalog?.[stageId];
+    const fromSelector = allAgents.find((a) => agentMatchesSelectors(a, stageDef?.selectors));
+    if (fromSelector)
+        return fromSelector.name;
+    const byMappedPhase = allAgents.find((a) => {
+        const phase = AGENT_PHASES[a.name.toLowerCase()] || "";
+        if (stageId === "qa-testing")
+            return phase === "qa";
+        if (stageId === "security-audit")
+            return phase === "security";
+        if (stageId === "code-review")
+            return phase === "code-review";
+        if (stageId === "ideation")
+            return phase === "ideation";
+        if (stageId === "blueprint")
+            return phase === "blueprint";
+        if (stageId === "ui-ux-design")
+            return phase === "design";
+        if (stageId === "implementation")
+            return phase === "implementation";
+        if (stageId === "integration")
+            return phase === "integration";
+        if (stageId === "feedback")
+            return phase === "feedback";
+        return false;
+    });
+    if (byMappedPhase)
+        return byMappedPhase.name;
+    const fallbackByName = getAgentByNameFromList(fallback, allAgents);
+    return fallbackByName?.name || fallback;
+}
+function detectTaskStageId(task, allAgents) {
+    const direct = normalizeStageId(typeof task.stage_id === "string" ? task.stage_id : null);
+    if (direct && config.factoryOrchestration.stageCatalog[direct])
+        return direct;
+    const assigned = typeof task.assigned_agent === "string" ? task.assigned_agent : "";
+    const agent = getAgentByNameFromList(assigned, allAgents);
+    if (agent) {
+        const entries = Object.entries(config.factoryOrchestration.stageCatalog)
+            .sort((a, b) => (a[1].order || 999) - (b[1].order || 999));
+        for (const [stageId, stageDef] of entries) {
+            if (agentMatchesSelectors(agent, stageDef.selectors)) {
+                return stageId;
+            }
+        }
+    }
+    const blob = `${task.title || ""} ${task.description || ""}`.toLowerCase();
+    if (/\b(qa|test|smoke|edge case)\b/.test(blob))
+        return "qa-testing";
+    if (/\b(security|vulnerab|auth|gdpr|xss|sqli)\b/.test(blob))
+        return "security-audit";
+    if (/\b(code review|review code|refactor review)\b/.test(blob))
+        return "code-review";
+    if (/\b(deploy|docker|infra|kubernetes|vercel|aws)\b/.test(blob))
+        return "deployment";
+    if (/\b(release|semver|changelog|release notes)\b/.test(blob))
+        return "release";
+    if (/\b(feedback|support|user report)\b/.test(blob))
+        return "feedback";
+    if (/\b(design|ui|ux|wireframe)\b/.test(blob))
+        return "ui-ux-design";
+    if (/\b(architecture|blueprint|schema|system design)\b/.test(blob))
+        return "blueprint";
+    if (/\b(integration|webhook|external api)\b/.test(blob))
+        return "integration";
+    if (/\b(implement|build|develop|feature|frontend|backend|api)\b/.test(blob))
+        return "implementation";
+    if (/\b(product spec|user stor|acceptance criteria)\b/.test(blob))
+        return "ideation";
+    return null;
+}
+function buildInjectedStageTask(stageId, assignedAgent, dependencies, maxRetries) {
+    const templates = {
+        "ideation": {
+            title: "Ideation & Product Specification",
+            description: "Refine product scope, user stories, and acceptance criteria based on current project context.",
+        },
+        "blueprint": {
+            title: "Technical Blueprint",
+            description: "Create or refine architecture decisions, system boundaries, and technical constraints.",
+        },
+        "ui-ux-design": {
+            title: "UI/UX Design",
+            description: "Deliver interaction flow, visual language, and implementation-ready design guidance.",
+        },
+        "implementation": {
+            title: "Implementation",
+            description: "Implement the required product functionality in code according to accepted architecture and quality standards.",
+        },
+        "integration": {
+            title: "Integration",
+            description: "Integrate modules and external services; ensure interfaces and contracts are correctly connected.",
+        },
+        "security-audit": {
+            title: "Security Audit",
+            description: "Audit for vulnerabilities, auth weaknesses, secrets handling, and compliance/security posture.",
+        },
+        "qa-testing": {
+            title: "QA Testing",
+            description: "Run smoke, regression, and edge-case validation against acceptance criteria.",
+        },
+        "code-review": {
+            title: "Code Review",
+            description: "Review maintainability, readability, correctness, and architecture adherence.",
+        },
+        "final-review": {
+            title: "Final Product Review",
+            description: "Verify final output against original user stories and acceptance criteria.",
+        },
+        "deployment": {
+            title: "Deployment",
+            description: "Prepare and execute deployment workflow with environment and release safety checks.",
+        },
+        "release": {
+            title: "Release",
+            description: "Prepare release notes, versioning, and rollout communication.",
+        },
+        "feedback": {
+            title: "Feedback Collection",
+            description: "Collect post-release feedback and convert findings into actionable follow-up tasks.",
+        },
+    };
+    const template = templates[stageId] || {
+        title: `Pipeline Stage: ${stageId}`,
+        description: `Execute required activities for stage ${stageId}.`,
+    };
+    return {
+        title: template.title,
+        description: template.description,
+        assigned_agent: assignedAgent,
+        reviewer_agent: null,
+        dependencies,
+        max_retries: maxRetries,
+        stage_id: stageId,
+    };
+}
+async function decomposeProject(description) {
+    const agents = listAgents();
+    const agentList = agents
+        .map((a) => `- ${a.name} (${a.role}, team: ${a.team})`)
+        .join("\n");
+    const codeAgents = agents.filter((a) => isCodeAgent(a));
+    const qaAgents = agents.filter((a) => isQaAgent(a));
+    const reviewAgents = agents.filter((a) => isReviewAgent(a));
+    const securityAgents = agents.filter((a) => isSecurityAgent(a));
+    const suggestedProfile = resolveProjectProfile(description, null);
+    const formatAgentList = (list) => list.length > 0
+        ? list.map((a) => `- ${a.name} (${a.role})`).join("\n")
+        : "- (none available)";
+    const FredrixPrompt = Fredrix_DECOMPOSE_PROMPT
+        .replace("{agents}", agentList)
+        .replace("{description}", description);
+    console.log("🏭 Fredrix decomposing requirements...");
+    const FredrixAgent = getAgent("Fredrix");
+    const FredrixResponse = await chatCompletionWithFallback(FredrixAgent?.model || undefined, FredrixAgent?.fallbackModel || undefined, { messages: [{ role: "user", content: FredrixPrompt }] });
+    const FredrixText = FredrixResponse.content?.trim() || "{}";
+    const FredrixJsonMatch = FredrixText.match(/\{[\s\S]*\}/);
+    if (!FredrixJsonMatch)
+        throw new Error("Fredrix failed to produce valid JSON");
+    const FredrixSpec = JSON.parse(FredrixJsonMatch[0]);
+    console.log("🏭 Stoffe building architecture...");
+    const StoffeAgent = getAgent("Stoffe");
+    const StoffePrompt = Stoffe_DECOMPOSE_PROMPT
+        .replace("{agents}", agentList)
+        .replace("{Fredrix_spec}", JSON.stringify(FredrixSpec, null, 2))
+        .replace("{profiles}", formatProfilesForPrompt())
+        .replace("{selected_profile}", suggestedProfile)
+        .replace("{code_agents}", formatAgentList(codeAgents))
+        .replace("{qa_agents}", formatAgentList(qaAgents))
+        .replace("{review_agents}", formatAgentList(reviewAgents))
+        .replace("{security_agents}", formatAgentList(securityAgents));
+    const StoffeResponse = await chatCompletionWithFallback(StoffeAgent?.model || undefined, StoffeAgent?.fallbackModel || undefined, { messages: [{ role: "user", content: StoffePrompt }] });
+    const StoffeText = StoffeResponse.content?.trim() || "[]";
+    let rawTasks = [];
+    let StoffePipelineProfile = null;
+    const objectMatch = StoffeText.match(/\{[\s\S]*\}/);
+    if (objectMatch) {
+        const parsed = JSON.parse(objectMatch[0]);
+        if (typeof parsed.pipeline_profile === "string") {
+            StoffePipelineProfile = parsed.pipeline_profile;
+        }
+        if (Array.isArray(parsed.tasks)) {
+            rawTasks = parsed.tasks;
+        }
+    }
+    if (rawTasks.length === 0) {
+        const StoffeJsonMatch = StoffeText.match(/\[[\s\S]*\]/);
+        if (!StoffeJsonMatch)
+            throw new Error("Stoffe failed to produce valid JSON");
+        rawTasks = JSON.parse(StoffeJsonMatch[0]);
+    }
+    const pipelineProfile = resolveProjectProfile(description, StoffePipelineProfile);
+    const validAgents = new Set(agents.map((a) => a.name.toLowerCase()));
+    const defaultSecurityReviewer = findAgentForStage("security-audit", agents, "sara");
+    const tasks = rawTasks.map((t) => {
+        const assigned = validAgents.has((t.assigned_agent || "").toLowerCase())
+            ? t.assigned_agent.toLowerCase()
+            : "chris";
+        let reviewer = t.reviewer_agent && validAgents.has(t.reviewer_agent.toLowerCase())
+            ? t.reviewer_agent.toLowerCase()
+            : null;
+        if (isSecuritySensitiveTask(t) && (!reviewer || reviewer !== defaultSecurityReviewer)) {
+            reviewer = defaultSecurityReviewer;
+        }
+        return {
+            title: t.title || "Untitled task",
+            description: t.description || "",
+            assigned_agent: assigned,
+            reviewer_agent: reviewer,
+            dependencies: Array.isArray(t.dependencies) ? t.dependencies : [],
+            max_retries: Number.isInteger(t.max_retries)
+                ? Math.max(1, Number(t.max_retries))
+                : DEFAULT_MAX_RETRIES,
+            stage_id: normalizeStageId(typeof t.stage_id === "string" ? t.stage_id : detectTaskStageId(t, agents)),
+            architecture_contract: normalizeArchitectureContract(t.architecture_contract),
+        };
+    });
+    return {
+        title: FredrixSpec.title || description.substring(0, 60),
+        tasks,
+        pipelineProfile,
+    };
+}
+function isCodeTask(agentName, allAgents) {
+    const agent = getAgentByNameFromList(agentName, allAgents);
+    if (!agent)
+        return false;
+    return isCodeAgent(agent);
+}
+function isSecuritySensitiveTask(task) {
+    const blob = `${task.title || ""} ${task.description || ""}`.toLowerCase();
+    if (/\b(auth|authentication|authorization|oauth|jwt|token|payment|billing|invoice|card|pci|gdpr|pii|personal data|secret|api key|encryption|password|session|security)\b/.test(blob)) {
+        return true;
+    }
+    const contract = normalizeArchitectureContract(task.architecture_contract);
+    if (!contract)
+        return false;
+    const contractBlob = `${contract.stackType || ""} ${contract.notes || ""} ${contract.reviewerFocus.join(" ")}`.toLowerCase();
+    return /\b(security|auth|gdpr|privacy|compliance)\b/.test(contractBlob);
+}
+function injectMissingStages(tasks, profileId, allAgents) {
+    const patched = tasks.map((t) => ({ ...t }));
+    const profile = config.factoryOrchestration.profiles[profileId]
+        || config.factoryOrchestration.profiles[config.factoryOrchestration.selection.defaultProfile]
+        || { mandatoryStages: ["qa-testing"], optionalStages: [] };
+    const mandatoryStages = (profile.mandatoryStages || []).map((s) => normalizeStageId(s)).filter((s) => !!s);
+    const stageOrder = Object.fromEntries(Object.entries(config.factoryOrchestration.stageCatalog).map(([id, def]) => [id, def.order || 999]));
+    mandatoryStages.sort((a, b) => (stageOrder[a] || 999) - (stageOrder[b] || 999));
+    for (const task of patched) {
+        const detected = normalizeStageId(task.stage_id) || detectTaskStageId(task, allAgents);
+        task.stage_id = detected;
+    }
+    const codeTaskIndices = [];
+    patched.forEach((t, i) => {
+        if (isCodeTask(t.assigned_agent, allAgents) || t.stage_id === "implementation" || t.stage_id === "integration") {
+            codeTaskIndices.push(i);
+        }
+    });
+    const stageIndices = (stageId) => patched
+        .map((t, idx) => ({ stageId: t.stage_id, idx }))
+        .filter((x) => x.stageId === stageId)
+        .map((x) => x.idx);
+    for (let i = 0; i < mandatoryStages.length; i++) {
+        const stageId = mandatoryStages[i];
+        const exists = stageIndices(stageId).length > 0;
+        if (exists)
+            continue;
+        const prevStages = mandatoryStages.slice(0, i).reverse();
+        let deps = [];
+        for (const prev of prevStages) {
+            const found = stageIndices(prev);
+            if (found.length > 0) {
+                deps = found;
+                break;
+            }
+        }
+        if (stageId === "qa-testing" || stageId === "security-audit") {
+            deps = codeTaskIndices.length > 0 ? [...codeTaskIndices] : deps;
+        }
+        else if (stageId === "code-review") {
+            const qaDeps = stageIndices("qa-testing");
+            deps = qaDeps.length > 0 ? qaDeps : (codeTaskIndices.length > 0 ? [...codeTaskIndices] : deps);
+        }
+        else if (stageId === "final-review") {
+            const reviewDeps = stageIndices("code-review");
+            const qaDeps = stageIndices("qa-testing");
+            deps = reviewDeps.length > 0 ? reviewDeps : (qaDeps.length > 0 ? qaDeps : deps);
+        }
+        else if (stageId === "deployment") {
+            const finalDeps = stageIndices("final-review");
+            const reviewDeps = stageIndices("code-review");
+            deps = finalDeps.length > 0 ? finalDeps : (reviewDeps.length > 0 ? reviewDeps : deps);
+        }
+        else if (stageId === "release") {
+            const deployDeps = stageIndices("deployment");
+            deps = deployDeps.length > 0 ? deployDeps : deps;
+        }
+        else if (stageId === "feedback") {
+            const releaseDeps = stageIndices("release");
+            const finalDeps = stageIndices("final-review");
+            deps = releaseDeps.length > 0 ? releaseDeps : (finalDeps.length > 0 ? finalDeps : deps);
+        }
+        const stagePolicy = config.factoryOrchestration.stageCatalog[stageId];
+        const stageMaxRetries = stagePolicy?.retryPolicy?.maxRetries ?? DEFAULT_MAX_RETRIES;
+        const fallbackAgent = stageId === "qa-testing"
+            ? "tess"
+            : stageId === "code-review"
+                ? "chris"
+                : stageId === "security-audit"
+                    ? "sara"
+                    : stageId === "ideation" || stageId === "final-review"
+                        ? "Fredrix"
+                        : stageId === "blueprint"
+                            ? "Stoffe"
+                            : stageId === "ui-ux-design"
+                                ? "ulla"
+                                : stageId === "implementation"
+                                    ? "chris"
+                                    : stageId === "integration"
+                                        ? "ivan"
+                                        : stageId === "deployment"
+                                            ? "dan"
+                                            : stageId === "release"
+                                                ? "stig"
+                                                : stageId === "feedback"
+                                                    ? "sune"
+                                                    : "chris";
+        const selectedAgent = findAgentForStage(stageId, allAgents, fallbackAgent);
+        const injectedTask = buildInjectedStageTask(stageId, selectedAgent, deps, Math.max(1, stageMaxRetries));
+        patched.push(injectedTask);
+        console.log(`🏭 Injected missing stage ${stageId} → ${selectedAgent}, deps: [${deps.join(",")}]`);
+    }
+    const qaAgent = findAgentForStage("qa-testing", allAgents, "tess");
+    const securityAgent = findAgentForStage("security-audit", allAgents, "sara");
+    for (const idx of codeTaskIndices) {
+        if (!patched[idx].reviewer_agent) {
+            patched[idx].reviewer_agent = qaAgent;
+        }
+    }
+    for (let i = 0; i < patched.length; i++) {
+        const task = patched[i];
+        if (isSecuritySensitiveTask(task)) {
+            task.reviewer_agent = securityAgent;
+        }
+    }
+    for (const task of patched) {
+        const stageId = normalizeStageId(task.stage_id);
+        if (!stageId)
+            continue;
+        const stagePolicy = config.factoryOrchestration.stageCatalog[stageId];
+        if (stagePolicy?.retryPolicy?.maxRetries) {
+            task.max_retries = Math.max(1, Number(stagePolicy.retryPolicy.maxRetries));
+        }
+    }
+    return patched;
+}
+export async function factoryCreate(description) {
+    const { title, tasks, pipelineProfile } = await decomposeProject(description);
+    const allAgents = listAgents();
+    const profile = resolveProjectProfile(description, pipelineProfile);
+    const patchedTasks = injectMissingStages(tasks, profile, allAgents);
+    const project = createFactoryProject(title, description);
+    const projectId = project.id;
+    const taskMap = new Map();
+    for (let i = 0; i < patchedTasks.length; i++) {
+        const t = patchedTasks[i];
+        const phase = AGENT_PHASES[t.assigned_agent?.toLowerCase()] || null;
+        const contextPayload = {
+            ...(t.architecture_contract ? { architecture_contract: t.architecture_contract } : {}),
+            ...(t.stage_id ? { stage_id: t.stage_id } : {}),
+            pipeline_profile: profile,
+        };
+        const result = insertTask.run(projectId, t.title, t.description, t.assigned_agent, t.reviewer_agent || null, "[]", t.max_retries, JSON.stringify(contextPayload), phase);
+        taskMap.set(i, Number(result.lastInsertRowid));
+    }
+    for (let i = 0; i < patchedTasks.length; i++) {
+        const taskId = taskMap.get(i);
+        if (!taskId)
+            continue;
+        const mappedDependencies = (Array.isArray(patchedTasks[i].dependencies) ? patchedTasks[i].dependencies : [])
+            .map((depIdx) => {
+            if (typeof depIdx !== "number" || !Number.isInteger(depIdx))
+                return null;
+            return taskMap.get(depIdx) ?? null;
+        })
+            .filter((depId) => depId !== null);
+        updateTaskDependencies.run(JSON.stringify(mappedDependencies), taskId);
+    }
+    const created = getFactoryTasks(projectId);
+    updateProjectStatus.run("running", projectId);
+    const updatedRow = getProjectById.get(projectId);
+    return {
+        project: rowToProject(updatedRow),
+        tasks: created,
+    };
+}
+function areDependenciesMet(task, allTasks) {
+    if (task.dependencies.length === 0)
+        return true;
+    return task.dependencies.every((depId) => {
+        const dep = allTasks.find((t) => t.id === depId);
+        return dep && dep.status === "done";
+    });
+}
+function buildContextFromDeps(task, allTasks) {
+    const context = {};
+    for (const depId of task.dependencies) {
+        const dep = allTasks.find((t) => t.id === depId);
+        if (dep && dep.result) {
+            context[`${dep.title} (${dep.assignedAgent})`] = dep.result;
+        }
+    }
+    return context;
+}
+function normalizeLegacyProjectDependencies(projectId) {
+    const projectTasks = getTasksByProject.all(projectId).map(rowToTask);
+    if (projectTasks.length === 0)
+        return;
+    const hasLegacyDependencies = projectTasks.some((task) => task.dependencies.includes(0));
+    if (!hasLegacyDependencies)
+        return;
+    const indexToTaskId = projectTasks.map((task) => task.id);
+    let changed = 0;
+    for (const task of projectTasks) {
+        const normalizedDeps = task.dependencies
+            .map((depIdx) => {
+            if (!Number.isInteger(depIdx) || depIdx < 0)
+                return null;
+            return indexToTaskId[depIdx] ?? null;
+        })
+            .filter((depId) => depId !== null);
+        if (JSON.stringify(normalizedDeps) !== JSON.stringify(task.dependencies)) {
+            updateTaskDependencies.run(JSON.stringify(normalizedDeps), task.id);
+            changed++;
+        }
+    }
+    if (changed > 0) {
+        autoNormalizedProjects.add(projectId);
+        updateProjectUpdatedAt.run(projectId);
+        console.log(`🏭 Normalized legacy dependencies for project ${projectId} (${changed} tasks)`);
+    }
+}
+async function notifyHumanIntervention(task, project) {
+    const userId = [...config.allowedUserIds][0];
+    if (!userId)
+        return;
+    const msg = `⚠️ **Factory Alert**\n\nProject: ${project.title}\nTask: ${task.title}\nAgent: ${task.assignedAgent}\n\n${task.assignedAgent} and ${task.reviewerAgent || "QA"} are stuck in a loop (${task.retryCount} retries).\n\nUse \`/factory retry ${task.id}\` to force retry.`;
+    try {
+        await sendToTelegram(userId, msg);
+    }
+    catch (err) {
+        console.error("Factory: failed to send Telegram notification:", err);
+    }
+}
+const MAX_CONCURRENT = 3;
+const TASK_AGENT_MAX_ITERATIONS = 14;
+const REVIEW_AGENT_MAX_ITERATIONS = 10;
+const STALE_IN_PROGRESS_MINUTES = 8;
+let activeRuns = 0;
+const autoNormalizedProjects = new Set();
+const finalizedProjects = new Set();
+export function wasProjectAutoNormalized(projectId) {
+    return autoNormalizedProjects.has(projectId);
+}
+function extractLatestReviewFeedback(contextPayload) {
+    const raw = contextPayload.latest_review_feedback;
+    if (!raw)
+        return null;
+    if (typeof raw === "string") {
+        return {
+            status: "rejected",
+            from: "review",
+            to: "agent",
+            reason: raw,
+            retry_count: 0,
+            problem: raw,
+            fix: "Address each issue in this review and verify against the task requirements.",
+        };
+    }
+    if (typeof raw !== "object")
+        return null;
+    const obj = raw;
+    const reason = typeof obj.reason === "string" ? obj.reason : "Review identified issues";
+    const retryCount = typeof obj.retry_count === "number" && Number.isInteger(obj.retry_count)
+        ? obj.retry_count
+        : 0;
+    return {
+        status: "rejected",
+        from: typeof obj.from === "string" ? obj.from : "review",
+        to: typeof obj.to === "string" ? obj.to : "agent",
+        reason,
+        retry_count: retryCount,
+        problem: typeof obj.problem === "string" ? obj.problem : reason,
+        fix: typeof obj.fix === "string" ? obj.fix : "Address all review issues before submitting.",
+    };
+}
+function getAttemptsByAgent(contextPayload) {
+    const raw = contextPayload.attempts_by_agent;
+    if (!raw || typeof raw !== "object")
+        return {};
+    const attempts = {};
+    for (const [name, value] of Object.entries(raw)) {
+        if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+            attempts[name.toLowerCase()] = Math.floor(value);
+        }
+    }
+    return attempts;
+}
+function getExecutionAgent(task, contextPayload, contract) {
+    const attemptsByAgent = getAttemptsByAgent(contextPayload);
+    const allAgents = listAgents();
+    const stageId = normalizeStageId(typeof contextPayload.stage_id === "string" ? contextPayload.stage_id : null);
+    const stagePreferred = stageId
+        ? allAgents
+            .filter((a) => {
+            const stageDef = config.factoryOrchestration.stageCatalog[stageId];
+            return stageDef ? agentMatchesSelectors(a, stageDef.selectors) : false;
+        })
+            .map((a) => a.name.toLowerCase())
+        : [];
+    const preferred = preferredAgentsForContract(contract, allAgents);
+    const candidates = Array.from(new Set([task.assignedAgent.toLowerCase(), ...stagePreferred, ...preferred].filter(Boolean)));
+    let selected = task.assignedAgent.toLowerCase();
+    let reason = "default assigned agent";
+    if (task.retryCount >= 7) {
+        const unseenCandidate = candidates.find((candidate) => (attemptsByAgent[candidate] || 0) === 0 && getAgent(candidate));
+        if (unseenCandidate) {
+            selected = unseenCandidate;
+            reason = `rerouted after repeated retries (${task.retryCount})`;
+        }
+    }
+    if (task.retryCount >= 9) {
+        const sortedCandidates = candidates
+            .filter((candidate) => getAgent(candidate))
+            .sort((a, b) => (attemptsByAgent[a] || 0) - (attemptsByAgent[b] || 0));
+        if (sortedCandidates.length > 0) {
+            selected = sortedCandidates[0];
+            reason = `lowest-attempt candidate at high retry (${task.retryCount})`;
+        }
+    }
+    return {
+        agentName: selected,
+        forceFallbackModel: task.retryCount >= 9,
+        reason,
+    };
+}
+async function executeTask(task, allTasks) {
+    const project = getFactoryProject(task.projectId);
+    const workspacePath = project?.workspacePath || null;
+    setTaskStarted.run(task.id);
+    const context = buildContextFromDeps(task, allTasks);
+    const mergedContext = { ...task.contextPayload, ...context };
+    const contract = resolveTaskArchitectureContract(task, mergedContext);
+    if (contract) {
+        mergedContext.architecture_contract = contract;
+    }
+    const latestReviewFeedback = extractLatestReviewFeedback(mergedContext);
+    const agentChoice = getExecutionAgent(task, mergedContext, contract);
+    const chosenAgent = getAgent(agentChoice.agentName) || getAgent(task.assignedAgent);
+    if (!chosenAgent) {
+        console.error(`🏭 Agent "${task.assignedAgent}" not found for task ${task.id}`);
+        updateTaskResult.run("failed", `Agent "${task.assignedAgent}" not found`, JSON.stringify(mergedContext), task.id);
+        return;
+    }
+    const attemptsByAgent = getAttemptsByAgent(mergedContext);
+    attemptsByAgent[chosenAgent.name] = (attemptsByAgent[chosenAgent.name] || 0) + 1;
+    mergedContext.attempts_by_agent = attemptsByAgent;
+    mergedContext.last_execution_agent = chosenAgent.name;
+    mergedContext.last_execution_reason = agentChoice.reason;
+    const agentDef = agentChoice.forceFallbackModel && chosenAgent.fallbackModel
+        ? { ...chosenAgent, model: chosenAgent.fallbackModel, fallbackModel: undefined }
+        : chosenAgent;
+    const needsCodeOutput = /\b(implement|build|scaffold|frontend|backend|api|ui|dom|component|code|create)\b/i.test(`${task.title} ${task.description}`) && !/\b(specification|diagram|flow|review|audit|document)\b/i.test(`${task.title} ${task.description}`);
+    const codeDeliveryGuard = needsCodeOutput
+        ? "\n\n## Delivery requirement\nYou must produce real code changes in the project workspace using file_write and/or file_create. Descriptions without actual file operations are invalid."
+        : "";
+    const nudgeHint = buildNudgeHint(task);
+    const reviewRequirements = latestReviewFeedback
+        ? `\n\n## Reviewer findings to resolve\n- Reason: ${latestReviewFeedback.reason}\n- Problem: ${latestReviewFeedback.problem || latestReviewFeedback.reason}\n- Fix required: ${latestReviewFeedback.fix || "Resolve all identified issues."}\n\n## Retry acceptance checklist\n- Address every review item above explicitly\n- State which files were changed and why\n- Confirm the output now satisfies task requirements`
+        : null;
+    const contractGuard = contract
+        ? `\n\n## Architecture contract (must be honored)\n${formatArchitectureContract(contract)}`
+        : "";
+    const taskPrompt = `${task.description}${codeDeliveryGuard}${contractGuard}${reviewRequirements || ""}${nudgeHint}`;
+    console.log(`🏭 Running task ${task.id}: "${task.title}" → ${chosenAgent.name}`);
+    try {
+        const run = await runFactoryAgent(agentDef, taskPrompt, mergedContext, TASK_AGENT_MAX_ITERATIONS, workspacePath);
+        if (needsCodeOutput && run.fileWriteCalls === 0) {
+            const newRetryCount = task.retryCount + 1;
+            const bounce = buildBounceFeedback("system", chosenAgent.name, "Agent provided no code changes", newRetryCount, "This task requires implementation, but no file_write/file_create operations were executed.", "Create/modify the required project files in the workspace and include concrete code output, not only descriptive text.");
+            const newContext = {
+                ...mergedContext,
+                latest_review_feedback: bounce,
+                [`review_feedback_attempt_${newRetryCount}`]: bounce,
+            };
+            if (newRetryCount >= task.maxRetries) {
+                updateTaskResult.run("human_intervention", run.content, JSON.stringify(newContext), task.id);
+                console.log(`🏭 Task ${task.id} produced no code and hit max retries (${newRetryCount}) → human_intervention`);
+                if (project) {
+                    await notifyHumanIntervention(task, project);
+                }
+            }
+            else {
+                updateTaskRetry.run("backlog", newRetryCount, JSON.stringify(newContext), task.id);
+                console.log(`🏭 Task ${task.id} produced no code → retry ${newRetryCount}/${task.maxRetries}`);
+            }
+            return;
+        }
+        const contractValidation = validateWorkspaceAgainstContract(workspacePath, contract);
+        if (!contractValidation.ok) {
+            const newRetryCount = task.retryCount + 1;
+            const problem = contractValidation.violations.join("\n");
+            const bounce = buildBounceFeedback("system", chosenAgent.name, "Output violates architecture contract", newRetryCount, problem, "Bring workspace artifacts in line with the architecture contract before resubmitting.");
+            const newContext = {
+                ...mergedContext,
+                latest_review_feedback: bounce,
+                [`review_feedback_attempt_${newRetryCount}`]: bounce,
+            };
+            if (newRetryCount >= task.maxRetries) {
+                updateTaskResult.run("human_intervention", run.content, JSON.stringify(newContext), task.id);
+                console.log(`🏭 Task ${task.id} hit max retries (${newRetryCount}) after contract validation failure → human_intervention`);
+                if (project) {
+                    await notifyHumanIntervention(task, project);
+                }
+            }
+            else {
+                updateTaskRetry.run("backlog", newRetryCount, JSON.stringify(newContext), task.id);
+                console.log(`🏭 Task ${task.id} failed contract validation → retry ${newRetryCount}/${task.maxRetries}`);
+            }
+            return;
+        }
+        updateTaskResult.run("review", run.content, JSON.stringify(mergedContext), task.id);
+        console.log(`🏭 Task ${task.id} completed → review`);
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.error(`🏭 Task ${task.id} failed: ${errMsg}`);
+        updateTaskResult.run("failed", errMsg, JSON.stringify(mergedContext), task.id);
+    }
+}
+function buildBounceFeedback(from, to, reason, retryCount, problem, fix) {
+    return {
+        status: "rejected",
+        from,
+        to,
+        reason,
+        retry_count: retryCount,
+        problem,
+        fix,
+    };
+}
+function buildNudgeHint(task) {
+    if (task.retryCount < 2)
+        return "";
+    const previousFeedback = [];
+    for (const [key, val] of Object.entries(task.contextPayload)) {
+        if (key.startsWith("review_feedback_attempt_") && typeof val === "object" && val !== null) {
+            const bounce = val;
+            if (bounce.reason)
+                previousFeedback.push(`- Attempt ${bounce.retry_count}: ${bounce.reason}`);
+        }
+    }
+    const hint = previousFeedback.length > 0
+        ? `\n\nPrevious review feedback:\n${previousFeedback.join("\n")}`
+        : "";
+    return `\n\n## Nudge\nYou have tried to complete this task ${task.retryCount} times now.${hint}\nConsider a different approach. Check skills and documentation for inspiration.`;
+}
+async function reviewTask(task) {
+    if (!task.reviewerAgent) {
+        updateTaskStatus.run("done", task.id);
+        console.log(`🏭 Task ${task.id} auto-approved (no reviewer) → done`);
+        return;
+    }
+    const reviewerDef = getAgent(task.reviewerAgent);
+    if (!reviewerDef) {
+        updateTaskStatus.run("done", task.id);
+        console.log(`🏭 Task ${task.id} auto-approved (reviewer not found) → done`);
+        return;
+    }
+    console.log(`🏭 Reviewing task ${task.id}: "${task.title}" → ${task.reviewerAgent}`);
+    const project = getFactoryProject(task.projectId);
+    const workspacePath = project?.workspacePath || null;
+    const contract = resolveTaskArchitectureContract(task, task.contextPayload);
+    const contractReviewBlock = contract
+        ? `\n\nArchitecture contract (must be enforced):\n${formatArchitectureContract(contract)}\n\nIf the output violates this contract, you MUST return FAIL.`
+        : "";
+    const reviewPrompt = `You are reviewing the output of agent "${task.assignedAgent}" for task "${task.title}".
+
+Original task description: ${task.description}
+
+Agent output:
+${task.result || "(no output)"}
+
+Evaluate the output:
+- Does it fulfill the task description?
+- Are there any errors or issues?
+- Is the quality acceptable?
+${contract ? "- Does it comply with the architecture contract?" : ""}
+
+Reply with EXACTLY one of these formats:
+
+PASS: <reasoning>
+or
+FAIL: <short summary>
+PROBLEM: <what is wrong, concrete and specific>
+FIX: <clear actions the next agent attempt must take>
+
+The first non-whitespace text in your response must be PASS: or FAIL:.
+
+If FAIL, make PROBLEM and FIX specific enough that another agent can implement the fix without guessing.${contractReviewBlock}`;
+    const parseReviewVerdict = (raw) => {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return "unclear";
+        const upper = trimmed.toUpperCase();
+        if (upper.startsWith("PASS:"))
+            return "pass";
+        if (upper.startsWith("FAIL:"))
+            return "fail";
+        if (/^\s*PASS\s*:/im.test(raw))
+            return "pass";
+        if (/^\s*FAIL\s*:/im.test(raw))
+            return "fail";
+        if (/^\s*PROBLEM\s*:/im.test(raw) || /^\s*FIX\s*:/im.test(raw))
+            return "fail";
+        const passMarks = (raw.match(/✅/g) || []).length;
+        const failMarks = (raw.match(/❌|FAIL\b/gi) || []).length;
+        if (passMarks >= 2 && failMarks === 0)
+            return "pass";
+        return "unclear";
+    };
+    try {
+        const reviewRun = await runFactoryAgent(reviewerDef, reviewPrompt, {}, REVIEW_AGENT_MAX_ITERATIONS, workspacePath);
+        const reviewResult = reviewRun.content;
+        const verdict = parseReviewVerdict(reviewResult);
+        if (verdict === "pass") {
+            updateTaskStatus.run("done", task.id);
+            console.log(`🏭 Task ${task.id} PASSED review → done`);
+        }
+        else if (verdict === "fail") {
+            const newRetryCount = task.retryCount + 1;
+            const normalizedFeedback = /^\s*FAIL\s*:/im.test(reviewResult)
+                ? reviewResult
+                : `FAIL: Review identified issues.\n\n${reviewResult}`;
+            const bounce = buildBounceFeedback(task.reviewerAgent, task.assignedAgent, normalizedFeedback.split("\n").find((l) => l.startsWith("FAIL:"))?.replace(/^FAIL:\s*/, "") || "Review identified issues", newRetryCount, normalizedFeedback, normalizedFeedback);
+            const newContext = {
+                ...task.contextPayload,
+                latest_review_feedback: bounce,
+                [`review_feedback_attempt_${newRetryCount}`]: bounce,
+            };
+            if (newRetryCount >= task.maxRetries) {
+                updateTaskResult.run("human_intervention", task.result, JSON.stringify(newContext), task.id);
+                console.log(`🏭 Task ${task.id} hit max retries (${newRetryCount}) → human_intervention`);
+                const project = getFactoryProject(task.projectId);
+                if (project) {
+                    await notifyHumanIntervention(task, project);
+                }
+            }
+            else {
+                updateTaskRetry.run("backlog", newRetryCount, JSON.stringify(newContext), task.id);
+                console.log(`🏭 Task ${task.id} FAILED review → retry ${newRetryCount}/${task.maxRetries}`);
+            }
+        }
+        else {
+            const newRetryCount = task.retryCount + 1;
+            const bounce = buildBounceFeedback(task.reviewerAgent, task.assignedAgent, "Review response format was unclear", newRetryCount, "Reviewer did not provide a valid PASS/FAIL response with actionable fixes.", "Rework the task output against the original requirements and provide explicit rationale for each requirement fulfilled.");
+            const unclearFeedback = {
+                ...bounce,
+                raw_review: reviewResult,
+            };
+            const newContext = {
+                ...task.contextPayload,
+                latest_review_feedback: unclearFeedback,
+                [`review_feedback_attempt_${newRetryCount}`]: unclearFeedback,
+            };
+            if (newRetryCount >= task.maxRetries) {
+                updateTaskResult.run("human_intervention", task.result, JSON.stringify(newContext), task.id);
+                console.log(`🏭 Task ${task.id} hit max retries (${newRetryCount}) after unclear review → human_intervention`);
+                const project = getFactoryProject(task.projectId);
+                if (project) {
+                    await notifyHumanIntervention(task, project);
+                }
+            }
+            else {
+                updateTaskRetry.run("backlog", newRetryCount, JSON.stringify(newContext), task.id);
+                console.log(`🏭 Task ${task.id} review unclear → retry ${newRetryCount}/${task.maxRetries}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`🏭 Review failed for task ${task.id}:`, err);
+        const newRetryCount = task.retryCount + 1;
+        const bounce = buildBounceFeedback(task.reviewerAgent, task.assignedAgent, "Reviewer execution failed", newRetryCount, "Review step crashed before validating the output.", "Re-validate task output against requirements and ensure all acceptance points are covered.");
+        const newContext = {
+            ...task.contextPayload,
+            latest_review_feedback: bounce,
+            [`review_feedback_attempt_${newRetryCount}`]: bounce,
+        };
+        if (newRetryCount >= task.maxRetries) {
+            updateTaskResult.run("human_intervention", task.result, JSON.stringify(newContext), task.id);
+            const project = getFactoryProject(task.projectId);
+            if (project) {
+                await notifyHumanIntervention(task, project);
+            }
+        }
+        else {
+            updateTaskRetry.run("backlog", newRetryCount, JSON.stringify(newContext), task.id);
+        }
+    }
+}
+function normalizeProjectMaxRetries(projectId) {
+    const result = updateProjectTaskMaxRetries.run(DEFAULT_MAX_RETRIES, projectId);
+    if (result.changes > 0) {
+        autoNormalizedProjects.add(projectId);
+        updateProjectUpdatedAt.run(projectId);
+        console.log(`🏭 Normalized invalid max retries to ${DEFAULT_MAX_RETRIES} for project ${projectId} (${result.changes} tasks)`);
+    }
+}
+function normalizeProjectWorkspace(row) {
+    if (row.workspace_path) {
+        ensureWorkspaceDir(row.workspace_path);
+        return;
+    }
+    const workspacePath = buildDefaultWorkspacePath(row.id, row.title || "project");
+    ensureWorkspaceDir(workspacePath);
+    updateProjectWorkspacePath.run(workspacePath, row.id);
+    autoNormalizedProjects.add(row.id);
+    console.log(`🏭 Assigned workspace for project ${row.id}: ${workspacePath}`);
+}
+function collectFiles(rootDir, maxFiles = 400) {
+    const files = [];
+    function walk(current) {
+        if (files.length >= maxFiles)
+            return;
+        const entries = fs.readdirSync(current, { withFileTypes: true });
+        for (const entry of entries) {
+            if (files.length >= maxFiles)
+                return;
+            if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") {
+                continue;
+            }
+            const abs = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                walk(abs);
+            }
+            else {
+                files.push(abs);
+            }
+        }
+    }
+    walk(rootDir);
+    return files;
+}
+function findLikelyAppRoot(workspaceAbs) {
+    const rootPkg = path.join(workspaceAbs, "package.json");
+    if (fs.existsSync(rootPkg))
+        return workspaceAbs;
+    const allFiles = collectFiles(workspaceAbs, 500);
+    const pkgFiles = allFiles.filter((f) => path.basename(f) === "package.json");
+    if (pkgFiles.length === 0)
+        return workspaceAbs;
+    pkgFiles.sort((a, b) => a.length - b.length);
+    return path.dirname(pkgFiles[0]);
+}
+function detectTechStack(appRootAbs) {
+    const stack = new Set();
+    const scripts = {};
+    const packageJsonPath = path.join(appRootAbs, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+            const deps = {
+                ...(parsed.dependencies || {}),
+                ...(parsed.devDependencies || {}),
+            };
+            Object.assign(scripts, parsed.scripts || {});
+            if (deps.react)
+                stack.add("React");
+            if (deps.vue)
+                stack.add("Vue");
+            if (deps.svelte)
+                stack.add("Svelte");
+            if (deps.vite || fs.existsSync(path.join(appRootAbs, "vite.config.ts")) || fs.existsSync(path.join(appRootAbs, "vite.config.js"))) {
+                stack.add("Vite");
+            }
+            if (deps.tailwindcss || fs.existsSync(path.join(appRootAbs, "tailwind.config.js")) || fs.existsSync(path.join(appRootAbs, "tailwind.config.ts"))) {
+                stack.add("Tailwind CSS");
+            }
+            if (deps.typescript || fs.existsSync(path.join(appRootAbs, "tsconfig.json"))) {
+                stack.add("TypeScript");
+            }
+            else {
+                stack.add("JavaScript");
+            }
+        }
+        catch {
+            stack.add("JavaScript");
+        }
+    }
+    else {
+        stack.add("Static HTML/CSS/JS");
+    }
+    return {
+        stack: [...stack],
+        scripts,
+    };
+}
+function buildGeneratedReadme(project, tasks, appDirRel, stack, scripts) {
+    const doneTasks = tasks.filter((t) => t.status === "done");
+    const stackLines = stack.length > 0 ? stack.map((s) => `- ${s}`).join("\n") : "- Not automatically detected";
+    const installCmd = scripts.install ? "npm run install" : "npm install";
+    const devCmd = scripts.dev ? "npm run dev" : "npm run start";
+    const buildCmd = scripts.build ? "npm run build" : "npm run build  # if available";
+    const testCmd = scripts.test ? "npm run test" : "npm test  # if available";
+    const appDirNote = appDirRel === "."
+        ? "Run commands from the project workspace root."
+        : `Run commands from: \`${appDirRel}\``;
+    return `# ${project.title}
+
+<!-- generated-by-cf-factory -->
+
+## Overview
+
+This project was generated by CF Claw Factory and is currently marked as completed.
+
+## Tech Stack
+
+${stackLines}
+
+## Completed Scope
+
+${doneTasks.map((t) => `- ${t.title}`).join("\n") || "- No completed tasks recorded"}
+
+## Getting Started
+
+${appDirNote}
+
+1. Install dependencies:
+
+\`\`\`bash
+${installCmd}
+\`\`\`
+
+2. Start development server:
+
+\`\`\`bash
+${devCmd}
+\`\`\`
+
+3. Build for production:
+
+\`\`\`bash
+${buildCmd}
+\`\`\`
+
+4. Run tests:
+
+\`\`\`bash
+${testCmd}
+\`\`\`
+
+## Notes
+
+- This README was generated automatically when the Factory project reached completion.
+- Review task outputs in Factory history if you want a detailed implementation log.
+`;
+}
+function finalizeCompletedProject(projectId) {
+    const project = getFactoryProject(projectId);
+    if (!project)
+        return;
+    const tasks = getFactoryTasks(projectId);
+    if (tasks.length === 0)
+        return;
+    const workspaceAbs = absoluteWorkspacePath(project.workspacePath);
+    ensureWorkspaceDir(project.workspacePath);
+    const readmePath = path.join(workspaceAbs, "README.md");
+    const existingReadme = fs.existsSync(readmePath)
+        ? fs.readFileSync(readmePath, "utf-8")
+        : "";
+    if (existingReadme && !existingReadme.includes("generated-by-cf-factory")) {
+        finalizedProjects.add(projectId);
+        return;
+    }
+    const appRootAbs = findLikelyAppRoot(workspaceAbs);
+    const appDirRel = path.relative(workspaceAbs, appRootAbs) || ".";
+    const { stack, scripts } = detectTechStack(appRootAbs);
+    const readme = buildGeneratedReadme(project, tasks, appDirRel, stack, scripts);
+    fs.writeFileSync(readmePath, readme, "utf-8");
+    finalizedProjects.add(projectId);
+    updateProjectUpdatedAt.run(projectId);
+    console.log(`🏭 Project ${projectId} finalized → README generated at ${project.workspacePath}/README.md`);
+}
+async function recoverStaleInProgressTasks() {
+    const threshold = `-${STALE_IN_PROGRESS_MINUTES} minutes`;
+    const staleRows = getStaleInProgressTasks.all(threshold);
+    if (staleRows.length === 0)
+        return;
+    for (const row of staleRows) {
+        const task = rowToTask(row);
+        const project = getFactoryProject(task.projectId);
+        if (!project || project.status !== "running")
+            continue;
+        const newRetryCount = task.retryCount + 1;
+        const recoveryNote = `Factory recovered stale in_progress task after ${STALE_IN_PROGRESS_MINUTES}+ minutes without completion.` +
+            (task.startedAt ? ` Last started at ${task.startedAt}.` : "");
+        const newContext = {
+            ...task.contextPayload,
+            [`system_recovery_attempt_${newRetryCount}`]: recoveryNote,
+        };
+        if (newRetryCount >= task.maxRetries) {
+            updateTaskResult.run("human_intervention", task.result, JSON.stringify(newContext), task.id);
+            console.log(`🏭 Task ${task.id} recovered from stale in_progress but hit max retries (${newRetryCount}) → human_intervention`);
+            await notifyHumanIntervention(task, project);
+            continue;
+        }
+        updateTaskRetry.run("backlog", newRetryCount, JSON.stringify(newContext), task.id);
+        console.log(`🏭 Recovered stale in_progress task ${task.id} → backlog (${newRetryCount}/${task.maxRetries})`);
+    }
+}
+export async function tickFactory() {
+    const projectRows = getAllProjects.all();
+    const runningProjectIds = [];
+    for (const row of projectRows) {
+        if (row.status === "running") {
+            runningProjectIds.push(row.id);
+            normalizeProjectWorkspace(row);
+            normalizeLegacyProjectDependencies(row.id);
+            normalizeProjectMaxRetries(row.id);
+        }
+    }
+    await recoverStaleInProgressTasks();
+    const reviewRows = getReviewTasks.all();
+    for (const row of reviewRows) {
+        try {
+            await reviewTask(rowToTask(row));
+        }
+        catch (err) {
+            console.error("Factory review error:", err);
+        }
+    }
+    for (const projectId of runningProjectIds) {
+        checkProjectCompletion(projectId);
+    }
+    if (activeRuns >= MAX_CONCURRENT)
+        return;
+    const backlogRows = getBacklogTasks.all();
+    const allBacklogTasks = backlogRows.map(rowToTask);
+    const readyTasks = [];
+    for (const task of allBacklogTasks) {
+        const projectTasks = getTasksByProject.all(task.projectId).map(rowToTask);
+        if (areDependenciesMet(task, projectTasks)) {
+            const project = getFactoryProject(task.projectId);
+            if (project && project.status === "running") {
+                readyTasks.push(task);
+            }
+        }
+    }
+    const toRun = readyTasks.slice(0, MAX_CONCURRENT - activeRuns);
+    if (toRun.length === 0)
+        return;
+    const promises = toRun.map(async (task) => {
+        activeRuns++;
+        try {
+            const projectTasks = getTasksByProject.all(task.projectId).map(rowToTask);
+            await executeTask(task, projectTasks);
+        }
+        catch (err) {
+            console.error(`Factory task ${task.id} execution error:`, err);
+        }
+        finally {
+            activeRuns--;
+        }
+    });
+    await Promise.all(promises);
+    const projectIds = new Set(toRun.map((t) => t.projectId));
+    for (const projectId of projectIds) {
+        checkProjectCompletion(projectId);
+    }
+}
+function checkProjectCompletion(projectId) {
+    if (finalizedProjects.has(projectId)) {
+        const project = getFactoryProject(projectId);
+        if (project?.status === "running") {
+            finalizedProjects.delete(projectId);
+        }
+    }
+    const counts = getTaskCounts.get(projectId);
+    if (!counts || counts.total === 0)
+        return;
+    const taskRows = getTasksByProject.all(projectId);
+    const hasBlockingTasks = taskRows.some((r) => r.status === "human_intervention" || r.status === "failed");
+    if (hasBlockingTasks)
+        return;
+    if (counts.completed >= counts.total) {
+        const currentRow = getProjectById.get(projectId);
+        if (!currentRow || currentRow.status !== "completed") {
+            updateProjectStatus.run("completed", projectId);
+            console.log(`🏭 Project ${projectId} completed!`);
+        }
+        if (!finalizedProjects.has(projectId)) {
+            finalizeCompletedProject(projectId);
+        }
+    }
+    else {
+        const progress = Math.round((counts.completed / counts.total) * 100);
+        const currentRow = getProjectById.get(projectId);
+        if (currentRow && currentRow.status === "running") {
+            console.log(`🏭 Project ${projectId} progress: ${progress}% (${counts.completed}/${counts.total})`);
+        }
+    }
+}
+let factoryInterval = null;
+const TICK_INTERVAL_MS = 30_000;
+export function startFactory() {
+    if (factoryInterval)
+        return;
+    console.log("🏭 Factory orchestrator started (tick every 30s)");
+    tickFactory().catch((err) => {
+        console.error("Factory initial tick error:", err);
+    });
+    factoryInterval = setInterval(async () => {
+        try {
+            await tickFactory();
+        }
+        catch (err) {
+            console.error("Factory tick error:", err);
+        }
+    }, TICK_INTERVAL_MS);
+}
+export function stopFactory() {
+    if (factoryInterval) {
+        clearInterval(factoryInterval);
+        factoryInterval = null;
+        console.log("🏭 Factory orchestrator stopped");
+    }
+}
+process.on("exit", () => db.close());
+//# sourceMappingURL=factory.js.map