@agentistics/mcp 2.202.1 → 2.203.0

package/dist/agentistics-mcp.js

@@ -3,6 +3,8 @@
 // live-delivery-args.ts
 var LIVE_STAGES = ["queue", "running", "qa", "adjust", "leader", "merge", "published"];
 var LIVE_SORTS = ["priority", "time-in-stage", "recent"];
+var LIVE_TABS = ["active", "queue", "published", "all"];
+var LIVE_PERIODS = ["24h", "7d", "30d", "all"];
 function liveDeliveryQuery(a) {
   const q = new URLSearchParams;
   const task = typeof a?.task === "string" ? a.task.trim() : "";
@@ -12,10 +14,10 @@ function liveDeliveryQuery(a) {
     q.set("stage", a.stage);
   if (a?.stalledOnly === true)
     q.set("stalled", "1");
-  if (a?.onlyActive === false)
-    q.set("onlyActive", "0");
-  if (a?.showQueue === false)
-    q.set("showQueue", "0");
+  if (typeof a?.tab === "string" && LIVE_TABS.includes(a.tab))
+    q.set("tab", a.tab);
+  if (typeof a?.period === "string" && LIVE_PERIODS.includes(a.period))
+    q.set("period", a.period);
   if (typeof a?.sort === "string" && LIVE_SORTS.includes(a.sort))
     q.set("sort", a.sort);
   return q.toString() ? `?${q}` : "";
@@ -780,6 +782,8 @@ var HARNESS_MODELS = {
   hermes: []
 };
 var SPAWN_SPECS_MODEL_IDS = Object.fromEntries(Object.entries(HARNESS_MODELS).map(([h, opts]) => [h, opts.map((o) => o.id)]));
+// ../core/src/liveBoard.ts
+var PERIOD_MS = { "24h": 24 * 3600000, "7d": 7 * 24 * 3600000, "30d": 30 * 24 * 3600000, all: Infinity };
 // ../core/src/taskThreads.ts
 var LIVE = new Set(["working", "waiting", "waiting-approval"]);
 // ../core/src/attachments.ts
@@ -1004,8 +1008,8 @@ var AGENT_TOOL_POLICY = {
   agentistics_task_phase: {
     ...TASKS,
     risk: "W",
-    routes: ["GET /api/deliveries", "GET /api/deliveries/:subtask", "POST /api/deliveries/:subtask", "POST /api/deliveries/release"],
-    reason: "reads or moves a delivery through the fixed phase table; release declares which pieces a release shipped (leader/owner only; the host still reads the green run and the tag); a skipped phase is refused (422 fase_pulada) and every gate is checked by the host from evidence, never from the caller"
+    routes: ["GET /api/deliveries", "GET /api/deliveries/:subtask", "POST /api/deliveries/:subtask", "POST /api/deliveries/release", "POST /api/deliveries/reconcile"],
+    reason: "reads or moves a delivery through the fixed phase table; release declares which pieces a release shipped (leader/owner only; the host still reads the green run and the tag); reconcile backfills merged/released pieces (dry run unless apply, leader/owner only); a skipped phase is refused (422 fase_pulada) and every gate is checked by the host from evidence, never from the caller"
   },
   agentistics_task_stage: {
     ...TASKS,
@@ -1135,7 +1139,7 @@ var roomOf = (b) => Math.max(b.fiveHourPct, b.weekPct);
 function pickAccount(candidates) {
   return candidates.map((b, i) => ({ b, i })).sort((x, y) => (x.b.daysToWeekReset > 0 ? x.b.weekResetsAt : Infinity) - (y.b.daysToWeekReset > 0 ? y.b.weekResetsAt : Infinity) || roomOf(x.b) - roomOf(y.b) || (y.b.updatedAt ?? 0) - (x.b.updatedAt ?? 0) || y.i - x.i)[0]?.b;
 }
-function routeRecommendation(budgets, kind, authorHarness) {
+function routeRecommendation(budgets, kind, authorHarness, opts = {}) {
   const authorVendor = kind === "qa" && authorHarness ? HARNESS_VENDOR[authorHarness] : undefined;
   budgets = budgets.flatMap((b) => {
     if (!b.scopes?.length)
@@ -1145,9 +1149,15 @@ function routeRecommendation(budgets, kind, authorHarness) {
       return { ...row, ...sb, scope: scope.id, model: scope.models[0], scopeProviders: scope.providers };
     });
   });
-  const aggregates = new Map(harnessAggregate(budgets.filter((b) => b.plan !== "unregistered")).map((a) => [a.harness, a]));
+  const aggregates = new Map(harnessAggregate(budgets.filter((b) => b.plan !== "unregistered" && !b.stale)).map((a) => [a.harness, a]));
   const eligibleHarness = (agg) => eligibleAccounts(agg.harness).length > 0 && agg.status !== "hold" && agg.harness !== (kind === "qa" ? authorHarness : undefined);
-  const eligibleAccounts = (h) => budgets.filter((b) => b.harness === h && b.spawnable !== false && b.plan !== "unregistered" && !b.yieldsTo && b.status !== "hold");
+  const eligibleAccounts = (h) => budgets.filter((b) => b.harness === h && b.spawnable !== false && b.plan !== "unregistered" && !b.yieldsTo && b.status !== "hold" && !b.stale);
+  const knownHarnesses = [...new Set([...opts.visibleHarnesses ?? [], ...budgets.map((b) => b.harness)])];
+  const unknownList = knownHarnesses.flatMap((h) => {
+    const rows = budgets.filter((b) => b.harness === h && b.plan !== "unregistered");
+    return rows.some((b) => !b.stale) ? [] : [{ harness: h, why: rows.length ? "stale" : "no-reading" }];
+  });
+  const unknown = unknownList.length ? { unknown: unknownList } : {};
   const harnesses = [...aggregates.values()].filter(eligibleHarness);
   const ordered = [...harnesses].sort((a, b) => {
     const ap = a.paceStatus === "under" ? 0 : 1;
@@ -1162,14 +1172,19 @@ function routeRecommendation(budgets, kind, authorHarness) {
   const chosen = ordered.find((a) => preference.some(([h]) => h === a.harness));
   const pickAgg = chosen ?? ordered[0];
   const noRoute = () => {
+    const base = { harness: null, alternatives: [], accountAlternatives: [], confidence: "none", ...unknown };
     if (budgets.length && budgets.every((b) => b.spawnable === false)) {
-      return { harness: null, reason: "No harness can start a new session.", alternatives: [], accountAlternatives: [], cadence: { parallel: 0, note: "Install or repair a harness before opening workers." } };
+      return { ...base, reason: "No harness can start a new session.", cadence: { parallel: 0, note: "Install or repair a harness before opening workers." } };
     }
     if (budgets.length && budgets.every((b) => b.status === "hold")) {
       const earliest = Math.min(...budgets.map((b) => b.pauseUntil ?? b.weekResetsAt));
-      return { harness: null, reason: `all plans on hold until ${new Date(earliest).toISOString()}`, alternatives: [], accountAlternatives: [], cadence: { parallel: 0, note: "Wait for a plan to renew." } };
+      return { ...base, reason: `all plans on hold until ${new Date(earliest).toISOString()}`, cadence: { parallel: 0, note: "Wait for a plan to renew." } };
+    }
+    const registered = budgets.filter((b) => b.plan !== "unregistered" && b.spawnable !== false && b.status !== "hold");
+    if (registered.length && registered.every((b) => b.stale)) {
+      return { ...base, reason: `No fresh plan_limits reading for ${kind}: ${[...new Set(registered.map((b) => b.harness))].join(", ")} ${registered.length === 1 ? "was" : "were"} last read more than ${PLAN_LIMITS_STALE_MS / 60000} minutes ago.`, cadence: { parallel: 0, note: "Read the plan windows again before opening workers; a stale meter is never trusted." } };
     }
-    return { harness: null, reason: `No eligible plan for ${kind}.`, alternatives: [], accountAlternatives: [], cadence: { parallel: 0, note: "Check plan registration, account availability, and author-harness exclusions." } };
+    return { ...base, reason: `No eligible plan for ${kind}.`, cadence: { parallel: 0, note: "Check plan registration, account availability, and author-harness exclusions." } };
   };
   if (!pickAgg)
     return noRoute();
@@ -1192,7 +1207,9 @@ function routeRecommendation(budgets, kind, authorHarness) {
     reason: `${pick.harness} is the preferred eligible plan for ${kind}.${budgetText}${paceText}`,
     alternatives,
     accountAlternatives,
-    cadence: { parallel, note: pick.note ?? "Keep one worker running." }
+    cadence: { parallel, note: pick.note ?? "Keep one worker running." },
+    confidence: "fresh",
+    ...unknown
   };
 }
 var NEW_PERIOD_MS = 5 * 60000;
@@ -1697,7 +1714,8 @@ function planLimitsTool(args, body) {
     const label = plainLabel(accountLabel);
     return label !== undefined ? { ...rest, accountLabel: label } : rest;
   });
-  const routed = args?.kind ? routeRecommendation(budgets, args.kind, args.authorHarness) : undefined;
+  const visibleHarnesses = Object.entries(body.harnesses ?? {}).filter(([, v]) => v?.spawnable).map(([h]) => h);
+  const routed = args?.kind ? routeRecommendation(budgets, args.kind, args.authorHarness, { visibleHarnesses }) : undefined;
   const recommendation = routed?.accountLabel !== undefined ? { ...routed, accountLabel: plainLabel(routed.accountLabel) } : routed;
   const aggregates = harnessAggregate(budgets);
   const offBySchedule = (body.hiddenFromAgents ?? []).filter((b) => b?.agentUse && !b.agentUse.on).map((b) => ({ harness: b.harness, account: b.account, reason: b.agentUse.reason }));
@@ -2247,10 +2265,15 @@ var TOOLS = [
   },
   {
     name: "agentistics_task_create",
-    description: "Create a task. A title is required; a description is optional. Creating a title that already exists returns the existing task rather than a duplicate, so this is safe to call before filing work under a name you are not sure exists.",
+    description: "Create a task. A title is required; a description is optional. Set `priority` (urgent | high | medium | low — default low, and nobody chose a default) and `type` (an id from agentistics_task_types) when you know them: a board of defaults orders nothing. Creating a title that already exists returns the existing task rather than a duplicate (its priority and type are left alone — use agentistics_task_edit), so this is safe to call before filing work under a name you are not sure exists.",
     inputSchema: {
       type: "object",
-      properties: { title: { type: "string" }, detail: { type: "string" } },
+      properties: {
+        title: { type: "string" },
+        detail: { type: "string" },
+        priority: { type: "string", enum: ["urgent", "high", "medium", "low"], description: "Defaults to low. Decides the order of the queue and of the Live delivery line." },
+        type: { type: "string", description: "A type id from agentistics_task_types (an unknown one is dropped)." }
+      },
       required: ["title"]
     }
   },
@@ -2371,7 +2394,7 @@ var TOOLS = [
         },
         status: {
           type: "string",
-          enum: ["backlog", "todo", "in_progress", "blocked", "in_review", "done", "abandoned"]
+          description: "A status id this board currently has — call agentistics_task_statuses for the live list (the vocabulary is editable, so it is NOT fixed here). The four every board starts with are todo | in_progress | blocked | done."
         },
         dueDate: { type: "string" },
         startDate: { type: "string" },
@@ -2457,15 +2480,15 @@ var TOOLS = [
   },
   {
     name: "agentistics_live_delivery",
-    description: 'What is being DELIVERED right now — the Live Delivery line, the same source as the screen. Use it to answer "what is running", "when does X ship" and "is anything stalled". Returns a `summary` (active deliveries, agents working, stalled, the next delivery with an estimate), the active `deliveries` with their stage (queue, running, qa, adjust, leader, merge, published), the agents on each (harness, model, account, live state), time in the stage and in total, the step inside the stage (`step`, with `stepSource` = `reported` or `signals` and `stepSignal` naming the observed fact — null `step` means nothing is observable, say so; the screen then draws no percent), the ETA with its source and confidence (`kind: none` means there is NO estimate — say so, never invent a time), the last action, and the `leaders` band (each leader\'s current action, its workers and what waits on a decision — leaders are never deliveries). Each delivery carries its Agentask `priority` (urgent | high | medium | low; a subtask inherits its task\'s). Filters: `task` (id or part of the title), `stage`, `stalledOnly`, and the screen\'s own switches — `onlyActive` (the stages after the queue; default true) and `showQueue` (the Na fila column; default true), pass false to turn one off — plus `sort` (how each stage lists its cards; default `priority`, highest first, ties by longest in the stage). Stage names on screen: queue = Na fila, running = Em desenvolvimento, qa = QA. `history` is the screen\'s Histórico column: pieces published more than 24 h ago (up to 30 days, newest first, same `task` filter, no live agents) — Publicado keeps a card for 24 h and then it moves there.',
+    description: 'What is being DELIVERED right now — the Live Delivery line, the same source as the screen. Use it to answer "what is running", "when does X ship" and "is anything stalled". Returns a `summary` (active deliveries, agents working, stalled, the next delivery with an estimate), the active `deliveries` with their stage (queue, running, qa, adjust, leader, merge, published), the agents on each (harness, model, account, live state), time in the stage and in total, the step inside the stage (`step`, with `stepSource` = `reported` or `signals` and `stepSignal` naming the observed fact — null `step` means nothing is observable, say so; the screen then draws no percent), the ETA with its source and confidence (`kind: none` means there is NO estimate — say so, never invent a time), the last action, and the `leaders` band (each leader\'s current action, its workers and what waits on a decision — leaders are never deliveries). Each delivery carries its Agentask `priority` (urgent | high | medium | low; a subtask inherits its task\'s). Filters: `task` (id or part of the title), `stage`, `stalledOnly`, and the screen\'s own tabs — `tab`: `active` (Em andamento: only what has an agent working or waiting), `queue` (Na fila), `published` (Publicado) or `all` (Tudo: every piece in its real column, old legacy reviews marked `old`; the default here, while the screen opens on `active`) — and `period`, the Publicado period: `24h` (default), `7d`, `30d` or `all`. The answer\'s `view` carries `{tab, period, counts, defaulted, capped}`: `tab`/`period` are the EFFECTIVE values (a missing or invalid one falls back to `all` / `24h`, and `defaulted` names which did), `counts` is the count of EVERY tab under the same `task` filter and period, the very numbers the screen\'s tabs print, and `capped` (`{cap, omitted}`, else null) says the list was cut at 400 pieces per kind and that many older ones are NOT in the answer — then a count is not the total. Plus `sort` (how each stage lists its cards; default `priority`, highest first, ties by longest in the stage). Stage names on screen: queue = Na fila, running = Em desenvolvimento, qa = QA. There is no Histórico column any more: a piece published earlier is in `deliveries` whenever `period` covers it.',
     inputSchema: {
       type: "object",
       properties: {
         task: { type: "string", description: "A task id or part of its title." },
         stage: { type: "string", enum: ["queue", "running", "qa", "adjust", "leader", "merge", "published"] },
         stalledOnly: { type: "boolean", description: "Only deliveries that need a person, lost an agent or are blocked." },
-        onlyActive: { type: "boolean", description: `The screen's "apenas ativas": the cards of the stages after the queue. Default true; false hides them.` },
-        showQueue: { type: "boolean", description: `The screen's "exibir itens na fila": the cards of the Na fila column. Default true; false hides them.` },
+        tab: { type: "string", enum: ["active", "queue", "published", "all"], description: "The screen's tab: active (Em andamento), queue (Na fila), published (Publicado) or all (Tudo). Default all." },
+        period: { type: "string", enum: ["24h", "7d", "30d", "all"], description: "How far back Publicado reaches. Default 24h." },
         sort: { type: "string", enum: ["priority", "time-in-stage", "recent"], description: "Order within each stage. Default priority (highest first, ties by longest in the stage)." }
       },
       required: []
@@ -2529,11 +2552,12 @@ var TOOLS = [
   },
   {
     name: "agentistics_task_phase",
-    description: "`tick` also enables the mandatory owner-request/placement flows through the official engine switches and reads canonical pedidos; after 10 minutes without complete staging it wakes the current live task leader, including after a handoff or restart, and never asks the owner. " + "Queue actions: `dequeue` withdraws a queued piece with a required free-text `reason` (task leader or owner only), keeps the draft/history, and refuses dispatch until explicitly restaged; `tick` reconciles stale queued pieces against board review/done/abandoned and records a comment. Vacancy counts live backend processes; lost/exited/closed sessions reserve no slots. " + "FLUXO.ENTREGA-DSL — read or move a DELIVERY (one subtask) through its fixed phases: fila → executando → qa → (ajuste ⇄ qa) → revisao_lider → pr_merge → ci → publicado, plus bloqueado (from any phase, back to the stored origin only). Any transition outside that table is REFUSED (422 `fase_pulada`) with a sentence naming what is missing — executando → revisao_lider, ajuste → revisao_lider and every other skip included. The gates each edge needs are run BY THE SERVER from evidence (predispatch, vaga, salvo = sha on origin per ls-remote, qa-modelo = QA model ≠ author model from the registry and never Sonnet over Sonnet, cabeca = the pushed branch is still at the sha QA tested, delecoes = no file deleted outright by the PR, mergeado = gh says the PR is MERGED, the merge commit is on origin/main and the PR head is the sha QA approved — the merge sha is READ FROM THE PR, never from you, release = the batch's version tag exists AND the release.yml run that produced it is green, read in the repository the release recorded); salvo needs every check run on the pushed head to have concluded green (pending or absent refuse); you never pass proof. `action`: `get` (default; omit `subtaskId` to list every delivery) | `phase` (`to` + what that edge reads: `verdict` APROVADO/REPROVADO + `findings` from qa, `reviewedSha` = the sha QA approved for revisao_lider → pr_merge, `detail` for a request for change or a failure reason) | `gate` (`name`: run ONE gate and record its evidence) | `block` (`reason` one of dependencia, pedido_de_bloqueio, limite, maquina, externo, fora_das_autorizacoes; `text`) | `unblock` (`detail`; the leader of the task or the owner — an owner-decision block only the owner) | `step` (`step` 1..9: the step of the current phase, for the Live %. The Live already DERIVES the step from real signals — a session open, a file edit, a test run, a commit, the gates, the PR — so report only when you know better; the card shows the larger of the two and says which it is. Works for a legacy piece with no delivery record too: only the board's `step` event is written, nothing is adopted into the flow) | `configure` (the LEADER of the task or the owner only; `patch`: versionTarget, humanGates [phases needing the owner's approval — skipped and recorded as 'pulado: modo autônomo' while autonomous mode is on], leaderSessionId, pr, tag, allowDeletions {paths, reason}; the QA and author sessions are never settable — the host records them from the sessions it opened and the registry) | `approve` (`phase`, `decision` approve|reject, `note`: answers a human gate the owner was ASKED about; a session identity is deliberately not sent, the owner answers through this same door as the Live card button and `agentop flow approve`) | `stage-run` (predispatch + vaga gates, then start the staged session and move to executando) | `merge` (delecoes gate, squash-merge the PR, move to ci; a failure goes back to revisao_lider) | `release` (the LEADER of the task or the owner DECLARES what a release contains: `version` x.y.z, `mergeSha` = the commit on main carrying it (information only; 40 characters, or a short sha the server resolves), optional `repo` = owner/name (default agentistics/agentistics), `subtaskIds` = every piece in it; no `subtaskId`. Each piece gets its record (a legacy one is adopted), versionTarget/mergeSha/tag/repo, goes to ci and then to publicado as soon as the tag `v<version>` exists and the release.yml run that produced it is green — read by the server from the TAG, not from the sha — with the release's own publish time; a declared piece is never sent back to revisao_lider by the tick (a red tag run keeps it in ci and wakes the leader once); done/abandoned/blocked/unknown/other-task pieces refuse the whole batch, which is written in ONE store write; a second run changes nothing). In autonomous mode nothing here ever asks or waits for the owner.",
+    description: "FLUXO.CICLO-COMPLETO — the minute `tick` also moves a piece in revisao_lider or pr_merge to ci BY ITSELF once its PR is merged (found from the piece's PR number, branch, the PR containing the sha QA approved, or its author worktree's branch; the merge gates `delecoes` + `mergeado` still run, and a refusal leaves the piece where it is with the reason), publishes ci pieces from the FIRST tag that contains the merge, and reminds the LIVE leader of the task (never the owner) of a piece waiting on them for 30 min, then every 2 h, at most 3 times. `get` with a `subtaskId` returns `tickReason`: why the tick has not moved it. `reconcile` (no `subtaskId`; `apply` true to write) is the one-shot BACKFILL: every piece in revisao_lider/pr_merge/ci matched to its merged PR and the first release tag containing it — a report of what moves and what cannot be proven, with the reason. " + "`tick` also enables the mandatory owner-request/placement flows through the official engine switches and reads canonical pedidos; after 10 minutes without complete staging it wakes the current live task leader, including after a handoff or restart, and never asks the owner. " + "Queue actions: `dequeue` withdraws a queued piece with a required free-text `reason` (task leader or owner only), keeps the draft/history, and refuses dispatch until explicitly restaged; `tick` reconciles stale queued pieces against board review/done/abandoned and records a comment. Vacancy counts live backend processes; lost/exited/closed sessions reserve no slots. " + "FLUXO.ENTREGA-DSL — read or move a DELIVERY (one subtask) through its fixed phases: fila → executando → qa → (ajuste ⇄ qa) → revisao_lider → pr_merge → ci → publicado, plus bloqueado (from any phase, back to the stored origin only). Any transition outside that table is REFUSED (422 `fase_pulada`) with a sentence naming what is missing — executando → revisao_lider, ajuste → revisao_lider and every other skip included. The gates each edge needs are run BY THE SERVER from evidence (predispatch, vaga, salvo = sha on origin per ls-remote, qa-modelo = QA model ≠ author model from the registry and never Sonnet over Sonnet, cabeca = the pushed branch is still at the sha QA tested, delecoes = no file deleted outright by the PR, mergeado = gh says the PR is MERGED, the merge commit is on origin/main and the PR head is the sha QA approved — the merge sha is READ FROM THE PR, never from you, release = the batch's version tag exists AND the release.yml run that produced it is green, read in the repository the release recorded); salvo needs every check run on the pushed head to have concluded green (pending or absent refuse); you never pass proof. `action`: `get` (default; omit `subtaskId` to list every delivery) | `phase` (`to` + what that edge reads: `verdict` APROVADO/REPROVADO + `findings` from qa, `reviewedSha` = the sha QA approved for revisao_lider → pr_merge, `detail` for a request for change or a failure reason) | `gate` (`name`: run ONE gate and record its evidence) | `block` (`reason` one of dependencia, pedido_de_bloqueio, limite, maquina, externo, fora_das_autorizacoes; `text`) | `unblock` (`detail`; the leader of the task or the owner — an owner-decision block only the owner) | `step` (`step` 1..9: the step of the current phase, for the Live %. The Live already DERIVES the step from real signals — a session open, a file edit, a test run, a commit, the gates, the PR — so report only when you know better; the card shows the larger of the two and says which it is. Works for a legacy piece with no delivery record too: only the board's `step` event is written, nothing is adopted into the flow) | `configure` (the LEADER of the task or the owner only; `patch`: versionTarget, humanGates [phases needing the owner's approval — skipped and recorded as 'pulado: modo autônomo' while autonomous mode is on], leaderSessionId, pr, tag, allowDeletions {paths, reason}; the QA and author sessions are never settable — the host records them from the sessions it opened and the registry) | `approve` (`phase`, `decision` approve|reject, `note`: answers a human gate the owner was ASKED about; a session identity is deliberately not sent, the owner answers through this same door as the Live card button and `agentop flow approve`) | `stage-run` (predispatch + vaga gates, then start the staged session and move to executando) | `merge` (delecoes gate, squash-merge the PR, move to ci; a failure goes back to revisao_lider) | `release` (the LEADER of the task or the owner DECLARES what a release contains: `version` x.y.z, `mergeSha` = the commit on main carrying it (information only; 40 characters, or a short sha the server resolves), optional `repo` = owner/name (default agentistics/agentistics), `subtaskIds` = every piece in it; no `subtaskId`. Each piece gets its record (a legacy one is adopted), versionTarget/mergeSha/tag/repo, goes to ci and then to publicado as soon as the tag `v<version>` exists and the release.yml run that produced it is green — read by the server from the TAG, not from the sha — with the release's own publish time; a declared piece is never sent back to revisao_lider by the tick (a red tag run keeps it in ci and wakes the leader once); done/abandoned/blocked/unknown/other-task pieces refuse the whole batch, which is written in ONE store write; a second run changes nothing). In autonomous mode nothing here ever asks or waits for the owner.",
     inputSchema: {
       type: "object",
       properties: {
-        action: { type: "string", enum: ["get", "phase", "gate", "block", "unblock", "dequeue", "tick", "step", "configure", "approve", "stage-run", "merge", "release"] },
+        action: { type: "string", enum: ["get", "phase", "gate", "block", "unblock", "dequeue", "tick", "step", "configure", "approve", "stage-run", "merge", "release", "reconcile"] },
+        apply: { type: "boolean", description: "reconcile: write the moves (a leader of the task, or the owner). Absent/false = dry run: the report only" },
         subtaskId: { type: "string" },
         version: { type: "string", description: "release: the version the pieces shipped in, x.y.z" },
         mergeSha: { type: "string", description: "release: the commit on main that carries the release (information only: stored on the record; a short sha is resolved to 40 characters or refused). The publication evidence is the version tag's own green release.yml run" },
@@ -2645,7 +2669,7 @@ var TOOLS = [
         to: { type: "string", description: "The target session reference." },
         kind: { type: "string", enum: ["handback", "block", "question"] },
         body: { type: "string", description: "The message." },
-        awaiting: { type: "string", description: "kind=handback only: what you stopped waiting for (marks the handback as intermediate; the worker is not closed). Omit on a final handback." }
+        awaiting: { type: "string", description: `kind=handback only: what you stopped waiting for (marks the handback as intermediate: the worker is not closed, your subtask stays in_progress and the leader's check-in does not list it as delivered). A text that says it is part N of M ("parte 2 de 5", "2/5", "seguindo com…") with no awaiting is read the same way, and the reply tells you so. Omit on the FINAL handback.` }
       },
       required: ["to", "kind", "body"]
     }
@@ -3024,7 +3048,12 @@ async function callTool(req) {
       }
       case "agentistics_task_create": {
         const a = args;
-        const body = await apiSend("POST", "/api/tasks", { title: a?.title, detail: a?.detail });
+        const body = await apiSend("POST", "/api/tasks", {
+          title: a?.title,
+          detail: a?.detail,
+          ...typeof a?.priority === "string" ? { priority: a.priority } : {},
+          ...typeof a?.type === "string" ? { type: a.type } : {}
+        });
         return { content: [{ type: "text", text: JSON.stringify(body, null, 2) }] };
       }
       case "agentistics_task_status": {
@@ -3189,6 +3218,10 @@ async function callTool(req) {
           });
           return { content: [{ type: "text", text: JSON.stringify(body, null, 2) }] };
         }
+        if (action === "reconcile") {
+          const body = await apiSend("POST", "/api/deliveries/reconcile", { apply: a.apply === true, session: sessionProof(process.env) });
+          return { content: [{ type: "text", text: JSON.stringify(body, null, 2) }] };
+        }
         if (action !== "tick" && (typeof a.subtaskId !== "string" || !a.subtaskId))
           throw new Error("subtaskId is required");
         const { subtaskId: _s, action: _a, ...rest } = a;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentistics/mcp",
-  "version": "2.202.1",
+  "version": "2.203.0",
   "description": "Agentistics MCP server — Claude Code analytics for Claude Desktop and Claude Code",
   "type": "module",
   "main": "./dist/agentistics-mcp.js",