effort

type ActionableOutcome ¶

type ActionableOutcome struct {
	Category        string   `json:"category"`
	Condition       string   `json:"condition"`
	ChangedActivity bool     `json:"changedActivity"`
	NextActions     []string `json:"nextActions"`
	Cause           string   `json:"cause,omitempty"`
}

ActionableOutcome describes a handled refusal and independently executable recovery actions.

type Activity ¶

type Activity struct {
	SchemaVersion int       `json:"schemaVersion"`
	Owner         string    `json:"owner"`
	AttachedAt    time.Time `json:"attachedAt"`
	HeartbeatAt   time.Time `json:"heartbeatAt"`
}

Activity is the optional protocol-v2 advisory claim.

type ActivityCondition ¶

type ActivityCondition string

ActivityCondition identifies the handled protocol-v2 activity result.

const (
	// ActivityAttached reports that the invocation attached a new activity.
	ActivityAttached ActivityCondition = "attached"
	// ActivityTakenOver reports that the invocation replaced a prior activity.
	ActivityTakenOver ActivityCondition = "taken-over"
	// ActivityHeartbeat reports that the invocation refreshed its activity.
	ActivityHeartbeat ActivityCondition = "heartbeat"
	// ActivityDetached reports that the invocation removed its activity.
	ActivityDetached ActivityCondition = "detached"
	// ActivityNotOwner reports that the resident belongs to another owner.
	ActivityNotOwner ActivityCondition = "not-owner"
	// ActivityMissing reports that the requested effort or activity is absent.
	ActivityMissing ActivityCondition = "missing"
	// ActivityInvalidMemory reports that the effort memory is unreadable or invalid.
	ActivityInvalidMemory ActivityCondition = "invalid-memory"
	// ActivityUnsafeResident reports that a resident cannot be safely used.
	ActivityUnsafeResident ActivityCondition = "unsafe-resident"
)

type ActivityEffort ¶

type ActivityEffort struct {
	Slug  string `json:"slug"`
	Title string `json:"title"`
}

ActivityEffort is the immutable effort identity included in successful replies.

type ActivityReply ¶

type ActivityReply struct {
	SchemaVersion int                `json:"schemaVersion"`
	Condition     ActivityCondition  `json:"condition"`
	Effort        *ActivityEffort    `json:"effort,omitempty"`
	Memory        *MemoryMetadata    `json:"memory,omitempty"`
	Activity      *Activity          `json:"activity,omitempty"`
	Outcome       *ActionableOutcome `json:"outcome,omitempty"`
}

ActivityReply is the protocol-v2 envelope returned by activity operations.

type CorruptError ¶

type CorruptError struct {
	Path string
	Err  error
}

CorruptError identifies resident input that must be preserved byte-for-byte.

func (e *CorruptError) Diagnostic() (presentation.Diagnostic, error)

func (e *CorruptError) Error() string

func (e *CorruptError) Unwrap() error

type Dependencies ¶

type Dependencies struct {
	Clock        func() time.Time
	UUID         func() (string, error)
	Worktrees    func(context.Context) ([]awfgit.WorktreeRegistration, error)
	BranchExists func(context.Context, string) (bool, error)
	ValidateRef  func(context.Context, string) (bool, error)
	RemoveTree   func(string) error
	// Fault is the durability-boundary hook the restartable-finish tests
	// interrupt the service at. It is the one optional member: a nil Fault
	// injects nothing, which is what production wants and what "no fault
	// injection configured" means.
	Fault func(stage string) error
}

Dependencies is everything the service reaches the outside world through: the clock, the identity allocator, the three Git questions it asks, and tree removal. Every one is supplied by the composition root, because a service that quietly substituted its own would make what a caller composed unverifiable from the call site.

The Git dependencies are stated as this package's own questions rather than as a repository object, so the service depends on what it asks and not on who answers. Each is bound to the checkout the service was opened against, so none of them names a root.

type FinishResult ¶

type FinishResult struct {
	Renamed bool
	Cleaned bool
}

FinishResult reports the restartable deletion mutations separately.

func (r FinishResult) FinishMutation(slug string) (presentation.Mutation, error)

type InvalidMemoryError ¶

type InvalidMemoryError struct {
	Slug       string
	NextAction string
	Err        error
}

InvalidMemoryError reports a memory which could not safely be updated. A caller can use NextAction directly without trying to interpret parser prose.

func (e *InvalidMemoryError) Diagnostic() (presentation.Diagnostic, error)

func (e *InvalidMemoryError) Error() string

func (e *InvalidMemoryError) Unwrap() error

type MemoryMetadata ¶

type MemoryMetadata struct {
	Effort  string `json:"effort"`
	Phase   string `json:"phase"`
	Next    string `json:"next"`
	Updated string `json:"updated"`
}

MemoryMetadata is the closed, mutable header of an owned memory file.

type MemoryUpdate ¶

type MemoryUpdate struct {
	Phase *string
	Next  *string
}

MemoryUpdate names the mutable fields requested by a structured update.

type NewInput ¶

type NewInput struct {
	Slug  string
	Title string
}

NewInput carries the caller-selected immutable identity and independent descriptive title for one effort creation.

type PartialFinishError ¶

type PartialFinishError struct {
	Result  FinishResult
	Cause   error
	Actions []RecoveryAction
}

PartialFinishError preserves a failed restartable finish's observed state, mechanism cause, and site-specific recovery actions.

func (e *PartialFinishError) Diagnostic() (presentation.Diagnostic, error)

func (e *PartialFinishError) Error() string

func (e *PartialFinishError) Unwrap() error

type Record ¶

type Record struct {
	SchemaVersion int       `json:"-"`
	ID            string    `json:"id"`
	Slug          string    `json:"slug"`
	Title         string    `json:"title"`
	CreatedAt     time.Time `json:"createdAt"`
	MemoryPath    string    `json:"memoryPath"`
}

Record is the public protocol-2 effort view. SchemaVersion belongs to the containing reply, while static state carries it directly.

func (r Record) Detail() (presentation.Detail, error)

func (r Record) NewEffortMutation(mutation presentation.Mutation) (presentation.Mutation, error)

type RecoveryAction ¶

type RecoveryAction struct{ Text string }

RecoveryAction is one independently executable ordered remedy for a failed effort operation. Its meaning remains model-owned until presentation maps it.

type Service ¶

type Service struct {
	// contains filtered or unexported fields
}

Service owns immutable effort residents and restartable finish.

func Open(roots awfgit.ControlRoots, deps Dependencies) (*Service, error)

func (s *Service) AttachActivity(slug, owner string) ActivityReply

func (s *Service) DetachActivity(slug, owner string) ActivityReply

func (s *Service) Finish(ctx context.Context, slug string) (FinishResult, error)

func (s *Service) HeartbeatActivity(slug, owner string) ActivityReply

func (s *Service) InvokingRoot() string

func (s *Service) List() ([]Record, error)

func (s *Service) New(ctx context.Context, input NewInput) (Record, error)

func (s *Service) Show(slug string) (Record, error)

func (s *Service) UpdateMemory(slug string, update MemoryUpdate) error