pi-feats 0.1.4 → 0.1.7

package/extensions/sequential-workflow.ts

@@ -9,7 +9,7 @@ import { isAbsolute, join, resolve } from "node:path";
 import { createHash } from "node:crypto";
 type TaskType = "action" | "collect" | "evaluate" | "workflow";
 type TaskStatus = "pending" | "running" | "awaiting_user" | "waiting_subworkflow" | "evaluating" | "accepted" | "rejected" | "failed";
-type WorkflowStatus = "running" | "awaiting_user" | "evaluating" | "completed" | "cancelled" | "failed";
+type WorkflowStatus = "pending_definition" | "running" | "awaiting_user" | "evaluating" | "completed" | "cancelled" | "failed";
 type Task = {
     id: number;
     workflow_id: number;
@@ -48,43 +48,45 @@ const templateMaxTasks = 1000;
 const templateMaxTitleLength = 1000;
 const templateMaxSourceLength = 2000;
 const templateMaxTextLength = 10000;
+const maxActionAttempts = 5;
 const taskType = StringEnum(["action", "collect", "evaluate", "workflow"] as const);
 const phaseType = StringEnum(["action", "collect"] as const);
+const evaluationOutcome = StringEnum(["accept", "retry", "fail"] as const);
 const workflowRoot = () => process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
 const workflowDatabase = () => join(workflowRoot(), "sequential-workflow.db");
 const templateDirectory = () => join(workflowRoot(), "sequential_workflow_templates");
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
 const requiredText = (value: unknown, field: string, maxLength: number) => {
     if (typeof value !== "string" || value.trim().length === 0)
-        throw new Error(`Template inválido: ${field} é obrigatório.`);
+        throw new Error(`Invalid template: ${field} is required.`);
     if (value.length > maxLength)
-        throw new Error(`Template inválido: ${field} excede ${maxLength} caracteres.`);
+        throw new Error(`Invalid template: ${field} exceeds ${maxLength} characters.`);
     return value;
 };
 const onlyProperties = (value: Record<string, unknown>, allowed: string[], field: string) => {
     const unexpected = Object.keys(value).find((key) => !allowed.includes(key));
     if (unexpected)
-        throw new Error(`Template inválido: ${field} contém a propriedade não permitida ${unexpected}.`);
+        throw new Error(`Invalid template: ${field} contains unsupported property ${unexpected}.`);
 };
 const validateTemplate = (value: unknown): WorkflowTemplate => {
     if (!isRecord(value))
-        throw new Error("Template inválido: a raiz deve ser um objeto JSON.");
+        throw new Error("Invalid template: root must be a JSON object.");
     onlyProperties(value, ["version", "title", "source", "tasks"], "raiz");
     if (value.version !== 1)
-        throw new Error("Template inválido: version deve ser 1.");
+        throw new Error("Invalid template: version must be 1.");
     if (!Array.isArray(value.tasks) || value.tasks.length === 0)
-        throw new Error("Template inválido: tasks deve conter ao menos uma task.");
+        throw new Error("Invalid template: tasks must contain at least one task.");
     if (value.tasks.length > templateMaxTasks)
-        throw new Error(`Template inválido: tasks não pode exceder ${templateMaxTasks} itens.`);
+        throw new Error(`Invalid template: tasks cannot exceed ${templateMaxTasks} items.`);
     const tasks = value.tasks.map((item, index) => {
         if (!isRecord(item))
-            throw new Error(`Template inválido: tasks[${index}] deve ser um objeto.`);
+            throw new Error(`Invalid template: tasks[${index}] must be an object.`);
         onlyProperties(item, ["type", "instruction", "criteria"], `tasks[${index}]`);
         if (item.type !== "action" && item.type !== "collect" && item.type !== "evaluate" && item.type !== "workflow")
-            throw new Error(`Template inválido: tasks[${index}].type deve ser action, collect, evaluate ou workflow.`);
+            throw new Error(`Invalid template: tasks[${index}].type must be action, collect, evaluate, or workflow.`);
         const criteria = item.criteria === undefined ? undefined : requiredText(item.criteria, `tasks[${index}].criteria`, templateMaxTextLength);
         if (item.type === "collect" && !criteria)
-            throw new Error(`Template inválido: tasks[${index}] é Collect e exige criteria.`);
+            throw new Error(`Invalid template: tasks[${index}] is Collect and requires criteria.`);
         return { type: item.type as TaskType, instruction: requiredText(item.instruction, `tasks[${index}].instruction`, templateMaxTextLength), criteria };
     });
     return { version: 1, title: requiredText(value.title, "title", templateMaxTitleLength), source: requiredText(value.source, "source", templateMaxSourceLength), tasks };
@@ -99,20 +101,20 @@ const loadTemplate = async (inputPath: string) => {
     try {
         const info = await stat(path);
         if (!info.isFile())
-            throw new Error("não é um arquivo regular");
+            throw new Error("not a regular file");
         if (info.size > templateMaxBytes)
             throw new Error(`excede o limite de ${templateMaxBytes} bytes`);
         content = await readFile(path, "utf8");
     }
     catch (error) {
-        throw new Error(`Não foi possível ler o template ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Could not read template ${path}: ${error instanceof Error ? error.message : String(error)}`);
     }
     let document: unknown;
     try {
         document = JSON.parse(content);
     }
     catch (error) {
-        throw new Error(`Template inválido: JSON malformado em ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Invalid template: malformed JSON in ${path}: ${error instanceof Error ? error.message : String(error)}`);
     }
     return { path, hash: createHash("sha256").update(content).digest("hex"), template: validateTemplate(document) };
 };
@@ -135,13 +137,14 @@ CREATE TABLE IF NOT EXISTS workflow_events (id INTEGER PRIMARY KEY AUTOINCREMENT
     const one = <T>(sql: string, ...params: SQLInputValue[]) => db.prepare(sql).get(...params) as T | undefined;
     const many = <T>(sql: string, ...params: SQLInputValue[]) => db.prepare(sql).all(...params) as T[];
     const event = (workflowId: number, taskId: number | null, phase: string, payload: unknown) => db.prepare("INSERT INTO workflow_events (workflow_id, task_id, phase, payload) VALUES (?, ?, ?, ?)").run(workflowId, taskId, phase, JSON.stringify(payload));
+    const evaluationRecord = (task: Task, outcome: "accept" | "retry" | "fail", reasoning: string, decision?: { evaluator?: string; model?: string; confidence?: number; probabilities?: Record<string, number> }) => JSON.stringify({ version: 1, outcome, reasoning, contract: { instruction: task.instruction, criteria: task.criteria }, evidence: { result: task.result }, decision, evaluatedAt: new Date().toISOString() });
     const workflow = (id: number) => one<Workflow>("SELECT id, title, source, status, parent_workflow_id FROM workflows WHERE id = ?", id);
-    const isActive = (item: Workflow) => ["running", "awaiting_user", "evaluating"].includes(item.status);
+    const isActive = (item: Workflow) => ["pending_definition", "running", "awaiting_user", "evaluating"].includes(item.status);
     const currentTask = (workflowId: number) => one<Task>("SELECT id, workflow_id, position, type, instruction, criteria, status, attempts, result, evaluation, child_workflow_id FROM workflow_tasks WHERE workflow_id = ? AND status NOT IN ('accepted', 'failed') ORDER BY position LIMIT 1", workflowId);
     const taskSummary = (task: Task) => ({ id: task.id, position: task.position, type: task.type, instruction: task.instruction, criteria: task.criteria, status: task.status, attempts: task.attempts, childWorkflowId: task.child_workflow_id });
     const requireActiveWorkflow = (id: number) => { const item = workflow(id); if (!item)
-        throw new Error(`Workflow #${id} não existe.`); if (!isActive(item))
-        throw new Error(`Workflow #${id} está ${item.status} e não pode ser alterado.`); return item; };
+        throw new Error(`Workflow #${id} does not exist.`); if (!isActive(item))
+        throw new Error(`Workflow #${id} is ${item.status} and cannot be changed.`); return item; };
     const resolveParentAfterChild = (child: Workflow) => {
         const parentTask = one<Task>("SELECT id, workflow_id, position, type, instruction, criteria, status, attempts, result, evaluation, child_workflow_id FROM workflow_tasks WHERE child_workflow_id = ? AND status = 'waiting_subworkflow'", child.id);
         if (!parentTask)
@@ -149,7 +152,7 @@ CREATE TABLE IF NOT EXISTS workflow_events (id INTEGER PRIMARY KEY AUTOINCREMENT
         const parent = workflow(parentTask.workflow_id);
         if (!parent || !isActive(parent))
             return;
-        const result = `Subworkflow #${child.id} (${child.title}) terminou com status ${child.status}.`;
+        const result = `Subworkflow #${child.id} (${child.title}) finished with status ${child.status}.`;
         if (child.status === "completed" && !parentTask.criteria) {
             db.prepare("UPDATE workflow_tasks SET result = ?, status = 'accepted', updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(result, parentTask.id);
             event(parent.id, parentTask.id, "subworkflow_completed", { childWorkflowId: child.id, accepted: true });
@@ -168,7 +171,7 @@ CREATE TABLE IF NOT EXISTS workflow_events (id INTEGER PRIMARY KEY AUTOINCREMENT
         if (!next) {
             db.prepare("UPDATE workflows SET status = 'completed', updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(item.id);
             const completed = workflow(item.id)!;
-            event(item.id, null, "completed", { message: "Todas as tasks foram aceitas." });
+            event(item.id, null, "completed", { message: "All tasks were accepted." });
             resolveParentAfterChild(completed);
             return { completed: true };
         }
@@ -185,68 +188,87 @@ CREATE TABLE IF NOT EXISTS workflow_events (id INTEGER PRIMARY KEY AUTOINCREMENT
         db.prepare("UPDATE workflows SET status='cancelled', updated_at=CURRENT_TIMESTAMP WHERE id=?").run(item.id);
         event(item.id, null, "cancelled", { by: "user", sessionId: harness.session() });
         resolveParentAfterChild(workflow(item.id)!);
-        return { content: [{ type: "text" as const, text: `Workflow #${item.id} cancelado.` }], details: { workflowId: item.id, status: "cancelled" } };
+        return { content: [{ type: "text" as const, text: `Workflow #${item.id} cancelled.` }], details: { workflowId: item.id, status: "cancelled" } };
     };
-    const createWorkflow = (definition: WorkflowDefinition, parentWorkflowId?: number, parentTaskId?: number) => {
+    const validateDefinition = (definition: WorkflowDefinition) => {
         for (const [index, task] of definition.tasks.entries())
             if (task.type === "collect" && !task.criteria)
-                throw new Error(`Task ${index + 1} é Collect e exige criteria.`);
-        let parentTask: Task | undefined;
-        if (parentTaskId !== undefined) {
-            parentTask = one<Task>("SELECT id, workflow_id, position, type, instruction, criteria, status, attempts, result, evaluation, child_workflow_id FROM workflow_tasks WHERE id = ?", parentTaskId);
-            if (!parentTask)
-                throw new Error(`Task pai #${parentTaskId} não existe.`);
-            if (parentTask.type !== "workflow")
-                throw new Error(`Task pai #${parentTaskId} deve ser do tipo workflow.`);
-            if (parentTask.status !== "running")
-                throw new Error(`Task pai #${parentTaskId} não está pronta para iniciar um subworkflow.`);
-            if (parentTask.child_workflow_id !== null)
-                throw new Error(`Task pai #${parentTaskId} já possui um subworkflow vinculado.`);
-            if (parentWorkflowId !== undefined && parentWorkflowId !== parentTask.workflow_id)
-                throw new Error("parentWorkflowId não corresponde ao workflow da parentTaskId.");
-            parentWorkflowId = parentTask.workflow_id;
-            requireActiveWorkflow(parentWorkflowId);
-        }
-        else if (parentWorkflowId !== undefined && !workflow(parentWorkflowId))
-            throw new Error(`Workflow pai #${parentWorkflowId} não existe.`);
-        {
-            const inserted = db.prepare("INSERT INTO workflows (title, source, status, parent_workflow_id, session_id) VALUES (?, ?, 'running', ?, ?)").run(definition.title, definition.source, parentWorkflowId ?? null, harness.session());
-            const workflowId = Number(inserted.lastInsertRowid);
-            const insertTask = db.prepare("INSERT INTO workflow_tasks (workflow_id, position, type, instruction, criteria, status) VALUES (?, ?, ?, ?, ?, 'pending')");
-            definition.tasks.forEach((task, index) => insertTask.run(workflowId, index + 1, task.type, task.instruction, task.criteria ?? null));
-            event(workflowId, null, "created", { title: definition.title, taskCount: definition.tasks.length, parentWorkflowId: parentWorkflowId ?? null });
-            if (parentTask) {
-                db.prepare("UPDATE workflow_tasks SET child_workflow_id = ?, status = 'waiting_subworkflow', updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(workflowId, parentTask.id);
-                event(parentTask.workflow_id, parentTask.id, "child_linked", { childWorkflowId: workflowId });
-            }
-            const next = activateNext(workflow(workflowId)!);
-            const suffix = parentTask ? ` vinculado à task pai #${parentTask.id}.` : ".";
-            return { content: [{ type: "text" as const, text: next.completed ? `Workflow #${workflowId} criado e concluído${suffix}` : `Workflow #${workflowId} criado${suffix} Execute somente a task #${next.task!.position}: ${next.task!.instruction}` }], details: { workflowId, parentWorkflowId: parentWorkflowId ?? null, parentTaskId: parentTask?.id ?? null, next } };
+                throw new Error(`Task ${index + 1} is Collect and requires criteria.`);
+    };
+    const insertTasks = (workflowId: number, definition: WorkflowDefinition) => {
+        const insertTask = db.prepare("INSERT INTO workflow_tasks (workflow_id, position, type, instruction, criteria, status) VALUES (?, ?, ?, ?, ?, 'pending')");
+        definition.tasks.forEach((task, index) => insertTask.run(workflowId, index + 1, task.type, task.instruction, task.criteria ?? null));
+    };
+    const workflowResult = (workflowId: number, parentTask?: Task) => {
+        const next = activateNext(workflow(workflowId)!);
+        const suffix = parentTask ? ` linked to parent task #${parentTask.id}.` : ".";
+        return { content: [{ type: "text" as const, text: next.completed ? `Workflow #${workflowId} created and completed${suffix}` : `Workflow #${workflowId} created${suffix} Execute only task #${next.task!.position}: ${next.task!.instruction}` }], details: { workflowId, parentWorkflowId: parentTask?.workflow_id ?? null, parentTaskId: parentTask?.id ?? null, next } };
+    };
+    const createRootWorkflow = (definition: WorkflowDefinition) => {
+        validateDefinition(definition);
+        const pendingWorkflowId = harness.pendingWorkflow();
+        const workflowId = pendingWorkflowId ?? Number(db.prepare("INSERT INTO workflows (title, source, status, session_id) VALUES (?, ?, 'running', ?)").run(definition.title, definition.source, harness.session()).lastInsertRowid);
+        if (pendingWorkflowId) {
+            db.prepare("UPDATE workflows SET title=?, source=?, status='running', updated_at=CURRENT_TIMESTAMP WHERE id=?").run(definition.title, definition.source, workflowId);
+            event(workflowId, null, "definition_supplied", { title: definition.title, taskCount: definition.tasks.length });
         }
+        else
+            event(workflowId, null, "created", { title: definition.title, taskCount: definition.tasks.length, parentWorkflowId: null });
+        insertTasks(workflowId, definition);
+        return workflowResult(workflowId);
+    };
+    const createSubworkflow = (definition: WorkflowDefinition, parentWorkflowId: number, parentTaskId: number) => {
+        validateDefinition(definition);
+        const parentTask = one<Task>("SELECT id, workflow_id, position, type, instruction, criteria, status, attempts, result, evaluation, child_workflow_id FROM workflow_tasks WHERE id = ?", parentTaskId);
+        if (!parentTask)
+            throw new Error(`Parent task #${parentTaskId} does not exist.`);
+        if (parentTask.workflow_id !== parentWorkflowId)
+            throw new Error("parentWorkflowId does not match parentTaskId's workflow.");
+        if (parentTask.type !== "workflow")
+            throw new Error(`Task pai #${parentTaskId} deve ser do tipo workflow.`);
+        if (parentTask.status !== "running")
+            throw new Error(`Parent task #${parentTaskId} is not ready to start a subworkflow.`);
+        if (parentTask.child_workflow_id !== null)
+            throw new Error(`Parent task #${parentTaskId} already has a linked subworkflow.`);
+        requireActiveWorkflow(parentWorkflowId);
+        const workflowId = Number(db.prepare("INSERT INTO workflows (title, source, status, parent_workflow_id, session_id) VALUES (?, ?, 'running', ?, ?)").run(definition.title, definition.source, parentWorkflowId, harness.session()).lastInsertRowid);
+        event(workflowId, null, "created", { title: definition.title, taskCount: definition.tasks.length, parentWorkflowId });
+        insertTasks(workflowId, definition);
+        db.prepare("UPDATE workflow_tasks SET child_workflow_id = ?, status = 'waiting_subworkflow', updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(workflowId, parentTask.id);
+        event(parentTask.workflow_id, parentTask.id, "child_linked", { childWorkflowId: workflowId });
+        return workflowResult(workflowId, parentTask);
     };
-    pi.registerTool({ name: "sequential_workflow_create", label: "Create Sequential Workflow", description: "Persiste um workflow e ativa sua primeira task, sem bloquear outros workflows.", promptSnippet: "Create a persisted sequential workflow", promptGuidelines: ["Use sequential_workflow_create only after the user explicitly names Sequential Workflow, sequential-workflow, workflow sequencial, or fluxo de trabalho sequencial and asks to create or execute it.", "A Collect task passed to sequential_workflow_create must include acceptance criteria."], parameters: Type.Object({ title: Type.String({ minLength: 1 }), source: Type.String({ minLength: 1 }), parentWorkflowId: Type.Optional(Type.Integer({ minimum: 1 })), parentTaskId: Type.Optional(Type.Integer({ minimum: 1 })), tasks: Type.Array(Type.Object({ type: taskType, instruction: Type.String({ minLength: 1 }), criteria: Type.Optional(Type.String({ minLength: 1 })) }), { minItems: 1 }) }), async execute(_id, params): Promise<{
+    const definitionParameters = { title: Type.String({ minLength: 1 }), source: Type.String({ minLength: 1 }), tasks: Type.Array(Type.Object({ type: taskType, instruction: Type.String({ minLength: 1 }), criteria: Type.Optional(Type.String({ minLength: 1 })) }), { minItems: 1 }) };
+    pi.registerTool({ name: "sequential_workflow_create", label: "Create Sequential Workflow", description: "Creates a root workflow or defines the focused pending workflow.", promptSnippet: "Create or define a root Sequential Workflow", promptGuidelines: ["Use sequential_workflow_create only after an explicit Sequential Workflow requirement was identified in the current user input or a Skill. It creates a root workflow or defines the focused pending workflow; it never creates a subworkflow.", "Do not use a template unless the user explicitly requested a named template; use sequential_workflow_create_from_template only for that case.", "Generate every workflow artifact in English: title, source, instructions, criteria, and recorded result summaries.", "A Collect task passed to sequential_workflow_create must include strict acceptance criteria. Criteria are a durable acceptance contract: preserve every material collection requirement in concrete, verifiable terms. Do not weaken a compound requirement to non-empty input; for example, collecting a full name must require both given name and surname.", "Action criteria must be outcome-oriented and proportionate: verify completion and recorded evidence of the requested action, without requiring an evaluator to independently reconstruct incidental calculations unless the request explicitly makes that verification critical.", "An Action task with criteria fails its workflow after five rejected attempts."], parameters: Type.Object(definitionParameters), async execute(_id, params): Promise<{
             content: {
                 type: "text";
                 text: string;
             }[];
             details: Record<string, unknown>;
-        }> { return createWorkflow(params, params.parentWorkflowId, params.parentTaskId); } });
-    pi.registerTool({ name: "sequential_workflow_prepare_template_directory", label: "Prepare Sequential Workflow Template Directory", description: "Cria, quando necessário, e informa o diretório padrão de templates JSON de Sequential Workflow do profile ativo.", promptSnippet: "Prepare the active profile's default Sequential Workflow template directory", promptGuidelines: ["Use sequential_workflow_prepare_template_directory only when the user explicitly names Sequential Workflow and asks to create or edit its JSON template without specifying an output directory."], parameters: Type.Object({}), async execute() { const path = templateDirectory(); await mkdir(path, { recursive: true }); return { content: [{ type: "text", text: `Diretório de templates pronto: ${path}` }], details: { path } }; } });
-    pi.registerTool({ name: "sequential_workflow_validate_template", label: "Validate Sequential Workflow Template", description: "Lê e valida um arquivo JSON de template de Sequential Workflow sem criar ou executar um workflow.", promptSnippet: "Validate a Sequential Workflow JSON template before it is used", promptGuidelines: ["Use sequential_workflow_validate_template only when the user explicitly names Sequential Workflow and asks to create, edit, or validate its JSON template."], parameters: Type.Object({ path: Type.String({ minLength: 1 }) }), async execute(_id, params): Promise<{
+        }> { return createRootWorkflow(params); } });
+    pi.registerTool({ name: "sequential_workflow_create_subworkflow", label: "Create Sequential Subworkflow", description: "Creates a child workflow for the focused running workflow task.", promptSnippet: "Create a Sequential Workflow child", promptGuidelines: ["Use only when the focused current task has type workflow and requires a child workflow.", "parentWorkflowId and parentTaskId are required and must identify that focused running task."], parameters: Type.Object({ parentWorkflowId: Type.Integer({ minimum: 1 }), parentTaskId: Type.Integer({ minimum: 1 }), ...definitionParameters }), async execute(_id, params): Promise<{
             content: {
                 type: "text";
                 text: string;
             }[];
             details: Record<string, unknown>;
-        }> { const loaded = await loadTemplate(params.path); return { content: [{ type: "text", text: `Template válido: ${loaded.path} (${loaded.template.tasks.length} tasks, SHA-256: ${loaded.hash}).` }], details: loaded }; } });
-    pi.registerTool({ name: "sequential_workflow_create_from_template", label: "Create Sequential Workflow from Template", description: "Lê um template JSON validado e cria um workflow.", promptSnippet: "Create and start a persisted Sequential Workflow from a validated JSON template", promptGuidelines: ["Use sequential_workflow_create_from_template only when the user explicitly names Sequential Workflow and asks to execute a JSON template."], parameters: Type.Object({ path: Type.String({ minLength: 1 }), parentWorkflowId: Type.Optional(Type.Integer({ minimum: 1 })), parentTaskId: Type.Optional(Type.Integer({ minimum: 1 })) }), async execute(_id, params): Promise<{
+        }> { return createSubworkflow(params, params.parentWorkflowId, params.parentTaskId); } });
+    pi.registerTool({ name: "sequential_workflow_prepare_template_directory", label: "Prepare Sequential Workflow Template Directory", description: "Creates when needed and reports the active profile's default Sequential Workflow JSON template directory.", promptSnippet: "Prepare the active profile's default Sequential Workflow template directory", promptGuidelines: ["Use sequential_workflow_prepare_template_directory only when the user explicitly names Sequential Workflow and asks to create or edit its JSON template without specifying an output directory."], parameters: Type.Object({}), async execute() { const path = templateDirectory(); await mkdir(path, { recursive: true }); return { content: [{ type: "text", text: `Template directory is ready: ${path}` }], details: { path } }; } });
+    pi.registerTool({ name: "sequential_workflow_validate_template", label: "Validate Sequential Workflow Template", description: "Reads and validates a Sequential Workflow JSON template without creating or executing a workflow.", promptSnippet: "Validate a Sequential Workflow JSON template before it is used", promptGuidelines: ["Use sequential_workflow_validate_template only when the user explicitly names Sequential Workflow and asks to create, edit, or validate its JSON template."], parameters: Type.Object({ path: Type.String({ minLength: 1 }) }), async execute(_id, params): Promise<{
             content: {
                 type: "text";
                 text: string;
             }[];
             details: Record<string, unknown>;
-        }> { const loaded = await loadTemplate(params.path); return createWorkflow({ title: loaded.template.title, source: `Template ${loaded.path} (SHA-256: ${loaded.hash}): ${loaded.template.source}`, tasks: loaded.template.tasks }, params.parentWorkflowId, params.parentTaskId); } });
-    pi.registerTool({ name: "sequential_workflow_record_result", label: "Record Workflow Result", description: "Registra o resultado da Action ou Collect atual de um workflow identificado.", promptSnippet: "Record the result of the active Action or Collect task", promptGuidelines: ["Use sequential_workflow_record_result immediately after completing the active Action or receiving the active Collect response."], parameters: Type.Object({ workflowId: Type.Integer({ minimum: 1 }), taskId: Type.Integer({ minimum: 1 }), phase: phaseType, result: Type.String({ minLength: 1 }) }), async execute(_id, params): Promise<{
+        }> { const loaded = await loadTemplate(params.path); return { content: [{ type: "text", text: `Valid template: ${loaded.path} (${loaded.template.tasks.length} tasks, SHA-256: ${loaded.hash}).` }], details: loaded }; } });
+    pi.registerTool({ name: "sequential_workflow_create_from_template", label: "Create Sequential Workflow from Template", description: "Loads an explicitly named reusable template to create a root workflow or hydrate a template-mode pending workflow.", promptSnippet: "Create a root Sequential Workflow from an explicitly named template", promptGuidelines: ["Use sequential_workflow_create_from_template only when the user explicitly requested activation from a named reusable Sequential Workflow JSON template, or when template-mode definition context supplies that exact path.", "The path must be explicitly supplied by the user or the controlled template-mode context. Never guess, search for, infer, or invent a template name or use this tool as a fallback for an ordinary workflow request.", "This tool never creates a subworkflow."], parameters: Type.Object({ path: Type.String({ minLength: 1 }) }), async execute(_id, params): Promise<{
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            details: Record<string, unknown>;
+        }> { const loaded = await loadTemplate(params.path); return createRootWorkflow({ title: loaded.template.title, source: `Template ${loaded.path} (SHA-256: ${loaded.hash}): ${loaded.template.source}`, tasks: loaded.template.tasks }); } });
+    pi.registerTool({ name: "sequential_workflow_record_result", label: "Record Workflow Result", description: "Records the result of the current Action or Collect task in an identified workflow.", promptSnippet: "Record the result of the active Action or Collect task", promptGuidelines: ["Use sequential_workflow_record_result immediately after completing the active Action or receiving the active Collect response."], parameters: Type.Object({ workflowId: Type.Integer({ minimum: 1 }), taskId: Type.Integer({ minimum: 1 }), phase: phaseType, result: Type.String({ minLength: 1 }) }), async execute(_id, params): Promise<{
             content: {
                 type: "text";
                 text: string;
@@ -256,23 +278,23 @@ CREATE TABLE IF NOT EXISTS workflow_events (id INTEGER PRIMARY KEY AUTOINCREMENT
             const item = requireActiveWorkflow(params.workflowId);
             const task = currentTask(item.id);
             if (!task)
-                throw new Error("Não existe task pendente.");
+                throw new Error("There is no pending task.");
             if (task.type !== params.phase)
-                throw new Error(`A task atual é ${task.type}, não ${params.phase}.`);
+                throw new Error(`The current task is ${task.type}, not ${params.phase}.`);
             if (task.status === "evaluating")
-                throw new Error("O resultado já foi registrado; avalie a task atual.");
+                throw new Error("The result is already recorded; evaluate the current task.");
             if (task.criteria) {
                 db.prepare("UPDATE workflow_tasks SET result = ?, status = 'evaluating', updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(params.result, task.id);
                 db.prepare("UPDATE workflows SET status = 'evaluating', updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(item.id);
                 event(item.id, task.id, "result_recorded", { phase: params.phase, result: params.result });
-                return { content: [{ type: "text", text: `Resultado registrado. Agora avalie a task #${task.position} contra o critério.` }], details: { taskId: task.id, needsEvaluation: true } };
+                return { content: [{ type: "text", text: `Result recorded. Now evaluate task #${task.position} against its criteria.` }], details: { taskId: task.id, needsEvaluation: true } };
             }
             db.prepare("UPDATE workflow_tasks SET result = ?, status = 'accepted', updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(params.result, task.id);
             event(item.id, task.id, "accepted_without_criteria", { result: params.result });
             const next = activateNext(item);
-            return { content: [{ type: "text", text: next.completed ? "Task aceita; workflow concluído." : `Task aceita. Execute a task #${next.task!.position}: ${next.task!.instruction}` }], details: { next } };
+            return { content: [{ type: "text", text: next.completed ? "Task accepted; workflow completed." : `Task accepted. Execute task #${next.task!.position}: ${next.task!.instruction}` }], details: { next } };
         } });
-    pi.registerTool({ name: "sequential_workflow_evaluate", label: "Evaluate Workflow Task", description: "Registra a aceitação ou reprovação da task atual de um workflow identificado.", promptSnippet: "Accept or reject the active workflow task after evaluation", promptGuidelines: ["Use sequential_workflow_evaluate after every task with criteria and for every Evaluate task; never advance a rejected task."], parameters: Type.Object({ workflowId: Type.Integer({ minimum: 1 }), taskId: Type.Integer({ minimum: 1 }), accepted: Type.Boolean(), reasoning: Type.String({ minLength: 1 }) }), async execute(_id, params): Promise<{
+    pi.registerTool({ name: "sequential_workflow_evaluate", label: "Evaluate Workflow Task", description: "Records acceptance, retry, or terminal failure of the current task in an identified workflow.", promptSnippet: "Evaluate the active workflow task", promptGuidelines: ["Use sequential_workflow_evaluate after every task with criteria and for every Evaluate task.", "Use outcome 'retry' only when repeating the task could produce a different result. Use outcome 'fail' after recording evidence when the task cannot safely progress; it ends the workflow without advancing or retrying.", "The legacy accepted boolean remains supported: true means accept and false means retry."], parameters: Type.Object({ workflowId: Type.Integer({ minimum: 1 }), taskId: Type.Integer({ minimum: 1 }), outcome: Type.Optional(evaluationOutcome), accepted: Type.Optional(Type.Boolean()), reasoning: Type.String({ minLength: 1 }), decision: Type.Optional(Type.Object({ evaluator: Type.Optional(Type.String()), model: Type.Optional(Type.String()), confidence: Type.Optional(Type.Number()), probabilities: Type.Optional(Type.Record(Type.String(), Type.Number())) })) }), async execute(_id, params): Promise<{
             content: {
                 type: "text";
                 text: string;
@@ -282,14 +304,34 @@ CREATE TABLE IF NOT EXISTS workflow_events (id INTEGER PRIMARY KEY AUTOINCREMENT
             const item = requireActiveWorkflow(params.workflowId);
             const task = currentTask(item.id);
             if (!task)
-                throw new Error("Não existe task pendente.");
+                throw new Error("There is no pending task.");
             if (task.type !== "evaluate" && task.status !== "evaluating")
-                throw new Error("Registre o resultado da task antes de avaliá-la.");
-            if (params.accepted) {
-                db.prepare("UPDATE workflow_tasks SET status = 'accepted', evaluation = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(params.reasoning, task.id);
+                throw new Error("Record the task result before evaluating it.");
+            if (!params.outcome && typeof params.accepted !== "boolean")
+                throw new Error("Provide an evaluation outcome.");
+            if (params.outcome && typeof params.accepted === "boolean")
+                throw new Error("Provide outcome or accepted, not both.");
+            const outcome = params.outcome ?? (params.accepted ? "accept" : "retry");
+            const evaluation = evaluationRecord(task, outcome, params.reasoning, params.decision);
+            if (outcome === "fail") {
+                db.prepare("UPDATE workflow_tasks SET status = 'failed', evaluation = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(evaluation, task.id);
+                db.prepare("UPDATE workflows SET status = 'failed', updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(item.id);
+                event(item.id, task.id, "failed_evaluation", { reasoning: params.reasoning, attempts: task.attempts });
+                resolveParentAfterChild(workflow(item.id)!);
+                return { content: [{ type: "text", text: `Task #${task.position} failed by terminal evaluation; workflow failed.` }], details: { accepted: false, failed: true, terminal: true, task: taskSummary(currentTask(item.id) ?? task) } };
+            }
+            if (outcome === "accept") {
+                db.prepare("UPDATE workflow_tasks SET status = 'accepted', evaluation = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(evaluation, task.id);
                 event(item.id, task.id, "accepted", { reasoning: params.reasoning });
                 const next = activateNext(item);
-                return { content: [{ type: "text", text: next.completed ? "Avaliação aceita; workflow concluído." : `Avaliação aceita. Execute somente a task #${next.task!.position}: ${next.task!.instruction}` }], details: { accepted: true, next } };
+                return { content: [{ type: "text", text: next.completed ? "Evaluation accepted; workflow completed." : `Evaluation accepted. Execute only task #${next.task!.position}: ${next.task!.instruction}` }], details: { accepted: true, next } };
+            }
+            if (task.type === "action" && task.attempts + 1 >= maxActionAttempts) {
+                db.prepare("UPDATE workflow_tasks SET status = 'failed', attempts = attempts + 1, evaluation = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(evaluation, task.id);
+                db.prepare("UPDATE workflows SET status = 'failed', updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(item.id);
+                event(item.id, task.id, "failed_attempt_limit", { reasoning: params.reasoning, attempts: task.attempts + 1, maxAttempts: maxActionAttempts });
+                resolveParentAfterChild(workflow(item.id)!);
+                return { content: [{ type: "text", text: `Task #${task.position} failed after ${maxActionAttempts} rejected attempts; workflow failed.` }], details: { accepted: false, failed: true, attempts: task.attempts + 1, maxAttempts: maxActionAttempts } };
             }
             if (task.type === "workflow") {
                 event(item.id, task.id, "child_detached", { childWorkflowId: task.child_workflow_id });
@@ -298,10 +340,10 @@ CREATE TABLE IF NOT EXISTS workflow_events (id INTEGER PRIMARY KEY AUTOINCREMENT
             db.prepare("DELETE FROM workflow_collect_checkpoint WHERE task_id=?").run(task.id);
             const retryStatus: TaskStatus = task.type === "collect" ? "awaiting_user" : "running";
             const workflowStatus: WorkflowStatus = task.type === "collect" ? "awaiting_user" : "running";
-            db.prepare("UPDATE workflow_tasks SET status = ?, attempts = attempts + 1, evaluation = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(retryStatus, params.reasoning, task.id);
+            db.prepare("UPDATE workflow_tasks SET status = ?, attempts = attempts + 1, evaluation = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(retryStatus, evaluation, task.id);
             db.prepare("UPDATE workflows SET status = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(workflowStatus, item.id);
             event(item.id, task.id, "rejected", { reasoning: params.reasoning });
-            return { content: [{ type: "text", text: task.type === "collect" ? `Critério reprovado. Permaneça na task #${task.position}.` : `Critério reprovado. Permaneça na task #${task.position} e repita a ação.` }], details: { accepted: false, task: taskSummary(currentTask(item.id)!) } };
+            return { content: [{ type: "text", text: task.type === "collect" ? `Criteria rejected. Remain on task #${task.position}.` : `Criteria rejected. Remain on task #${task.position} and repeat the action.` }], details: { accepted: false, task: taskSummary(currentTask(item.id)!) } };
         } });
     pi.registerTool({ name: "sequential_workflow_cancel", label: "Cancel Sequential Workflow", description: "Cancela um workflow ativo deste profile, sem cancelar seus descendentes.", promptSnippet: "Cancel a Sequential Workflow", promptGuidelines: ["Use sequential_workflow_cancel only after the user explicitly asks to cancel a named Sequential Workflow.", "sequential_workflow_cancel can cancel a workflow created in another session of the same profile; do not require adoption first.", "Cancelling a child workflow lets its parent handle the terminal child state; do not cancel descendants automatically."], parameters: Type.Object({ workflowId: Type.Integer({ minimum: 1 }) }), async execute(_id, params): Promise<{
             content: {
@@ -310,7 +352,7 @@ CREATE TABLE IF NOT EXISTS workflow_events (id INTEGER PRIMARY KEY AUTOINCREMENT
             }[];
             details: Record<string, unknown>;
         }> { return cancelWorkflow(params.workflowId); } });
-    pi.registerTool({ name: "sequential_workflow_status", label: "Sequential Workflow Status", description: "Lista workflows ativos ou consulta o estado persistido de um workflow.", promptGuidelines: ["Use sequential_workflow_status only when the user explicitly asks to inspect, list, or continue a persisted Sequential Workflow. Never select or resume an existing workflow merely because it is active."], parameters: Type.Object({ workflowId: Type.Optional(Type.Integer({ minimum: 1 })), includeChildren: Type.Optional(Type.Boolean()) }), async execute(_id, params): Promise<{
+    pi.registerTool({ name: "sequential_workflow_status", label: "Sequential Workflow Status", description: "Lists active workflows or inspects the persisted state of an identified workflow.", promptGuidelines: ["Use sequential_workflow_status only when the user explicitly asks to inspect, list, or continue a persisted Sequential Workflow. Never select or resume an existing workflow merely because it is active."], parameters: Type.Object({ workflowId: Type.Optional(Type.Integer({ minimum: 1 })), includeChildren: Type.Optional(Type.Boolean()) }), async execute(_id, params): Promise<{
             content: {
                 type: "text";
                 text: string;
@@ -318,15 +360,15 @@ CREATE TABLE IF NOT EXISTS workflow_events (id INTEGER PRIMARY KEY AUTOINCREMENT
             details: Record<string, unknown>;
         }> {
             if (params.workflowId === undefined) {
-                const items = many<Workflow>("SELECT id, title, source, status, parent_workflow_id FROM workflows WHERE session_id = ? AND status IN ('running', 'awaiting_user', 'evaluating') ORDER BY id DESC", harness.session());
-                return { content: [{ type: "text", text: items.length ? items.map((item) => `#${item.id} ${item.title} (${item.status})${item.parent_workflow_id ? `, pai #${item.parent_workflow_id}` : ""}; task #${currentTask(item.id)?.position ?? "nenhuma"}.`).join("\n") : "Não há workflows ativos." }], details: { workflows: items.map((item) => ({ ...item, currentTask: currentTask(item.id) })) } };
+                const items = many<Workflow>("SELECT id, title, source, status, parent_workflow_id FROM workflows WHERE session_id = ? AND status IN ('pending_definition', 'running', 'awaiting_user', 'evaluating') ORDER BY id DESC", harness.session());
+                return { content: [{ type: "text", text: items.length ? items.map((item) => `#${item.id} ${item.title} (${item.status})${item.parent_workflow_id ? `, parent #${item.parent_workflow_id}` : ""}; current task #${currentTask(item.id)?.position ?? "none"}.`).join("\n") : "There are no active workflows." }], details: { workflows: items.map((item) => ({ ...item, currentTask: currentTask(item.id) })) } };
             }
             const item = workflow(params.workflowId);
             if (!item)
-                throw new Error(`Workflow #${params.workflowId} não existe.`);
+                throw new Error(`Workflow #${params.workflowId} does not exist.`);
             const tasks = many<Task>("SELECT id, workflow_id, position, type, instruction, criteria, status, attempts, result, evaluation, child_workflow_id FROM workflow_tasks WHERE workflow_id = ? ORDER BY position", item.id);
             const children = params.includeChildren ? many<Workflow>("SELECT id, title, source, status, parent_workflow_id FROM workflows WHERE parent_workflow_id = ? ORDER BY id", item.id) : [];
-            return { content: [{ type: "text", text: `Workflow #${item.id} (${item.status}). Task atual: ${currentTask(item.id)?.position ?? "nenhuma"}.` }], details: { workflow: item, tasks, children } };
+            return { content: [{ type: "text", text: `Workflow #${item.id} (${item.status}). Current task: ${currentTask(item.id)?.position ?? "none"}.` }], details: { workflow: item, tasks, children } };
         } });
     pi.registerCommand("workflow-status", { description: "Show this session's workflows", handler: async (args, ctx) => {
             try {

package/extensions/skill-sources/store.ts

@@ -50,7 +50,22 @@ export class SkillSourceStore {
     return this.db.prepare("SELECT source_identifier,source_relative_path,target_path FROM skill_source_installations WHERE profile=? AND skill_name=?").get(profile, skillName) as Row | undefined;
   }
 
-  async publish(identifier: string, profile: string, skillName: string, skillPath: string) {
+  private async replacePublishedSkill(source: string, target: string): Promise<void> {
+    const temporary = `${target}.publish-${randomUUID()}`, backup = `${target}.backup-${randomUUID()}`;
+    try {
+      await rm(temporary, { recursive: true, force: true });
+      await cp(source, temporary, { recursive: true, filter: (path) => !path.split("/").includes("node_modules") && !path.split("/").includes(".git") });
+      if (existsSync(target)) await rename(target, backup);
+      await rename(temporary, target);
+      await rm(backup, { recursive: true, force: true });
+    } catch (error) {
+      await rm(temporary, { recursive: true, force: true });
+      if (!existsSync(target) && existsSync(backup)) await rename(backup, target);
+      throw error;
+    }
+  }
+
+  async publish(identifier: string, profile: string, skillName: string, skillPath: string, confirmOverwrite = false) {
     const previous = this.publishing.get(identifier) ?? Promise.resolve();
     let release!: () => void;
     const queued = new Promise<void>((resolveRun) => { release = resolveRun; });
@@ -66,17 +81,21 @@ export class SkillSourceStore {
       await this.validateSkillDirectory(local);
       const installation = this.installation(profile, skillName);
       if (installation && String(installation.source_identifier) !== identifier) throw Object.assign(new Error("This skill was imported from a different Skill Source. Publish it there or create a new local skill."), { status: 409 });
-      const targetRelative = installation ? String(installation.source_relative_path) : join(source.basePath, skillName).replaceAll("\\", "/");
-      if (targetRelative.split("/").includes("..") || targetRelative.startsWith("/")) throw Object.assign(new Error("Invalid skill destination."), { status: 400 });
-      const sameName = this.skills(identifier).filter((item) => item.name === skillName && item.relativePath !== targetRelative && item.status === "synced");
-      if (sameName.length) throw Object.assign(new Error(`A different skill named '${skillName}' already exists in this Skill Source. Publish by its original path or rename the local skill.`), { status: 409 });
       const refreshed = await this.sync(identifier);
       if (refreshed.status !== "succeeded") throw Object.assign(new Error(refreshed.error ?? "Unable to synchronize the Skill Source before publishing."), { status: 502 });
+      const available = this.skills(identifier).filter((item) => item.status === "synced");
+      const matching = available.filter((item) => item.name === skillName);
+      if (!installation && matching.length > 1) throw Object.assign(new Error(`Multiple Skills named '${skillName}' exist in this Skill Source. Rename the local Skill before publishing.`), { status: 409 });
+      const sourceRelative = installation ? String(installation.source_relative_path) : matching[0]?.relativePath ?? skillName;
+      if (sourceRelative.split("/").includes("..") || sourceRelative.startsWith("/")) throw Object.assign(new Error("Invalid skill destination."), { status: 400 });
+      const existing = available.find((item) => item.relativePath === sourceRelative);
+      if (installation && !existing) throw Object.assign(new Error("The Skill no longer exists in its Skill Source. Import it again or publish it as a new local Skill."), { status: 409 });
+      const targetRelative = join(source.basePath, sourceRelative).replaceAll("\\", "/");
+      if (existing && !confirmOverwrite) return { action: "confirmation_required" as const, source: identifier, relativePath: targetRelative, description: existing.description, commitHash: existing.commitHash };
       const repository = resolve(this.root, ".git-cache", identifier), target = resolve(repository, targetRelative);
       if (!target.startsWith(`${repository}/`)) throw Object.assign(new Error("Invalid skill destination."), { status: 400 });
-      await rm(target, { recursive: true, force: true });
       await mkdir(dirname(target), { recursive: true });
-      await cp(local, target, { recursive: true, filter: (path) => !path.split("/").includes("node_modules") && !path.split("/").includes(".git") });
+      await this.replacePublishedSkill(local, target);
       const token = String((this.db.prepare("SELECT credential_token FROM skill_sources WHERE identifier=?").get(identifier) as Row).credential_token);
       const askpass = join(this.root, `.git-askpass-publish-${randomUUID()}`), env: NodeJS.ProcessEnv = {
         ...process.env,
@@ -101,9 +120,9 @@ export class SkillSourceStore {
       } finally { await rm(askpass, { force: true }); }
       const synced = await this.sync(identifier);
       if (synced.status !== "succeeded") throw Object.assign(new Error(synced.error ?? "The Skill Source was pushed but could not be synchronized."), { status: 502 });
-      const published = this.skills(identifier).find((item) => item.relativePath === targetRelative);
-      if (published) this.db.prepare("INSERT INTO skill_source_installations VALUES (?,?,?,?,?,?,?,?) ON CONFLICT(profile,skill_name) DO UPDATE SET source_identifier=excluded.source_identifier,source_relative_path=excluded.source_relative_path,source_commit_hash=excluded.source_commit_hash,source_content_hash=excluded.source_content_hash,target_path=excluded.target_path,installed_at=excluded.installed_at").run(profile,skillName,identifier,targetRelative,published.commitHash,published.contentHash,local,now());
-      return { action: installation ? "updated" as const : "created" as const, source: identifier, relativePath: targetRelative, commitHash: synced.commitHash };
+      const published = this.skills(identifier).find((item) => item.relativePath === sourceRelative);
+      if (published) this.db.prepare("INSERT INTO skill_source_installations VALUES (?,?,?,?,?,?,?,?) ON CONFLICT(profile,skill_name) DO UPDATE SET source_identifier=excluded.source_identifier,source_relative_path=excluded.source_relative_path,source_commit_hash=excluded.source_commit_hash,source_content_hash=excluded.source_content_hash,target_path=excluded.target_path,installed_at=excluded.installed_at").run(profile,skillName,identifier,sourceRelative,published.commitHash,published.contentHash,local,now());
+      return { action: existing ? "updated" as const : "created" as const, source: identifier, relativePath: targetRelative, commitHash: synced.commitHash };
     } finally { release(); if (this.publishing.get(identifier) === chain) this.publishing.delete(identifier); }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-feats",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "description": "A modular Pi package for profiles, sandboxing, remote access, applications, guardrails, skills, session management, observability, and web-based operations.",
   "keywords": [
     "pi-package",
@@ -29,6 +29,7 @@
     "scripts",
     "schemas",
     "skills",
+    "themes",
     "README.md",
     "LICENSE",
     "THIRD_PARTY_NOTICES.md",
@@ -40,18 +41,18 @@
     "node": ">=22"
   },
   "scripts": {
-    "build:web": "cd extensions/pi-console-webui && npx --no-install next build",
+    "build:web": "node scripts/build-console-webui.mjs",
+    "build:web:next": "cd extensions/pi-console-webui && npx --no-install next build",
     "ensure:nono": "sh scripts/install-nono.sh",
-    "postinstall": "npm run ensure:nono && npm run build:web",
-    "test": "npm run test:composio && npm run build:web",
-    "test:composio": "node --experimental-strip-types --test tests/*.test.ts"
+    "postinstall": "npm run ensure:nono && node scripts/ensure-console-build.mjs",
+    "test": "npm run test:extensions && npm run build:web",
+    "test:extensions": "node --experimental-strip-types --test tests/*.test.ts"
   },
   "dependencies": {
     "@codemirror/lang-javascript": "^6.2.5",
     "@codemirror/lang-json": "^6.0.2",
     "@codemirror/lang-markdown": "^6.5.2",
     "@composio/core": "^0.18.1",
-    "@earendil-works/pi-ai": "^0.85.1",
     "@fastify/websocket": "^11.3.0",
     "@homebridge/node-pty-prebuilt-multiarch": "^0.14.1",
     "@radix-ui/react-slot": "^1.2.4",
@@ -79,22 +80,27 @@
     "remark-gfm": "^4.0.1",
     "tailwind-merge": "^3.0.2",
     "tailwindcss": "^3.4.17",
-    "typebox": "^1.3.30",
     "typescript": "^5.7.2"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
   },
   "pi": {
     "extensions": [
+      "./extensions/cli-tui-mode.ts",
       "./extensions/api-server",
       "./extensions/browser-harness",
       "./extensions/cli-resources.ts",
       "./extensions/composio",
       "./extensions/context-memory",
+      "./extensions/conversation-search",
       "./extensions/guardrails",
       "./extensions/pi-console-webui",
       "./extensions/profiles.ts",
+      "./extensions/profile-ssh.ts",
       "./extensions/pulse",
       "./extensions/sequential-workflow.ts",
       "./extensions/skill-sources"
@@ -102,9 +108,15 @@
     "skills": [
       "./skills"
     ],
+    "themes": [
+      "./themes/*.json"
+    ],
     "image": "https://raw.githubusercontent.com/rjaskonis/pi-feats/v0.1.4/assets/pi-feats-preview.png"
   },
   "devDependencies": {
-    "@types/ws": "^8.18.1"
+    "@earendil-works/pi-ai": "^0.85.1",
+    "@earendil-works/pi-tui": "^0.85.1",
+    "@types/ws": "^8.18.1",
+    "typebox": "^1.3.30"
   }
 }

package/scripts/build-console-webui.mjs

@@ -0,0 +1,7 @@
+import { spawnSync } from "node:child_process";
+import { packageRoot, saveBuildCache } from "./console-webui-cache.mjs";
+
+const result = spawnSync(process.platform === "win32" ? "npm.cmd" : "npm", ["run", "build:web:next"], { cwd: packageRoot, stdio: "inherit" });
+if (result.status !== 0) process.exit(result.status ?? 1);
+await saveBuildCache();
+console.log("Cached Pi Console WebUI build for future updates.");