Struct LatchRequest 

pub struct LatchRequest {
    pub nonce: String,
    pub command: String,
    pub paths: Vec<String>,
    pub hint: String,
    pub tool: String,
    pub argv: Vec<String>,
    pub ttl: u64,
    pub job_id: Option<u64>,
}

A pending confirmation-latch request, decoded from a latched ExecResult.

When the confirmation latch (set -o latch) gates a destructive operation, the kernel returns exit code 2 with this typed payload on the dedicated ExecResult::latch field. Embedders read it via ExecResult::latch_request — the seam to apply preapproval policy or a model review before approving the operation. It is deliberately not the data-plane ExecResult::data: a stdout redirect clears .data but never this control-plane signal, and it survives --json formatting (surfaced under a latch key in the error envelope).

To approve, re-run the same argv with --confirm=<nonce> (the hint shows the exact form). The nonce is command- and path-scoped, so it cannot authorize a different command or a path outside paths.

Fields

nonce: String

Confirmation nonce — pass back as --confirm=<nonce> on the same command.

command: String

The canonical command being gated (e.g. "rm", "kaish-trash empty"). A human/display label — for a precise machine replay use tool + argv.

paths: Vec<String>

The resolved paths the operation would touch. Empty for command-only ops.

hint: String

A ready-to-run confirmation command string (informational, for humans). Machine fulfillment should prefer Kernel::confirm (which replays the captured tool/argv); the hint is a display string and does not robustly quote paths with spaces or glob characters.

tool: String

The dispatch name of the gated tool (e.g. "rm", "kaish-trash"), as resolved at the dispatch seam — the argv0 for a replay via Kernel::execute_argv. Empty only when the latch was produced outside a dispatch (a direct tool.execute in a unit test).

argv: Vec<String>

The exact captured argv (ToolArgs::to_argv) of the gated invocation, minus the tool name and the --confirm nonce. Kernel::confirm prepends --confirm=<nonce> and replays execute_argv(tool, argv) — the highest-fidelity fulfillment, with no re-parsing of the hint.

ttl: u64

Seconds until the nonce expires.

job_id: Option<u64>

The id of the backgrounded job that raised this latch, if any — Some only when the gate came from a job the JobManager is tracking (rm x & reaching its gate), None for a foreground latch (the common case: rm x gated directly at the dispatch seam, no job involved).

Deliberately a bare u64, not a JobId: this crate (kaish-types) is a dependency-light leaf with no notion of JobId — that type lives in kaish-kernel’s scheduler module, which depends on kaish-types, not the other way around. kaish-kernel re-wraps this as JobId(id) at the two call sites that care ([JobManager]’s Job::latch() stamps it; Kernel::confirm reads it back to retire the originating job after a successful replay). Skipped on the wire when absent, so a foreground latch’s --json shape is unchanged.

Trait Implementations

impl Clone for LatchRequest

fn clone(&self) -> LatchRequest

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LatchRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LatchRequest

fn deserialize<__D>( __deserializer: __D, ) -> Result<LatchRequest, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for LatchRequest

impl PartialEq for LatchRequest

fn eq(&self, other: &LatchRequest) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for LatchRequest

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LatchRequest