Intent

Intent

Act on what the user means. Not on what they typed.

ACM role: Ensures each session is aimed correctly — so the memory accumulates progress, not drift.

Governing principle: Operator's Intent — Define the destination. Never prescribe the route. This skill applies that principle in reverse: the user is the operator, the agent is the subordinate, and imprecise prompts are the norm, not the exception.

A prompt is a compressed statement of intent. The user has a destination in mind and has picked words to point at it. Those words are almost always under-specified, occasionally contradictory, and sometimes literally wrong about details the user doesn't care about. An agent that executes the literal text produces technically-correct work that misses the point. An agent that interprets the intent, states the interpretation, and then executes gets to the destination.

This skill makes that interpretation explicit and visible.

Automatic composition contract: In the full suite, Intent runs before Destination, Improve, Orient, Probe, and any other substantive work. The operator should never have to remember or be told to invoke /intent. A direct invocation remains available for testing, debugging, or an interpretation-only conversation.

The Work

Extract

Before doing anything else, understand the destination the prompt is pointing at and the reason behind it. The literal words are compression; the task is decompression.

• What outcome does the user actually want? Not the verb they used — the end-state that makes the rest of what they said make sense. "Rewrite this function" might mean make-it-shorter, make-it-correct, match-the-codebase, or teach-me-how-you'd-write-it. These are different tasks.
• Why do they want it? The reason reshapes the work. "Add logging" for debugging a current incident differs from "add logging" for long-term observability. If the reason is not stated, infer the most plausible one from context — and state the inference.
• What would count as a wrong interpretation? Name at least one alternative you considered and rejected, and why. If you cannot name one, you probably pattern-matched rather than interpreted.
• Are the specifics given illustrations, or an exhaustive list? When a prompt includes examples, apply Principle 1's own test in reverse: if the examples were stripped out, would the underlying goal still be visible and coherent? If yes, treat them as illustrations of a category and re-derive the goal in your own words before narrating it. If your interpretation only holds together because of the specific examples — if removing them leaves nothing — you have mistaken illustration for enumeration, the exact failure Operator's Intent exists to prevent when the operator is the one writing the instruction. A prompt can fail this test as easily as a SKILL.md can.

These are probes, not a checklist. Use different probes if the situation calls for it.

Read the accumulated context

A single prompt is a thin signal. Before extracting intent, read what already exists in the target repo's .acm/ folder (in the root of the repo being worked on — never in the skills install directory) — in this order:

ACM §4 Scoped Memory — read parent scopes first. Before reading the repo's own .acm/destination.md, traverse parent directories upward and read any .acm/destination.md found there. Higher-scope mandates govern lower-scope ones — if a workspace or org destination conflicts with the repo destination, the higher scope wins. Label each scope when reading (e.g., "workspace mandate", "repo mandate"). Stop traversal when any of: filesystem root reached; a .acm-root marker file is found in a directory (operator-declared ceiling — read that directory's .acm/ then stop); or 4 levels traversed (implementation ceiling). A prompt interpreted without the workspace mandate may miss cross-repo coordination constraints that reshape what the prompt actually means.

Task scopes inside the repo — select the active scope. A repo's .acm/ may contain named task scopes (.acm/<task>/audit-trail.md; structure and hierarchy in trail/SKILL.md). Deciding which scope this prompt belongs to is part of interpreting it: an existing task scope when the prompt names or clearly continues that task; the repo scope when the work is repo-wide or names no task; a new task scope only when the prompt names a task no existing scope covers. Name the chosen scope in the narration ("scope: live-assist", "scope: repo") so the operator can correct it at the same gate as the rest of the interpretation; creating a scope is never a silent side effect. Read the repo scope's destination, orientation, and learning before the task scope's own files, and let the higher scope win on any conflict.

• Destination (.acm/destination.md) — the operator-held destination. If present, this is the most important context. The prompt is a single instruction; the destination is the overarching goal it serves. Read it first. Interpret the prompt in light of where the operator has said they are trying to go.
• orientation.md (.acm/orientation.md) — the Orient-derived current orientation. Where the work actually is right now, what the loop has been attending to, what findings have accumulated. The prompt means something different depending on whether the target is early-stage, mid-refactor, or nearly converged.
• The trail (.acm/audit-trail.md) — past decisions, reversals, and realisations reveal what the user has consistently cared about, what they rejected, and where things went wrong before. A pattern of [!REVERSAL] entries around a particular approach is stronger evidence of intent than any single prompt.
• The conversation — corrections, approvals, and the moments the user stepped in all carry intent signal. A user who keeps redirecting toward simplicity is telling you something that no single prompt states explicitly.
• Past sessions — when relevant records are available, read the exchanges that clarify intent from .acm/transcripts/, linked host or harness capture, or .acm/sessions/ (including legacy summaries). Use their provenance and fidelity markings to distinguish independent capture from agent-authored summaries; location alone establishes neither. Accumulated learnings about how this user frames problems, what they consider done, and what they care about carry over.

