Reorient

---
name: reorient
description: Use mid-task when the working thread is lost — after a context compaction, a long agent run, or coming back to a feature unsure of the role, the current checkpoint, or the next action. Triggers — "/engineer.reorient", "reorient", "re-anchor", "what should I be doing right now", "I lost track", "where was I".
---

# reorient

Restore the working contract mid-task. After a context compaction or a long
run, an agent loses role identity, invents constraints that do not exist, skips
required steps, and loses the task thread. `reorient` reloads the durable state
that should have survived — the discipline contract first, the task pointer
second.

Read-only and advisory. It changes nothing, produces no artifact, and emits
**no handoff** — like `next`, the orientation block is the whole output; a
handoff would only restate it. The third skill exempt from the agentic summary
contract.

`reorient` is the mid-task, feature-scoped counterpart to `next` (project-scoped,
session-start).

## When to use

- Right after a context compaction (a `SessionStart` hook can auto-invoke it).
- Mid-task, when unsure of the role, the current checkpoint, or the next action.
- Returning to a feature after an interruption.

**Not for:** session-start "what should I pick up across the project" (`next`);
loading a feature not yet started (`prime-context`); validating artifacts
(`consistency-check`).

## Workflow

### Step 1 — Resolve and locate

Resolve the methodology root + manifest via
`${CLAUDE_PLUGIN_ROOT}/scripts/dae_resolve.py` (see `references/resolving.md`).
Locate the feature (slug arg or branch name). If no feature is in scope, say so
and suggest `next` instead. **Layout disambiguation:** if the project has BOTH a
`features/NNN-*/` and a `specs/NNN-*/` tree (a speckit migration in progress),
say which one holds this feature; and if more than one acceptance-IR convention
exists (`features/NNN/.build/spec.json` vs an `acceptance-pipeline/ir/` per-GWT
layout), name the one in force — so re-anchoring doesn't rediscover the split.
(`speckit-consolidate` unifies it.)

### Step 2 — Reload the discipline contract, then the task pointer

Read, read-only, in this order:

1. **Role + autonomy** — `CHARTER.md` + manifest: the autonomy level in force,
   and what the agent may and may not decide. Counters invented constraints.
2. **Current checkpoint + exit criteria** — the Checkpoint Exit Contract
   (Foundation Design Section 8) for the checkpoint `progress.md` shows in
   progress: its goal, its exit criteria, and which are already met. Run
   `${CLAUDE_PLUGIN_ROOT}/scripts/dae_progress.py <feature-dir>` and show its
   breadcrumb — the same pipeline-position line the checkpoint skills surface
   at Step 0.
3. **Non-negotiables** — verification independence and charter-mandated
   mutation: steps that must not be skipped regardless of cost. The cost of a
   step is never a reason to skip it.
4. **Current task + next action** — the `progress.md` CURRENT header.
5. **Feature contract** — `feature.md` outcome + scope. Counters goal drift.

Also run `${CLAUDE_PLUGIN_ROOT}/scripts/dae_handoff.py <feature-dir>` — report any
checkpoint marked done without a complete handoff as a discipline gap.

Also run `${CLAUDE_PLUGIN_ROOT}/scripts/dae_reconcile.py <feature-dir>` (read-only):
if it reports `needs_reconcile: true`, this feature's PR is already merged (`gh`-detected —
covers squash-merge and `git.manual`) and the local state is stale. Do **not** re-anchor on
a phantom in-progress checkpoint — surface that it shipped and recommend `/engineer.post-merge`
to reconcile. `reorient` is read-only, so it never applies the flip itself.

### Step 3 — Emit the orientation block

Output one tight block, nothing else:

```
You are <role> at autonomy <level>.
Feature NNN-slug — Checkpoint N (<goal>).
Exit criteria: <m>/<n> met — unmet: <list>.
Current task: <task> -> next action: <action>.
Must not skip: <non-negotiables>.
Constraints: <charter / autonomy limits>.
```

### Step 4 — Stuck-loop detection

Before stopping, scan the feature's recent handoffs for a stuck loop. A loop is "stuck" when **three or more consecutive handoffs** from the same skill share:
- the same `status` (typically `interrupted` or `complete`-with-unmet-criteria), AND
- the same recommended-next, AND
- substantially the same `findings_summary` / failure signature (e.g. same error class, same blocker name, same infra failure type).

A stuck loop is the agent re-attempting the same operation expecting different results. nexthq saw 60+ identical ticks over 12 hours on a Functions emulator blocker — the autonomous loop never escalated to the human.

Threshold is tunable via `manifest.autonomy.stuck_loop_threshold` (default `3`).

When detected: STOP. Do not silently re-run. Emit (just this once — break the no-handoff rule) a `session-summary`-style escalation handoff that:
- Names the repeated failure signature.
- Lists the N affected handoffs by filename.
- Sets `human_action_needed: decision` and `human_action_kind: unblock-stuck-loop`.
- `recommended_next`: "human review required — N consecutive identical failures from <skill>".

The escalation handoff lives in `.engineer/handoffs/` (it's project-scope, not feature-scope progress). The human picks the unblock — a different approach, a charter amendment, an environment fix, or a deferred re-try.

### Step 5 — Stop

If Step 4 found no loop: `reorient` orients; it does not act. The human resumes the work. No handoff.

If Step 4 escalated: the escalation handoff is the output. The loop is broken — wait for the human.

## Optional: auto-invoke on compaction

A project may add a `SessionStart` hook (`source: compact`) that nudges
`/engineer.reorient` after every compaction. See
`${CLAUDE_PLUGIN_ROOT}/examples/session-start-reorient.md`. The hook is optional
project config, not part of this skill.

## References

- [Foundation Design](https://www.notion.so/3585ecdee0e2811bbc67ff4913c03207) —
  the Checkpoint Exit Contract (Section 8); agentic summary exemptions (Section 5)
- Sister skill: `next` — the project-scoped, session-start counterpart