Autoconference:resume

Autoconference Resume — Checkpoint Recovery

Resume an interrupted conference from its last checkpoint. Reads conference_events.jsonl to determine exactly where to re-enter the conference protocol.

Purpose

Conferences are interrupted. Power failures, context window limits, timeouts, and user interruptions all happen. The resume skill reconstructs the conference state from its append-only event log and re-enters the autoconference protocol at the correct point — without re-running work that was already completed.

This skill does NOT restart a conference from scratch. It recovers from interruption and continues forward.

Recovery Protocol

Follow all 6 steps in order. Do not skip steps. Do not begin Phase 1 research until the recovery point is confirmed and state is validated.

Step 1: Locate Conference Directory

Objective: Find the conference directory and verify it is recoverable.

Ask the user:

"Where is the conference directory? (Or press Enter to search the current directory.)"

If the user provides a path, verify it exists and contains the required files.

If the user does not provide a path, search the current directory for conference artifacts:

find . -name "conference_events.jsonl" -maxdepth 4

For each candidate path found, show it to the user and ask: "Is this the conference you want to resume?"

Verify these files exist in the conference directory:

• conference.md — required. If missing, cannot resume.
• conference_events.jsonl — required. If missing, cannot resume (no event log = no checkpoint).

If either file is missing, stop and tell the user:

"Cannot resume: {file} is missing from {path}. To start a new conference, use /autoconference. To set up a new conference, use /autoconference:plan."

Also check for:

• conference_results.tsv — if present, read the last row to get the last-known best metric.
• researcher_*_results.tsv — to verify per-researcher state.
• researcher_*_log.md — to understand what each researcher accomplished.

Record: conference_dir — the confirmed absolute path to the conference directory.

Step 2: Parse Event Log

Objective: Determine the exact state of the conference at interruption.

Read the full conference_events.jsonl file. Parse all events in order to reconstruct state.

cat {conference_dir}/conference_events.jsonl

Build a state summary:

Show the user a plain-English summary:

Conference state:
  - Total rounds completed: {N}
  - Last completed event: {event_type} at {timestamp}
  - Researchers in last round: {A, B, C}
  - Convergence reached: {yes/no}
  - Interruption point: {description}

Record: All fields above as event_state.

Step 3: Determine Recovery Point

Objective: Map the last completed event to the exact re-entry point in the conference protocol.

Use this table to determine the recovery point:

Present the determined recovery point to the user and confirm:

"Based on the event log, I'll resume at: {recovery_point_description}. Does this look correct?"

If the user disagrees, ask them to describe where they think the conference was interrupted and resolve manually.

Record: recovery_point — the confirmed re-entry point.

Step 4: Validate State

Objective: Verify that the files on disk are consistent with the event log before re-entering.

Check 1: Researcher TSV files

For each researcher {ID} expected (from conference.md count):

• Verify researcher_{ID}_results.tsv exists.
• Check that the row count is consistent with the number of researcher.iteration events logged for that researcher.
• If TSV is missing but iterations were logged: warn and offer to reconstruct a minimal TSV from the event log.
• If TSV row count is higher than event log: warn — "Researcher {ID} TSV has more rows than events logged. Data may be from a previous interrupted run."

Check 2: Worktree branches (if metric mode with code changes)

Read conference.md to determine if worktree mode is active (mode: metric AND code change research).

If worktrees are in use:

git worktree list

For each expected branch (conference/researcher-{ID}, conference/best):

• Verify the worktree exists.
• Check for uncommitted changes: git -C {worktree_path} status --porcelain
• If uncommitted changes exist: warn the user. These are from the interrupted session and may represent partial work.

Check 3: Staleness warning

Check the timestamp of the last event in conference_events.jsonl.

Calculate hours since last event. If > 24 hours:

"Warning: This conference was interrupted {N} hours ago. The state may be stale. Environment changes (dependency updates, file deletions, code changes outside the conference) could cause failures. Proceed with caution."

Ask: "Do you want to proceed with recovery, or start fresh with /autoconference?"

Check 4: conference.md integrity

Re-read conference.md and verify:

• Required fields are present (goal, mode, count, max_rounds).
• Shared Knowledge section exists (may be empty if no rounds completed).
• Conference Log table exists.

If any required field is missing or corrupted, stop and ask the user to repair the file before resuming.

Record: validation_warnings — list of any warnings found (do not block on warnings, only on errors).

Step 5: Revert Incomplete Work

Objective: Bring all researcher state to a clean, known-good checkpoint.

This step ensures no researcher resumes from a partially-completed, inconsistent state.

