Add agent tool domain types: ToolScope, ToolRiskLevel enums, ITaskdeckTool, ITaskdeckToolRegistry interfaces, and PolicyDecision value object

Part of #337 (AGT-02). These domain primitives define the tool
abstraction, scope/risk classification, and policy decision contract
that the Application layer policy evaluator and tool registry build on.

Author: Chris0Jeky

backend/src/Taskdeck.Domain/Agents/ITaskdeckTool.cs

@@ -0,0 +1,25 @@
+using Taskdeck.Domain.Enums;
+
+namespace Taskdeck.Domain.Agents;
+
+/// <summary>
+/// Describes a tool that an agent can invoke. Tools are registered in the
+/// tool registry and evaluated by the policy engine before execution.
+/// </summary>
+public interface ITaskdeckTool
+{
+    /// <summary>Unique machine-readable key (e.g. "inbox.triage", "board.create-card").</summary>
+    string Key { get; }
+
+    /// <summary>Human-readable display name shown in review UIs.</summary>
+    string DisplayName { get; }
+
+    /// <summary>Short description of what this tool does.</summary>
+    string Description { get; }
+
+    /// <summary>The operational scope this tool acts within.</summary>
+    ToolScope Scope { get; }
+
+    /// <summary>Risk classification used by the policy evaluator.</summary>
+    ToolRiskLevel RiskLevel { get; }
+}

backend/src/Taskdeck.Domain/Agents/ITaskdeckToolRegistry.cs

@@ -0,0 +1,22 @@
+using Taskdeck.Domain.Enums;
+
+namespace Taskdeck.Domain.Agents;
+
+/// <summary>
+/// Registry of all available agent tools. Populated at application startup
+/// and queried by the policy evaluator and agent templates.
+/// </summary>
+public interface ITaskdeckToolRegistry
+{
+    /// <summary>Register a tool. Throws if a tool with the same key is already registered.</summary>
+    void RegisterTool(ITaskdeckTool tool);
+
+    /// <summary>Look up a tool by its unique key. Returns null if not found.</summary>
+    ITaskdeckTool? GetTool(string key);
+
+    /// <summary>Return all registered tools.</summary>
+    IReadOnlyList<ITaskdeckTool> GetAllTools();
+
+    /// <summary>Return tools filtered by operational scope.</summary>
+    IReadOnlyList<ITaskdeckTool> GetToolsByScope(ToolScope scope);
+}

backend/src/Taskdeck.Domain/Agents/PolicyDecision.cs

@@ -0,0 +1,50 @@
+namespace Taskdeck.Domain.Agents;
+
+/// <summary>
+/// Value object representing the outcome of a policy evaluation for a tool use request.
+/// Immutable by design — once produced by the policy evaluator, a decision is final.
+/// </summary>
+public sealed class PolicyDecision
+{
+    /// <summary>Whether the tool invocation is allowed to proceed.</summary>
+    public bool Allowed { get; }
+
+    /// <summary>Whether the result must be routed through the review gate before applying.</summary>
+    public bool RequiresReview { get; }
+
+    /// <summary>Human-readable reason for the decision, suitable for audit trails.</summary>
+    public string Reason { get; }
+
+    private PolicyDecision(bool allowed, bool requiresReview, string reason)
+    {
+        Allowed = allowed;
+        RequiresReview = requiresReview;
+        Reason = reason;
+    }
+
+    /// <summary>Create a decision allowing execution but requiring proposal review.</summary>
+    public static PolicyDecision AllowWithReview(string reason)
+        => new(true, true, reason);
+
+    /// <summary>Create a decision denying execution entirely.</summary>
+    public static PolicyDecision Deny(string reason)
+        => new(false, false, reason);
+
+    /// <summary>Create a decision allowing direct execution (low-risk, auto-apply enabled).</summary>
+    public static PolicyDecision AllowDirect(string reason)
+        => new(true, false, reason);
+
+    public override bool Equals(object? obj)
+    {
+        if (obj is not PolicyDecision other) return false;
+        return Allowed == other.Allowed
+            && RequiresReview == other.RequiresReview
+            && Reason == other.Reason;
+    }
+
+    public override int GetHashCode()
+        => HashCode.Combine(Allowed, RequiresReview, Reason);
+
+    public override string ToString()
+        => $"PolicyDecision(Allowed={Allowed}, RequiresReview={RequiresReview}, Reason=\"{Reason}\")";
+}

backend/src/Taskdeck.Domain/Enums/ToolRiskLevel.cs

@@ -0,0 +1,18 @@
+namespace Taskdeck.Domain.Enums;
+
+/// <summary>
+/// Risk classification for agent tools. Determines policy evaluation behavior.
+/// High and Medium risk tools require review by default; Low risk tools
+/// are still review-first unless explicitly configured otherwise.
+/// </summary>
+public enum ToolRiskLevel
+{
+    /// <summary>Read-only or informational tools with no mutation side effects.</summary>
+    Low = 0,
+
+    /// <summary>Tools that create or update entities within a bounded scope.</summary>
+    Medium = 1,
+
+    /// <summary>Tools that delete, archive, or perform cross-scope mutations.</summary>
+    High = 2
+}

backend/src/Taskdeck.Domain/Enums/ToolScope.cs

@@ -0,0 +1,16 @@
+namespace Taskdeck.Domain.Enums;
+
+/// <summary>
+/// Defines the operational scope of an agent tool.
+/// </summary>
+public enum ToolScope
+{
+    /// <summary>Tool operates on a specific board (columns, cards, labels).</summary>
+    Board = 0,
+
+    /// <summary>Tool operates on the capture inbox (triage, categorization).</summary>
+    Inbox = 1,
+
+    /// <summary>Tool operates at workspace/global level (settings, cross-board).</summary>
+    Global = 2
+}