Enum Op 

pub enum Op {
    RepoInit {
        repo: String,
        daemon_key: String,
        human: String,
        human_key: HumanKey,
        policy: GitId,
        trunk: GitId,
    },
    HumanEnroll {
        human: String,
        key: HumanKey,
    },
    HumanRotate {
        human: String,
        key: HumanKey,
    },
    HumanRevoke {
        human: String,
        reason: String,
    },
    HumanRecoveryKey {
        human: String,
        key: HumanKey,
    },
    HumanRecover {
        human: String,
        key: HumanKey,
    },
    DaemonRotate {
        key: String,
    },
    DaemonRecover {
        key: String,
        recover: Option<Recovery>,
    },
    PolicyUpdate {
        policy: GitId,
    },
    SessionStart {
        session: String,
        agent: String,
        model: Option<String>,
        task: String,
        scope: Scope,
        expires_ms: i64,
        continues: Option<Continuation>,
        harness: Option<String>,
    },
    SessionBind {
        session: String,
        checks: BindChecks,
        level: ObservationLevel,
    },
    SessionIsolate {
        session: String,
        sandbox: String,
        profile: String,
    },
    SessionEnd {
        session: String,
        reason: String,
    },
    CapAttenuate {
        parent: String,
        child: String,
        agent: String,
        scope: Scope,
        expires_ms: i64,
        leases: Vec<String>,
    },
    CapRevoke {
        session: String,
        reason: String,
    },
    LeaseAcquire {
        set: String,
        items: Vec<LeaseItem>,
        intent: String,
        ttl_ms: i64,
    },
    LeaseRelease {
        set: String,
    },
    LeaseRenew {
        set: String,
        ttl_ms: i64,
    },
    LeaseInterest {
        items: Vec<LeaseItem>,
        intent: String,
    },
    ChangePropose {
        change: ChangeId,
        commit: GitId,
        base: GitId,
        claim: Claim,
    },
    ChangeWithdraw {
        change: ChangeId,
    },
    ChangeIntegrate {
        change: ChangeId,
        trunk_before: GitId,
        merged: Option<GitId>,
        conflicts: Vec<String>,
    },
    ChangeIntegrateBatch {
        trunk_before: GitId,
        merged: Vec<(ChangeId, GitId)>,
    },
    Approve {
        target_seq: u64,
        note: String,
        checks: Vec<String>,
    },
    Reject {
        target_seq: u64,
        reason: String,
    },
    Observe {
        session: String,
        events: Vec<Observation>,
    },
    Taint {
        session: String,
        reason: String,
    },
    ImportExternal {
        remote: String,
        commit: GitId,
        trunk_before: GitId,
    },
    ImportUnmediated {
        refname: String,
        found: Option<GitId>,
        expected: Option<GitId>,
    },
    BridgePush {
        remote: String,
        oplog_seq: u64,
        oplog_hash: String,
    },
    Freeze {
        reason: String,
    },
    Unfreeze {
        reason: String,
    },
    Negotiate {
        thread: String,
        to_session: String,
        message: NegotiationMsg,
    },
    Redact {
        blob: GitId,
        reason: String,
    },
}

Variants

RepoInit

Fields

repo: String

daemon_key: String

human: String

human_key: HumanKey

policy: GitId

trunk: GitId

HumanEnroll

Fields

human: String

key: HumanKey

HumanRotate

Replaces the signer’s own key. Signed with the current key.

Fields

human: String

key: HumanKey

HumanRevoke

Withdraws a human’s keys and everything they set in motion.

Fields

human: String

reason: String

HumanRecoveryKey

Sets (or replaces) the signer’s recovery key, kept off the machine. Signed with the current key.

Fields

human: String

key: HumanKey

HumanRecover

Replaces a lost key. Signed with the human’s recovery key, which is used up by it.

Fields

human: String

key: HumanKey

DaemonRotate

Replaces the daemon key (Ed25519, hex). Signed by the old daemon key and by a human; later entries are signed by the new key.

