@erclx/aitk 0.77.0 → 0.77.1

package/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "aitk",
   "description": "Automated governance, versioning, and discovery tools for Claude Code.",
-  "version": "0.77.0",
+  "version": "0.77.1",
   "author": {
     "name": "Eric Le",
     "url": "https://github.com/erclx"

package/docs/agents/context-audit-checks.md

@@ -45,7 +45,7 @@ A fence answers that test for itself, because every scan here skips a fenced lin
 
 The opening delimiter decides that for the whole block rather than each line deciding for itself. A blank line inside an indented fence carries no indentation to read, and a content line may sit at column zero inside one because CommonMark strips the fence's own indent and nothing further. Reading either as unindented ends a run that should have continued, which costs findings rather than inventing them, so no corpus count moves when it is wrong.
 
-Two fenced blocks with nothing between them read as one, so the second takes the first's answer. An unindented block written directly behind an indented one therefore leaves a run standing that it should have ended, which is a false positive rather than a missed finding. Separating the two needs the closing delimiter, which the line walker does not report, and no entry writes adjacent fences today.
+Two fenced blocks with nothing between them are one contiguous run of fenced lines, so the mark alone cannot say where the first ends. The line walker reports which block each line sits in, and the boundary re-reads indentation whenever that number changes, so an unindented block written directly behind an indented one ends the run rather than inheriting the answer above it. No markdown file this repository tracks holds that shape, because a formatter inserts a blank line between two fences on contact, and a target running these commands over an unformatted tree still can.
 
 Precision is the whole value, so recall is the accepted exposure, and two shapes are knowingly out of reach. A narration written as one bullet carrying its own before and after slips through, and nothing else sees it either. So does the perfect passive, since `has been superseded` narrates a supersession and the copula guard rejects it with the passives it exists for. A rejected alternative is a back-reference in the past tense by construction, and the standard keeps what was tried and why it lost, so a legitimate hit exists and no measure separates it from a violation. The report states that on every run, which is why the finding names a line to read rather than a line to delete. The JSON record carries the findings per entry as `entries[].narration` and the sets as `checkpoints.narration`, which is absent under `--citations-only` where the run never loads them and null where no rule publishes both.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/aitk",
   "type": "module",
-  "version": "0.77.0",
+  "version": "0.77.1",
   "description": "Infrastructure and quality tooling for developer workflows",
   "license": "MIT",
   "bin": {

package/src/context/audit.ts

@@ -306,7 +306,8 @@ function narration(
 
   const findings: NarrationFinding[] = []
   let following = false
-  let fenceInsideList: boolean | undefined
+  let fenceBlock: number | undefined
+  let fenceInsideList = false
 
   for (const line of lines) {
     // A fenced line is never a bullet, but an unindented block still ends the
@@ -314,29 +315,25 @@ function narration(
     // the bullets around it are two lists and the second has no antecedent
     // above it. A block indented under its bullet stays inside the item.
     //
-    // The first delimiter of a contiguous fenced run decides for every line of
-    // it. Reading each line instead ends the run on a blank line inside an
-    // indented fence, which has no indentation to read, and on a content line
-    // at column zero, which CommonMark permits since only the fence's own
-    // indent is stripped.
+    // The opening delimiter decides for every line of its own block. Reading
+    // each line instead ends the run on a blank line inside an indented fence,
+    // which has no indentation to read, and on a content line at column zero,
+    // which CommonMark permits since only the fence's own indent is stripped.
     //
-    // Two blocks with nothing between them are one such run, so the second
-    // inherits the first's answer and an unindented block behind an indented
-    // one leaves a run standing that should have ended. Telling them apart
-    // needs the closing delimiter, which `BodyLine` does not carry, and parsing
-    // one here would be the second fence walker this repository consolidated
-    // away after its first pair disagreed. That fix belongs in
-    // `src/markdown/scan.ts` rather than in a copy of it.
+    // The block index is what re-opens that decision, so two blocks written
+    // with nothing between them are answered separately rather than the second
+    // inheriting the first. Indentation stays the test here because what
+    // interrupts a list is this check's own judgment, and the walker only says
+    // which lines share a block.
     if (line.fenced) {
-      if (fenceInsideList === undefined) {
+      if (line.fenceBlock !== fenceBlock) {
+        fenceBlock = line.fenceBlock
         fenceInsideList = INSIDE_LIST.test(line.text)
       }
       if (!fenceInsideList) following = false
       continue
     }
 
-    fenceInsideList = undefined
-
     if (line.text.trim() === '') continue
 
     const bullet = line.text.match(TOP_BULLET)

package/src/markdown/scan.ts

@@ -39,6 +39,17 @@ export interface BodyLine {
   readonly text: string
   /** True on a fence delimiter and on every line between one pair. */
   readonly fenced: boolean
+  /**
+   * Which fenced block the line sits in, counted from one, and undefined
+   * outside one. Two blocks written with nothing between them are one
+   * contiguous run of fenced lines, so this is the only field telling them
+   * apart. Counting from one keeps the outside answer from reading as a block.
+   *
+   * The name carries the fence because `block` alone already names a run of
+   * `BodyLine` values in `src/markdown/structure.ts`, and one word meaning both
+   * an aggregate of lines and an index on each line reads as a bug.
+   */
+  readonly fenceBlock: number | undefined
 }
 
 export type BanKind = 'character' | 'word' | 'spelling'
@@ -58,17 +69,25 @@ export interface BanSets {
 }
 
 /**
- * Marks which lines sit inside a fence without dropping them.
+ * Marks which lines sit inside a fence without dropping them, and which block
+ * each of those lines belongs to.
  *
  * Each measure excludes a fence for its own reason and needs a different
  * response. The depth measure skips a fenced line so an example cannot break
  * the run around it, bullet folding treats one as a break so a bullet does not
  * absorb the block below it, and the ban scan ignores it outright. Returning
  * the mark rather than a filtered list is what lets one walk serve all three.
+ *
+ * The block index answers the consumer that has to decide per block rather
+ * than per contiguous run, since two adjacent blocks are indistinguishable
+ * through the mark alone. It is counted here because the walk already holds
+ * the opening delimiter, and a consumer parsing its own would be the second
+ * fence walker this repository consolidated away.
  */
 function markFences(texts: readonly string[], offset: number): BodyLine[] {
   const lines: BodyLine[] = []
   let fence: string | undefined
+  let fenceBlock = 0
 
   for (const [index, text] of texts.entries()) {
     const match = FENCE.exec(text.trim())
@@ -82,9 +101,15 @@ function markFences(texts: readonly string[], offset: number): BodyLine[] {
     } else if (match) {
       fenced = true
       fence = match[1]
+      fenceBlock += 1
     }
 
-    lines.push({ number: offset + index + 1, text, fenced })
+    lines.push({
+      number: offset + index + 1,
+      text,
+      fenced,
+      fenceBlock: fenced ? fenceBlock : undefined,
+    })
   }
 
   return lines