@tacuchi/agent-workflow-cli 21.8.0 → 21.9.0

package/dist/domain/retirement/proposal.js

@@ -0,0 +1,83 @@
+/**
+ * The exact retirement somebody is about to authorize — under ONE seal.
+ *
+ * `LocalProposal` seals a publication: the bytes that will be written, the bases
+ * they were computed from, the effect classes. A retirement is the mirror of it
+ * and needs the same guarantee for a different set of facts: what DISAPPEARS,
+ * what goes back to bytes it used to have, which uncommitted change is dropped,
+ * which commit gets a revert, which unit is reconciled and which row is appended.
+ * So it is a record of its own, sealed the same way and over all of it.
+ *
+ * Two properties are what the seal buys, and both are properties of the data
+ * rather than rules somebody has to remember:
+ *
+ * - **An identical retry never re-asks.** Same closure, same bytes, same SHAs →
+ *   same digest → the approval still fits.
+ * - **Anything material that moved always re-asks.** One more session in the
+ *   closure, a plan whose bytes changed since the preview, a commit that gained a
+ *   descendant: all of them change the digest, and the old approval stops fitting.
+ *
+ * The `read_set` is the compare-and-swap. A retirement is computed FROM a state of
+ * the workspace — the board, each session's custody, git — and applying it later
+ * is only legitimate while that state still holds. Recording what was read, with
+ * its digest, is what lets `apply` refuse instead of acting on a world that moved.
+ *
+ * The preview is DERIVED from this object and never authored beside it, for the
+ * same reason a publication's is: two descriptions of the same deletion can
+ * disagree, and the one a person reads would be the one that is wrong.
+ */
+import { semanticDigest } from "../../application/semantic-operation/protocol.js";
+export const RETIREMENT_MODES = ["discard", "reset"];
+export const RETIREMENT_PROPOSAL_VERSION = 1;
+export function sealRetirementProposal(input) {
+    const body = { version: RETIREMENT_PROPOSAL_VERSION, ...input };
+    return { ...body, digest: retirementDigest(body) };
+}
+/**
+ * The seal, over the SET rather than the order a builder happened to append in —
+ * except for `closure` and `reverts`, whose ORDER is material: a closure removed
+ * in another order can leave a dangling reference, and reverts applied in another
+ * order can conflict. Content travels as its own digest so the seal stays a fixed
+ * size whatever the restored bytes weigh.
+ */
+export function retirementDigest(body) {
+    return semanticDigest({
+        version: body.version,
+        mode: body.mode,
+        target: body.target,
+        closure: body.closure,
+        deletes: [...body.deletes].sort((a, b) => order(a.path, b.path)),
+        restores: [...body.restores]
+            .map((r) => ({
+            path: r.path,
+            existed: r.existed,
+            digest: r.digest,
+            current_digest: r.current_digest,
+        }))
+            .sort((a, b) => order(a.path, b.path)),
+        bindings: [...body.bindings].sort(order),
+        units: [...body.units].sort((a, b) => order(`${a.alias}/${a.session}`, `${b.alias}/${b.session}`)),
+        dirty: [...body.dirty]
+            .map((d) => ({ ...d, paths: [...d.paths].sort(order) }))
+            .sort((a, b) => order(a.alias, b.alias)),
+        reverts: body.reverts,
+        publication: body.publication,
+        event: body.event,
+        read_set: [...body.read_set].sort((a, b) => order(a.id, b.id)),
+    });
+}
+function order(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/**
+ * Whether this proposal would touch git history at all.
+ *
+ * It is what decides whether the authorization has to be LABELLED with its
+ * reverts: approving a retirement that only deletes local files is not the same
+ * decision as approving one that adds commits to a branch, and the difference has
+ * to be visible in the question rather than in the preview somebody may not read.
+ */
+export function proposesReverts(proposal) {
+    return proposal.reverts.length > 0;
+}
+//# sourceMappingURL=proposal.js.map

package/dist/domain/retirement/proposal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposal.js","sourceRoot":"","sources":["../../../src/domain/retirement/proposal.ts"],"names":[],"mappings":"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"}

package/dist/domain/retirement/selector.js

@@ -0,0 +1,109 @@
+/**
+ * Naming what to retire, unambiguously or not at all.
+ *
+ * A destructive command cannot take "024" and decide what the person meant. The
+ * board holds a spec 024, a plan 024 and a session 024 at the same time, and each
+ * one is a different amount of work to delete. So the selector is EXPLICIT by
+ * default (`plan:024`), a bare number is accepted only while exactly one node
+ * answers to it, and a path is accepted because a path is already unambiguous.
+ *
+ * Parsing here is pure: it says what SHAPE was asked for. Whether that shape
+ * resolves to one node, several, or none is the resolver's job — the two are kept
+ * apart so a parse error and an ambiguous target never come back as the same
+ * failure.
+ */
+import { isWorklineKind, nodeFromDocPath } from "../workline-node.js";
+const BARE_NUMBER = /^\d{1,4}$/;
+const SESSION_FOLDER = /^(?:session)?\d{3,}-[A-Za-z0-9._-]+$/;
+export function parseTargetSelector(raw) {
+    const text = raw.trim();
+    if (text.length === 0) {
+        return {
+            ok: false,
+            problem: {
+                code: "TARGET_EMPTY",
+                message: "no se indicó ningún objetivo",
+                action: "pasá el objetivo: spec:<NNN> | plan:<PPP> | quick:<NNN> | session:<NNN|carpeta> | una ruta exacta",
+            },
+        };
+    }
+    // A path is checked first: `docs/plans/024-plan-x.md` contains no `:` on any
+    // platform we support, but a Windows spelling could, and the path reading is
+    // the more specific of the two.
+    const fromPath = nodeFromDocPath(text);
+    if (fromPath !== null) {
+        return {
+            ok: true,
+            selector: {
+                form: "path",
+                path: normalizeSlashes(text),
+                kind: fromPath.kind,
+                key: fromPath.key,
+            },
+        };
+    }
+    const colon = text.indexOf(":");
+    if (colon > 0)
+        return parseQualified(text, colon);
+    if (BARE_NUMBER.test(text))
+        return { ok: true, selector: { form: "bare", key: pad(text) } };
+    if (SESSION_FOLDER.test(text))
+        return { ok: true, selector: { form: "folder", folder: text } };
+    return {
+        ok: false,
+        problem: {
+            code: "TARGET_MALFORMED",
+            message: `'${raw}' no es un objetivo reconocible`,
+            action: "usá spec:<NNN>, plan:<PPP>, quick:<NNN>, session:<NNN|carpeta> o la ruta exacta del documento",
+        },
+    };
+}
+function parseQualified(text, colon) {
+    const kind = text.slice(0, colon).trim().toLowerCase();
+    const key = text.slice(colon + 1).trim();
+    if (!isWorklineKind(kind)) {
+        return {
+            ok: false,
+            problem: {
+                code: "TARGET_UNKNOWN_KIND",
+                message: `'${kind}' no es una clase de nodo de Workline`,
+                action: "las clases son spec, plan, quick y session",
+            },
+        };
+    }
+    if (key.length === 0) {
+        return {
+            ok: false,
+            problem: {
+                code: "TARGET_MALFORMED",
+                message: `'${kind}:' no nombra nada`,
+                action: `pasá ${kind}:<identidad>`,
+            },
+        };
+    }
+    // A session or a quick is addressed by number OR by folder; a spec and a plan
+    // only ever by number, and padding it is what makes `plan:24` and `plan:024`
+    // the same request instead of one that silently finds nothing.
+    const normalized = BARE_NUMBER.test(key) ? pad(key) : key;
+    return { ok: true, selector: { form: "qualified", kind, key: normalized } };
+}
+function pad(key) {
+    return key.padStart(3, "0");
+}
+function normalizeSlashes(path) {
+    return path.split("\\").join("/");
+}
+/** How the selector reads back to a person, verbatim in a rejection. */
+export function selectorText(selector) {
+    switch (selector.form) {
+        case "qualified":
+            return `${selector.kind}:${selector.key}`;
+        case "bare":
+            return selector.key;
+        case "path":
+            return selector.path;
+        case "folder":
+            return selector.folder;
+    }
+}
+//# sourceMappingURL=selector.js.map

package/dist/domain/retirement/selector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selector.js","sourceRoot":"","sources":["../../../src/domain/retirement/selector.ts"],"names":[],"mappings":"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"}

package/dist/domain/session/custody.js

@@ -0,0 +1,176 @@
+/**
+ * What a session RECEIVED, what it CREATED and what it CHANGED — sealed, and
+ * written before the session can produce a single effect.
+ *
+ * `SESSION.md`'s `## Origin` was the only record of where a run came from, and it
+ * is prose: it can say "derived from the plan 024" and still not answer the two
+ * questions a retirement has to answer before deleting anything. Which artifacts
+ * existed BEFORE this run, byte for byte? And which of the things that exist now
+ * are this run's, as opposed to somebody else's work that happens to sit in the
+ * same tree? Neither is derivable from names, dates or tags, and guessing either
+ * one wrong destroys work nobody can reconstruct.
+ *
+ * So custody is the authority and `## Origin` becomes its human projection:
+ *
+ * - **Born with the session, in the same operation.** A session that exists
+ *   without custody could already have mutated something by the time anybody
+ *   thinks to record a baseline, and a baseline taken afterwards is a fiction.
+ * - **A baseline is bytes or an explicit absence.** "The file was not there" is a
+ *   fact a restore needs as much as its previous content; leaving it implicit is
+ *   what turns a reset into a delete.
+ * - **Effects are receipts, never inferences.** A commit's SHAs come back from
+ *   the commit that made them. Reading ownership off a commit MESSAGE would make
+ *   the advisor's convention load-bearing, and a message is not evidence.
+ * - **Incomplete is a refusal, not a partial answer.** A custody that cannot say
+ *   what it received blocks the mutation that would promise retirement later,
+ *   because the alternative is promising a retirement that cannot be delivered.
+ *
+ * Custody lives INSIDE its session folder and dies with it. A durable record
+ * outside would outlive the thing it describes — a parallel history of deleted
+ * work, which is precisely the surface `S025/AC-04` says must not exist.
+ */
+import { semanticDigest } from "../../application/semantic-operation/protocol.js";
+/** Bumped only when a reader can no longer trust the older shape. */
+export const CUSTODY_VERSION = 1;
+/** Session-local file the record lives in. Dot-prefixed: it is not an artifact. */
+export const CUSTODY_FILE = ".custody.json";
+/** The one way to digest a baseline's bytes, shared with the proposal's bases. */
+export function baselineDigest(text) {
+    return semanticDigest(text);
+}
+/** A baseline for a path that was not there. Explicit, never an absent field. */
+export const ABSENT_BASELINE = {
+    existed: false,
+    digest: null,
+    bytes: null,
+    content: null,
+};
+/** A baseline that preserves the previous text, for what only we can restore. */
+export function preservedBaseline(content) {
+    return {
+        existed: true,
+        digest: baselineDigest(content),
+        bytes: Buffer.byteLength(content, "utf8"),
+        content,
+    };
+}
+export function sealCustody(input) {
+    const body = {
+        version: CUSTODY_VERSION,
+        subject: input.subject,
+        subject_path: input.subjectPath,
+        parents: [...(input.parents ?? [])],
+        created: input.created,
+        artifacts: [...(input.artifacts ?? [])],
+        sources: [...(input.sources ?? [])],
+        effects: [...(input.effects ?? [])],
+    };
+    return { ...body, digest: custodyDigest(body) };
+}
+/**
+ * The seal, over the SET rather than the order things were appended in.
+ *
+ * Two custodies that recorded the same facts in a different order are the same
+ * custody, and a digest that disagreed would report tampering on a detail nobody
+ * can see. Content travels as its own digest so the seal stays a fixed size
+ * whatever the preserved bytes weigh.
+ */
+export function custodyDigest(body) {
+    return semanticDigest({
+        version: body.version,
+        subject: body.subject,
+        subject_path: body.subject_path,
+        parents: [...body.parents].sort(nodeOrder),
+        created: body.created,
+        artifacts: [...body.artifacts]
+            .map((a) => ({
+            path: a.path,
+            role: a.role,
+            before: {
+                existed: a.before.existed,
+                digest: a.before.digest,
+                bytes: a.before.bytes,
+                content_digest: a.before.content === null ? null : baselineDigest(a.before.content),
+            },
+        }))
+            .sort((a, b) => order(a.path, b.path)),
+        sources: [...body.sources].sort((a, b) => order(a.alias, b.alias)),
+        effects: [...body.effects],
+    });
+}
+function nodeOrder(a, b) {
+    return order(`${a.kind}:${a.key}`, `${b.kind}:${b.key}`);
+}
+/** Code-unit ordering, the same reason `canonicalJson` avoids `localeCompare`. */
+function order(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/**
+ * Whether this record can still answer "what did the session receive".
+ *
+ * Called at two very different moments and that is deliberate: before a mutation
+ * that promises retirement, and again before a retirement is prepared. The first
+ * refuses to make the promise; the second refuses to pretend it was kept. Both
+ * read the same rule, so a session that was allowed to mutate is never one whose
+ * retirement turns out to be unprovable.
+ */
+export function custodyCompleteness(custody) {
+    const gaps = [];
+    if (custody.version !== CUSTODY_VERSION) {
+        gaps.push({
+            what: `versión de custodia ${custody.version}`,
+            why: `este CLI sella y lee la versión ${CUSTODY_VERSION}`,
+        });
+    }
+    if (custody.digest !== custodyDigest(stripDigest(custody))) {
+        gaps.push({
+            what: "sello de la custodia",
+            why: "el registro no coincide con su digest: fue editado fuera del CLI",
+        });
+    }
+    for (const artifact of custody.artifacts) {
+        if (artifact.role !== "input")
+            continue;
+        if (artifact.before.existed && artifact.before.digest === null) {
+            gaps.push({
+                what: `baseline de '${artifact.path}'`,
+                why: "la entrada existía y no se conservó su estado previo",
+            });
+        }
+    }
+    for (const source of custody.sources) {
+        if (source.baseline_head === null && source.unit_branch !== null) {
+            gaps.push({
+                what: `baseline git de '${source.alias}'`,
+                why: "la sesión tomó una unidad sobre una fuente cuyo HEAD no se registró",
+            });
+        }
+    }
+    return { complete: gaps.length === 0, gaps };
+}
+function stripDigest(custody) {
+    const { digest: _digest, ...body } = custody;
+    return body;
+}
+/**
+ * Every commit this session can prove is its own, per source.
+ *
+ * Two independent readings, and both are receipts rather than heuristics: the
+ * commits a typed commit reported making, and — for a session with its own unit
+ * — the range its branch advanced over its recorded baseline. The second is what
+ * covers commits the agent made with plain git inside its unit: the branch is
+ * the session's by convention and the baseline is sealed, so the range is
+ * exclusive by construction and needs nobody's commit message.
+ */
+export function attributableCommits(custody, alias) {
+    const seen = new Set();
+    for (const effect of custody.effects) {
+        if (effect.kind !== "commit" && effect.kind !== "unit_integrated")
+            continue;
+        if (effect.alias !== alias || effect.after === null)
+            continue;
+        seen.add(effect.after);
+    }
+    return [...seen];
+}
+//# sourceMappingURL=custody.js.map

package/dist/domain/session/custody.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custody.js","sourceRoot":"","sources":["../../../src/domain/session/custody.ts"],"names":[],"mappings":"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"}

package/dist/domain/workline-node.js

@@ -0,0 +1,56 @@
+/**
+ * The identity of a Workline node, said the same way by everybody who points at
+ * one.
+ *
+ * Provenance is a graph over four kinds of thing — a spec, a plan, a quick and a
+ * session — and until now each reader spelled them its own way: the index keys
+ * plans by `number`, sessions by folder, and a session's `## Origin` names its
+ * parent in prose. Prose is exactly what cannot carry an edge: two readings of
+ * "derived from the plan 024" can disagree about which document that is, and a
+ * retirement that guessed wrong would delete somebody else's work.
+ *
+ * So a node has ONE canonical id, `<kind>:<key>`, and every edge is a pair of
+ * those. The path is carried beside the id rather than inside it because a
+ * document can move: identity is `plan:024`, the path is where it lives today,
+ * and a stale path is a warning while a wrong id is a defect.
+ */
+export const WORKLINE_KINDS = ["spec", "plan", "quick", "session"];
+const KIND_SET = new Set(WORKLINE_KINDS);
+export function isWorklineKind(value) {
+    return typeof value === "string" && KIND_SET.has(value);
+}
+/** `plan:024` — the one spelling of a node, in output and in a seal alike. */
+export function formatNodeId(id) {
+    return `${id.kind}:${id.key}`;
+}
+const DOC_PATH_RE = /(?:^|\/)docs\/(specs|plans)\/(\d{3})-(spec|plan)(?:-[^/]*)?\.md$/i;
+/**
+ * The node a document path IS — `docs/plans/024-plan-x.md` is `plan:024`.
+ *
+ * This is not inferring provenance from a name: the workspace's own layout fixes
+ * that a spec lives at `docs/specs/NNN-spec-*.md`, and the board already reads
+ * every spec and plan by exactly this shape. Identity is what the path declares;
+ * what the document is DERIVED from is a different question, answered by the
+ * document's own `Derived from` line or by a session's sealed custody.
+ */
+export function nodeFromDocPath(path) {
+    const m = DOC_PATH_RE.exec(path.split("\\").join("/"));
+    if (m?.[2] === undefined)
+        return null;
+    return { kind: m[1]?.toLowerCase() === "specs" ? "spec" : "plan", key: m[2] };
+}
+/**
+ * Why an edge is believed.
+ *
+ * `custody` and `derived-from` are provable: one was sealed by the CLI when the
+ * node was born, the other is the plan's own machine-readable `Derived from`
+ * line. `origin-prose` is the legacy reading of a free-text `## Origin`, and it
+ * is kept SEPARATE precisely so a retirement can refuse to act on it — an edge
+ * nobody can prove is the one case where deleting is not recoverable.
+ */
+export const EDGE_EVIDENCE = ["custody", "derived-from", "origin-prose"];
+/** Whether an edge is strong enough for a destructive closure to include it. */
+export function isProvable(evidence) {
+    return evidence === "custody" || evidence === "derived-from";
+}
+//# sourceMappingURL=workline-node.js.map

package/dist/domain/workline-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workline-node.js","sourceRoot":"","sources":["../../src/domain/workline-node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,CAAU,CAAC;AAa5E,MAAM,QAAQ,GAAwB,IAAI,GAAG,CAAC,cAAc,CAAC,CAAC;AAE9D,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AAC1D,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,YAAY,CAAC,EAAkB;IAC7C,OAAO,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC;AAChC,CAAC;AAED,MAAM,WAAW,GAAG,mEAAmE,CAAC;AAExF;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,MAAM,CAAC,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACvD,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACtC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AAChF,CAAC;AAiBD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,SAAS,EAAE,cAAc,EAAE,cAAc,CAAU,CAAC;AAIlF,gFAAgF;AAChF,MAAM,UAAU,UAAU,CAAC,QAAsB;IAC/C,OAAO,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,cAAc,CAAC;AAC/D,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tacuchi/agent-workflow-cli",
-  "version": "21.8.0",
+  "version": "21.9.0",
   "description": "Runtime CLI for Workline — the stages + loops + artifacts system for agent work. Bundles the universal `w` skill set under `skills/w/` (slash commands `/w:*`: spec-new/spec-refine, plan-new/plan-exec, quick, persist, workspace-init, export-*); `self install --target <host>` copies SKILL + commands + hooks into the host. Pluggable capability skills via `.workflow/skills.toml`. Multi-empresa parametrization via `profile.json` cascade. Namespace auto-detected from any `.<ns>/sessions/` dir in CWD; default `workflow`.",
   "type": "module",
   "bin": {

package/skills/w/commands/discard.md

@@ -0,0 +1,49 @@
+---
+description: Use to retire a spec, plan, quick or session for good with everything it exclusively owns. `aw discard` resolves the closure from sealed provenance, previews it whole and applies it all-or-nothing on one approval. Never rewrites git history.
+argument-hint: "<spec:NNN | plan:PPP | quick:NNN | session:NNN|carpeta | ruta>"
+allowed-tools: ["Bash", "Read"]
+---
+
+# discard — retire work and everything it exclusively owns
+
+No loop, no session — the closure can include the session that would be driving it.
+Output in the **user's language**.
+
+**Hard floor:**
+
+1. **`prepare` first, always** — read-only: no session, no journal, no file, no ref,
+   so a wrong target costs nothing.
+2. **You never decide the scope.** It comes from sealed custody and each document's
+   `Derived from`; a descendant nobody can prove is a REFUSAL, not a guess.
+3. **One approval, over the exact digest.** `apply` recomputes under the workspace
+   lock and refuses if anything material moved. Approving is not applying.
+4. **Reverts are commits, never rewrites** — no `reset --hard`, rebase, amend, force
+   or push; a published commit's revert leaves its push pending and external.
+
+## Run
+
+1. `aw discard prepare <objetivo> --format human` — what disappears, which local
+   change is dropped, which SHA gets a revert, which unit is reconciled, which
+   `HISTORY` row it adds, and the **digest**.
+2. Show that preview and ask approval. If it touches git history, say so: approving
+   also authorizes commits.
+3. `aw discard apply <objetivo> --approval <digest> --format human`.
+4. A rejection names cause, candidates and next action; **nothing was applied**.
+   `024` resolves only while one node answers to it.
+
+## What the CLI decides (do not re-derive)
+
+- **The closure**, in removal order; a node something outside also descends from
+  blocks the whole operation.
+- **Attribution** of changes and commits, from baselines and receipts — never from a
+  message, an author or a tag.
+- **Whether all-or-nothing holds**: two publication units, a conflicting revert, an
+  operation in progress or an unsyncable tree block before anything mutates.
+- **What survives**: the originals stay reachable and the only durable Workline trace
+  is one append-only `HISTORY` row.
+
+## More context
+
+`aw context-plan --command discard --root "${CLAUDE_PLUGIN_ROOT}/skills/w"` lists what to read.
+
+- Back to before an **incomplete** session instead: `/w:reset`.

package/skills/w/commands/reset.md

@@ -0,0 +1,50 @@
+---
+description: Use to undo an incomplete session and put its document back as it was before that session ran. `aw reset` restores the inputs byte for byte and retires the session, all-or-nothing on one approval. Never rewrites git history.
+argument-hint: "<plan:PPP | session:NNN|carpeta | ruta>"
+allowed-tools: ["Bash", "Read"]
+---
+
+# reset — put an incomplete session's inputs back
+
+No loop, no session. Output in the **user's language**. It is **not**
+`/w:plan-refine`: refining carries a document forward keeping validated phases, this
+takes it back to the bytes it had before the session started.
+
+**Hard floor:**
+
+1. **`prepare` first, always** — read-only, so a wrong target costs nothing.
+2. **Only an INCOMPLETE session.** One that converged does not become resettable by
+   being selected, and `.closed` is never the test: a session closed with work
+   pending is exactly this case.
+3. **The target must resolve to ONE incomplete session**; two is a rejection with its
+   candidates, and then you name the session.
+4. **One approval, over the exact digest.** `apply` recomputes under the lock and
+   refuses if the document moved since the preview.
+5. **Reverts are commits, never rewrites** — no `reset --hard`, rebase, amend, force
+   or push, whatever this command's name suggests.
+
+## Run
+
+1. `aw reset prepare <objetivo> --format human` — which session it resolved, which
+   paths go back to their previous bytes and whether they moved since the baseline,
+   what disappears, which SHA gets a revert, and the **digest**.
+2. Show that preview and ask approval; if it touches git history, say so.
+3. `aw reset apply <objetivo> --approval <digest> --format human`.
+4. A rejection names cause, candidates and next action; **nothing was applied**.
+
+## What the CLI decides (do not re-derive)
+
+- **Which session** an artifact resolves to, and whether it is incomplete.
+- **What "before" was**: the baseline sealed at creation. Never reconstructed from
+  names, dates or tags — without it, it fails closed.
+- **Inputs vs outputs**: an input returns to its bytes, an output is removed, and a
+  document with work of its own blocks instead of being orphaned. A quick with no
+  base document is retired whole.
+- **All-or-nothing**: either the scope is intact, or the result is complete, not
+  resumable, and leaves one append-only `HISTORY` row.
+
+## More context
+
+`aw context-plan --command reset --root "${CLAUDE_PLUGIN_ROOT}/skills/w"` lists what to read.
+
+- Deleting a document and everything under it: `/w:discard`.