Fields

key: String

DaemonRecover

Re-anchors the log on a new daemon key when the old one is gone (or belongs to a daemon that is being replaced). Signed by the new key and by a human: with the human’s key, or, with recover, with their recovery key, when the Mac that held both keys is lost (log format 27).

Fields

key: String

recover: Option<Recovery>

PolicyUpdate

Fields

policy: GitId

SessionStart

Fields

session: String

agent: String

model: Option<String>

task: String

scope: Scope

expires_ms: i64

continues: Option<Continuation>

The session whose workspace this one takes over.

harness: Option<String>

The harness the human runs the session under. Their word, and the only one an observation level is read for (format 20).

SessionBind

Fields

session: String

checks: BindChecks

level: ObservationLevel

SessionIsolate

A human’s word that the session runs in a sandbox Lonca built: what gives it level: isolated. Never from the agent, and never from the daemon, which can not see the sandbox: the launcher builds it and the human who started the session signs for it.

Fields

session: String

sandbox: String

The kind of sandbox (seatbelt, bwrap).

profile: String

SHA-256 of the sandbox’s definition, lowercase hex.

SessionEnd

Fields

session: String

reason: String

CapAttenuate

Fields

parent: String

child: String

agent: String

scope: Scope

expires_ms: i64

leases: Vec<String>

Lease sets the parent hands to the child; they come back when the child ends.

CapRevoke

Fields

session: String

reason: String

LeaseAcquire

Fields

set: String

items: Vec<LeaseItem>

intent: String

ttl_ms: i64

LeaseRelease

Fields

set: String

LeaseRenew

Fields

set: String

ttl_ms: i64

LeaseInterest

Holds nothing: when what conflicts with items is freed, the oldest interest gets a short reservation. Until then, for a limited time, no new lease can be taken that conflicts with items.

Fields

items: Vec<LeaseItem>

intent: String

ChangePropose

Fields

change: ChangeId

commit: GitId

base: GitId

claim: Claim

ChangeWithdraw

Fields

change: ChangeId

ChangeIntegrate

Fields

change: ChangeId

trunk_before: GitId

merged: Option<GitId>

The merged trunk commit, or None when the merge conflicted.

conflicts: Vec<String>

ChangeIntegrateBatch

Changes at the head of the queue, integrated at once. One entry, so that a crash can not leave trunk at a state nothing verified: the evidence is of the last commit, and trunk moves straight to it. The commits before it are in its history and were never trunk.

Fields

trunk_before: GitId

merged: Vec<(ChangeId, GitId)>

Each change, in queue order, with the commit it merged to.

Approve

checks: named checks of verification.checks the change owes from here on, besides what it owed already; only on a proposal (log format 25). Sorted, each name once.

Fields

target_seq: u64

note: String

checks: Vec<String>

Reject

A human declines an escalated operation; the reason is for the requester (a worker fixes and proposes again) and is never interpreted.

Fields

target_seq: u64

reason: String

Observe

Fields

session: String

events: Vec<Observation>

Taint

Fields

session: String

reason: String

ImportExternal

Fields

remote: String

commit: GitId

trunk_before: GitId

ImportUnmediated

Fields

refname: String

found: Option<GitId>

expected: Option<GitId>

BridgePush

Fields

remote: String

oplog_seq: u64

oplog_hash: String

Freeze

Fields

reason: String

Unfreeze

Fields

reason: String

Negotiate

Fields

thread: String

to_session: String

message: NegotiationMsg

Redact

Fields

blob: GitId

reason: String

Implementations

impl Op

pub fn kind(&self) -> OpKind

pub fn signed_by_recovery_key(&self) -> bool

Whether the human’s recovery key signs this operation, not their current key: human.recover, and daemon.recover with recover.

pub fn daemon_key_switch(&self) -> Option<&str>

The daemon key this operation installs, if it is a key switch.

Trait Implementations

impl Clone for Op

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Op

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Op

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Op

impl PartialEq for Op

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Op

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Op