@mrrlin-dev/mcp 0.4.42 → 0.4.43

package/dist/bin.cjs

@@ -36816,6 +36816,17 @@ var ARTIFACT_CHECKS = {
   structured_data: null,
   message: { verifier: "status" }
 };
+var ARTIFACT_DESTINATIONS = {
+  document: "wiki",
+  page: "git",
+  file_set: null,
+  code_change: "git",
+  structured_data: null,
+  message: null
+};
+function resolveKindCapability(kind) {
+  return ARTIFACT_DESTINATIONS[kind];
+}
 
 // ../../packages/schemas/dist/operationIds.js
 var openApiOperationIds = {
@@ -36957,7 +36968,11 @@ var openApiOperationIds = {
   upsertCapabilityRoute: "upsertCapabilityRoute",
   resolveCapabilityRoute: "resolveCapabilityRoute",
   overrideCapabilityToolClass: "overrideCapabilityToolClass",
-  listCapabilityUses: "listCapabilityUses"
+  listCapabilityUses: "listCapabilityUses",
+  confirmFirstWrite: "confirmFirstWrite",
+  resolveArtifactKindRoute: "resolveArtifactKindRoute",
+  resolveDeliveryForArtifactKind: "resolveDeliveryForArtifactKind",
+  recordCapabilityUse: "recordCapabilityUse"
 };
 
 // ../../packages/schemas/dist/session.js
@@ -37533,6 +37548,18 @@ var mrrlinDeclaredOutcomeSchema = mrrlinDeclaredOutcomeShapeSchema.superRefine((
       message: `requires spans more than one verifier, so no receipt can ever satisfy it (${spread}). Declare the outcome rather than the steps that produced it; if two things must genuinely exist and neither is a means to the other, split them into linked tasks.`
     });
   }
