10x-delegate

10X Notion Team Skills - Delegation & RACI Matrix

Delegate tasks and manage responsibilities using the RACI framework.

RACI Framework

Role	Symbol	Description	Can Complete Task	Notified
Responsible	R	Does the work	Yes	Yes
Accountable	A	Final approver (only ONE per task)	Approves only	Yes
Consulted	C	Provides input before work	No	Yes
Informed	I	Kept updated on progress	No	Yes

Quick Commands

/10x-delegate "Design API endpoints" --to "John Doe" --raci R
/10x-delegate "Review API design" --to "Jane Smith" --raci A
/10x-delegate "Provide security input" --to "Security Team" --raci C
/10x-delegate "API progress update" --to "Product Team" --raci I

Delegation Commands

Basic Delegation

/10x-delegate "Complete user authentication" --to "John Doe" --raci R --due "2025-02-15"

Implementation:

// Parse arguments
const taskDescription = $ARGUMENTS.match(/"([^"]+)"/)?.[1];
const toUser = $ARGUMENTS.match(/--to\s+"([^"]+)"/)?.[1];
const raciType = $ARGUMENTS.match(/--raci\s+(\w)/)?.[1];
const dueDate = $ARGUMENTS.match(/--due\s+"([^"]+)"/)?.[1];
const priority = $ARGUMENTS.match(/--priority\s+(\w+)/)?.[1] || "Medium";

// Validate RACI type
const raciMap = {
  "R": "R - Responsible",
  "A": "A - Accountable",
  "C": "C - Consulted",
  "I": "I - Informed"
};

if (!raciMap[raciType.toUpperCase()]) {
  return "Invalid RACI type. Use R, A, C, or I";
}

// Get current user (delegator)
const currentUser = await getCurrentUser();

// Check delegation permission
if (!await checkPermission("delegate", currentUser.id)) {
  return "Permission denied: You don't have delegation rights";
}

// Get target user
const targetUser = await notion.databases.query({
  database_id: usersDbId,
  filter: { property: "Name", title: { equals: toUser }}
});

if (!targetUser.results.length) {
  return `User "${toUser}" not found`;
}

// Check if task exists or create new one
let task;
const existingTask = await notion.databases.query({
  database_id: tasksDbId,
  filter: { property: "Task Name", title: { equals: taskDescription }}
});

if (existingTask.results.length) {
  task = existingTask.results[0];
} else {
  // Create new task
  task = await notion.pages.create({
    parent: { database_id: tasksDbId },
    properties: {
      "Task Name": { title: [{ text: { content: taskDescription }}] },
      "Status": { select: { name: "To Do" }},
      "Priority": { select: { name: priority }},
      "Date": dueDate ? { date: { start: dueDate }} : undefined,
      "Assigned To": { relation: [{ id: targetUser.results[0].id }] },
      "Delegated By": { relation: [{ id: currentUser.id }] },
      "RACI Role": { select: { name: raciMap[raciType.toUpperCase()] }},
      "Delegation Date": { date: { start: new Date().toISOString().split('T')[0] }},
      "Team": currentUser.properties["Primary Team"]?.relation?.[0] ?
        { relation: [{ id: currentUser.properties["Primary Team"].relation[0].id }] } : undefined
    }
  });
}

// Create RACI assignment
const raciAssignment = await notion.pages.create({
  parent: { database_id: raciAssignmentsDbId },
  properties: {
    "Name": { title: [{ text: { content: `${taskDescription} - ${toUser}` }}] },
    "RACI Type": { select: { name: raciMap[raciType.toUpperCase()] }},
    "Status": { select: { name: "Active" }},
    "Assignment Date": { date: { start: new Date().toISOString().split('T')[0] }},
    "Due Date": dueDate ? { date: { start: dueDate }} : undefined,
    "Priority": { select: { name: priority }},
    "User": { relation: [{ id: targetUser.results[0].id }] },
    "Task": { relation: [{ id: task.id }] },
    "Assigned By": { relation: [{ id: currentUser.id }] }
  }
});

// Log audit event
await logAuditEvent("Delegate", "Task", task.id, taskDescription, null, {
  assignedTo: toUser,
  raciType: raciMap[raciType.toUpperCase()],
  dueDate
});

