Struct ShippedChecks 

pub struct ShippedChecks<F: RepositoryFacts> {
    pub can_apply_patches: bool,
    pub facts: F,
    pub arguments: Vec<OsString>,
    pub candidates: LifecycleContent,
    pub allowed_worktree_dirs: Vec<PathBuf>,
    pub content: ContentState,
    pub scanner_settings: ScannerSettings,
    pub scanner: ScannerState,
    pub markdown: MarkdownState,
}

What: The shipped policies over one invocation. <F: RepositoryFacts> says the record works with any one type F that provides the facts interface, chosen where the record is built: real Git in the executable, a script in tests. Why: Holding the provider by value keeps its remembered answers and its query count for the whole invocation, and lets a test read them back afterwards.

In TS you’d write (pseudocode):

type ShippedChecks<F extends RepositoryFacts> = { facts: F; arguments: string[]; candidates: LifecycleContent; allowedWorktreeDirs: string[]; content: ContentState; markdown: MarkdownState };

Fields

can_apply_patches: bool

Whether a pass may propose corrections that its caller applies; the commit path’s convergence sets it.

facts: F

Where repository facts come from.

arguments: Vec<OsString>

The command’s arguments without wrapper controls; for a direct command, the Git global options written before cli-git.

candidates: LifecycleContent

What the lifecycle offers content policies.

allowed_worktree_dirs: Vec<PathBuf>

Tool-cache directories exempt from linked-worktree enforcement.

content: ContentState

The candidates once a content policy prepared them, shared by every later one.

scanner_settings: ScannerSettings

Where the forbidden-strings rules come from: options and environment.

scanner: ScannerState

The forbidden-strings scanner once loaded, shared by every later scan.

markdown: MarkdownState

The Markdown autofix policy’s options, linter and exclude patterns.

Trait Implementations

impl<F: RepositoryFacts> PolicyChecks for ShippedChecks<F>

What: impl<F: RepositoryFacts> PolicyChecks for ShippedChecks<F> provides the engine’s interface for the shipped policies, for any facts provider F. Why: One match over the typed policy identity is the whole registry of behavior: the compiler refuses a policy without a check.

In TS you’d write (pseudocode):

check(policy: PolicyId, trigger: PolicyTrigger): Promise<PolicyOutcome> { switch (policy) { /* ... */ } }

fn check(&mut self, policy: PolicyId, trigger: Trigger) -> PolicyOutcome

What: The outcome of one policy at one lifecycle point. Why: Each arm calls the one check that owns the policy.

In TS you’d write (pseudocode):

check(policy: PolicyId, trigger: PolicyTrigger): PolicyOutcome;