+  const distinctCapabilities = new Set(value.requires.map((kind) => resolveKindCapability(kind)).filter((capability) => capability !== null));
+  if (distinctCapabilities.size > 1) {
+    const spread = value.requires.map((kind) => {
+      const capability = resolveKindCapability(kind);
+      return capability === null ? `${kind} has no destination` : `${kind} routes to ${capability}`;
+    }).join(", ");
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["requires"],
+      message: `requires spans more than one capability, so no single delivery can satisfy it (${spread}). Split into linked tasks, one per destination.`
+    });
+  }
   const hasVerifiableKind = value.requires.some((kind) => ARTIFACT_CHECKS[kind] !== null);
   const hasUnverifiableKind = value.requires.some((kind) => ARTIFACT_CHECKS[kind] === null);
   if (value.verification === "human_tap" && hasVerifiableKind) {
@@ -37660,6 +37687,13 @@ var mrrlinRunBlockingReasonCodeSchema = external_exports.enum([
   // with a task-content block; before it existed such a failure fell through to `unknown` and was
   // handed off to the operator as though the Director had judged the task.
   "provider_limit_exhausted",
+  // Крок 3, task 8.1: the dispatch pre-flight's own refusal — the task's declared outcome requires
+  // an artifact kind with no capability route at all (client-side, resolveKindCapability) or no
+  // configured route in this project (server-side, resolveArtifactKindRoute). Distinct from
+  // `task_blocked` (which is about blocker TASKS, not this run's own delivery destination): a task
+  // whose blockers clear can start; a task whose required kind cannot route needs an operator to
+  // configure the missing route before any retry would succeed.
+  "capability_not_routed",
   "unknown"
 ]);
 var mrrlinExecutionArtifactKindSchema = external_exports.enum([
@@ -37740,6 +37774,13 @@ var mrrlinStopReasonSchema = external_exports.enum([
   "consensus_disabled_spec_not_ready",
   "spec_approval_pending",
   "awaiting_handoff",
+  // Крок 3 (delivery-as-capability-call), task 3.1: the parked reason for an open capability
+  // question (origin: "capability"), the same shape as awaiting_clarification's own open gate
+  // question (origin: "gate") one line above -- caught by the whole-change gate (task 9.3), not
+  // task 3.1 itself: this schema and mrrlinSchedulerParkedReasonSchema are siblings apps/web's
+  // autopilotQueue.ts assumes stay in lockstep (every parked reason not explicitly remapped is
+  // used as a stop reason directly), and no per-package typecheck in this change ever ran apps/web.
+  "awaiting_capability_decision",
   "assigned_to_other",
   "backlog",
   "attempts_exhausted",
@@ -38923,7 +38964,11 @@ var mrrlinSchedulerParkedReasonSchema = external_exports.enum([
   "awaiting_handoff",
   "awaiting_clarification",
   "spec_awaiting_approval",
-  "blocked_by_active"
+  "blocked_by_active",
+  // Derived, not stored (design.md, "Parking is derived"): an open `question` inbox item with
+  // `origin === "capability"` yields this reason, exactly as an `origin === "gate"` one already
+  // yields `awaiting_clarification`. No column, and nobody but the derivation may set it.
+  "awaiting_capability_decision"
 ]);
 var mrrlinSchedulerParkedTaskSchema = external_exports.object({
   task: mrrlinTaskSchema,
@@ -39262,6 +39307,16 @@ var capabilityRouteResponseSchema = external_exports.object({ data: CapabilityRo
 var capabilityRouteListResponseSchema = external_exports.object({ data: external_exports.array(CapabilityRouteSchema) });
 var capabilityToolClassResponseSchema = external_exports.object({ data: CapabilityToolClassSchema });
 var capabilityUseListResponseSchema = external_exports.object({ data: external_exports.array(CapabilityUseSchema) });
+var capabilityUseResponseSchema = external_exports.object({ data: CapabilityUseSchema.nullable() });
+var capabilityUseCreateSchema = external_exports.object({
+  serverId: capabilityServerIdSchema,
+  toolName: capabilityToolNameSchema,
+  taskId: mrrlinTaskIdSchema.nullable(),
+  outcome: capabilityUseOutcomeSchema
+});
+var deliveryResolutionResponseSchema = external_exports.object({
+  data: external_exports.object({ route: CapabilityRouteSchema, verdict: CapabilityGateVerdictSchema })
+});
 
 // ../../packages/agent-client/dist/providers/codex/render-context-bundle.js
 var DEFAULT_SPEC_BUDGET_CHARS = 6e3;
@@ -40551,6 +40606,12 @@ function createAgentTokenProvider(opts) {
 }
 
 // ../../packages/client/dist/index.js
+var CAPABILITY_ROUTE_RESOLUTION_REASON_BY_CODE = {
+  NO_ROUTE: "no_route",
+  NO_GRANT: "no_grant",
+  PROJECT_MISMATCH: "project_mismatch",
+  AMBIGUOUS_ROUTE: "ambiguous_route"
+};
 function appendQuery(url2, params) {
   const search = new URLSearchParams();
   for (const [key, value] of Object.entries(params)) {
@@ -41180,6 +41241,52 @@ function createMrrlinClient(config2) {
       const body = await request(`${projectPath(projectSlug)}/capability-grants/${encodeURIComponent(serverId)}`, { method: "DELETE" });
       return capabilityGrantResponseSchema.parse(body).data;
     },
+    async confirmFirstWrite(projectSlug, serverId) {
+      try {
+        const body = await request(`${projectPath(projectSlug)}/capability-grants/${encodeURIComponent(serverId)}/first-write-confirmation`, { method: "POST" });
+        return capabilityGrantResponseSchema.parse(body).data;
+      } catch (error51) {
+        if (error51 instanceof MrrlinApiError && error51.code === "NO_GRANT")
+          return null;
+        throw error51;
+      }
+    },
+    async resolveArtifactKindRoute(projectSlug, artifactKind, taskProjectSlug) {
+      try {
+        const body = await request(`${projectPath(projectSlug)}/artifact-kinds/${encodeURIComponent(artifactKind)}/resolution?taskProjectSlug=${encodeURIComponent(taskProjectSlug)}`, { method: "POST" });
+        return { ok: true, route: capabilityRouteResponseSchema.parse(body).data };
+      } catch (error51) {
+        if (error51 instanceof MrrlinApiError) {
+          const reason = CAPABILITY_ROUTE_RESOLUTION_REASON_BY_CODE[error51.code];
+          if (reason)
+            return { ok: false, reason, message: error51.message };
+        }
+        throw error51;
+      }
+    },
+    async resolveDeliveryForArtifactKind(projectSlug, artifactKind, taskProjectSlug, taskId) {
+      try {
+        const url2 = appendQuery(`${projectPath(projectSlug)}/artifact-kinds/${encodeURIComponent(artifactKind)}/delivery-resolution`, { taskProjectSlug, taskId });
+        const body = await request(url2, { method: "POST" });
+        const { route, verdict } = deliveryResolutionResponseSchema.parse(body).data;
+        return { ok: true, route, verdict };
+      } catch (error51) {
+        if (error51 instanceof MrrlinApiError) {
+          const reason = CAPABILITY_ROUTE_RESOLUTION_REASON_BY_CODE[error51.code];
+          if (reason)
+            return { ok: false, reason, message: error51.message };
+        }
+        throw error51;
+      }
+    },
+    async recordCapabilityUse(projectSlug, input) {
+      const body = await request(`${projectPath(projectSlug)}/capability-uses`, {
+        body: JSON.stringify(input),
+        headers: { "content-type": "application/json" },
+        method: "POST"
+      });
+      return capabilityUseResponseSchema.parse(body).data;
+    },
     async listInboxItems(projectSlug, filters = {}) {
       const url2 = appendQuery(`${projectPath(projectSlug)}/inbox`, {
         groupId: filters.groupId,
@@ -42188,7 +42295,7 @@ Do NOT derail the current task - if the operator has an in-flight question, answ
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.4.42";
+var PKG_VERSION = "0.4.43";
 
 // src/api-base-url-migrate.ts
 var import_node_fs3 = __toESM(require("node:fs"), 1);
@@ -47598,6 +47705,35 @@ async function driveRun(deps, projectSlug, runId) {
     return legacy != null ? Math.min(legacy, remaining) : remaining;
   };
   const task = await deps.client.getTask(projectSlug, claimed.taskId);
+  if (task.declaredOutcome != null) {
+    for (const kind of task.declaredOutcome.requires) {
+      if (resolveKindCapability(kind) === null) {
+        await failRun(
+          deps,
+          projectSlug,
+          task,
+          runId,
+          leaseId,
+          `capability_not_routed: run ${runId} targets ${task.id}, which requires artifact kind "${kind}" -- that kind has no capability at all`,
+          "capability_not_routed"
+        );
+        return;
+      }
+      const routeResolution = await deps.client.resolveArtifactKindRoute(projectSlug, kind, projectSlug);
+      if (!routeResolution.ok) {
+        await failRun(
+          deps,
+          projectSlug,
+          task,
+          runId,
+          leaseId,
+          `capability_not_routed: run ${runId} targets ${task.id}, which requires artifact kind "${kind}" -- no route (${routeResolution.reason})`,
+          "capability_not_routed"
+        );
+        return;
+      }
+    }
+  }
   const blockerTasks = task.blockedBy.length ? await Promise.all(task.blockedBy.map((blockerTaskId) => deps.client.getTask(projectSlug, blockerTaskId))) : [];
   const missingBlockers = task.blockedBy.filter((_, index) => !blockerTasks[index]);
   if (missingBlockers.length > 0) {
@@ -57305,7 +57441,7 @@ async function startDirectorBridge() {
   const relayUrl = process.env.MRRLIN_RELAY_URL?.trim();
   const relayConfigured = Boolean(agentSecret && relayUrl);
   const buildReseedPrefix = async (args) => {
-    const refuse = (reason) => {
+    const refuse2 = (reason) => {
       bridgeLogger.logOut({
         spanId: "reseed",
         sessionId: args.directorSessionId,
@@ -57314,8 +57450,8 @@ async function startDirectorBridge() {
       });
       return NO_HISTORY_BLOCK;
     };
-    if (!resolveBridgeLogEnabled()) return refuse("log-disabled");
-    if (!resolvePromptsEnabled()) return refuse("prompts-not-logged");
+    if (!resolveBridgeLogEnabled()) return refuse2("log-disabled");
+    if (!resolvePromptsEnabled()) return refuse2("prompts-not-logged");
     const retentionWindowMs = readEnvInt("MRRLIN_LOG_RETENTION_AGE_DAYS", 30) * 864e5;
     const reseedWindowMs = Math.min(config2.idleThreadTtlMs, retentionWindowMs);
     if (reseedWindowMs < config2.idleThreadTtlMs) {
@@ -57334,13 +57470,13 @@ async function startDirectorBridge() {
     const sessionIds = [args.directorSessionId, ...args.priorSessionIds];
     const { lines: lines2, missingFiles } = await readSessionRows(import_node_path27.default.join(config2.stateDir, "logs"), files, sessionIds);
     const { items, skipped: skipped2 } = extractItems(lines2, sessionIds);
-    if (items.length === 0) return refuse("no-rows");
+    if (items.length === 0) return refuse2("no-rows");
     const budget = Math.max(0, Math.min(config2.reseedMaxTokens, config2.turnMaxTokens - args.otherBytes));
     const block = renderReseedBlock(items, {
       maxTokens: budget,
       minConversationalItems: config2.reseedMinItems
     });
-    if (!block) return refuse("below-minimum-after-truncation");
+    if (!block) return refuse2("below-minimum-after-truncation");
     bridgeLogger.logOut({
       spanId: "reseed",
       sessionId: args.directorSessionId,
@@ -61997,6 +62133,245 @@ async function resolveActivePanel(input, deps) {
   }
 }
 
+// src/delivery/wiki.ts
+async function deliverToWiki(client, projectSlug, payload) {
+  if (payload.operation === "create") return client.createWikiPage(projectSlug, payload.page);
+  return client.updateWikiPage(projectSlug, payload.pageId, payload.patch);
+}
+
+// src/delivery/git.ts
+async function deliverToGit(client, projectSlug, payload) {
+  if (payload.operation === "branch") {
+    return client.createGithubBranch(projectSlug, { baseBranch: payload.baseBranch, branchName: payload.branchName });
+  }
+  return client.createGithubPullRequest(projectSlug, {
+    baseBranch: payload.baseBranch,
+    body: payload.body,
+    draft: payload.draft,
+    headBranch: payload.headBranch,
+    title: payload.title
+  });
+}
+
+// src/delivery/index.ts
+async function deliverThroughCapability(client, input) {
+  if (resolveKindCapability(input.artifactKind) === null) {
+    return { ok: false, reason: "blocked_kind" };
+  }
+  let resolution;
+  try {
+    resolution = await client.resolveDeliveryForArtifactKind(
+      input.projectSlug,
+      input.artifactKind,
+      input.taskProjectSlug,
+      input.taskId ?? void 0
+    );
+  } catch {
+    return { ok: false, reason: "transport_error" };
+  }
+  if (!resolution.ok) {
+    return { ok: false, reason: resolution.reason };
+  }
+  const { route, verdict } = resolution;
+  if (verdict === "silent") {
+    return proceedToDestination(client, route, input);
+  }
+  if (verdict === "ask_once") {
+    return handleAskOnce(client, route, input);
+  }
+  if (verdict === "window") {
+    return handleWindow(client, route, input);
+  }
+  if (verdict === "approval") {
+    return handleApproval(client, route, input);
+  }
+  await recordUse(client, route, input, "refused");
+  return { ok: false, reason: "gate_refused" };
+}
+async function proceedToDestination(client, route, input) {
+  try {
+    const result = await callDestination(client, input.taskProjectSlug, route.capability, input.payload);
+    const recorded = await recordUse(client, route, input, "ok");
+    return { ok: true, use: recorded, result };
+  } catch {
+    await recordUse(client, route, input, "error");
+    return { ok: false, reason: "delivery_failed" };
+  }
+}
+async function refuse(client, route, input) {
+  await recordUse(client, route, input, "refused");
+  return { ok: false, reason: "gate_refused" };
+}
+async function handleAskOnce(client, route, input) {
+  const groupId = `capability:ask-once:${input.taskProjectSlug}:${route.serverId}`;
+  try {
+    await client.createInboxItem(input.taskProjectSlug, {
+      id: `II-capability-ask-once-${input.taskProjectSlug}-${route.serverId}`,
+      kind: "question",
+      origin: "capability",
+      groupId,
+      body: `The first write to ${route.serverId} (via ${route.toolName}) needs a one-time confirmation before it can proceed.`,
+      taskId: input.taskId
+    });
+  } catch {
+  }
+  return refuse(client, route, input);
+}
+async function alreadyConsumed(client, route, input, after) {
+  let uses;
+  try {
+    uses = await client.listCapabilityUses(input.taskProjectSlug);
+  } catch {
+    return true;
+  }
+  const afterMs = Date.parse(after);
+  if (!Number.isFinite(afterMs)) return true;
+  return uses.some((use) => {
+    if (use.serverId !== route.serverId || use.toolName !== route.toolName || use.taskId !== input.taskId || use.outcome !== "ok") {
+      return false;
+    }
+    const useAtMs = Date.parse(use.at);
+    if (!Number.isFinite(useAtMs)) return true;
+    return useAtMs > afterMs;
+  });
+}
+async function handleApproval(client, route, input) {
+  const scopeId = input.runId ?? input.taskId;
+  if (scopeId === null) {
+    return refuse(client, route, input);
+  }
+  const groupId = `capability:approval:${scopeId}:${route.serverId}:${route.toolName}`;
+  const id = `II-capability-approval-${scopeId}-${route.serverId}-${route.toolName}`;
+  let items;
+  try {
+    items = await client.listInboxItems(input.taskProjectSlug, { groupId });
+  } catch {
+    return refuse(client, route, input);
+  }
+  const existing = items[0];
+  if (!existing) {
+    try {
+      await client.createInboxItem(input.taskProjectSlug, {
+        id,
+        kind: "question",
+        origin: "capability",
+        groupId,
+        body: `Approve ${route.toolName} on ${route.serverId}?`,
+        taskId: input.taskId
+      });
+    } catch {
+    }
+    return refuse(client, route, input);
+  }
+  if (existing.status !== "approved") {
+    return refuse(client, route, input);
+  }
+  if (existing.decidedAt === null) {
+    return refuse(client, route, input);
+  }
+  if (await alreadyConsumed(client, route, input, existing.decidedAt)) {
+    return refuse(client, route, input);
+  }
+  return proceedToDestination(client, route, input);
+}
+async function handleWindow(client, route, input) {
+  if (input.taskId === null) {
+    return refuse(client, route, input);
+  }
+  const taskId = input.taskId;
+  const scopeId = input.runId ?? taskId;
+  const groupId = `capability:window:${scopeId}:${route.serverId}:${route.toolName}`;
+  const id = `II-capability-window-${scopeId}-${route.serverId}-${route.toolName}`;
+  let items;
+  try {
+    items = await client.listInboxItems(input.taskProjectSlug, { groupId });
+  } catch {
+    return refuse(client, route, input);
+  }
+  const existing = items[0];
+  if (!existing) {
+    try {
+      await client.createInboxItem(input.taskProjectSlug, {
+        id,
+        kind: "question",
+        origin: "capability",
+        groupId,
+        body: `Waiting for the ${route.toolName} window on ${route.serverId} to elapse.`,
+        taskId
+      });
+    } catch {
+    }
+    await extendFollowUpAt(client, input.taskProjectSlug, taskId);
+    return refuse(client, route, input);
+  }
+  if (existing.status === "rejected") {
+    return refuse(client, route, input);
+  }
+  let task;
+  try {
+    task = await client.getTask(input.taskProjectSlug, taskId);
+  } catch {
+    return refuse(client, route, input);
+  }
+  const elapsed = task.followUpAt !== null && Date.parse(task.followUpAt) <= Date.now();
+  if (!elapsed) {
+    return refuse(client, route, input);
+  }
+  if (await alreadyConsumed(client, route, input, existing.createdAt)) {
+    return refuse(client, route, input);
+  }
+  const result = await proceedToDestination(client, route, input);
+  if (result.ok) {
+    try {
+      await client.decideInboxItem(input.taskProjectSlug, existing.id, { verdict: "acknowledged", decidedBy: "system" });
+    } catch {
+    }
+  }
+  return result;
+}
+async function extendFollowUpAt(client, taskProjectSlug, taskId) {
+  try {
+    const task = await client.getTask(taskProjectSlug, taskId);
+    const existingMs = task.followUpAt !== null ? Date.parse(task.followUpAt) : -Infinity;
+    const candidateMs = Date.now() + 5 * 60 * 1e3;
+    if (candidateMs > existingMs) {
+      await client.updateTask(taskProjectSlug, taskId, { followUpAt: new Date(candidateMs).toISOString() });
+    }
+  } catch {
+  }
+}
+async function recordUse(client, route, input, outcome) {
+  try {
+    return await client.recordCapabilityUse(input.taskProjectSlug, {
+      serverId: route.serverId,
+      toolName: route.toolName,
+      taskId: input.taskId,
+      outcome
+    });
+  } catch {
+    return null;
+  }
+}
+async function callDestination(client, projectSlug, capability, payload) {
+  const operation = isRecord4(payload) ? payload.operation : void 0;
+  if (capability === "wiki") {
+    if (operation !== "create" && operation !== "update") {
+      throw new Error(`callDestination: payload.operation "${String(operation)}" is not valid for wiki`);
+    }
+    return deliverToWiki(client, projectSlug, payload);
+  }
+  if (capability === "git") {
+    if (operation !== "branch" && operation !== "pull_request") {
+      throw new Error(`callDestination: payload.operation "${String(operation)}" is not valid for git`);
+    }
+    return deliverToGit(client, projectSlug, payload);
+  }
+  throw new Error(`callDestination: no destination wired for capability "${capability}"`);
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null;
+}
+
 // src/decision-consensus.ts
 var ANCHOR_TIMEOUT_MS = Number(process.env["MRRLIN_DECISION_TIMEOUT_MS"] ?? 9e4);
 var PICK_TIMEOUT_MS3 = 15e3;
@@ -63040,7 +63415,7 @@ var import_node_path29 = require("node:path");
 function evidenceDedupKey(sessionId, reportId) {
   return `${sessionId}:${reportId}`;
 }
-function isRecord4(v) {
+function isRecord5(v) {
   return v !== null && typeof v === "object";
 }
 async function readDayLines(stateDir, day, sessionId) {
@@ -63059,7 +63434,7 @@ async function readDayLines(stateDir, day, sessionId) {
     } catch {
       continue;
     }
-    if (!isRecord4(rec) || !isRecord4(rec.payload)) continue;
+    if (!isRecord5(rec) || !isRecord5(rec.payload)) continue;
     if (rec.payload.directorSessionId !== sessionId) continue;
     kept.push(rec);
   }
@@ -63129,7 +63504,7 @@ async function assembleEvidence(stateDir, sessionId, reportId, gateCtx) {
       } catch {
         continue;
       }
-      if (!isRecord4(rec) || !Array.isArray(rec.daysRemoved)) continue;
+      if (!isRecord5(rec) || !Array.isArray(rec.daysRemoved)) continue;
       for (const removedDay of rec.daysRemoved) {
         if (daysRead.includes(removedDay)) {
           windowPruned = true;
@@ -64231,6 +64606,20 @@ function pingAsyncWorkerDispatch(projectSlug, jobId) {
   }).catch(() => {
   });
 }
+async function deliverBuiltIn(client, projectSlug, artifactKind, payload) {
+  const result = await deliverThroughCapability(client, {
+    projectSlug,
+    taskProjectSlug: projectSlug,
+    artifactKind,
+    taskId: null,
+    runId: null,
+    payload
+  });
+  if (!result.ok) {
+    throw new McpToolCodedError(`CAPABILITY_${result.reason.toUpperCase()}`, `Delivery refused: ${result.reason}`);
+  }
+  return result.result;
+}
 function makeTool(client, name, fallbackCode, fallbackMessage, handler) {
   return {
     description: mcpToolDescriptions[name],
@@ -64400,19 +64789,24 @@ function createMrrlinTools(options) {
       "Unable to bind project repository.",
       async (c, { projectSlug, ...input }) => await c.bindProjectGithubRepo(projectSlug, input)
     ),
+    // Task 8.2: routed through deliverBuiltIn, not c.createGithubBranch directly. artifactKind
+    // "code_change" (not "page"): this tool is a generic git operation, not specifically about
+    // publishing a website page (design.md, "`page` routes to git, not the wiki") -- there is no
+    // dedicated page-publishing tool in this change's scope, so a task requiring "page" has no path
+    // through these generic tools today, an accepted limitation of the current scope.
     [mcpToolNames.createGithubBranch]: makeTool(
       client,
       mcpToolNames.createGithubBranch,
       "GITHUB_BRANCH_CREATE_FAILED",
       "Unable to create GitHub branch.",
-      async (c, { projectSlug, ...input }) => await c.createGithubBranch(projectSlug, input)
+      async (c, { projectSlug, ...input }) => await deliverBuiltIn(c, projectSlug, "code_change", { operation: "branch", ...input })
     ),
     [mcpToolNames.createGithubPullRequest]: makeTool(
       client,
       mcpToolNames.createGithubPullRequest,
       "GITHUB_PULL_REQUEST_CREATE_FAILED",
       "Unable to create GitHub pull request.",
-      async (c, { projectSlug, ...input }) => await c.createGithubPullRequest(projectSlug, input)
+      async (c, { projectSlug, ...input }) => await deliverBuiltIn(c, projectSlug, "code_change", { operation: "pull_request", ...input })
     ),
     [mcpToolNames.createPlan]: makeTool(
       client,
@@ -64477,12 +64871,13 @@ function createMrrlinTools(options) {
       "Unable to append task event.",
       async (c, { projectSlug, taskId, ...input }) => await c.appendTaskEvent(projectSlug, taskId, input)
     ),
+    // Task 8.2: routed through deliverBuiltIn, not c.createWikiPage directly.
     [mcpToolNames.createWikiPage]: makeTool(
       client,
       mcpToolNames.createWikiPage,
       "WIKI_PAGE_CREATE_FAILED",
       "Unable to create wiki page.",
-      async (c, { projectSlug, ...input }) => await c.createWikiPage(projectSlug, input)
+      async (c, { projectSlug, ...input }) => await deliverBuiltIn(c, projectSlug, "document", { operation: "create", page: input })
     ),
     [mcpToolNames.deleteTaskDependency]: makeTool(
       client,
@@ -64665,12 +65060,13 @@ function createMrrlinTools(options) {
       "Unable to close task as won't-do.",
       async (c, { projectSlug, taskId, reason }) => await c.closeTaskAsWontDo(projectSlug, taskId, reason)
     ),
+    // Task 8.2: routed through deliverBuiltIn, not c.updateWikiPage directly.
     [mcpToolNames.updateWikiPage]: makeTool(
       client,
       mcpToolNames.updateWikiPage,
       "WIKI_PAGE_UPDATE_FAILED",
       "Unable to update wiki page.",
-      async (c, { projectSlug, pageId, ...patch }) => await c.updateWikiPage(projectSlug, pageId, patch)
+      async (c, { projectSlug, pageId, ...patch }) => await deliverBuiltIn(c, projectSlug, "document", { operation: "update", pageId, patch })
     ),
     [mcpToolNames.markSpecReady]: makeTool(
       client,
@@ -65515,7 +65911,7 @@ function parseArgs(args) {
   }
   return map2;
 }
-function isRecord5(v) {
+function isRecord6(v) {
   return v !== null && typeof v === "object";
 }
 async function runExtract(args, deps) {
@@ -65552,8 +65948,8 @@ Missing required flag(s): ${missing.join(
       } catch {
         continue;
       }
-      const payload = isRecord5(parsed) ? parsed.payload : void 0;
-      if (isRecord5(payload) && payload.directorSessionId === sessionId) {
+      const payload = isRecord6(parsed) ? parsed.payload : void 0;
+      if (isRecord6(payload) && payload.directorSessionId === sessionId) {
         matchingLines.push(line);
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrlin-dev/mcp",
-  "version": "0.4.42",
+  "version": "0.4.43",
   "type": "module",
   "bin": {
     "mrrlin-mcp": "dist/bin.cjs"
@@ -22,11 +22,11 @@
     "esbuild": "^0.24.0",
     "tsx": "^4.22.3",
     "@mrrlin/client": "0.0.0",
+    "@mrrlin/agent-client": "0.0.0",
+    "@mrrlin/director-e2e": "0.0.0",
     "@mrrlin/schemas": "0.0.0",
     "@mrrlin/tsconfig": "0.0.0",
-    "@mrrlin/wiki": "0.0.0",
-    "@mrrlin/director-e2e": "0.0.0",
-    "@mrrlin/agent-client": "0.0.0"
+    "@mrrlin/wiki": "0.0.0"
   },
   "dependencies": {
     "@iarna/toml": "^2.2.5",