@ainova-systems/intelligence 0.11.3 → 0.11.5

package/engine/lib/contract.sh

@@ -92,8 +92,8 @@ _ver_gt() {
     IFS=. read -r -a A <<< "$a"
     IFS=. read -r -a B <<< "$b"
     for i in 0 1 2; do
-        ai=$(printf '%s' "${A[$i]:-0}" | tr -cd '0-9'); ai=${ai:-0}
-        bi=$(printf '%s' "${B[$i]:-0}" | tr -cd '0-9'); bi=${bi:-0}
+        ai="${A[$i]:-0}"; ai="${ai//[!0-9]/}"; ai=${ai:-0}
+        bi="${B[$i]:-0}"; bi="${bi//[!0-9]/}"; bi=${bi:-0}
         if [ "$((10#$ai))" -gt "$((10#$bi))" ]; then return 0; fi
         if [ "$((10#$ai))" -lt "$((10#$bi))" ]; then return 1; fi
     done

package/engine/sync.sh

@@ -86,24 +86,38 @@ echo "  Config: $CONFIG_FILE"
 echo "  Root:   $REPO_ROOT"
 echo ""
 
+# The engine never mutates the manifest, so parse its hot sections exactly
+# once: every later read_yaml_list / target lookup — in this process and in
+# adapter process substitutions — hits the in-memory copy instead of
+# spawning awk.
+load_targets_cache "$CONFIG_FILE"
+for section in rules agents skills ignore submodules; do
+    load_yaml_list "$CONFIG_FILE" "$section"
+done
+
 # Lint frontmatter across all source files (rules, agents, skills).
 # Catches issues like unquoted colons that strict YAML consumers reject.
+LINT_FILES=()
 for section in rules agents skills; do
+    load_yaml_list "$CONFIG_FILE" "$section"
     while IFS= read -r src; do
         [ -z "$src" ] && continue
-        src_dir="$(resolve_source_dir "$REPO_ROOT" "$src")"
+        src_dir="$REPO_ROOT/$src"
         [ -d "$src_dir" ] || continue
         if [ "$section" = "skills" ]; then
             while IFS= read -r f; do
-                [ -n "$f" ] && lint_frontmatter "$f"
+                [ -n "$f" ] && LINT_FILES+=("$f")
             done < <(find "$src_dir" -mindepth 2 -maxdepth 2 -name 'SKILL.md' 2>/dev/null)
         else
             for f in "$src_dir"/*.md; do
-                [ -f "$f" ] && lint_frontmatter "$f"
+                [ -f "$f" ] && LINT_FILES+=("$f")
             done
         fi
-    done < <(read_yaml_list "$CONFIG_FILE" "$section")
+    done <<< "$IS_YAML_LIST"
 done
+if [ "${#LINT_FILES[@]}" -gt 0 ]; then
+    lint_frontmatter_files "${LINT_FILES[@]}"
+fi
 
 # Adapters come from two places, discovered by filename (minus `.sh`,
 # `_template` excluded):
@@ -149,24 +163,27 @@ done
 # point of view.
 SYNC_TX_DIR="$(mktemp -d -t intelligence-sync-XXXXXX)"
 SYNC_TX_INDEX="$SYNC_TX_DIR/paths.tsv"
-SYNC_TX_SEEN="$SYNC_TX_DIR/seen"
 mkdir -p "$SYNC_TX_DIR/data"
 : > "$SYNC_TX_INDEX"
-: > "$SYNC_TX_SEEN"
 SYNC_TX_ACTIVE=0
+SYNC_TX_SEEN_LIST=$'\n'
+SYNC_TX_COUNT=0
 
 snapshot_sync_path() {
     local adapter_name="$1" rel="$2" src index present=0
-    grep -Fqx -- "$rel" "$SYNC_TX_SEEN" && return 0
-    printf '%s\n' "$rel" >> "$SYNC_TX_SEEN"
+    case "$SYNC_TX_SEEN_LIST" in
+        *$'\n'"$rel"$'\n'*) return 0 ;;
+    esac
+    SYNC_TX_SEEN_LIST="$SYNC_TX_SEEN_LIST$rel"$'\n'
     validate_output_path "$REPO_ROOT" "$CONFIG_FILE" "$adapter_name" "$REPO_ROOT/$rel"
-    index="$(wc -l < "$SYNC_TX_INDEX" | tr -d ' ')"
+    index="$SYNC_TX_COUNT"
     src="$REPO_ROOT/$rel"
     if [ -e "$src" ] || [ -L "$src" ]; then
         cp -a "$src" "$SYNC_TX_DIR/data/$index"
         present=1
     fi
     printf '%s\t%s\t%s\n' "$index" "$rel" "$present" >> "$SYNC_TX_INDEX"
+    SYNC_TX_COUNT=$((SYNC_TX_COUNT + 1))
 }
 
 restore_sync_snapshot() {
@@ -204,14 +221,17 @@ while [ "$preflight_idx" -lt "${#ADAPTERS[@]}" ]; do
     if [ -n "$TARGET_FILTER" ] && [ "$adapter" != "$TARGET_FILTER" ]; then
         continue
     fi
-    [ "$(is_target_enabled "$CONFIG_FILE" "$adapter")" = "1" ] || continue
-    output="$(get_target_output "$CONFIG_FILE" "$adapter")"
+    target_enabled_var "$CONFIG_FILE" "$adapter"
+    [ "$IS_TGT_ENABLED" = "1" ] || continue
+    target_output_var "$CONFIG_FILE" "$adapter"
+    output="$IS_TGT_OUTPUT"
     [ -n "$output" ] || output=".$adapter"
     validate_output_path "$REPO_ROOT" "$CONFIG_FILE" "$adapter" "$REPO_ROOT/$output"
     records="$(adapter_contract_records "$adapter" "$adapter_file" "$output")" || exit 1
     while IFS=$'\t' read -r kind value; do
         [ "$kind" = "requires" ] || continue
-        if [ "$(is_target_enabled "$CONFIG_FILE" "$value")" != "1" ]; then
+        target_enabled_var "$CONFIG_FILE" "$value"
+        if [ "$IS_TGT_ENABLED" != "1" ]; then
             echo "ERROR: targets.$adapter requires enabled target '$value'." >&2
             echo "       Enable it first: intelligence adapter enable $value" >&2
             exit 1
@@ -240,7 +260,8 @@ while [ "$adapter_idx" -lt "$adapter_count" ]; do
     fi
 
     # Check if target is enabled in config
-    enabled=$(is_target_enabled "$CONFIG_FILE" "$adapter")
+    target_enabled_var "$CONFIG_FILE" "$adapter"
+    enabled="$IS_TGT_ENABLED"
     if [ "$enabled" != "1" ]; then
         if [ -n "$TARGET_FILTER" ]; then
             echo "ERROR: Adapter '$TARGET_FILTER' is disabled in $CONFIG_FILE." >&2
@@ -251,7 +272,8 @@ while [ "$adapter_idx" -lt "$adapter_count" ]; do
     fi
 
     # Get output directory
-    output=$(get_target_output "$CONFIG_FILE" "$adapter")
+    target_output_var "$CONFIG_FILE" "$adapter"
+    output="$IS_TGT_OUTPUT"
     if [ -z "$output" ]; then
         output=".$adapter"
     fi
@@ -289,6 +311,9 @@ trap - EXIT INT TERM
 # Warn about unsynced directories
 warn_unsynced "$REPO_ROOT" "$CONFIG_FILE"
 
+# Report adapter-agnostic source context pressure on every successful sync.
+report_context_source_sizes "$REPO_ROOT" "$CONFIG_FILE"
+
 # Report model overrides that drift from intelligence-sync defaults
 # (helpful when defaults move forward — e.g., gpt-5.5 -> gpt-5.6).
 report_model_drift "$CONFIG_FILE"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ainova-systems/intelligence",
-  "version": "0.11.3",
+  "version": "0.11.5",
   "description": "Build, version and distribute AI agent intelligence across your organization — one CLI, versioned Intelligence Packages, and a sync engine for Claude Code, Cursor, Copilot, Codex, Pi and OpenCode.",
   "bin": {
     "intelligence": "bin/intelligence.js"

package/packages/sync/agents/intelligence-architect.md

@@ -8,6 +8,7 @@ skills:
   - intelligence-add-agent
   - intelligence-add-skill
   - intelligence-extract-skill
+  - intelligence-compact-context
   - intelligence-review-skills
   - intelligence-learn-from-repository
   - intelligence-learn-from-context
@@ -45,6 +46,7 @@ The per-artifact checks are procedure, so they live in the meta-skills rather th
 |---|---|
 | `intelligence-add-rule` / `intelligence-add-agent` / `intelligence-add-skill` | author one artifact |
 | `intelligence-extract-skill` | turn an observed workflow into a skill |
+| `intelligence-compact-context` | reduce context without changing behavior or teaching terse output |
 | `intelligence-review-skills` | audit the layer for duplication, drift, size, hardcoded paths |
 | `intelligence-learn-from-repository` | recover and complete first-time repository onboarding |
 | `intelligence-learn-from-context` | fold one later session lesson into an established layer |

package/packages/sync/references/adapters.md

@@ -131,18 +131,26 @@ Use the engine library instead of copying parsers or file-handling logic.
 |---|---|
 | `resolve_source_dir(repo_root, source)` | Resolve a manifest source to its local directory. |
 | `read_yaml_list(config, section)` | Stream entries from `sources.<section>`. |
+| `load_yaml_list(config, section)` | Same list into `IS_YAML_LIST`, cached — no subprocess on repeat reads. |
 | `get_frontmatter_value(key, file)` | Read a scalar from the first frontmatter block. |
+| `frontmatter_index(keys, file...)` | Read several frontmatter scalars for many files in one pass (`\x1f`-separated rows; special key `paths#` counts `paths:` lines). |
 | `has_frontmatter(file)` / `has_paths(file)` | Inspect source shape. |
 | `strip_frontmatter(file)` | Emit the body without its first frontmatter block. |
 | `get_model(config, tool, tier)` | Resolve a `heavy`, `standard` or `light` model, including manifest overrides. |
 | `get_model_default(tool, tier)` | Read the built-in model default. |
+| `load_model_tiers(config, tool)` / `resolve_model_var(tier)` | Resolve the three standard tiers once, then map per file without subprocesses. |
 | `copy_skill_bundle(src, dest)` | Copy `SKILL.md` and all resources safely, normalize Markdown and quote free-text frontmatter. |
+| `copy_skill_bundle_dirs(dest_root, src...)` | Batch form: copy every skill directory into `dest_root/<name>` with one copy and one finalize pass. |
 | `sync_open_skill_dirs(root, config, dest)` | Own and populate a shared Agent Skills directory such as `.agents/skills/`. |
 | `finalize_output_file(file)` | Expand layout tokens and normalize line endings; required for every emitted text file. |
+| `finalize_output_files(file...)` / `finalize_copy_files(dest, src...)` | Batch forms: finalize in place, or copy-and-finalize into a directory, in one process. |
+| `emit_wrapped_bodies(spec)` | Emit many header + source-body + tail outputs in one process (see `engine/lib/common.sh` for the spec format). |
 | `get_target_field(config, target, field)` | Read another field from the target configuration. |
 | `repo_rel_link(root, path)` | Produce a stable repo-relative link for a committed output. |
 
-`lint_frontmatter` is run across all inputs by the engine before adapters execute. It warns about common YAML hazards; adapters should not duplicate that pass.
+`lint_frontmatter` is run across all inputs by the engine before adapters execute (batched as `lint_frontmatter_files`). It warns about common YAML hazards; adapters should not duplicate that pass.
+
+Prefer the batched forms inside per-file loops: a process spawn costs tens of milliseconds on Git Bash for Windows, so one-awk-per-file adapters turn large projects into minutes of process creation. The built-in adapters are the reference for the pattern.
 
 ## Rules, skills and agents
 
@@ -164,6 +172,10 @@ Intelligence routes always-on rules once through `AGENTS.md` for tools that cons
 
 If a new adapter relies on `AGENTS.md` for always-on rules, its target must require `agents`. Add that invariant to `engine/sync.sh` when contributing the adapter upstream.
 
+Every successful sync prints an adapter-agnostic `CONTEXT:` summary with source byte totals and file counts. It separates always-on rules from custom context (scoped rules, agent prompts and skill entry points), then reports a numeric `agents-md` byte count and `generated`, `not-generated`, or `disabled` status; supporting skill assets are excluded until explicitly read. Adapter-specific hard limits and suppression controls stay inside the adapter that owns them.
+
+The Codex adapter checks its `project_doc_max_bytes` default (32 KiB). When generated `AGENTS.md` exceeds it, sync prints the byte count and a sufficient Codex setting. The warning says "may truncate" because a developer can already have a larger override. `targets.codex.warn_project_doc_limit` accepts `true` or omission for the default threshold, a positive byte count to match another effective limit, or `false` to disable the Intelligence warning. Both inline and block target forms work, and the field does not change Codex configuration. The warning remains visible in `sync --compact`.
+
 ### Skills
 
 Skills follow the [Agent Skills standard](https://agentskills.io). Copy each skill directory as a complete bundle—not only `SKILL.md`—because its body may reference `references/`, `scripts/` or `assets/` beside it.

package/packages/sync/references/conventions.md

@@ -385,7 +385,7 @@ The permanent applied-schema key is the top-level scalar `schema_version` in `in
 The public lifecycle is deliberately compact:
 
 - `intelligence init [--preview|--apply]` is universal: it creates a new setup, aligns an existing Intelligence project, or plans/applies conversion of an eligible legacy Intelligence Sync project.
-- `intelligence sync [adapter] [--compact]` first aligns an existing Intelligence project with the installed CLI, restores a missing store strictly from `intelligence.lock`, then renders. Compact mode shows only final status on success and all diagnostics on failure. In CI it refuses an alignment that would change tracked files and points to a local `intelligence init --apply` plus review/commit.
+- `intelligence sync [adapter] [--compact]` first aligns an existing Intelligence project with the installed CLI, restores a missing store strictly from `intelligence.lock`, then renders. Compact mode shows context sizes, actionable warnings and final status on success, and all diagnostics on failure. In CI it refuses an alignment that would change tracked files and points to a local `intelligence init --apply` plus review/commit.
 - `intelligence update [@scope/name] [--preview|--apply]` is the only update surface. It prints the CLI/project/package plan; default mode prompts, `--preview` never writes, and `--apply` does not prompt. It never moves `ref:` pins.
 - `intelligence package add|remove|list|search` owns package inventory.
 - `intelligence adapter list|create|enable|disable|remove` owns adapter inventory and target state.

package/packages/sync/rules/intelligence-authoring.md

@@ -60,7 +60,7 @@ The mistakes that actually happen, in order of frequency:
 
 ### Invariants
 
-- **Never state behaviour of a tool or engine you have not verified in its documentation or source.** This invariant exists because the claim *"Claude Code does not auto-load `.claude/rules/`"* was once written into this layer as fact. It is false — rules without `paths:` load at launch, path-scoped ones activate on matching files, and custom subagents inherit both (Claude Code docs: *Memory → Organize rules with `.claude/rules/`*, and *Subagents → What loads at startup*). An unverified claim about tooling is worse than a gap: nothing in the repository contradicts it, so it silently reshapes every decision downstream.
+- **Never state behaviour of a tool or engine you have not verified in its documentation or source.** An unverified claim about tooling is worse than a gap: nothing in the repository contradicts it, so it silently reshapes every decision downstream. Verified means a page you can cite - for how rules load, the Claude Code docs *Memory → Organize rules with `.claude/rules/`* and *Subagents → What loads at startup*.
 - **Never write a current defect into a rule as if it were the design.** Known breakage belongs in one place that says so. Every other rule describes the project *as it is meant to work* — a workaround documented as procedure becomes permanent.
 - **Never link from one always-on rule to another.** Always-on rules are inlined verbatim into `AGENTS.md`, and the path-scoped channels carry only scoped rules, so a relative link is dead in at least one output. Name the rule instead; it loads on its own.
 

package/packages/sync/skills/intelligence-compact-context/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: intelligence-compact-context
+description: "Reduce rules, agents, and skills without changing behavior or teaching terse output"
+argument-hint: "[target: rules|agents|skills|all]"
+agent: intelligence-architect
+---
+
+# Compact intelligence context
+
+Reduce persistent and on-demand prompt cost by changing structure before wording.
+The result must preserve the layer's behavioral contract and ordinary, complete
+language; a smaller file is not a success if agents become terse, vague, or less
+reliable.
+
+## Analyze
+
+1. Resolve `<manifest>`, `<content-dir>`, and `<module>`. Enumerate the source
+   directories declared under `sources.rules`, `sources.agents`, and
+   `sources.skills`; skip installed package sources and generated adapter output.
+
+2. Read `<module>/references/conventions.md`, the `intelligence-authoring` rule,
+   and [references/principles.md](references/principles.md). The reference
+   explains which forms of indirection save context and which merely move text.
+
+3. Run `<sync-cmd> --compact` and save the `CONTEXT:` line as the baseline,
+   including its rendered `agents-md` byte count. Record individual source-file
+   byte and line counts for the requested target.
+
+4. Invoke `intelligence-review-skills` for the same target. Reuse its findings
+   for duplication, misplaced content, scope, stale artifacts, pressure markers,
+   history narrative, and description budget; do not reproduce its audit.
+
+5. Build a semantic ledger before drafting edits. For every candidate passage,
+   record:
+
+   - the behavior, constraint, procedure, or expertise it carries;
+   - its one authoritative owner;
+   - when it must load;
+   - the reason or example needed to apply it correctly;
+   - the repository evidence or external documentation that supports it.
+
+   Two passages are duplicates only when those meanings match. Similar wording
+   with different scope, priority, or failure behavior is not duplication.
+
+## Draft the compaction
+
+6. Apply structural reductions in this order:
+
+   1. Replace an instruction with a deterministic gate or command when the
+      repository already enforces it.
+   2. Delete generic knowledge and facts the agent can read directly from the
+      repository, unless a non-obvious interpretation is the instruction.
+   3. Keep one owner for duplicated guidance and remove the copies. A skill may
+      invoke another skill by name; an agent may list a skill; neither restates
+      the called artifact.
+   4. Add `paths:` to rules that matter only in part of the repository.
+   5. Move multi-step procedures from rules or agents into skills, and move
+      reusable constraints or expertise to the artifact type that owns them.
+   6. Move optional skill detail into skill-local `references/` and state the
+      exact condition that requires each file. Do not use an always-loaded
+      import or an unconditional read step and call that compaction.
+   7. Tighten prose only after the preceding reductions are exhausted.
+
+7. Preserve language quality while tightening prose:
+
+   - Use complete grammatical sentences and ordinary project vocabulary.
+   - Preserve the reason when it guides judgment, and keep one minimal example
+     when the rule would otherwise be ambiguous.
+   - Preserve triggers, boundaries, ordering, failure behavior, verification,
+     and output contracts exactly.
+   - Shorten descriptions by retaining the unique trigger that distinguishes a
+     sibling; never reduce them to vague labels.
+   - Do not add instructions telling agents to be terse, abbreviated, clipped,
+     or concise unless that response style is an explicit product requirement.
+   - Do not turn prose into fragments, dense acronyms, slash-separated phrases,
+     or unexplained labels. Compression targets redundancy, not grammar.
+
+8. Treat references according to load behavior:
+
+   - A conditional skill reference saves startup context.
+   - An always-loaded import improves organization but does not save context.
+   - A plain link is navigation, not guaranteed instruction loading; never hide
+     a critical constraint behind one.
+   - An always-on rule that is too large normally needs deletion, scoping, a
+     gate, or conversion of its procedure into a skill—not a reference index.
+
+## Approval and apply
+
+9. Present a proposal grouped as `DELETE`, `MERGE`, `SCOPE`, `MOVE`,
+   `REFERENCE`, or `REWRITE`. For each item show the owner, semantic contract,
+   estimated bytes saved, and any behavior that could change. Ask for approval
+   before changing meaning, ownership, scope, or load timing.
+
+10. Apply only accepted items to project-owned sources. Preserve unapproved
+    passages byte-for-byte and never edit generated output or installed package
+    sources locally.
+
+## Verify
+
+11. Compare the semantic ledger with the diff. Every original behavior must be
+    present once in its authoritative owner, deliberately removed with approval,
+    or enforced by the named deterministic mechanism. Check that no move created
+    a dead link, unconditional reference load, conflicting instruction, or
+    broader scope.
+
+12. Run `<sync-cmd> --compact`, require `IS_STATUS=ok`, then run
+    `intelligence status --check`. Compare the new `CONTEXT:` line and per-file
+    counts with the baseline.
+
+13. Exercise three representative prompts when the environment supports agent
+    evaluation: one direct case governed by a compacted instruction, one adjacent
+    judgment case that needs its reason, and one ordinary explanation that would
+    reveal clipped language. If behavioral evaluation is unavailable, report
+    that explicitly; a smaller byte count proves size reduction, not quality.
+
+14. Report bytes and percentage saved for always-on and custom context, the
+    before-and-after `agents-md` size, the artifacts changed, the semantic
+    checks performed, and any remaining item that needs an owner decision.

package/packages/sync/skills/intelligence-compact-context/references/principles.md

@@ -0,0 +1,58 @@
+# Context compaction principles
+
+Use these principles to decide what to remove, relocate, or keep. They summarize
+current primary guidance; they do not replace repository evidence or an
+artifact's semantic ledger.
+
+## What consistently improves instruction context
+
+- Keep persistent instructions specific, focused, and grounded in behavior the
+  agent would otherwise miss. Current vendor guidance consistently recommends
+  removing unclear or conflicting instructions because they reduce adherence.
+- Scope narrow guidance so it loads only for matching work. Anthropic, GitHub,
+  and Cursor all recommend path-specific rules instead of making framework or
+  component guidance repository-wide.
+- Prefer one authoritative statement. Duplicate instructions spend context;
+  slightly different copies can also become a conflict whose winner is
+  unpredictable.
+- Keep what is non-obvious: project conventions, pitfalls, rationale, failure
+  behavior, and evidence-backed exceptions. Remove generic tutorials and facts
+  the agent can obtain directly from code or configuration.
+- Use progressive disclosure for skills. Keep the executable core in
+  `SKILL.md`; move optional detail to a nearby reference and name the exact
+  condition under which the agent reads it.
+- Test changes on representative work. Instruction quality is behavioral, so a
+  byte reduction alone cannot prove that meaning or adherence survived.
+
+## References are not automatically compression
+
+Indirection saves context only when the target is not loaded until it is needed.
+Anthropic explicitly notes that `@path` imports still enter startup context. A
+plain Markdown link has the opposite risk: some tools will not load it at all.
+
+Use a reference when all three conditions hold:
+
+1. the parent artifact remains actionable without the detail;
+2. the parent gives a precise condition for reading the reference; and
+3. every adapter that needs the detail copies or can resolve the reference.
+
+This works naturally for skill-local `references/`. It is usually the wrong fix
+for an always-on rule: scope the rule, convert its procedure to a skill, enforce
+it mechanically, or delete redundant material instead.
+
+## Preserve natural language
+
+Compaction changes the information architecture, not the desired voice of the
+agent. Keep complete sentences, clear headings, reasons that support judgment,
+and one concrete example where it prevents ambiguity. Do not achieve a smaller
+file by instructing the agent to answer tersely or by rewriting the source into
+telegraphic fragments. Persistent instructions shape behavior as well as task
+decisions, so clipped source language is a quality risk rather than a valid
+optimization.
+
+## Primary sources
+
+- [Claude Code memory documentation](https://code.claude.com/docs/en/memory) — specific instructions, path scoping, conflict removal, and why imports do not reduce startup context.
+- [Agent Skills best practices](https://agentskills.io/skill-creation/best-practices) — omit generic knowledge, keep coherent units, and use conditional progressive disclosure.
+- [GitHub Copilot custom-instruction guidance](https://docs.github.com/en/copilot/tutorials/customize-code-review) — short, focused instructions, path-specific files, concrete examples, and iteration.
+- [Cursor rules documentation](https://docs.cursor.com/context/rules) — focused, actionable, scoped rules and composable rule files.

package/packages/sync/skills/intelligence-review-skills/SKILL.md

@@ -19,23 +19,26 @@ The name uses "skills" as shorthand for all AI artifacts (rules, agents, and ski
 
 3. **Skip installed package sources.** Sources under `<module>/` (`<module>/rules`, `<module>/agents`, `<module>/skills/intelligence-*`) are package-owned and restored by CLI lifecycle operations, so a local "fix" is not durable. Never propose a project-local edit to them. If one is wrong, make an upstream proposal instead.
 
-4. **Never read or edit generated output** (`.claude/`, `.cursor/`, `.github/`, `.codex/`, `.agents/`, `.pi/`, `.opencode/`, `AGENTS.md`). Sync owns those entirely; the finding always belongs to the source.
+4. **Never read or edit generated output** (`.claude/`, `.cursor/`, `.github/`, `.codex/`, `.agents/`, `.pi/`, `.opencode/`, `AGENTS.md`). Sync owns those entirely; the finding always belongs to the source. Reading its byte count from sync's `CONTEXT:` summary or a byte-count command is the metadata-only exception—do not open the output to audit its prose.
 
 ## Steps
 
 5. **Pull git history** (when available) for each artifact — last edit, edit count, first-add date. A stale candidate has no recent edits *and* nothing cross-referencing it.
 
-6. **Run the detection checks.** Judgement decides; the checks only make a finding evidence rather than an impression.
+6. **Run the detection checks.** Resolve the shared agents target output from `<manifest>` and measure only its byte count; use the `agents-md` value when a fresh `CONTEXT:` summary is already available. Apply the shared instruction budget below, but do not run sync during this read-only audit. Judgement decides; the checks only make a finding evidence rather than an impression.
 
    | Check | What it is | Proposed action |
    |---|---|---|
    | **Duplicate content** | Two artifacts cover overlapping scope, or their descriptions share trigger phrases | `MERGE` — present both, propose one |
    | **Misplaced content** | A checklist or procedure in an agent body; a convention in an agent; a workflow in a rule; expertise in a skill (the *Pick the right artifact* table in `intelligence-authoring`) | `MOVE` — a move, not a rewrite: both files change together |
    | **Over the cap** | `SKILL.md` over 1000 lines, rule over 500, agent over 200 | `SPLIT` — two artifacts, or move detail into `references/<topic>.md` |
+   | **Shared instruction budget** | The measured shared agents output, or `agents-md` in sync's `CONTEXT:` summary, is over 32 KiB (32,768 bytes) | `COMPACT` — this is Intelligence's recommended maximum, not an adapter rejection threshold; use `intelligence-compact-context` to reduce the owning sources without teaching terse output |
    | **Rule links to a rule** | A markdown link from one rule to another (`R1`) | `UNLINK` — name the rule instead: always-on rules are inlined into `AGENTS.md` and the scoped channels carry only scoped rules, so the link is dead in at least one output |
    | **Machine facts in a rule** | OS, shell, editor or a local absolute path (`R2`) | `MOVE` — these belong in a personal, gitignored `CLAUDE.md`; a rule is committed and read by everyone, including whoever is on another platform |
    | **Literal path or command in a skill** | A path *outside the skill's own folder* baked into a procedure (`R3`) | `PARAMETERIZE` — a skill is *executed*, so a literal path breaks the moment the layout moves; resolve it from a rule or from `<manifest>`. **Exempt:** the skill's own bundle (`references/`, `scripts/`, `assets/` — content is co-located with its skill by default); rules and agents (describing the repository is their job); an example inside an output-format block; the resolution step itself |
    | **Skill with no verification** | Nothing at the end proves the procedure worked (`R4`) | `FLAG` — a procedure that proves nothing is a note, or just the work: give it a verification, or delete it |
+   | **Pressure marker** | A heading or section named CRITICAL / MANDATORY / HARD RULE / READ FIRST, or a density of `MUST` / `NEVER` / `ALWAYS` with no reason beside it (`R5`) | `REWRITE` - plain heading, one reason per constraint; when several instructions are each marked critical the marker stops carrying information, so keep emphasis for the one instruction demonstrably under-weighted without it |
+   | **History narrative** | A PR number, incident id, commit SHA, date or "this session" inside a rule body (`R6`) | `REWRITE` - keep the causal sentence, drop the archaeology; a rule's authority is the behaviour it prescribes, and git history keeps the date |
    | **Reserved prefix** | A project artifact named `intelligence-*` | `RENAME` — the prefix belongs to the sync package and collides in generated output |
    | **Naming** | A skill that is not `<domain>-<verb>-<noun>`, or a domain invented rather than reused | `RENAME` — or introduce the new domain deliberately |
    | **Stale** | No edits in 6+ months and nothing cross-references it | `ARCHIVE` — move to `<content-dir>/_archive/` |
@@ -50,6 +53,9 @@ The name uses "skills" as shorthand for all AI artifacts (rules, agents, and ski
    Detection commands, portable on purpose — no `\b` and no `-P`, so the same command works in Git Bash on Windows, on macOS (BSD grep) and on Linux. Run each over the source directories resolved in step 2, never over generated output:
 
    ```sh
+   # Shared instruction budget — resolve this output path from <manifest>
+   wc -c "<agents-output>"
+
    # R1 — a markdown link from one rule to another
    grep -rnE '\]\([^)]*\.md\)' <rule-dirs>
 
@@ -62,9 +68,17 @@ The name uses "skills" as shorthand for all AI artifacts (rules, agents, and ski
 
    # R4 — skills whose body never mentions verifying anything (-L lists files with NO match)
    grep -riLE --include=SKILL.md 'verif|expect|assert|check|test|IS_STATUS' <skill-dirs>
+
+   # R5 - pressure markers: a heading or label named for urgency, then absolute-language density per file
+   grep -rnE '^#+ .*(CRITICAL|MANDATORY|HARD RULE|READ FIRST)|\((CRITICAL|MANDATORY|HARD RULE)\)' <rule-dirs> <agent-dirs> <skill-dirs>
+   grep -rcE '(MUST|NEVER|ALWAYS)' <rule-dirs> <agent-dirs> <skill-dirs> | grep -vE ':0$'
+
+   # R6 - history narrative in a rule body: PR numbers, incident ids, dates, "this session", commit SHAs
+   grep -rniE -e '(#|PR )[0-9]{3,}' -e '[0-9]{4}-[0-9]{2}-[0-9]{2}' -e 'this session|origin session' \
+     -e '`[0-9a-f]{7,40}`' <rule-dirs>
    ```
 
-   `R4` is a coarse net, not a verdict: a skill that merely *mentions* a verification command anywhere passes it. Read the final step of every skill regardless — the question is whether something at the end **proves the work landed**, not whether the word appears.
+   `R4` is a coarse net, not a verdict: a skill that merely *mentions* a verification command anywhere passes it. Read the final step of every skill regardless — the question is whether something at the end **proves the work landed**, not whether the word appears. So are `R5` and `R6`: a `NEVER` that carries its reason and a date inside a frontmatter template are both legitimate hits, and the row's action applies only where the marker or the id is doing no work.
 
 7. **Ask subtraction first.** Before proposing any `SPLIT`, `REWRITE` or `PATCH`, ask whether the artifact should exist at all, whether two should become one, and whether the rule could be replaced by a gate the model cannot skip. A deletion is a better outcome than a tidy-up, and the punch-list should say so when it is true.
 
@@ -84,3 +98,4 @@ The user accepts items individually; bulk-accept for low-impact tweaks is fine.
 
 - `intelligence-learn-from-context` — single-session lesson capture; this skill delegates accepted edits to its Phase B
 - `intelligence-extract-skill` — when the audit surfaces a workflow that should become a skill
+- `intelligence-compact-context` — approval-gated structural compaction when the shared instruction budget or source size needs reduction