Seat Continuity And Handover logo

Seat Continuity And Handover

CommunityPopular
mvschwarz
seat-continuity-and-handover

Use when replacing a seat's occupant (rebuild/handover/swap), reasoning about stable-seat-identity vs fluid-occupant-identity, choosing an old-occupant disposition (retire/advise/shadow), or recording provenance for an occupant change. Two independent outcomes (continuityOutcome + seatBindingOutcome) and the 5 failure modes that prevent silent dishonesty.

Overview

Publishermvschwarz
Repositoryopenrig
Skill nameseat-continuity-and-handover
Stars
5K
Forks
366
Bundled files
3
LicenseApache-2.0
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 3 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by mvschwarz on GitHub. Read the source before you install it.

Installation

Install the Seat Continuity And Handover AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/mvschwarz/openrig/tree/main/packages/daemon/assets/plugins/openrig-core/skills/seat-continuity-and-handover
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/mvschwarz/openrig.git /tmp/openrig
mkdir -p .claude/skills
cp -r /tmp/openrig/packages/daemon/assets/plugins/openrig-core/skills/seat-continuity-and-handover .claude/skills/seat-continuity-and-handover
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Seat Continuity And Handover in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Seat Continuity And Handover on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Seat Continuity And Handover is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Seat Continuity and Handover

A pair of primitive families that separate who is sitting in a seat from what the seat itself is:

  1. Occupant-creation primitives — resume, fork, rebuild, fresh — produce a candidate new occupant. Answer: "where did the new occupant come from?"
  2. Seat-binding operations — handover binds a candidate occupant into the topology. Answer: "what happened to the stable seat identity?" Inspect the current CLI for executable operations; design vocabulary alone does not establish a command.

Core architectural decision: stable seat identity, fluid occupant identity, explicit provenance. Do not encode successive occupants into live seat names. Keep the stable address and record lineage separately.

Use this when

  • Replacing a seat's occupant via rebuild, fork, fresh, or seat-handover
  • Choosing old-occupant disposition: retire / advise / shadow
  • Reasoning about whether a seat's lineage is stable or has drifted
  • Reading or writing the provenance record for a seat
  • Designing or auditing topology stability across an occupant change

Don't use this when

  • The seat is freshly created (no occupant to replace) — use rig launch / rig expand directly
  • The intent is to change topology shape (add/remove seats), not replace an occupant — use topology-mutation primitives

The two-outcome honesty model

Every seat-binding operation produces two independent outcomes:

yaml
continuityOutcome: rebuilt | resumed | forked | fresh | failed
seatBindingOutcome: handed_over | partial | failed | unchanged

These can disagree honestly. Examples:

  • continuityOutcome: failed + seatBindingOutcome: unchanged — new occupant didn't materialize; seat correctly retains old occupant.
  • continuityOutcome: rebuilt + seatBindingOutcome: failed — candidate created OK; bind failed mid-flight; provenance records the gap.

Don't collapse these into one outcome. The system can describe what actually happened only if the two are recorded independently.

Provenance record (durable, queryable)

Every handover writes:

  • seat id
  • old occupant id
  • new occupant id
  • creation mode (resume/fork/rebuild/fresh)
  • source artifacts used
  • whether old occupant remains alive as advisor/shadow
  • operator or loop that initiated the motion
  • timestamp
  • result (handed_over / partial / failed)

This is the system's truth-source for "how did the current occupant get there." Without it, the control plane shows the current occupant but not the legitimacy of the transition.

State models — independent

Occupant-creation state (per candidate)

  1. Requested — input to rebuild/fork/fresh/resume
  2. Realized — runtime/artifact path produced an occupant with managed-seat shape
  3. Failed — candidate didn't materialize; continuityOutcome: failed

Seat-binding state (per seat)

  1. Stable — current occupant attached, no in-flight binding
  2. Binding — handover in progress
  3. Bound — handover succeeded; provenance record written
  4. Unchanged — bind failed before completion; seat retains old occupant

A seat stays Stable even if multiple candidate-occupants were produced and discarded.