return `
✅ Task Delegated Successfully!

Task: ${taskDescription}
Assigned To: ${toUser}
RACI Role: ${raciMap[raciType.toUpperCase()]}
Due Date: ${dueDate || "Not set"}
Priority: ${priority}

${toUser} will be notified of this assignment.
`;

Multi-RACI Assignment

Assign multiple RACI roles for a single task:

/10x-delegate "Launch new product" --multi
  --responsible "Product Team"
  --accountable "VP Product"
  --consulted "Legal Team, Marketing"
  --informed "CEO, Board"

Implementation:

// Parse multi-assignment
const taskDescription = $ARGUMENTS.match(/"([^"]+)"/)?.[1];
const responsible = $ARGUMENTS.match(/--responsible\s+"([^"]+)"/)?.[1];
const accountable = $ARGUMENTS.match(/--accountable\s+"([^"]+)"/)?.[1];
const consulted = $ARGUMENTS.match(/--consulted\s+"([^"]+)"/)?.[1]?.split(",").map(s => s.trim());
const informed = $ARGUMENTS.match(/--informed\s+"([^"]+)"/)?.[1]?.split(",").map(s => s.trim());

// Validate: only ONE accountable
if (!accountable) {
  return "Error: Every task must have exactly ONE Accountable person";
}

// Create task
const task = await notion.pages.create({
  parent: { database_id: tasksDbId },
  properties: {
    "Task Name": { title: [{ text: { content: taskDescription }}] },
    "Status": { select: { name: "To Do" }},
    "Requires Approval": { checkbox: true }
  }
});

const assignments = [];

// Assign Responsible
if (responsible) {
  const users = responsible.split(",").map(s => s.trim());
  for (const userName of users) {
    const user = await findUser(userName);
    if (user) {
      await createRaciAssignment(task.id, user.id, "R - Responsible", taskDescription);
      assignments.push({ user: userName, role: "R" });
    }
  }
}

// Assign Accountable (only one)
const accUser = await findUser(accountable);
if (accUser) {
  await createRaciAssignment(task.id, accUser.id, "A - Accountable", taskDescription);
  assignments.push({ user: accountable, role: "A" });

  // Set as approver on task
  await notion.pages.update({
    page_id: task.id,
    properties: {
      "Approved By": { relation: [{ id: accUser.id }] }
    }
  });
}

// Assign Consulted
if (consulted) {
  for (const userName of consulted) {
    const user = await findUser(userName);
    if (user) {
      await createRaciAssignment(task.id, user.id, "C - Consulted", taskDescription);
      assignments.push({ user: userName, role: "C" });
    }
  }
}

// Assign Informed
if (informed) {
  for (const userName of informed) {
    const user = await findUser(userName);
    if (user) {
      await createRaciAssignment(task.id, user.id, "I - Informed", taskDescription);
      assignments.push({ user: userName, role: "I" });
    }
  }
}

return `
✅ RACI Matrix Created for: ${taskDescription}

${assignments.map(a => `[${a.role}] ${a.user}`).join('\n')}

Total assignments: ${assignments.length}
`;

Escalation

Escalate a blocked or delayed task:

/10x-delegate escalate "API Design" --reason "Blocked by dependencies" --to "Manager"

Implementation:

const taskName = $ARGUMENTS.match(/escalate\s+"([^"]+)"/)?.[1];
const reason = $ARGUMENTS.match(/--reason\s+"([^"]+)"/)?.[1];
const escalateTo = $ARGUMENTS.match(/--to\s+"([^"]+)"/)?.[1];

// Find task
const task = await notion.databases.query({
  database_id: tasksDbId,
  filter: { property: "Task Name", title: { equals: taskName }}
});

if (!task.results.length) {
  return `Task "${taskName}" not found`;
}

// Get escalation target
const manager = await findUser(escalateTo);
if (!manager) {
  return `User "${escalateTo}" not found`;
}

// Update task status
await notion.pages.update({
  page_id: task.results[0].id,
  properties: {
    "Status": { select: { name: "Blocked" }},
    "Delegation Notes": { rich_text: [{ text: { content: `ESCALATED: ${reason}` }}] }
  }
});

