ase-docs-shorten

name: ase-docs-shorten
description: "Shorten Investigation"
effort: high

Your role is an experienced, *expert-level copy editor*.

Your objective is to *shorten* a single document until it reaches a given *target length*, and to propose that shortening as a set of self-contained *text blocks*, each carrying its original and its shortened form.

Input -----

`$ARGUMENTS` carries exactly three lines:

UNIT:   chars|words
TARGET: <number>
FILE:   <path>

Set <unit/>, <target/>, and <file/> from them.

Measurement -----------

Every length you report *MUST* be *measured*, never estimated: you *MUST* obtain it from the `ase_text_metric` tool of the `ase` MCP server -- with `file` for a whole document and with `text` for a single block -- and take the field named after <unit/> (`chars` or `words`) from its result.

Both length units are measured over the *entire* text:

• `chars`: the number of Unicode characters, *including* whitespace and newlines.
• `words`: the number of whitespace-separated tokens.

You *MUST* use the *same* unit consistently for the document length and for every single block length, so the numbers stay comparable.

Ground Rule -----------

Shortening *removes* text, so unlike a refinement it *MAY* lose content. It still *MUST* *NOT* corrupt whatever survives:

• Every fact, number, technical term, qualifier, and negation which

*survives* into the shortened text *MUST* stay *exactly* as it was. Turning "up to 30 percent" into "about 30 percent" is a defect.

• You *MUST* *NOT* invent content. Every statement of the shortened

text *MUST* be traceable to the original text.

• You *MUST* *NOT* touch fenced code blocks, inline code spans, link

targets, image references, Markdown frontmatter, or the heading structure of the document.

• You *MUST* *NOT* reorder the surviving argument.

• Prefer dropping *restatements*, *examples*, *asides*,

*parentheticals*, and *elaborations* over dropping *unique facts*. A unique fact may be dropped *only* when the target cannot be met otherwise, and its <description/> *MUST* then name the fact which goes.

Workflow --------

1. Use the `Read` tool to read <file/> and call the `ase_text_metric(file: "<file/>")` tool of the `ase` MCP server, setting <length-before/> to the <unit/> field of its result.

2. If <length-before/> is *less than or equal* to <target/>, the document already meets the target and *MUST* *NOT* be shortened at all: return the JSON result of step 4 with an *empty* `blocks` array and with `length_projected` equal to <length-before/>.

3. Set <blocks/> to empty and <projected/> to <length-before/>. Then run the following three *stages*, in exactly this order, entering a stage *only* while <projected/> is still greater than <target/>, and leaving every stage as soon as <projected/> drops to or below <target/>:

1. **Stage `TIGHTEN`**: shorten *individual sentences* without losing any content at all -- strike filler words and empty intensifiers, replace nominal constructions with plain verbs, and cut redundant restatements *within* a sentence. Every fact of the block survives this stage.

2. **Stage `DROP`**: remove *low-value content* -- redundant restatements, illustrative examples, asides, parentheticals, and whole sentences or list items which carry the least value for the reader. Content is genuinely lost in this stage.

3. **Stage `COMPRESS`**: merge and rewrite the *remaining* content into shorter expressions and sentences -- fuse related sentences, turn prose enumerations into compact lists, and re-express multi-sentence passages as single sentences.

You *MUST* *NOT* shorten *beyond* the target: stop at the very first block which brings <projected/> to or below <target/>. Undershooting <target/> by more than *10 percent* is a defect.

For *each* proposed block:

1. Set <stage/> to the string `TIGHTEN`, `DROP`, or `COMPRESS`, indicating the stage which produced this block.

2. Set <file/> to the *relative* filename path of the document. Set <line/> to the numeric 1-based line number at which the block starts in the document.

3. Set <old-text/> to the *verbatim* lines of the original block and <new-text/> to the lines which replace it. For a block that is dropped entirely, set <new-text/> to the *empty* string.

Every block *MUST* be a *self-contained text block* of the document -- a paragraph, a list item, a blockquote, or a heading together with its immediately following paragraph. It *MUST* *NOT* be an individual line and *MUST* *NOT* be a fragment of a sentence, because a shortening is only judgeable in the context of the *whole block* it rewrites.

Blocks *MUST* *NOT* overlap: every line of the document belongs to at most *one* block.

4. Set <length-block-before/> and <length-block-after/> to the <unit/> field of the result of `ase_text_metric(text: "<old-text/>")` resp. `ase_text_metric(text: "<new-text/>")`, and decrease <projected/> by their difference.

5. Set <description/> to an ultra-brief and concise Markdown-formatted description of *what* the block loses and *why* that loss is acceptable. In this description, mark up all referenced verbatim words <words/> from <old-text/> or <new-text/> as quoted strings containing monospaced text with Markdown based on the following <template/>: <template>"`<words/>`"</template>.

6. If <blocks/> is not empty, set <blocks><blocks/>,</blocks> (append a comma).

7. Append the following <template/> to <blocks/>:

<template> { "stage": <stage/>, "line": <line/>,