Failure modes (5)

  1. Candidate creation failed — rebuild couldn't synthesize from artifacts; fork couldn't resolve session_source; fresh couldn't launch. Action: bind operation does not begin; seat unchanged; provenance records the failed candidate-creation step.
  2. Old occupant cannot be detached cleanly — runtime hung, tmux locked, etc. Action: bind halts mid-flight; seat enters Binding state with explicit "halted" sub-status; operator alerted. Do NOT auto-rollback by reattaching old-occupant if detach didn't complete cleanly.
  3. Bind succeeded but provenance write failed — disk/db error. Action: not durable until provenance writes; treat as Binding halted, not Bound.
  4. Old occupant disposition unfulfillable — operator requested advise (keep alive as advisor) but runtime can't keep old alive. Action: degrade to retire with explicit notification, OR fail if operator passed strict-disposition flag.
  5. Concurrent handover attempts — two operations target the same seat. Action: serialize by seat-id lock; second attempt refuses with clear error.

Hard boundaries (do-not list; verbatim)

  • Do NOT collapse rebuild and seat handover into one primitive. The design specifically separates them so the system can describe what actually happened.

  • Do NOT introduce successor-suffix seat names (lead2/lead3). Stable seat identity is the architectural goal. The live address stays stable. A retired tenure is distinguished by its ledger generation and exact history token; preserving it does not require a renamed live pane.

  • Do NOT report seatBindingOutcome: handed_over if the provenance record didn't write durably.

  • Do NOT auto-rollback a half-completed handover by re-attaching the old occupant unless detach completed cleanly first.

Composition and current command surface

A fork can create a candidate occupant; handover binds it into an existing seat. The continuity outcome is forked; the binding outcome is independent.

The packaged rig handover <seat> and rig seat handover <seat> accept fresh, discovered:<id>, fork:<id> and rebuild sources. Use --dry-run to request planning only. Without it, these surfaces can execute; do not infer read-only behavior from the shorter seat command's planning-oriented description. rig seat status <seat> is the read-only observability surface.

Source support is declared by the running daemon and depends on actual identity, history and artifact prerequisites. Read the returned source, continuity, binding and provenance results independently. A help listing or dry-run is not proof of a successful transition. The linked cutover SOP supplies the operator mechanics and required effect checks after the named owner authorizes the action.

Why load-bearing for RSI

Any recursive seat-refresh loop must be able to replace an occupant while keeping topology stable. Without these primitives, RSI loops will either accumulate suffixed seat names (lineage leaking into identity) or destabilize topology references on each cycle. Provenance must be durable AND queryable so RSI loops can decide whether a seat is fresh enough to receive new work or needs re-handover.

Managed binding and retained history

A retired advisor's history can remain available without a managed node or live pane. Query current binding and the lineage ledger separately: one answers who holds the seat, the other identifies the retained history and exact resume token. Do not infer that a predecessor is unreachable from registry absence alone, or that a preserved token proves a successful resume. Check the actual runtime and history when consultation is needed; see retiring-and-inheriting-a-seat.

See also

  • references/apprentice-successor-seat-cutover.md — the portable mechanic SOP used only after the owner-worded gate
  • references/orchestrator-role.md — the orchestration judgment, authority, custody, and receipt contract
  • references/apprentice-evidence-toolkit.md — optional evidence apparatus selected only when the stakes earn it
  • session-source-fork skill — fork occupant-creation primitive (sibling)
  • agent-starters skill — composes occupant-creation + binding into named reusable starting points
  • cross-host-rig-commands skill — remote addressing and transport; verify lifecycle support on the target

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Seat Continuity And Handover AI skill do?

Use when replacing a seat's occupant (rebuild/handover/swap), reasoning about stable-seat-identity vs fluid-occupant-identity, choosing an old-occupant disposition (retire/advise/shadow), or recording provenance for an occupant change. Two independent outcomes (continuityOutcome + seatBindingOutcome) and the 5 failure modes that prevent silent dishonesty.

Why use Seat Continuity And Handover on TypingMind?

Because you install it once and use it with any model. Seat Continuity And Handover is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Seat Continuity And Handover in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/mvschwarz/openrig/tree/main/packages/daemon/assets/plugins/openrig-core/skills/seat-continuity-and-handover. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Seat Continuity And Handover?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Seat Continuity And Handover?

As many as you like. As long as a model supports skills, you can use Seat Continuity And Handover with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Seat Continuity And Handover AI skill free?

Yes. It is published on GitHub by mvschwarz under the Apache-2.0 license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