pi-feats 0.1.5 → 0.1.7

package/extensions/pulse/store.ts

@@ -7,9 +7,11 @@ export type PulseType = "cron" | "heartbeat";
 export type Pulse = { id: string; name: string; description: string; type: PulseType; schedule: string; prompt: string; thread_session_id: string; insertIntoApiSession: boolean; result: string | null; profile: string; enabled: boolean; nextRunAt: string | null; lastRunAt: string | null };
 export type PulseHistory = Pulse & { startedAt: string; finishedAt: string | null; status: string; error: string | null };
 export type PulseRun = { id: string; sessionId: string | null; startedAt: string; finishedAt: string | null; status: "running" | "success" | "error"; response: string | null; error: string | null };
+export type PulseExecutionSession = { sessionId: string; pulseId: string; pulseName: string; pulseType: PulseType; runId: string; status: PulseRun["status"]; startedAt: string; finishedAt: string | null };
 export type ClaimedPulse = { pulse: Pulse; runId: string };
 type Row = Record<string, unknown>;
 const iso = (date = new Date()) => date.toISOString();
+export const pulseId = (type: PulseType, date = new Date()): string => `pulse-${type}_${date.toISOString().slice(0, 16).replace("T", "-").replace(":", "-")}`;
 
 function fieldMatches(field: string, value: number, min: number, max: number): boolean {
   return field.split(",").some((part) => {
@@ -59,7 +61,7 @@ export class PulseStore {
   private db: DatabaseSync;
   constructor(path: string) {
     mkdirSync(dirname(path), { recursive: true }); this.db = new DatabaseSync(path); this.db.exec("PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON;");
-    this.db.exec(`CREATE TABLE IF NOT EXISTS pulses (id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, description TEXT NOT NULL, type TEXT NOT NULL CHECK(type IN ('cron','heartbeat')), schedule TEXT NOT NULL, prompt TEXT NOT NULL, thread_session_id TEXT NOT NULL, insert_into_api_session INTEGER NOT NULL DEFAULT 0, result TEXT);
+    this.db.exec(`CREATE TABLE IF NOT EXISTS pulses (id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, description TEXT NOT NULL, type TEXT NOT NULL CHECK(type IN ('cron','heartbeat')), schedule TEXT NOT NULL, prompt TEXT NOT NULL, thread_session_id TEXT NOT NULL, insert_into_api_session INTEGER NOT NULL DEFAULT 1, result TEXT);
       CREATE TABLE IF NOT EXISTS pulse_control (pulse_id TEXT PRIMARY KEY REFERENCES pulses(id) ON DELETE CASCADE, profile TEXT NOT NULL, enabled INTEGER NOT NULL DEFAULT 1, next_run_at TEXT, last_run_at TEXT, claimed_at TEXT, active_run_id TEXT, claim_owner TEXT, lease_expires_at TEXT, updated_at TEXT NOT NULL);
       CREATE TABLE IF NOT EXISTS pulse_state (pulse_id TEXT PRIMARY KEY REFERENCES pulses(id) ON DELETE CASCADE, handoff TEXT NOT NULL DEFAULT '', updated_at TEXT NOT NULL);
       CREATE TABLE IF NOT EXISTS pulse_runs (id TEXT PRIMARY KEY, pulse_id TEXT NOT NULL REFERENCES pulses(id) ON DELETE CASCADE, session_id TEXT, started_at TEXT NOT NULL, finished_at TEXT, status TEXT NOT NULL, response TEXT, error TEXT);
@@ -68,7 +70,7 @@ export class PulseStore {
     // Migrate databases created before the denormalized latest result column.
     const columns = this.db.prepare("PRAGMA table_info(pulses)").all() as Row[];
     if (!columns.some((column) => column.name === "result")) this.db.exec("ALTER TABLE pulses ADD COLUMN result TEXT");
-    if (!columns.some((column) => column.name === "insert_into_api_session")) this.db.exec("ALTER TABLE pulses ADD COLUMN insert_into_api_session INTEGER NOT NULL DEFAULT 0");
+    if (!columns.some((column) => column.name === "insert_into_api_session")) this.db.exec("ALTER TABLE pulses ADD COLUMN insert_into_api_session INTEGER NOT NULL DEFAULT 1");
     const runColumns = this.db.prepare("PRAGMA table_info(pulse_runs)").all() as Row[];
     if (!runColumns.some((column) => column.name === "session_id")) this.db.exec("ALTER TABLE pulse_runs ADD COLUMN session_id TEXT");
     const controlColumns = this.db.prepare("PRAGMA table_info(pulse_control)").all() as Row[];
@@ -93,12 +95,15 @@ export class PulseStore {
   list(profile?: string): Pulse[] { const query = `SELECT p.*, c.profile, c.enabled, c.next_run_at, c.last_run_at FROM pulses p JOIN pulse_control c ON c.pulse_id=p.id${profile ? " WHERE c.profile=?" : ""} ORDER BY p.name`; return this.db.prepare(query).all(...(profile ? [profile] : [])) .map((row) => this.pulse(row as Row)); }
   get(name: string, profile?: string): Pulse | undefined { return this.list(profile).find((item) => item.name === name); }
   history(profile: string): PulseHistory[] { return this.db.prepare(`SELECT p.*, c.profile, c.enabled, c.next_run_at, c.last_run_at, r.started_at AS startedAt, r.finished_at AS finishedAt, r.status, r.error FROM pulses p JOIN pulse_control c ON c.pulse_id=p.id JOIN pulse_runs r ON r.id=(SELECT id FROM pulse_runs WHERE pulse_id=p.id AND finished_at IS NOT NULL ORDER BY started_at DESC LIMIT 1) WHERE c.profile=? AND p.schedule LIKE '@once:%' ORDER BY r.started_at DESC`).all(profile).map((row) => { const record = row as Row; return { ...this.pulse(record), startedAt: String(record.startedAt), finishedAt: record.finishedAt == null ? null : String(record.finishedAt), status: String(record.status), error: record.error == null ? null : String(record.error) }; }); }
+  executionSessions(profile: string): Map<string, PulseExecutionSession> { const rows = this.db.prepare("SELECT r.session_id,p.id AS pulse_id,p.name AS pulse_name,p.type AS pulse_type,r.id AS run_id,r.status,r.started_at,r.finished_at FROM pulse_runs r JOIN pulses p ON p.id=r.pulse_id JOIN pulse_control c ON c.pulse_id=p.id WHERE c.profile=? AND r.session_id IS NOT NULL ORDER BY r.started_at DESC").all(profile) as Row[]; return new Map(rows.map((row) => [String(row.session_id), { sessionId: String(row.session_id), pulseId: String(row.pulse_id), pulseName: String(row.pulse_name), pulseType: row.pulse_type as PulseType, runId: String(row.run_id), status: row.status as PulseRun["status"], startedAt: String(row.started_at), finishedAt: row.finished_at == null ? null : String(row.finished_at) }])); }
   runs(profile: string, name: string, start: string, end: string, limit = 100): PulseRun[] { const pulse = this.get(name, profile); if (!pulse) throw new Error("Pulse not found."); return this.db.prepare("SELECT id, session_id, started_at, finished_at, status, response, error FROM pulse_runs WHERE pulse_id=? AND started_at>=? AND started_at<=? ORDER BY started_at DESC LIMIT ?").all(pulse.id, start, end, limit).map((row) => { const item = row as Row; return { id: String(item.id), sessionId: item.session_id == null ? null : String(item.session_id), startedAt: String(item.started_at), finishedAt: item.finished_at == null ? null : String(item.finished_at), status: item.status as PulseRun["status"], response: item.response == null ? null : String(item.response), error: item.error == null ? null : String(item.error) }; }); }
   create(input: Omit<Pulse, "id" | "enabled" | "nextRunAt" | "lastRunAt" | "type" | "result" | "insertIntoApiSession"> & { insertIntoApiSession?: boolean }): Pulse {
     if (!/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(input.name)) throw new Error("Invalid pulse name.");
     if (!validSchedule(input.schedule)) throw new Error("Invalid schedule. Use a five-field UTC cron expression or @once:<ISO-8601>.");
-    const type = pulseType(input.schedule), id = randomUUID(), next = nextRun(input.schedule)?.toISOString() ?? null;
-    this.db.prepare("INSERT INTO pulses (id, name, description, type, schedule, prompt, thread_session_id, insert_into_api_session, result) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL)").run(id, input.name, input.description, type, input.schedule, input.prompt, input.thread_session_id, input.insertIntoApiSession ? 1 : 0);
+    const type = pulseType(input.schedule), baseId = pulseId(type); let id = baseId, suffix = 2;
+    while (this.db.prepare("SELECT 1 FROM pulses WHERE id=?").get(id)) id = `${baseId}-${String(suffix++).padStart(2, "0")}`;
+    const next = nextRun(input.schedule)?.toISOString() ?? null;
+    this.db.prepare("INSERT INTO pulses (id, name, description, type, schedule, prompt, thread_session_id, insert_into_api_session, result) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL)").run(id, input.name, input.description, type, input.schedule, input.prompt, input.thread_session_id, input.insertIntoApiSession !== false ? 1 : 0);
     this.db.prepare("INSERT INTO pulse_control (pulse_id, profile, enabled, next_run_at, last_run_at, claimed_at, updated_at) VALUES (?, ?, 1, ?, NULL, NULL, ?)").run(id, input.profile, next, iso());
     if (type === "heartbeat") this.db.prepare("INSERT INTO pulse_state VALUES (?, '', ?)").run(id, iso());
     return this.get(input.name, input.profile)!;
@@ -109,13 +114,15 @@ export class PulseStore {
     this.db.prepare("UPDATE pulse_control SET enabled=?, next_run_at=?, updated_at=? WHERE pulse_id=?").run(enabled ? 1 : 0, next, iso(), pulse.id);
     return this.get(name, profile)!;
   }
-  update(name: string, profile: string | undefined, input: Pick<Pulse, "description" | "schedule" | "prompt" | "thread_session_id" | "insertIntoApiSession">): Pulse {
+  update(name: string, profile: string | undefined, input: Pick<Pulse, "description" | "schedule" | "prompt" | "thread_session_id" | "insertIntoApiSession"> & { name?: string }): Pulse {
     const pulse = this.get(name, profile); if (!pulse) throw new Error("Pulse not found.");
+    const nextName = input.name ?? pulse.name;
+    if (!/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(nextName)) throw new Error("Invalid pulse name.");
     if (!validSchedule(input.schedule)) throw new Error("Invalid schedule. Use a five-field UTC cron expression or @once:<ISO-8601>.");
     const type = pulseType(input.schedule);
-    this.db.prepare("UPDATE pulses SET description=?, type=?, schedule=?, prompt=?, thread_session_id=?, insert_into_api_session=? WHERE id=?").run(input.description, type, input.schedule, input.prompt, input.thread_session_id, input.insertIntoApiSession ? 1 : 0, pulse.id);
+    this.db.prepare("UPDATE pulses SET name=?, description=?, type=?, schedule=?, prompt=?, thread_session_id=?, insert_into_api_session=? WHERE id=?").run(nextName, input.description, type, input.schedule, input.prompt, input.thread_session_id, input.insertIntoApiSession ? 1 : 0, pulse.id);
     this.db.prepare("UPDATE pulse_control SET next_run_at=?, updated_at=? WHERE pulse_id=?").run(pulse.enabled ? nextRun(input.schedule)?.toISOString() ?? null : null, iso(), pulse.id);
-    return this.get(name, profile)!;
+    return this.get(nextName, profile)!;
   }
   delete(name: string, profile?: string): void { const pulse = this.get(name, profile); if (!pulse) throw new Error("Pulse not found."); this.db.prepare("DELETE FROM pulses WHERE id=?").run(pulse.id); }
   deleteProfile(profile: string): void { this.db.prepare("DELETE FROM pulses WHERE id IN (SELECT pulse_id FROM pulse_control WHERE profile=?)").run(profile); }
@@ -184,6 +191,21 @@ export class PulseStore {
       this.db.exec("COMMIT");
     } catch (cause) { this.db.exec("ROLLBACK"); throw cause; }
   }
+  finalizeRunning(name: string, profile: string, runId: string, status: "success" | "error"): PulseRun {
+    const pulse = this.get(name, profile); if (!pulse) throw new Error("Pulse not found.");
+    const now = iso(), result = status === "success" ? "Manually finalized as successful." : "Manually finalized as failed.", next = status === "success" ? nextRun(pulse.schedule)?.toISOString() ?? null : nextRun(pulse.schedule, new Date(Date.now() + 60_000))?.toISOString() ?? null;
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const run = this.db.prepare("UPDATE pulse_runs SET finished_at=?,status=?,response=?,error=? WHERE id=? AND pulse_id=? AND status='running'").run(now, status, status === "success" ? result : null, status === "error" ? result : null, runId, pulse.id);
+      if (!run.changes) throw new Error("Pulse run is not running.");
+      const control = this.db.prepare("UPDATE pulse_control SET last_run_at=?,next_run_at=?,claimed_at=NULL,active_run_id=NULL,claim_owner=NULL,lease_expires_at=NULL,updated_at=? WHERE pulse_id=? AND active_run_id=?").run(now, next, now, pulse.id, runId);
+      if (!control.changes) throw new Error("Pulse run is no longer active.");
+      if (status === "success") this.db.prepare("UPDATE pulses SET result=? WHERE id=?").run(result, pulse.id);
+      this.db.exec("COMMIT");
+    } catch (error) { this.db.exec("ROLLBACK"); throw error; }
+    const row = this.db.prepare("SELECT id,session_id,started_at,finished_at,status,response,error FROM pulse_runs WHERE id=?").get(runId) as Row;
+    return { id: String(row.id), sessionId: row.session_id == null ? null : String(row.session_id), startedAt: String(row.started_at), finishedAt: row.finished_at == null ? null : String(row.finished_at), status: row.status as PulseRun["status"], response: row.response == null ? null : String(row.response), error: row.error == null ? null : String(row.error) };
+  }
   claimTickLease(owner: string, leaseMs = 90_000): boolean {
     const now = iso(), expiresAt = new Date(Date.now() + leaseMs).toISOString();
     this.db.exec("BEGIN IMMEDIATE");

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); }
   }