policy

type AllowAll ¶

type AllowAll struct{}

AllowAll is a scaffold gate that permits everything. Equivalent to --dangerously-skip-permissions with no rules layered on top — use only in tests and local scaffolding, never as a shipped default.

func (AllowAll) Permit(ctx context.Context, call ports.ToolCall) (Decision, error)

type Decision ¶

type Decision int

const (
	Allow Decision = iota
	Ask
	Deny
)

func ParseDecision(s string) (Decision, error)

type DenyList ¶

type DenyList struct {
	Denied map[string]bool
}

DenyList denies any tool call whose name is in Denied, allows everything else. A minimal, illustrative precursor to the full rule engine.

func (d DenyList) Permit(ctx context.Context, call ports.ToolCall) (Decision, error)

type Gate ¶

type Gate interface {
	Permit(ctx context.Context, call ports.ToolCall) (Decision, error)
}

Gate is the port the agent loop calls before executing any tool call.

type Prompter ¶

type Prompter interface {
	Ask(ctx context.Context, call ports.ToolCall) (bool, error)
}

Prompter asks an operator to approve an Ask decision. The context carries the forced-ask timeout (deadline). Implementations are UI seams (T-031 TUI).

type Prompting ¶

type Prompting struct {
	Rules    *Rules
	Prompter Prompter // optional; nil → Ask becomes Deny
}

Prompting wraps a Rules engine with a Prompter, resolving Ask decisions interactively. It implements Gate. When Prompter is nil, Ask safely degrades to Deny (never silently allow).

func (p Prompting) Permit(ctx context.Context, call ports.ToolCall) (Decision, error)

type Rule ¶

type Rule struct {
	ToolGlob string // glob against the tool name; "" matches any
	PathGlob string // glob against a path argument; "" matches any/no path
	Decision Decision
}

Rule is one permission rule. A call matches if the tool name matches ToolGlob (empty = any tool) AND a path argument, if the rule specifies one, matches PathGlob (empty = any/no path). Rules are evaluated in list order; the last matching rule wins.

type Rules ¶

type Rules struct {
	Default Decision // decision when no rule matches
	List    []Rule
}

Rules is the rule engine. It implements Gate.

func NewRules(def Decision, toolRules, pathRules map[string]string) (*Rules, error)

func (r Rules) Permit(ctx context.Context, call ports.ToolCall) (Decision, error)

type Skip ¶

type Skip struct {
	Rules *Rules
}

Skip implements --dangerously-skip-permissions (T-024): an allow-all base where explicit rules still win, and prompts are skipped (Ask becomes Allow). It wraps a Rules engine whose Default is forced to Allow. Explicit Deny rules still deny; explicit Ask rules do not block. Use only for local/trusted runs.

func NewSkip(toolRules, pathRules map[string]string) (*Skip, error)

func (s Skip) Permit(ctx context.Context, call ports.ToolCall) (Decision, error)