npm - spexcode - Versions diffs - 0.2.6 → 0.2.7 - Mend

spexcode 0.2.6 → 0.2.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/spec-dashboard/dist/index.html CHANGED Viewed

@@ -19,7 +19,7 @@
         } catch (e) { /* localStorage/matchMedia unavailable — default (light) stands */ }
       })()
     </script>
-    <script type="module" crossorigin src="/assets/index-BO0Zuweu.js"></script>
+    <script type="module" crossorigin src="/assets/index-BhIslAau.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-uGs9v_9o.css">
   </head>
   <body>

package/spec-yatsu/src/cli.ts CHANGED Viewed

@@ -10,7 +10,6 @@ import { staleAxes, contentProbeFor } from './freshness.js'
 import { scenarioIndex } from './scenariofresh.js'
 import { loadEvalRemarkTracks, trackKey } from '../../spec-cli/src/issues.js'
 import { stripRefSigil } from '../../spec-cli/src/mentions.js'
-import { evaluatorTag } from './evaluator.js'
 import { putBlob, blobPath, listBlobs, gc, isStrayBlob } from './cache.js'
 import { validateTimeline, normalizeTimeline } from './timeline.js'
 import { evalTimeline, readBlobByHash, type EvalTimeline } from './evaltab.js'
@@ -303,7 +302,6 @@ async function evalCmd(args: string[]): Promise<number> {
     codeSha: headSha(root),
     ...(evidence.length ? { evidence } : {}),
     ...(timelineBlob ? { timelineBlob } : {}),
-    evaluator: evaluatorTag(),
     // the filing session — the originator an eval-comment thread loops in ([[mentions]]); absent if unknown
     ...((envSessionId() ?? undefined) ? { by: envSessionId()! } : {}),
     verdict,
@@ -313,7 +311,7 @@ async function evalCmd(args: string[]): Promise<number> {
   const ev = evidence.length
     ? evidence.map((e) => `${e.kind} ${e.hash.slice(0, 12)}…`).join(', ') + (timelineBlob ? ' +timeline' : '')
     : 'no evidence'
-  console.log(`  ✓ '${id}' scenario '${scenario.name}' → ${verdictText(verdict)} @ ${reading.codeSha.slice(0, 7)} [${reading.evaluator}] (${ev})`)
+  console.log(`  ✓ '${id}' scenario '${scenario.name}' → ${verdictText(verdict)} @ ${reading.codeSha.slice(0, 7)} (${ev})`)
   console.log(`spex yatsu eval: 1 measurement filed`)
   // @@@mis-anchor guard - a codeSha names a COMMIT, never a working tree: filed over uncommitted governed
@@ -423,7 +421,7 @@ async function retractCmd(args: string[]): Promise<number> {
   const now = left.length
     ? `latest is now ${left[left.length - 1].ts} (${verdictText(left[left.length - 1].verdict)})`
     : 'the scenario is unmeasured again (yatsu-missing)'
-  console.log(`  ⟲ '${id}' scenario '${scenario}' reading @ ${target.ts} (${verdictText(target.verdict)} [${target.evaluator}]) retracted — ${now}`)
+  console.log(`  ⟲ '${id}' scenario '${scenario}' reading @ ${target.ts} (${verdictText(target.verdict)}) retracted — ${now}`)
   console.log('spex yatsu retract: 1 reading retracted (an appended event — commit the sidecar so the retraction is attributed)')
   return 0
 }
@@ -521,7 +519,7 @@ export function formatTimeline(tl: EvalTimeline): string {
     const ev = list.length
       ? list.map((e) => e.state === 'miss' ? 'miss original file' : `${e.kind} ${(e.hash ?? '').slice(0, 12)}…`).join(', ')
       : 'no evidence'
-    const head = `  ${r.scenario.padEnd(w)}  ${verdictText(r.verdict)}  ${badge}  ${r.evaluator}  ${r.codeSha.slice(0, 7)}  ${ev}  ${r.ts}`
+    const head = `  ${r.scenario.padEnd(w)}  ${verdictText(r.verdict)}  ${badge}  ${r.codeSha.slice(0, 7)}  ${ev}  ${r.ts}`
     return r.expected ? [head, `  ${' '.repeat(w)}  expected: ${r.expected}`] : [head]
   })
   return [`spex yatsu show: '${tl.node}' — ${tl.readings.length} reading(s), newest first`, '', ...lines, ...retractLines].join('\n')

package/spec-yatsu/src/evaltab.ts CHANGED Viewed

@@ -41,7 +41,8 @@ export type EvalEntry = {
   blob: string | null
   blobKind?: EvidenceKind
   timelineBlob?: string
-  evaluator: string
+  // legacy instrument tag ('manual@1') — surfaced for old readings only, never written by new filings.
+  evaluator?: string
   // the SESSION that filed this reading ([[event-detail]] originator liveness / [[mentions]] loop-in): the
   // reachable actor an un-@'d eval remark courtesy-delivers to (the latest reading's filer is the chain's
   // first link). Surfaced so the eval detail can show whether that session is still alive. Absent on a legacy
@@ -190,7 +191,7 @@ export async function evalTimeline(id: string, ctx?: EvalContext): Promise<EvalT
       blob: primary?.hash ?? null,
       ...(primary ? { blobKind: primary.kind } : {}),
       ...(r.timelineBlob ? { timelineBlob: r.timelineBlob } : {}),
-      evaluator: r.evaluator,
+      ...(r.evaluator ? { evaluator: r.evaluator } : {}),
       ...(r.by ? { by: r.by } : {}),
       ...(r.verdict ? { verdict: r.verdict } : {}),
       ts: r.ts,

package/spec-yatsu/src/filing.ts CHANGED Viewed

@@ -7,9 +7,9 @@ export type FileResult = { ok: true; reading: Reading } | { ok: false; error: st
 // the eval seam over DATA (no argv, no file paths): a caller with a verdict in hand — the HTTP eval route,
 // a programmatic filer — appends through the SAME seam the CLI uses. Optional evidence arrives as text (a
-// report referencing the clip by hash) → a transcript blob in the same content-addressed cache; the
-// evaluator is the human hand, manual@1. yatsu still runs nothing — this only records. The dashboard files
-// nothing through this: [[event-detail]] is read-side on readings.
+// report referencing the clip by hash) → a transcript blob in the same content-addressed cache. yatsu
+// still runs nothing — this only records. The dashboard files nothing through this: [[event-detail]] is
+// read-side on readings.
 export function fileHumanReading(
   nodeId: string,
   input: { scenario: string; status: 'pass' | 'fail'; note?: string; transcript?: string; by?: string },
@@ -31,7 +31,6 @@ export function fileHumanReading(
     scenario: sc.name,
     codeSha: headSha(root),
     ...(blob ? { evidence: [{ hash: blob, kind: (buf && isJsonBlob(buf) ? 'data' : 'transcript') as EvidenceKind }] } : {}),
-    evaluator: 'manual@1',
     // the filing session (caller-passed — the human annotator has no reachable session, so it stays absent
     // there and the eval-comment loop-in is silent, per [[mentions]])
     ...(input.by ? { by: input.by } : {}),

package/spec-yatsu/src/freshness.ts CHANGED Viewed

@@ -1,11 +1,10 @@
 import { git, headSha, ancestorsOf, inAncestors, type DriftIndex } from '../../spec-cli/src/git.js'
 import type { Reading } from './sidecar.js'
-import { isEvaluatorStale } from './evaluator.js'
 import { scenarioChangeCommits, scenarioBlocksAt, type ScenarioIndex } from './scenariofresh.js'
 // the CODE axis is touch-based (DriftIndex), so a code-file rename is out of scope — the same blind spot lint's code-drift has
-export type StaleAxis = 'code' | 'scenario' | 'evaluator' | 'remark' | 'anchor'
+export type StaleAxis = 'code' | 'scenario' | 'remark' | 'anchor'
 // @@@ off-history content fallback - ancestry can't testify for a codeSha that isn't reachable from HEAD
 // (fold/rebase/squash-merge/cherry-pick all orphan the anchor), but the TREES still can: while the anchor
@@ -143,7 +142,6 @@ export function staleAxes(
     if (codeFiles.some((f) => changedSince(didx, reading.codeSha, f, probe))) axes.push('code')
     if (scenarioMoved(scIdx, didx, reading.codeSha, yatsuPath, reading.scenario, probe)) axes.push('scenario')
   }
-  if (isEvaluatorStale(reading.evaluator)) axes.push('evaluator')
   if (remarkStale(reading, remarks)) axes.push('remark')
   return axes
 }

package/spec-yatsu/src/proof.ts CHANGED Viewed

@@ -19,7 +19,8 @@ export type ProofReading = {
   fresh: boolean
   staleAxes: string[]
   score: ScoreState
-  evaluator: string
+  // legacy instrument tag ('manual@1') — present on old readings only.
+  evaluator?: string
   ts: string
   evidence:
     | { kind: 'image'; dataUri: string }
@@ -340,7 +341,7 @@ function renderReading(r: ProofReading): string {
       <span class="scenario">${esc(r.scenario)}</span>
       ${verdictBadge(r.verdict)}
       ${stale}
-      <span class="rmeta">${esc(r.evaluator)} · ${esc(r.ts)}</span>
+      <span class="rmeta">${r.evaluator ? `${esc(r.evaluator)} · ` : ''}${esc(r.ts)}</span>
     </div>
     ${r.expected ? `<div class="expected"><b>expected</b> ${esc(r.expected)}</div>` : ''}
     ${note}

package/spec-yatsu/src/scenariofresh.ts CHANGED Viewed

@@ -172,13 +172,35 @@ export function scenarioChangeCommits(idx: ScenarioIndex, yatsuPath: string, sce
   return idx.get(yatsuPath)?.get(scenario) ?? []
 }
+// (root, sha, path) -> the blob oid at that commit ('' = unresolvable: path absent there, or the commit
+// object gone). A FULL sha names an immutable tree, so entries never invalidate (freshness.ts's diffMemo
+// reasoning); the LRU only bounds memory, sized above the largest adopter reading corpus — one entry per
+// (reading, path) worst case — so a repeat board build never thrashes back into forking. This memo is what
+// keeps a fully off-history corpus (an adopter history rewrite) cheap on REPEAT builds: without it every
+// scenarioDiffers call re-forked `git rev-parse` for BOTH sides, per reading, per build (spexcode#39). A
+// symbolic rev (HEAD, a branch) moves, so it resolves live and is never cached.
+const FULL_SHA = /^[0-9a-f]{40}$/
+const oidMemo = new Map<string, string>()
+function oidAt(root: string, rev: string, path: string): string {
+  const resolve = () => { try { return git(['-C', root, 'rev-parse', `${rev}:${path}`]).trim() } catch { return '' } }
+  if (!FULL_SHA.test(rev)) return resolve()
+  const k = `${root}\x1f${rev}\x1f${path}`
+  const hit = oidMemo.get(k)
+  if (hit !== undefined) { oidMemo.delete(k); oidMemo.set(k, hit); return hit }
+  const v = resolve()
+  oidMemo.set(k, v)
+  if (oidMemo.size > 4096) oidMemo.delete(oidMemo.keys().next().value!)
+  return v
+}
 // canonical per-scenario SEMANTIC blocks of `rev:path` (the blockContent projection), for the off-history
-// content fallback ([[yatsu-core]]'s ContentProbe): resolve the blob oid first — oids are content-addressed,
-// so an unchanged file usually hits blockByOid straight from the index build — and parse only on a genuine
-// miss. null = the path is unreadable at that rev (absent, renamed since, or the rev itself is gone).
+// content fallback ([[yatsu-core]]'s ContentProbe): resolve the blob oid first (memoized above for a full
+// sha) — oids are content-addressed, so an unchanged file usually hits blockByOid straight from the index
+// build — and parse only on a genuine miss. null = the path is unreadable at that rev (absent, renamed
+// since, or the rev itself is gone).
 export function scenarioBlocksAt(root: string, rev: string, path: string): Map<string, string> | null {
-  let oid: string
-  try { oid = git(['-C', root, 'rev-parse', `${rev}:${path}`]).trim() } catch { return null }
+  const oid = oidAt(root, rev, path)
+  if (!oid) return null
   const hit = blockByOid.get(oid)
   if (hit) return hit
   try {

package/spec-yatsu/src/sidecar.ts CHANGED Viewed

@@ -22,8 +22,8 @@ export type Evidence = { hash: string; kind: EvidenceKind }
 // (timeline.ts) mapping clip moments to named steps — it anchors the reading's VIDEO evidence entry.
 // `by` is the SESSION that filed this reading (the filer, from envSessionId) — the ORIGINATOR an eval-comment
 // thread loops in on a reply ([[mentions]] implicit loop-in). Pure additive: a legacy reading without it simply
-// has no originator → silent. `evaluator` is WHO/WHAT measured (a tag like `manual@1`); `by` is the reachable
-// session behind the filing — two different axes.
+// has no originator → silent. WHO measured is deliberately NOT a schema axis — the agent is the measuring
+// hand; the retired `evaluator` tag survives on old lines only, read-tolerated like the scalar blob.
 export type Reading = {
   scenario: string
   codeSha: string
@@ -32,7 +32,8 @@ export type Reading = {
   blob?: string | null
   blobKind?: EvidenceKind
   timelineBlob?: string
-  evaluator: string
+  // legacy instrument tag (always 'manual@1') — read for old readings, never written by new filings.
+  evaluator?: string
   by?: string
   verdict?: Verdict
   ts: string
@@ -65,10 +66,9 @@ export function isJsonBlob(b: Buffer): boolean {
 // a RETRACTION is the sanctioned inverse of a filing — itself an appended event, never a deleted line
 // (the sidecar stays append-only; git shows who retracted what, when). `retracts` is the target reading's
-// `ts` within `scenario` (its natural key). Deliberately NO `evaluator` field: an old reader's line filter
-// (which requires an evaluator string) skips a retraction entirely, so version skew degrades to "the
-// retraction isn't applied yet", never to a mis-rendered reading. `by` is the retracting session; `note`
-// says why (a botched e2e filing, a wrong verdict).
+// `ts` within `scenario` (its natural key). The two event kinds are told apart POSITIVELY — a retraction
+// carries `retracts`, a reading carries `codeSha`; neither is recognized by another field's absence. `by`
+// is the retracting session; `note` says why (a botched e2e filing, a wrong verdict).
 export type Retraction = { retracts: string; scenario: string; note?: string; by?: string; ts: string }
 // parse the sidecar RAW: one event per non-blank line — a Reading, or a Retraction (a line carrying a
@@ -85,7 +85,7 @@ export function readSidecar(sidecarPath: string): { readings: Reading[]; retract
       const r = JSON.parse(t)
       if (!r || typeof r.scenario !== 'string') continue
       if (typeof r.retracts === 'string') retractions.push(r as Retraction)
-      else if (typeof r.evaluator === 'string') readings.push(r as Reading)
+      else if (typeof r.codeSha === 'string') readings.push(r as Reading)
     } catch { /* skip a malformed line */ }
   }
   return { readings, retractions }

package/spec-yatsu/src/evaluator.ts DELETED Viewed

@@ -1,24 +0,0 @@
-export const EVALUATORS: Record<string, number> = { manual: 1 }
-export const DEFAULT_EVALUATOR = 'manual'
-// the tag stamped on a reading. With no name → the default `manual`; an unknown name still tags (version 1)
-// so an out-of-band evaluator can record without the core having to know it yet.
-export function evaluatorTag(name: string = DEFAULT_EVALUATOR): string {
-  return `${name}@${EVALUATORS[name] ?? 1}`
-}
-// parse a recorded evaluator tag back into name + version (for comparing against the current version).
-export function parseEvaluator(tag: string): { name: string; version: number } {
-  const at = tag.lastIndexOf('@')
-  if (at < 0) return { name: tag, version: NaN }
-  return { name: tag.slice(0, at), version: Number(tag.slice(at + 1)) }
-}
-// a reading's evaluator tag is stale iff its evaluator is KNOWN to the core and its version is behind the
-// current one. An unknown evaluator invents no staleness — we can't version an instrument we don't define.
-export function isEvaluatorStale(tag: string): boolean {
-  const { name, version } = parseEvaluator(tag)
-  const cur = EVALUATORS[name]
-  if (cur === undefined) return false
-  return version !== cur
-}