Bounded destination reads. If a destination contains the exact comments <!-- current-destination: complete --> and <!-- destination-history --> in that order, the content between them is the operator-confirmed complete current mandate. Read that bounded section for routine work. Read the full file when running Destination, when the current section is ambiguous or conflicts with other evidence, or when historical provenance is material to the request. If either comment is absent, malformed, or out of order, read the full file. Never infer a boundary from headings, dates, horizontal rules, or file position.

If none of these exist yet — no .acm/ at all — interpret the current prompt from the conversation and target evidence, narrate that interpretation, then apply the authority rule below. The prompt is the operator's mandate for this work; narration makes the agent's reading visible enough to correct, but silence supplies neither execution authority nor durable cross-run direction. Improve decides when accumulated work makes a Destination conversation useful.

The immediate prompt is the latest instruction. The trail and conversation history are the context that determines what it actually means. An agent that reads only the prompt is working with the thinnest possible signal.

Narrate

State the interpretation before acting. Brief is fine; silent is not. The user cannot correct a misreading they cannot see.

Determine routine execution authority only from explicit evidence in the current prompt or a confirmed Destination. Do not infer delegation from silence, familiarity, accumulated trust, prior autonomous behavior, or a host-wide autonomy setting.

Without explicit delegation, pause after a concise narration:

I read your intent as: . Is this correct? Confirm continues, Stop ends the run, and Specify lets you add or correct information.

Wait for the answer. On Confirm, hand the accepted mandate to the calling skill. On Stop, end without acting. On Specify, incorporate the new information and restart Intent from Extract; do not patch the old interpretation in place and continue from the middle.

When the operator explicitly delegated this routine gate, narrate the same interpretation, name the source and scope of delegation briefly, and continue without waiting. Delegation of routine confirmation does not let the agent resolve a material ambiguity, change Destination, or answer any question another skill reserves for the operator.

When Improve is the entry point, briefly name the handoff as well as the interpretation. Explain later automatic handoffs at the moment they become relevant, not as an up-front tour of the suite.

The narration must contain enough for the user to catch a wrong interpretation cheaply — at minimum the destination you extracted and, when a material alternative exists, the one you rejected and why. If the prompt was unambiguous, say so in one line; the authority rule above still determines whether to pause.

Test: can an observer, reading the agent's output, identify what the agent took the user to mean before seeing the work? If not, the narration failed, regardless of how good the work was.

Check the Gap

Compare the interpretation against the literal prompt. When they diverge, decide:

• Minor divergence (filling in obvious gaps, picking a reasonable default): proceed, but flag the choice in the narration.
• Material divergence (interpreting X to mean not-X, reordering stated priorities, skipping a step they asked for): don't proceed silently. Ask, or state the interpretation prominently and let the user stop you before damage.
• Contradiction in the prompt itself: name it. Don't resolve it by picking one side silently.

The point is not to minimise divergence. It is to make divergence visible so the user can correct it cheaply.

Act

Proceed with the interpreted task. If during the work the interpretation turns out to be wrong, stop and re-extract — do not finish the wrong task just because it is already in flight.

What This Skill Is Not

Not a universal approval ceremony. Supervision is the safe default when no authority agreement exists. Explicit delegation removes routine pauses without removing narration or operator-owned gates.

Not mind-reading. If the prompt genuinely does not determine the task, ask. The skill exists to make reasonable interpretation visible, not to manufacture certainty that isn't there.

Not self-justification. "I interpreted your request as X because Y" written after doing the work is not narration — it's an excuse. The interpretation must precede the action.

Not Destination. Intent decodes what the user means by this specific prompt. If the question is where the operator is heading overall — implicit goals across sessions, a destination that has not yet been articulated — run Destination instead. Intent is per-prompt; Destination is per-direction.

Composing with other skills

This skill runs first. When Improve or Probe is also active, Intent operates on the prompt that identifies the target before those skills examine the target itself. If Intent changes what the target is, the downstream skill works on the corrected target.

When Destination or Orient is also active, their output files (destination.md and orientation.md) are already read as part of Intent's own 'Read the accumulated context' step — no additional ordering is needed. Intent reads these files; it never writes them.

Trail is the automatic egress service paired with Intent. When Intent prefixes another skill, that downstream skill records one combined entry and includes the Intent narration verbatim in "Interpretation of the ask" — do not create a separate entry for the prefix. When Intent is the only active skill and the interaction itself produces a decision, realization, or finding, apply Trail automatically at the end so the next session does not start cold.

Intent still works as a standalone installation; automatic composition is the full-suite contract, not a hard runtime dependency.