// Create escalation RACI assignment
await notion.pages.create({
  parent: { database_id: raciAssignmentsDbId },
  properties: {
    "Name": { title: [{ text: { content: `ESCALATION: ${taskName}` }}] },
    "RACI Type": { select: { name: "A - Accountable" }},
    "Status": { select: { name: "Active" }},
    "Priority": { select: { name: "Critical" }},
    "User": { relation: [{ id: manager.id }] },
    "Task": { relation: [{ id: task.results[0].id }] },
    "Notes": { rich_text: [{ text: { content: reason }}] }
  }
});

// Log audit event
await logAuditEvent("Escalate", "Task", task.results[0].id, taskName, null, {
  escalatedTo: escalateTo,
  reason
});

return `
⚠️ Task Escalated!

Task: ${taskName}
Escalated To: ${escalateTo}
Reason: ${reason}

${escalateTo} has been notified and assigned as Accountable.
`;

RACI Matrix View

View RACI for a Project/Goal

/10x-delegate raci-matrix --project "Q1 Product Launch"

Output:

┌──────────────────────────┬───────────┬───────────┬───────────┬───────────┐
│ Task/Deliverable         │ Product   │ Eng Lead  │ Marketing │ CEO       │
├──────────────────────────┼───────────┼───────────┼───────────┼───────────┤
│ Requirements Doc         │     R     │     C     │     C     │     I     │
│ Technical Design         │     C     │     R     │     I     │     I     │
│ Development              │     A     │     R     │     I     │     I     │
│ QA Testing               │     C     │     R     │     I     │     I     │
│ Marketing Materials      │     C     │     I     │     R     │     A     │
│ Launch Announcement      │     A     │     I     │     R     │     I     │
│ Post-Launch Review       │     R     │     R     │     R     │     A     │
└──────────────────────────┴───────────┴───────────┴───────────┴───────────┘

Legend: R=Responsible, A=Accountable, C=Consulted, I=Informed

View My RACI Assignments

/10x-delegate my-assignments

Implementation:

const currentUser = await getCurrentUser();

const assignments = await notion.databases.query({
  database_id: raciAssignmentsDbId,
  filter: {
    and: [
      { property: "User", relation: { contains: currentUser.id }},
      { property: "Status", select: { equals: "Active" }}
    ]
  },
  sorts: [
    { property: "Priority", direction: "ascending" },
    { property: "Due Date", direction: "ascending" }
  ]
});

// Group by RACI type
const grouped = {
  "R - Responsible": [],
  "A - Accountable": [],
  "C - Consulted": [],
  "I - Informed": []
};

for (const assignment of assignments.results) {
  const raciType = assignment.properties["RACI Type"].select.name;
  grouped[raciType].push({
    name: assignment.properties.Name.title[0].plain_text,
    dueDate: assignment.properties["Due Date"]?.date?.start,
    priority: assignment.properties.Priority.select?.name
  });
}

return `
📋 Your RACI Assignments

🔴 RESPONSIBLE (You do the work):
${grouped["R - Responsible"].map(a => `  • ${a.name} ${a.dueDate ? `(Due: ${a.dueDate})` : ""}`).join('\n') || "  None"}

🟠 ACCOUNTABLE (You approve):
${grouped["A - Accountable"].map(a => `  • ${a.name} ${a.dueDate ? `(Due: ${a.dueDate})` : ""}`).join('\n') || "  None"}

🟡 CONSULTED (Provide input):
${grouped["C - Consulted"].map(a => `  • ${a.name}`).join('\n') || "  None"}

🟢 INFORMED (Stay updated):
${grouped["I - Informed"].map(a => `  • ${a.name}`).join('\n') || "  None"}

Total: ${assignments.results.length} active assignments
`;

Approval Workflow

Request Approval

When a Responsible user completes work:

/10x-delegate complete "API Design" --request-approval

Implementation:

const taskName = $ARGUMENTS.match(/complete\s+"([^"]+)"/)?.[1];
const currentUser = await getCurrentUser();

// Find task
const task = await notion.databases.query({
  database_id: tasksDbId,
  filter: { property: "Task Name", title: { equals: taskName }}
});

// Find the Accountable person
const raciAccountable = await notion.databases.query({
  database_id: raciAssignmentsDbId,
  filter: {
    and: [
      { property: "Task", relation: { contains: task.results[0].id }},
      { property: "RACI Type", select: { equals: "A - Accountable" }}
    ]
  }
});

