@inerrata-corporation/errata 2.0.0-dev.55 → 2.0.0-dev.57

package/README.txt

@@ -2,36 +2,38 @@ errata - local-first observation engine for coding agents
 
 Requires Node.js 22 or newer on PATH (https://nodejs.org).
 
-Install (Windows, no admin rights required):
+INSTALL
 
-    .\install.ps1
+    npm i -g @inerrata-corporation/errata
 
-This copies errata.mjs + the tree-sitter runtime to %LOCALAPPDATA%\errata
-and adds that directory to your user PATH. A small errata.cmd shim runs the
-bundle under your system Node.
+That's the whole install: npm drops the bundle + tree-sitter runtime and puts
+the `errata` command on your PATH. Works on Windows, macOS, and Linux. (Alpha
+dogfooders track the dev channel: `npm i -g @inerrata-corporation/errata@dev`.)
 
-It also registers a Scheduled Task (\errata\ai.errata.daemon) that auto-starts
-the daemon (`errata dash`) at every logon, launched hidden via a small .vbs so
-no console window flashes. uninstall.ps1 removes it. Note: this runs the
-installed copy under %LOCALAPPDATA%\errata - re-run install.ps1 after rebuilding
-to keep the autostarted daemon current.
+Windows autostart (optional): run install.ps1 (shipped alongside this file) to
+register a hidden logon Scheduled Task that keeps `errata dash` running across
+reboots. It installs via the SAME `npm i -g` and points the task at the
+npm-managed bundle, so a later `errata update` is picked up automatically -
+install and update never diverge. uninstall.ps1 removes the task + the install.
 
-macOS / Linux:
+USE
 
-    errata.mjs carries a `#!/usr/bin/env node` shebang. Put the dist/ folder
-    somewhere stable, then symlink the bundle onto your PATH:
+    cd /path/to/your/project
+    errata init         # auto-detects the profile + installs harness hooks
+    errata start        # observe this repo   (or 'errata dash' to watch all projects)
+    errata status       # verify the whole chain (daemon, cloud, consent, version)
 
-        chmod +x errata.mjs
-        ln -s "$PWD/errata.mjs" ~/.local/bin/errata
+Dashboard: http://127.0.0.1:7891
 
-    The resources/wasm/ folder must stay next to errata.mjs.
+UPDATE
 
-Use:
+    errata update                    # pull the newest build on your channel (npm i -g)
+    errata update --channel latest   # switch channels; the choice is persisted
+    errata update --check            # just report whether you're behind
 
-    cd C:\path\to\your\project
-    errata init         # auto-detects profile + installs harness hooks
-    errata start        # observe this repo
-    errata status       # verify the whole chain (daemon, cloud, consent)
+CLOUD (optional - errata works fully local without it)
+
+    errata login        # browser OAuth (loopback); '--device' for the code flow
 
 Model caveat (Claude Code + Claude Fable 5): the harness treats Fable 5's
 mid-turn assistant text (written between tool calls) as ephemeral - it reaches
@@ -41,16 +43,10 @@ tells the agent to restate mid-turn tags in its final message (which always
 survives), so expect reduced mid-turn capture on Fable sessions; Opus/Sonnet
 sessions are fully captured. (Verified with a 3-model matrix, 2026-07-02.)
 
-Open the dashboard: http://127.0.0.1:7891
-
-Point at a cloud (defaults to the public instance):
-
-    errata init --cloud https://your-instance --token <api-key>
-    errata login        # or browser device-code flow
-
-Per-workspace state lives at .errata/ inside each project root and is
-preserved on uninstall - delete manually if you want it gone.
+Per-workspace state lives at .errata/ inside each project root and is preserved
+on uninstall - delete manually if you want it gone.
 
-Uninstall (Windows):
+UNINSTALL
 
-    .\uninstall.ps1
+    .\uninstall.ps1                                   # Windows (removes the autostart task too)
+    npm uninstall -g @inerrata-corporation/errata     # any platform

package/errata.mjs

@@ -21216,6 +21216,16 @@ var init_client = __esm({
        *  resolvable member ids. AUTHED. Always HTTP 200 — the `status` field
        *  discriminates outcomes (incl. the autophagy-floor refusal, which is a
        *  normal "not enough collective grounding yet" result, not an error). */
+      /** Durable skills pinned to this workspace's cloud project (bodies included).
+       *  The daemon claims these on its skill-sync tick and installs them into
+       *  `.errata/skills/`, unioned into the collective set (never pruned). Returns
+       *  an empty set when nothing is pinned or the project isn't linked. */
+      async getSkillPins(projectId) {
+        return this.json(
+          "GET",
+          `/v2/skill-pins?projectId=${encodeURIComponent(projectId)}`
+        );
+      }
       async induceSkill(body2) {
         return this.json("POST", "/v2/skills/induce", body2);
       }
@@ -42362,11 +42372,11 @@ function readSkillManifest(manifestPath) {
     return [];
   }
 }
-async function syncSkills(paths, client, seed) {
+async function syncSkills(paths, client, seed, pins = []) {
   const res = await client.getSkills(void 0, seed);
   const staleDaemon = res.staleDaemon && res.latestDaemonVersion ? { latest: res.latestDaemonVersion } : void 0;
   mkdirSync5(paths.skillsDir, { recursive: true });
-  if (res.skills.length === 0) {
+  if (res.skills.length === 0 && pins.length === 0) {
     const existing = readdirSync6(paths.skillsDir).filter((f) => f.endsWith(".md"));
     if (existing.length > 0) return { written: 0, pruned: 0, ...staleDaemon ? { staleDaemon } : {} };
   }
@@ -42384,6 +42394,19 @@ async function syncSkills(paths, client, seed) {
       file: `skills/${fileName}`
     });
   }
+  for (const p of pins) {
+    const fileName = skillFileName(p.id);
+    if (keep.has(fileName)) continue;
+    keep.add(fileName);
+    writeFileSync10(join18(paths.skillsDir, fileName), p.markdown, "utf8");
+    rows.push({
+      id: p.id,
+      title: p.title,
+      layer: p.layer,
+      confidence: p.confidence,
+      file: `skills/${fileName}`
+    });
+  }
   let pruned = 0;
   for (const f of readdirSync6(paths.skillsDir)) {
     if (!f.endsWith(".md")) continue;
@@ -42820,7 +42843,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.0-dev.55" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.0-dev.57" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -43802,7 +43825,8 @@ function createWorkspaceEngine(opts) {
       const cloudId = p.attrs["cloudNodeId"];
       return typeof cloudId === "string" && cloudId !== p.id ? [p.id, cloudId] : [p.id];
     });
-    return syncSkills(paths, cloud, skillSeed);
+    const pins = profile?.projectId ? await cloud.getSkillPins(profile.projectId).then((r) => r.pins).catch(() => []) : [];
+    return syncSkills(paths, cloud, skillSeed, pins);
   };
   return {
     profile,

package/install.ps1

@@ -1,15 +1,22 @@
-# errata Windows installer / patcher (Node-bundle distribution).
-# Idempotent: re-running upgrades an existing install in place.
+# errata Windows installer + logon autostart (no admin rights required).
 #
-# Unlike the old SEA build (a 90 MB self-contained errata.exe), this ships the
-# CLI as a single bundled errata.mjs run under the system Node — so Node 22+ must
-# be on PATH. Everything else (tree-sitter WASM) rides along under resources/.
+# The ONE install path is `npm i -g @inerrata-corporation/errata` - the SAME
+# mechanism `errata update` uses, so an update actually takes effect. (The old
+# installer copied a bundle to %LOCALAPPDATA%\errata while `errata update`
+# installed into npm's global prefix - two diverging locations, so the autostart
+# task kept relaunching the STALE copy and updates silently never landed. This
+# unifies them: install + update share one npm-managed location.)
+#
+# Requires Node 22+ on PATH (npm ships with it).
+#
+# Usage:  .\install.ps1                # dev channel (the alpha default)
+#         .\install.ps1 -Channel latest
+
+param([ValidateSet('dev', 'latest')][string]$Channel = 'dev')
 
 $ErrorActionPreference = "Stop"
-$ScriptRoot = $PSScriptRoot
-if (-not $ScriptRoot) { $ScriptRoot = Split-Path -Parent $MyInvocation.MyCommand.Path }
 
-# errata runs on the system Node — fail loudly if it's missing rather than after install.
+# errata runs on the system Node - fail loudly if it's missing rather than after install.
 $node = Get-Command node -ErrorAction SilentlyContinue
 if (-not $node) {
     Write-Host "[X] Node.js not found on PATH. Install Node 22+ from https://nodejs.org and re-run."
@@ -21,41 +28,55 @@ if ([int]$nodeMajor -lt 22) {
     exit 1
 }
 
-$Target = Join-Path $env:LOCALAPPDATA "errata"
-$IsPatch = Test-Path (Join-Path $Target "errata.mjs")
-
-if ($IsPatch) {
-    Write-Host "patching existing errata install at $Target"
-} else {
-    Write-Host "installing errata to $Target  (Node $nodeMajor)"
+$Pkg = "@inerrata-corporation/errata"
+Write-Host "installing $Pkg@$Channel via npm  (Node $nodeMajor)..."
+& npm install -g "$Pkg@$Channel"
+if ($LASTEXITCODE -ne 0) {
+    Write-Host "[X] npm install failed (exit $LASTEXITCODE). Is npm on PATH?"
+    exit 1
 }
 
-if (-not (Test-Path $Target)) {
-    New-Item -ItemType Directory -Path $Target | Out-Null
+# Migrate off the OLD %LOCALAPPDATA%\errata bundle install if present: delete its
+# copied bundle and drop it from PATH, so the npm-generated `errata` shim (which
+# `errata update` keeps current) is the one that wins instead of a stale shadow.
+$LegacyDir = Join-Path $env:LOCALAPPDATA "errata"
+$LegacyMjs = Join-Path $LegacyDir "errata.mjs"
+if (Test-Path $LegacyMjs) {
+    Write-Host "migrating off the legacy %LOCALAPPDATA%\errata bundle install..."
+    foreach ($f in @("errata.mjs", "errata.cmd", "pass-worker.mjs", "consolidate-worker.mjs", "resources")) {
+        $p = Join-Path $LegacyDir $f
+        if (Test-Path $p) { Remove-Item -Path $p -Recurse -Force -ErrorAction SilentlyContinue }
+    }
+    $UserPath = [Environment]::GetEnvironmentVariable("Path", "User")
+    if ($UserPath -and ($UserPath.Split(";") -contains $LegacyDir)) {
+        $NewPath = (($UserPath.Split(";") | Where-Object { $_ -ne $LegacyDir }) -join ";").Trim(";")
+        [Environment]::SetEnvironmentVariable("Path", $NewPath, "User")
+        Write-Host "removed the stale $LegacyDir entry from user PATH"
+    }
 }
-Copy-Item -Path (Join-Path $ScriptRoot "errata.mjs") -Destination $Target -Force
-Copy-Item -Path (Join-Path $ScriptRoot "errata.cmd") -Destination $Target -Force
-$ResSrc = Join-Path $ScriptRoot "resources"
-$ResDst = Join-Path $Target "resources"
-if (Test-Path $ResDst) { Remove-Item $ResDst -Recurse -Force }
-Copy-Item -Path $ResSrc -Destination $Target -Recurse -Force
 
-$UserPath = [Environment]::GetEnvironmentVariable("Path", "User")
-$PathParts = if ($UserPath) { $UserPath.Split(";") } else { @() }
-if ($PathParts -notcontains $Target) {
-    $NewPath = if ($UserPath) { "$UserPath;$Target" } else { $Target }
-    [Environment]::SetEnvironmentVariable("Path", $NewPath, "User")
-    Write-Host "added $Target to user PATH"
-    Write-Host "  (open a new terminal for PATH changes to take effect)"
-} else {
-    Write-Host "PATH already contains $Target"
+# Resolve the npm-installed bundle so autostart points at the SAME file `errata
+# update` (npm i -g) replaces IN PLACE - this is what makes an update take effect.
+$globalRoot = (& npm root -g).Trim()
+$Mjs = Join-Path (Join-Path (Join-Path $globalRoot "@inerrata-corporation") "errata") "errata.mjs"
+if (-not (Test-Path $Mjs)) {
+    Write-Host "[X] installed, but could not locate the bundle at $Mjs - autostart not registered."
+    Write-Host "    You can still run 'errata dash' manually."
+    exit 1
 }
 
+# Persist the update channel so `errata update` tracks the one you installed.
+# (No-op display-wise; the config default is already 'dev', so this only matters
+# when you install -Channel latest.)
+try { & node "$Mjs" update --channel $Channel --check | Out-Null } catch { }
+
 # Auto-start the daemon at logon via a Scheduled Task. We launch through a hidden
-# .vbs shim because node.exe is a console app — running it from the task directly
+# .vbs shim because node.exe is a console app - running it from the task directly
 # flashes a window every logon; WScript's Run(..., 0, False) starts it windowless.
 # Task name/path mirror uninstall.ps1 (\errata\ai.errata.daemon) so the two stay
-# symmetric. Best-effort: a failure here must not fail the install.
+# symmetric. The launcher points at the npm bundle above, so a later `errata
+# update` is picked up on next logon with no re-install. Best-effort.
+if (-not (Test-Path $LegacyDir)) { New-Item -ItemType Directory -Path $LegacyDir | Out-Null }
 $VbsTemplate = @'
 ' errata daemon autostart launcher (written by install.ps1) - runs `errata dash` fully hidden.
 Set sh = CreateObject("WScript.Shell")
@@ -63,8 +84,8 @@ sh.CurrentDirectory = "__CWD__"
 sh.Run """__NODE__"" ""__MJS__"" dash", 0, False
 '@
 try {
-    $Launcher = Join-Path $Target "errata-autostart.vbs"
-    $Vbs = $VbsTemplate.Replace("__CWD__", $env:USERPROFILE).Replace("__NODE__", $node.Source).Replace("__MJS__", (Join-Path $Target "errata.mjs"))
+    $Launcher = Join-Path $LegacyDir "errata-autostart.vbs"
+    $Vbs = $VbsTemplate.Replace("__CWD__", $env:USERPROFILE).Replace("__NODE__", $node.Source).Replace("__MJS__", $Mjs)
     Set-Content -Path $Launcher -Value $Vbs -Encoding ASCII
 
     $action    = New-ScheduledTaskAction -Execute "wscript.exe" -Argument ('"{0}"' -f $Launcher)
@@ -72,19 +93,19 @@ try {
     $settings  = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable -ExecutionTimeLimit (New-TimeSpan -Seconds 0) -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1)
     $principal = New-ScheduledTaskPrincipal -UserId $env:USERNAME -LogonType Interactive -RunLevel Limited
     Register-ScheduledTask -TaskName "ai.errata.daemon" -TaskPath "\errata\" -Action $action -Trigger $trigger -Settings $settings -Principal $principal -Description "Auto-start the errata dash daemon at logon." -Force | Out-Null
-    Write-Host "registered autostart task \errata\ai.errata.daemon (starts at logon)"
+    Write-Host "registered autostart task \errata\ai.errata.daemon (starts at logon, runs the npm-installed bundle)"
 } catch {
     Write-Host "[!] could not register autostart task: $($_.Exception.Message)"
     Write-Host "    (install still succeeded - start the daemon manually with 'errata dash')"
 }
 
 Write-Host ""
-if ($IsPatch) { Write-Host "[OK] errata patched." } else { Write-Host "[OK] errata installed." }
+Write-Host "[OK] errata installed (channel: $Channel)."
 Write-Host ""
 Write-Host "Next steps:"
-Write-Host "  1. Open a new terminal so PATH refreshes."
+Write-Host "  1. Open a new terminal so PATH refreshes (npm's global bin holds the 'errata' command)."
 Write-Host "  2. cd into the workspace you want to observe."
 Write-Host "  3. errata init"
 Write-Host "  4. errata start   (or 'errata dash' to watch all projects)"
 Write-Host ""
-Write-Host "The daemon will also auto-start at every logon from now on."
+Write-Host "Update anytime with:  errata update   (autostart picks it up on next logon)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.0-dev.55",
+  "version": "2.0.0-dev.57",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {

package/uninstall.ps1

@@ -1,29 +1,35 @@
 # errata uninstaller.
 $ErrorActionPreference = "Stop"
-$Target = Join-Path $env:LOCALAPPDATA "errata"
-
-if (-not (Test-Path $Target)) {
-    Write-Host "errata is not installed at $Target."
-    exit 0
-}
 
-Write-Host "removing $Target"
-Remove-Item -Path $Target -Recurse -Force
-
-$UserPath = [Environment]::GetEnvironmentVariable("Path", "User")
-if ($UserPath) {
-    $PathParts = $UserPath.Split(";") | Where-Object { $_ -ne $Target }
-    $NewPath = ($PathParts -join ";").Trim(";")
-    [Environment]::SetEnvironmentVariable("Path", $NewPath, "User")
-    Write-Host "removed $Target from user PATH"
+# Remove the npm-global install (the binary + bundle + npm's PATH shim).
+$node = Get-Command node -ErrorAction SilentlyContinue
+if ($node) {
+    Write-Host "removing @inerrata-corporation/errata (npm global)..."
+    & npm uninstall -g "@inerrata-corporation/errata" 2>$null | Out-Null
 }
 
+# Remove the logon autostart task.
 $Existing = Get-ScheduledTask -TaskName "ai.errata.daemon" -TaskPath "\errata\" -ErrorAction SilentlyContinue
 if ($Existing) {
     Unregister-ScheduledTask -TaskName "ai.errata.daemon" -TaskPath "\errata\" -Confirm:$false
     Write-Host "removed scheduled task errata\ai.errata.daemon"
 }
 
+# Remove %LOCALAPPDATA%\errata - the autostart launcher lives here, and (for
+# machines upgraded from the pre-npm installer) so did the legacy bundle. Also
+# drop the legacy dir from user PATH if a pre-npm install left it there.
+$Target = Join-Path $env:LOCALAPPDATA "errata"
+if (Test-Path $Target) {
+    Remove-Item -Path $Target -Recurse -Force
+    Write-Host "removed $Target"
+}
+$UserPath = [Environment]::GetEnvironmentVariable("Path", "User")
+if ($UserPath -and ($UserPath.Split(";") -contains $Target)) {
+    $NewPath = (($UserPath.Split(";") | Where-Object { $_ -ne $Target }) -join ";").Trim(";")
+    [Environment]::SetEnvironmentVariable("Path", $NewPath, "User")
+    Write-Host "removed the legacy $Target entry from user PATH"
+}
+
 Write-Host ""
 Write-Host "[OK] errata uninstalled."
 Write-Host "Per-workspace .errata/ folders are left in place - delete them manually if desired."