For researchers that were mid-iteration at interruption:

A researcher is "mid-iteration" if:

• round.started for Round N was logged
• Some (but not all) researcher.iteration events were logged for that researcher in Round N
• round.completed for Round N was NOT logged

For mid-iteration researchers, revert to their last kept state:

File-based (no worktrees):

• Read the researcher's TSV file. Find the last row where outcome == kept.
• This is the last good state. Any rows after the last kept are from the interrupted iteration and should be discarded.
• Truncate the TSV to the last kept row. (Do this carefully — show the user which rows will be removed before truncating.)

Worktree-based (metric mode with code changes):

• Find the last committed state on the researcher's branch: git -C {worktree_path} log --oneline -5
• Reset to the last commit (which corresponds to the last kept state): git -C {worktree_path} reset --hard HEAD
• Verify no uncommitted changes remain: git -C {worktree_path} status --porcelain

For researchers that completed their Phase 1 work:

A researcher is "complete" if their last researcher.iteration event for Round N has outcome == final or if round.poster_session was already logged.

No revert needed for complete researchers. Their state is already clean.

For the conference/best branch (if worktree mode):

Only cherry-pick validated findings to conference/best AFTER round.peer_review is completed and verdicts are parsed. If the conference was interrupted before round.peer_review, do not modify conference/best — wait until the review is done.

Record: reverted_researchers — list of researcher IDs that were reverted, and to which state.

Step 6: Resume

Objective: Re-enter the autoconference protocol at the confirmed recovery point and run to completion.

Log the resume event:

Append to conference_events.jsonl:

{"event": "conference.resumed", "timestamp": "{ISO_TIMESTAMP}", "payload": {"recovery_point": "{recovery_point}", "round": {N}, "reverted_researchers": [...]}}

Load the autoconference protocol:

Read the full autoconference SKILL.md from ../../skills/autoconference/SKILL.md (or the root ../../SKILL.md if the skills/autoconference directory is empty).

The autoconference SKILL.md contains the master Conference Orchestration Protocol. The resume skill's job is to:

1. Determine WHERE to re-enter that protocol (done in Steps 3–5 above)
2. Hand off to the autoconference protocol at that point

Re-entry by recovery point:

"Start of Round N, Phase 1": Re-enter at Step 6 of the autoconference protocol (ROUND LOOP → Phase 1). Spawn all N researchers for Round N. Pass the current Shared Knowledge from conference.md.

"Mid-Phase 1, Round N — re-spawn incomplete researchers": Re-enter at Step 6 (Phase 1), but only for researchers that did not complete Phase 1 in Round N. Do not re-spawn researchers that already logged their Phase 1 completion. Pass their reverted state as the starting point.

"Start of Phase 3, Round N — Poster done, re-spawn Reviewer": Re-enter at Step 8 (Phase 3 — Peer Review). The poster session file poster_session_round_{N}.md already exists. Spawn only the Reviewer agent.

"Phase 4, Round N — Knowledge Transfer": Re-enter at Step 9 (Phase 4 — Knowledge Transfer). The peer review file peer_review_round_{N}.md already exists. Parse its verdicts and run Knowledge Transfer.

"Start of Round N+1": Re-enter at Step 10 (convergence check). Round N is complete. Check convergence. If not converged and budget remains, begin Round N+1 at Step 6.

"Synthesis only": Re-enter at Step 11 (SYNTHESIS). Spawn the Synthesizer (Opus) with paths to all existing poster session, peer review, researcher log, and TSV files.

Proceed to completion:

From the re-entry point, follow the autoconference protocol exactly as written — do not abbreviate steps, do not skip phases. The conference runs to completion (convergence, budget exhaustion, or user interruption) from this point forward.

The Persistence Directive applies: Never stop a round prematurely. Never ask "should I continue?" Advance automatically until a terminal condition is reached.

Resume Invariants

• Never re-run work that has a round.completed event for that round.
• Never modify conference_events.jsonl except to append — it is an append-only log.
• Never skip the validation step (Step 4) — resuming into a corrupted state causes silent errors.
• Never skip the revert step (Step 5) for mid-iteration researchers — partial iterations produce misleading TSV rows that corrupt convergence detection.
• If conference.completed is already logged, do not resume — tell the user the conference is done.
• The conference.resumed event must be logged before any research resumes.
• After logging conference.resumed, follow the autoconference protocol exactly — do not invent an alternative protocol.

Chaining

resume → autoconference (continuation from recovery point)

Full skill chain for a complete conference lifecycle:

plan → autoconference → (resume if interrupted) → ship