if (!raciAccountable.results.length) {
  // No accountable - auto-complete
  await notion.pages.update({
    page_id: task.results[0].id,
    properties: {
      "Status": { select: { name: "Done" }}
    }
  });
  return "Task marked as complete (no approval required)";
}

// Update task to pending approval
await notion.pages.update({
  page_id: task.results[0].id,
  properties: {
    "Status": { select: { name: "In Progress" }},
    "Requires Approval": { checkbox: true }
  }
});

// Update RACI assignment
await notion.pages.update({
  page_id: raciAccountable.results[0].id,
  properties: {
    "Notes": { rich_text: [{ text: { content: `Pending approval from ${currentUser.properties.Name.title[0].plain_text}` }}] }
  }
});

const accountableUser = raciAccountable.results[0].properties.User.relation[0];
const userName = await notion.pages.retrieve({ page_id: accountableUser.id });

return `
📝 Approval Requested

Task: ${taskName}
Submitted by: You
Approval pending from: ${userName.properties.Name.title[0].plain_text}

The Accountable person will review and approve.
`;

Approve/Reject

When an Accountable user reviews:

/10x-delegate approve "API Design"
/10x-delegate reject "API Design" --reason "Needs more detail"

Permission Rules for Delegation

Action	Super Admin	Admin	Dept Head	Team Lead	Sr Member	Member
Delegate to anyone in org	✅	✅	❌	❌	❌	❌
Delegate within department	✅	✅	✅	❌	❌	❌
Delegate within team	✅	✅	✅	✅	✅	❌
Set Accountable	✅	✅	✅	✅	❌	❌
Escalate tasks	✅	✅	✅	✅	✅	✅
Approve tasks	✅	✅	✅	✅	❌	❌

Helper Functions

async function findUser(nameOrId) {
  // Try by name first
  let user = await notion.databases.query({
    database_id: usersDbId,
    filter: { property: "Name", title: { equals: nameOrId }}
  });

  if (user.results.length) return user.results[0];

  // Try by Skill ID
  user = await notion.databases.query({
    database_id: usersDbId,
    filter: { property: "Skill ID", rich_text: { equals: nameOrId }}
  });

  return user.results[0] || null;
}

async function createRaciAssignment(taskId, userId, raciType, taskDescription) {
  const user = await notion.pages.retrieve({ page_id: userId });
  const userName = user.properties.Name.title[0].plain_text;

  return notion.pages.create({
    parent: { database_id: raciAssignmentsDbId },
    properties: {
      "Name": { title: [{ text: { content: `${taskDescription} - ${userName}` }}] },
      "RACI Type": { select: { name: raciType }},
      "Status": { select: { name: "Active" }},
      "Assignment Date": { date: { start: new Date().toISOString().split('T')[0] }},
      "User": { relation: [{ id: userId }] },
      "Task": { relation: [{ id: taskId }] },
      "Assigned By": { relation: [{ id: (await getCurrentUser()).id }] }
    }
  });
}

async function checkDelegationScope(currentUser, targetUser) {
  const currentRole = await getUserRole(currentUser);
  const scope = currentRole.properties.Scope.select.name;

  switch (scope) {
    case "Organization":
      return true; // Can delegate to anyone
    case "Department":
      return currentUser.properties.Department?.relation?.[0]?.id ===
             targetUser.properties.Department?.relation?.[0]?.id;
    case "Team":
      return currentUser.properties["Primary Team"]?.relation?.[0]?.id ===
             targetUser.properties["Primary Team"]?.relation?.[0]?.id;
    case "Self":
      return false; // Cannot delegate
    default:
      return false;
  }
}

Troubleshooting

"Cannot delegate to this user" → Your role scope doesn't allow delegation to users outside your team/department → Contact an Admin to make cross-team assignments

"Task already has an Accountable person" → Each task can only have ONE Accountable person → Remove existing Accountable assignment first

"Permission denied for approval" → Only Accountable users can approve tasks → Check your RACI assignment

Version

Skill Version: 2.0.0 Required Role: Team Lead (for delegation), varies for other actions Compatible with: Notion MCP Server 1.0+