axstack 0.36.1 → 0.38.0

package/skills/axstack-explain/references/delivery.md

@@ -0,0 +1,22 @@
+# Delivery and holds
+
+Use this single fallback rule for Explain and direct Anatomy delivery.
+A whiteboard-defense explanation covers a whole system, PR, run or change
+under [Whiteboard defense](whiteboard-defense.md).
+If the reviewer is unavailable, hold the whiteboard-defense explanation and name the unavailable reviewer.
+Hold a whiteboard-defense explanation still failing claim review after two repair rounds with
+the same author, naming unresolved findings. Never deliver it unreviewed or as reviewed.
+Visual-only findings follow the visual rule, and claim findings hold the whiteboard-defense explanation.
+
+For a missing preview or render tool, unavailable verifier or check, or page
+absent after ambiguous `html_render`, hold the page and answer in plain prose
+naming the held page and the reason.
+Whiteboard-defense plain prose still requires `axstack-explainer-review`.
+If a required author or reviewer seat is unavailable, hold the visual and
+answer in plain prose naming the held visual.
+Replace a visual still failing checks after two repair rounds with the same
+author by plain prose with the reason.
+The driver never writes a substitute visual.
+Each repair round returns findings to the same author and rechecks the exact final bytes.
+An anatomy page above the size cap follows [Anatomy](../../axstack-anatomy/SKILL.md)
+for oversized delivery, with the same author and reviewer bindings.

package/skills/{axstack-diagram → axstack-explain}/references/fidelity.md

@@ -6,14 +6,8 @@ For uncommitted sources, use the content hash and mark their pins unknown.
 Keep the source map outside the reader view.
 Display the short SHA.
 
-Give planned and unknown nodes a visible marker in the node label and their card, if any.
-Use the literal marker `planned` or `unknown` for all five types.
+Give planned and unknown nodes a visible marker in the node label.
 Give planned and unknown edges a visible `planned` or `unknown` marker in the edge label.
-For dashed styling, use only properties the pinned schema accepts and verify with `validate`.
-This is an extra cue, such as a dashed relationship where supported.
-The pinned node collections reject `variant`.
-Add a planned or unknown legend entry only for sequence and dataflow.
-Architecture, workflow, and lifecycle reject a `dashed` legend entry.
 In Mermaid, use the same visible markers and a dashed cue where its syntax permits.
 
 Treat about 9 core nodes as a signal to split.

package/skills/axstack-explain/references/inline-pages.md

@@ -9,10 +9,11 @@ Use T3 theme variables and follow the live theme.
 Only an explicit user theme request overrides the page theme.
 Use `--background`, `--foreground`, `--muted-foreground`, `--ring`,
 `--font-sans`, and `--font-mono` for their named purposes.
-The dark default stays archify-only.
 
 Use fluid width, with zero outer horizontal padding.
 Never use an outer frame, banner, or viewport heights.
+Anatomy may retain its figure card as an inner panel with at least 16px padding
+and `var(--radius)`; its page wrapper still has zero gutters and no background.
 Let content set the page height. Use fixed chart heights.
 Set frame `height` to the larger contentHeight of the two previews, capped at 2000.
 
@@ -44,7 +45,9 @@ Pages never use storage, cookies, modals, or popups.
 
 Keep page bytes, SHA-256, and attachmentId in run evidence.
 Scan the exact bytes of every page for remote `src`, `srcset`, and `href` on loaded resources.
-Scan for `@import`, `url()`, `fetch`, XHR, WebSocket, EventSource, and meta refresh.
+Scan for `@import`, CSS `url(` tokens at a word boundary with non-`#` targets, `fetch`, XHR, WebSocket, EventSource, and meta refresh.
+A word boundary before `url(` excludes identifiers such as `knurl(`; local `url(#id)` remains allowed.
+Trim CSS URL target whitespace and quotes before checking whether it starts with `#`.
 Reject scan matches except local `url(#id)` references such as SVG markers and gradients.
 
 Before publishing, run `html_preview` at 728px dark and 360px light.
@@ -63,13 +66,10 @@ Follow [UI verification](../../axstack/references/ui-verification.md) for that p
 ## Publish or fall back
 
 Publish one page per answer.
-Publish with `html_render` from exactly the checked bytes.
+Only the driver publishes with `html_render` from exactly the checked bytes.
 Fix a failed check and rerun on the new bytes.
 A byte change invalidates affected checks and review.
-If either tool cannot be found after one bounded discovery attempt, fall back
-to chat with Mermaid and state the reason.
-If a check, verifier, or required reviewer is unavailable or still fails, fall
-back to chat with Mermaid and state the reason.
+Follow [Delivery](delivery.md) for missing tools, seats, failed checks and repair holds.
 After an ambiguous `html_render` result, never retry.
 After an ambiguous `html_render` result, read `t3_thread_read`, keep the page
-if present, and otherwise fall back to chat.
+if present, and otherwise hold the page and follow Delivery.

package/skills/axstack-explain/references/visual-qa.md

@@ -8,18 +8,16 @@ rendering matters.
 Browser and visual checks must run in the delegated `axstack-ui-verifier` in its own detached checkout; outputs go to its private evidence folder, never the driver worktree.
 
 1. Identify the final artifact bytes and theme. The explicit user theme wins;
-   otherwise use the dark default.
-   For archify output, bind the `axstack-ui-verifier` pass to the finalize receipt's `artifact.sha256`.
-   For archify output, bind `axstack-explainer-review` to the same finalize receipt's `artifact.sha256`.
+   otherwise use `prefers-color-scheme`.
 2. Delegate the rendered pass through [UI verification](../../axstack/references/ui-verification.md).
    Record actual desktop and mobile observations, or name the missing layout
    check.
 3. Have the verifier exercise relevant interactions, keyboard and screen-reader
    accessibility, and reduced-motion behavior. Report each unavailable check
    honestly.
-4. The explainer reviewer checks text and source fidelity. Keep source
+4. The explainer reviewer checks text and source fidelity, including every node
+   and edge against source. Keep source
    correctness, tests, rendered behavior, independent review, and publication
    evidence separate.
-   For archify output, require `axstack-explainer-review` of every node and edge against source.
 5. Bind review to the exact artifact identity. Any byte change invalidates the
    affected approval and requires fresh QA and review.

package/skills/axstack-explain/references/whiteboard-defense.md

@@ -0,0 +1,59 @@
+# Whiteboard defense
+
+Apply whiteboard defense to a whole system, PR, run or change, whether shipped,
+in review or planned. Narrow questions stay proportional.
+Triggers include "help me defend X", "whiteboard defense for PR N", and
+"prep me for questions on X".
+Extend §2.1's base for every explanation with the five elements below.
+Use the §1.6 decision trail as evidence for decisions.
+Spec-readback identity wins when defending a spec.
+Show-your-work and blast-radius requests keep their rules unless the user also
+asks to understand or defend the whole.
+
+1. Cover how it works at a high level and where data flows.
+2. Cover key decisions as "why X instead of Y".
+3. Cover the main data structures or state and why they were chosen.
+4. Cover what happens if a user, dependency, agent or attacker misbehaves or
+   acts maliciously.
+5. Cover where it fails and how that failure shows.
+
+Traced means source, tests, observation or recorded design (spec, run-record
+Decisions, ADR, PR), each with its §1.3 label.
+Label design-only claims planned/proposed.
+For shipped or in-review work, list design-only (4) or (5) as an open gap:
+"implementation not traced".
+List a missing alternative, reason, data-structure rationale, or untraced
+misbehaviour or failure as open gaps. Never invent alternatives, reasons,
+threats or failures.
+Name each trust boundary on the flow traced in (1), with an evidence pointer
+and the actors crossing it; an unclear boundary is an open gap.
+Answer each actor the user names or list it open.
+State in one line that other actors are out of scope.
+Omissions of (2) and (3) require "does not apply", a one-line reason and
+an evidence pointer. Never omit (1), (4) or (5); answer them or mark them open.
+Never drop an element silently.
+(5) does not trigger the blast-radius proof; that runs only on "what could this break".
+Use function names and line-level detail only as evidence pointers.
+
+Close with likely whiteboard questions beyond (1)-(5), each with an
+evidence-backed labelled answer or marked open.
+Give each open gap one line naming the missing evidence and saying to resolve
+it before defending the work.
+Every whiteboard-defense explanation is consequential for review, in chat too.
+Follow [Delivery](delivery.md) for reviewer-outage and two-round holds.
+
+If five elements and closing questions exceed 700 words, keep the top level,
+every element and the open gaps as at least one line each.
+Offer per-component explanations for closing questions that cannot fit and
+count how many moved. Never drop questions silently.
+If mandatory lines exceed 700 words, give the top-level explanation first and
+split the rest into per-component explanations; never exceed the cap.
+The delivered view keeps (1), one line each for (4) and (5), and the open-gap
+count with the components holding them.
+State how many elements and open gaps moved.
+
+When the user or stated records (run record, spec, PR body or README) identify
+a PoC, demo or experiment, use an optional checklist and proportional answer
+under the ordinary review rule. Never infer that status.
+An intent to ship overrides the PoC exemption.
+An explicit checklist request requires full whiteboard defense.

package/skills/axstack-research/SKILL.md

@@ -28,10 +28,20 @@ is part of research.
    gathering evidence only after the target and stopping boundary are explicit.
 
 2. **Fan out research:** A single factual lookup stays in the current chat.
-   Every other research run dispatches every configured research branch through
-   T3 `delegate_task`: requirements, code, and web (Sonnet high in mixed/claude-only;
-   Codex in codex-only), web-google (Gemini/Antigravity, with Google Search
-   built in), and X (Grok).
+   For other runs, dispatch through T3 `delegate_task` only branches whose
+   source class (requirements, code, execution, web, X) an open answer-changing claim needs.
+   Dispatch requirements only when scope is unclear.
+   Dispatch execution when a claim depends on runtime behavior.
+   Dispatch X only when a claim depends on X posts.
+   Record each skipped branch as `not needed (<reason>)`.
+   For each needed source class, retain two isolated branches where configured.
+   In mixed, each needed source class retains branches from different providers.
+   The code pair is `axstack-research-code` +
+   `axstack-research-code-sol`; the web pair is `axstack-research-web` +
+   `axstack-research-web-google`; the execution pair is `axstack-explore-execution` +
+   `axstack-explore-execution-sol`. Requirements, code, and web use Sonnet high
+   in mixed/claude-only and Codex in codex-only; web-google uses
+   Gemini/Antigravity with Google Search built in, and X uses Grok.
    Give each branch one owner, allow no cross-reading, and require a cited note
    with a URL and access date per claim; re-open sources and never trust a search
    summary. The driver reconciles agreements/disagreements per claim.
@@ -61,8 +71,10 @@ is part of research.
    never averaging findings. Record an intentionally absent pair and proceed
    with the base seat alone. The `-sol` pair is optional: fence a launch failure,
    trust/login prompt, or prompt block; record `absent (<reason>)`, and continue
-   with the base seat. In mixed fan-out,
-   retain a Codex and a Claude seat or hold the affected fan-out.
+   with the base seat. A sized mixed research fan-out requires dispatched
+   branches spanning at least two different providers; otherwise hold that fan-out.
+   Every other mixed fan-out, including arena and peer review, retains at least one
+   Codex and one Claude seat; otherwise hold that fan-out.
 
 3. **Gather primary source evidence.** Inspect the actual documentation, code,
    or tool output for every answer-changing claim. Apply the source standards

package/src/archify-legacy.js

@@ -0,0 +1,70 @@
+import { lstat, readFile, rm } from 'node:fs/promises';
+
+export const ARCHIFY_RECORD = 'axstack-diagram/archify.json';
+
+function archifyGit(path, ...args) {
+  try {
+    const result = Bun.spawnSync(['git', ...(path ? ['-C', path] : []), ...args], {
+      stdout: 'pipe', stderr: 'pipe', timeout: 60000,
+      env: { ...Bun.env, GIT_TERMINAL_PROMPT: '0' },
+    });
+    if (result.exitCode !== 0) throw new Error(result.stderr.toString().trim() || `git exit ${result.exitCode}`);
+    return result.stdout.toString().trim();
+  } catch (err) {
+    throw new Error(`git: ${err.message}`);
+  }
+}
+
+async function ownersSnapshot(path) {
+  const st = await lstat(path).catch((err) => {
+    if (err.code === 'ENOENT') return null;
+    throw err;
+  });
+  if (st && (!st.isFile() || st.isSymbolicLink())) throw new Error(`unsafe archify owners file: ${path}`);
+  const bytes = st ? await readFile(path) : null;
+  // JSON.parse coerces its argument to a string; preserve the existing Buffer coercion.
+  const owners = bytes ? /** @type {(text: {toString(): string}) => unknown} */ (JSON.parse)(bytes) : [];
+  if (!Array.isArray(owners) || owners.some((owner) => typeof owner !== 'string' || !owner.startsWith('/'))) {
+    throw new Error(`invalid archify owners file: ${path}`);
+  }
+  return { bytes, owners, mode: st ? st.mode & 0o777 : null };
+}
+
+// Drop ownership transactionally; defer destructive cleanup until the skills
+// manifest commits. A failed manifest write can then restore the owner list.
+export async function planArchifyRelease({ record, skillsRoot, writeAtomic, log }) {
+  const ownersFile = `${record.path}.owners.json`;
+  const before = await ownersSnapshot(ownersFile);
+  const remaining = before.owners.filter((owner) => owner !== skillsRoot);
+  if (!before.owners.includes(skillsRoot)) {
+    return { rollback: async () => {}, finish: async () => log(`archify: kept ${record.path} (owner is absent)`) };
+  }
+  try {
+    await writeAtomic(ownersFile, JSON.stringify(remaining) + '\n', { mode: 0o600 });
+  } catch (err) {
+    const current = await readFile(ownersFile);
+    if (!current.equals(before.bytes)) {
+      try { await writeAtomic(ownersFile, before.bytes, { mode: before.mode }); }
+      catch (restoreErr) { err.message += ` (archify owner restore failed: ${restoreErr.message})`; }
+    }
+    throw err;
+  }
+  return {
+    rollback: () => writeAtomic(ownersFile, before.bytes, { mode: before.mode }),
+    finish: async () => {
+      try {
+        if (remaining.length) throw new Error('other skills roots still own this copy');
+        const st = await lstat(record.path);
+        if (!st.isDirectory() || st.isSymbolicLink()) throw new Error('copy is not a real directory');
+        if (archifyGit(record.path, 'rev-parse', 'HEAD') !== record.sha) throw new Error('HEAD differs from the recorded SHA');
+        if (archifyGit(record.path, 'status', '--porcelain', '--ignored')) throw new Error('copy has tracked, untracked, or ignored changes');
+        await rm(record.path, { recursive: true });
+        await rm(ownersFile);
+        log(`archify: removed ${record.path}`);
+      } catch (err) {
+        log(`archify: kept ${record.path} (${err.message})`);
+      }
+    },
+  };
+}
+

package/src/capabilities.js

@@ -1,8 +1,4 @@
 // Host capability checks. Injected execution keeps tests off live runtimes.
-import { lstat, readFile } from 'node:fs/promises';
-import { join } from './posixpath.js';
-import { ARCHIFY_RECORD, archifyGit } from './archify.js';
-import { ARCHIFY_PIN } from './archify-pin.js';
 export const BUN_FLOOR = '1.3.14';
 export const T3_FLOOR = '0.0.46-nightly.20261003.2610';
 
@@ -109,28 +105,4 @@ export async function checkCapabilities(exec) {
   return { checks, gaps, limitations: [...PROBE_LIMITATIONS] };
 }
 
-export async function checkArchify(skillsDir) {
-  const recordFile = join(skillsDir, ARCHIFY_RECORD);
-  const override = Bun.env.ARCHIFY_CHROME;
-  const chrome = override ? Bun.which(override) :
-    ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser', 'chrome']
-      .map((name) => Bun.which(name)).find(Boolean);
-  let record = null;
-  let actual = null;
-  let reason = null;
-  try {
-    if ((await lstat(recordFile)).isSymbolicLink()) throw new Error('record is a symlink');
-    record = JSON.parse(await readFile(recordFile, 'utf8'));
-    if (!record || typeof record.path !== 'string' || !record.path.startsWith('/') ||
-        !/^[a-f0-9]{40}$/.test(record.sha)) throw new Error('invalid record');
-    const copy = await lstat(record.path);
-    if (!copy.isDirectory() || copy.isSymbolicLink()) throw new Error('copy is not a real directory');
-    actual = archifyGit(record.path, 'rev-parse', 'HEAD');
-    if (actual !== record.sha || record.sha !== ARCHIFY_PIN.sha) {
-      throw new Error(`SHA mismatch: recorded ${record.sha}, checked-out ${actual}, expected ${ARCHIFY_PIN.sha}`);
-    }
-  } catch (err) {
-    reason = err.code === 'ENOENT' ? 'missing record or copy' : err.message;
-  }
-  return { recordFile, record, actual, chrome: chrome ?? null, reason };
-}
+

package/src/installer.js

@@ -38,7 +38,7 @@ import {
   writeManifest,
 } from './manifest.js';
 import { planInstallClaudeSettings, planUninstallClaudeSettings } from './claude-settings.js';
-import { ARCHIFY_RECORD, planArchifyRelease, provisionArchify } from './archify.js';
+import { ARCHIFY_RECORD, planArchifyRelease } from './archify-legacy.js';
 import {
   applyInstructionPlan,
   findLegacyRoutingLines,
@@ -485,14 +485,13 @@ async function assertFileSnapshot(dest, expected) {
  */
 
 /**
- * @param {InstallerOptions & {bundleDir?: string, preset?: string, toolsDir?: string,
+ * @param {InstallerOptions & {bundleDir?: string, preset?: string,
  *   inheritedInstructions?: {path: string, hash: string}}} [options]
  */
 export async function installBundle({
   bundleDir,
   skillsDir,
   preset,
-  toolsDir = null,
   instructionsPath = null,
   inheritedInstructions = null,
   force = false,
@@ -511,14 +510,6 @@ export async function installBundle({
     ? await canonicalInstructionFile(instructionsPath)
     : null;
   assertOutsideHome(skillsRoot, { yes, kind: 'skills directory' });
-  const toolsPath = toolsDir ?? (homeDir() ? join(homeDir(), '.axstack', 'tools') : null);
-  if (!toolsPath) throw new Error('HOME is unavailable; pass --tools-dir explicitly');
-  await assertNoSymlinksBelow('/', resolve(toolsPath));
-  const toolsRoot = await canonicalTargetDir(toolsPath);
-  if (withinRoot(toolsRoot, skillsRoot) || withinRoot(skillsRoot, toolsRoot)) {
-    throw new Error('tools directory overlaps the skills root; refusing');
-  }
-  assertOutsideHome(toolsRoot, { yes, kind: 'tools directory' });
   if (instructionsFile) assertOutsideHome(instructionsFile, { yes, kind: 'instruction file' });
   const claudePlan = await planInstallClaudeSettings({ claude, skillsRoot });
   if (claudePlan.report.path) {
@@ -586,11 +577,6 @@ export async function installBundle({
   // manifest entry resolves its destination, current bytes, and pristine
   // flag through the same guard before Phase 2 mutates anything.
   const desired = [];
-  const archifyTarget = await readOwnedTarget(skillsRoot, ARCHIFY_RECORD);
-  if (archifyTarget.current !== null &&
-      hashContent(archifyTarget.current) !== ownedFiles[ARCHIFY_RECORD]) {
-    throw new Error('archify record is edited or unowned; refusing to replace it');
-  }
   for (const { rel, abs, content: inlineContent } of bundle.files) {
     const { dest, current, mode } = await readOwnedTarget(skillsRoot, rel);
     const content = inlineContent ?? await readFile(abs);
@@ -608,7 +594,6 @@ export async function installBundle({
   }
 
   const bundleRels = new Set(bundle.files.map((file) => file.rel));
-  bundleRels.add(ARCHIFY_RECORD);
   const stalePlan = [];
   for (const rel of Object.keys(ownedFiles)) {
     if (bundleRels.has(rel)) continue;
@@ -638,7 +623,6 @@ export async function installBundle({
   const installedHashes = {};
   const claudeWritten = [];
   let instructionWritten = false;
-  let archify = null;
   let archifyRelease = null;
   const manifestFile = join(skillsRoot, '.axstack-manifest.json');
   const manifestBefore = await readFile(manifestFile).catch((err) => {
@@ -649,12 +633,6 @@ export async function installBundle({
   let manifestAttempted = false;
   log('plan complete');
   try {
-    archify = await provisionArchify({ toolsRoot, skillsRoot, writeAtomic, log });
-    const archifyRecord = archify.record ?? prevManifest.archify ?? null;
-    if (archifyRecord) {
-      desired.push({ rel: ARCHIFY_RECORD, ...archifyTarget,
-        content: Buffer.from(JSON.stringify(archifyRecord, null, 2) + '\n') });
-    }
     if (instructionsFile) {
       await assertFileSnapshot(instructionsFile, existingInstructionsRaw);
     }
@@ -771,7 +749,11 @@ export async function installBundle({
       )
       : null;
 
-    if (prevManifest.archify && archifyRecord?.path !== prevManifest.archify.path) {
+    const legacyRecord = await readOwnedTarget(skillsRoot, ARCHIFY_RECORD);
+    if (legacyRecord.current !== null) {
+      log(`archify: kept ${prevManifest.archify?.path ?? 'unbound copy'} (preserved record ${legacyRecord.dest})`);
+    }
+    if (prevManifest.archify && legacyRecord.current === null) {
       archifyRelease = await planArchifyRelease({
         record: prevManifest.archify, skillsRoot, writeAtomic, log,
       });
@@ -785,7 +767,6 @@ export async function installBundle({
         path: claudePlan.settingsPath ?? boundClaudeSettingsPath,
       },
       instructions: nextInstructions,
-      archify: archifyRecord,
     });
     if (archifyRelease) await archifyRelease.finish();
     if (legacyProfileNote || legacyInstructionNote) {
@@ -837,10 +818,6 @@ export async function installBundle({
       try { await archifyRelease.rollback(); }
       catch (restoreErr) { rollbackErrors.push(`old archify owner: ${restoreErr.message}`); }
     }
-    if (archify) {
-      try { await archify.rollback(); }
-      catch (restoreErr) { rollbackErrors.push(`archify: ${restoreErr.message}`); }
-    }
     for (const write of claudeWritten.reverse()) {
       try {
         if (write.before === null) await rm(write.path);
@@ -1052,6 +1029,9 @@ export async function uninstallBundle({
     summary.claudeSettings = claudePlan.report;
 
     const remainingArchify = ARCHIFY_RECORD in remainingFiles ? manifest.archify : null;
+    if (remainingArchify) {
+      log(`archify: kept ${remainingArchify.path} (preserved record ${join(skillsRoot, ARCHIFY_RECORD)})`);
+    }
     if (manifest.archify && !remainingArchify) {
       archifyRelease = await planArchifyRelease({ record: manifest.archify, skillsRoot, writeAtomic, log });
     }
@@ -1070,10 +1050,10 @@ export async function uninstallBundle({
       await writeManifest(skillsRoot, {
         version: MANIFEST_VERSION,
         files: remainingFiles,
+        ...(remainingArchify ? { archify: remainingArchify } : {}),
         profiles: legacyProfiles,
         claudeSettings: { path: remainingClaudeSettingsPath },
         instructions: remainingInstructions,
-        archify: remainingArchify,
       });
     }
     if (archifyRelease) await archifyRelease.finish();

package/skills/axstack-diagram/SKILL.md

@@ -1,28 +0,0 @@
----
-name: axstack-diagram
-description: When an explanation needs a diagram, use axstack-diagram for inline SVG or CSS in pages, Mermaid in chat, GitHub, and docs, or archify only on an explicit viewer request.
----
-
-# Diagram
-
-Usage: `/axstack-diagram <question + destination>` or load this skill from explain.
-Load [Standing contracts](../axstack/references/contracts.md) before acting.
-Follow [Fidelity](references/fidelity.md) for every format.
-
-Use archify HTML only on an explicit viewer request.
-The configured `axstack-explainer` authors the viewer; follow [Archify](references/archify.md).
-Use inline SVG or CSS inside inline pages.
-Never use Mermaid in inline pages.
-Use Mermaid for chat, GitHub, and docs.
-Include `accTitle` and `accDescr` in each Mermaid view.
-Never use theme init in Mermaid.
-Split large Mermaid diagrams into views.
-T3 chat renders the Mermaid fence once the reply settles.
-
-Explain owns evidence, claim labels, the word cap, dispatch, and delivery.
-Diagram owns format and visual rules.
-Never call explain.
-For direct use, keep fidelity and rendered QA.
-For direct viewer requests, follow [Explain's declared launch path](../axstack-explain/SKILL.md#2-choose-proportional-output).
-
-Ideas: [archify](https://github.com/tt-a1i/archify), [diagram-design](https://github.com/cathrynlavery/diagram-design), [visual-explainer](https://github.com/nicobailon/visual-explainer), [Matt Pocock](https://github.com/mattpocock/skills), and [poteto](https://github.com/poteto/how); guidance uses Axstack's own words.

package/skills/axstack-diagram/references/archify.md

@@ -1,76 +0,0 @@
-# Archify
-
-Archify turns a typed JSON intermediate representation (IR) into an HTML viewer.
-Follow [Fidelity](fidelity.md) before authoring.
-
-## Bind the tool
-
-Read `archify.json` beside the skill entrypoint for its `{path, sha}` record.
-Verify that `git -C <path> rev-parse HEAD` equals the recorded SHA.
-If the record or copy is missing, HEAD mismatches the recorded SHA, or Chrome is missing, hold and ask the user.
-Honor `ARCHIFY_CHROME` when set.
-Otherwise find Chrome or Chromium on `PATH`.
-Set `ARCHIFY_UPDATE_CHECK_DISABLED=1` on every archify call.
-Never substitute Mermaid or unverified HTML when the viewer is required.
-
-## Author the IR
-
-If the pinned archify procedure conflicts with this file, this file takes precedence.
-Read `<path>/archify/SKILL.md` and follow its named references for IR authoring and repair.
-Run the referenced archify commands with Bun.
-
-Set `meta.title` and a portable relative HTML filename in `meta.output`.
-Use `meta.quality_profile: "showcase"`.
-Set `meta.animation: "none"`.
-Keep trace motion, exports, share cards, and brand marks off unless the user asks.
-Deliver the viewer with `?theme=dark` unless the user names a theme.
-Theme is viewer state rather than an IR field; without the query, localStorage and `prefers-color-scheme` determine it.
-Preserve explain's claim labels in `meta.subtitle` or the companion explanation.
-Set `meta.repository` to the inspected repository URL and full `revision`.
-Keep per-node source pins in each node's `sources` entries for inspected paths and line ranges.
-Keep the private source map for relationships that have no source field.
-Keep proposed sources distinct from factual pins.
-Use [Fidelity](fidelity.md) for visible planned and unknown markers.
-For a separate check, run `bun <path>/archify/bin/archify.mjs validate <type> <ir.json> --json --repo-root <repo>`.
-When sources are declared, require `--repo-root <repo>` on both `validate` and `finalize`.
-For sequence and dataflow, a schema-valid legend cue is `meta.legend.entries.dashed: {"label":"Planned or unknown"}`.
-
-Use one top-level `cards[]` entry with `{dot, title, items[]}` per key node as its node detail card.
-Each node detail card has at most 40 words and cites its source.
-Count the title plus all items toward each card's 40-word cap.
-Cite each card's source inline as `file:lines` in its `items[]`.
-Node detail cards are exempt from explain's 700-word cap.
-Count node labels, headings, captions, and all non-card text.
-
-## Build and hold
-
-Write the IR, HTML, and receipt only inside the private evidence folder.
-For direct invocation, create a private run evidence folder first.
-Override archify's default `.archify/` folder with an evidence output path and `--out-dir <evidence dir>`.
-Run `bun <path>/archify/bin/archify.mjs finalize <type> <ir.json> <out.html> --quality showcase --json --out-dir <evidence dir> --repo-root <repo>`.
-This is the author's headless build gate.
-Read the saved receipt named by the JSON result's `evidence.receipt`.
-Accept only receipt `status: "pass"` as success.
-Never trust exit codes as proof of a pass.
-When a receipt is missing or remains non-pass after two repair rounds, hold delivery and ask the user.
-If Chrome is missing, report "viewer not verified: Chrome missing".
-Chrome absence yields `status: "skipped"` and exit 2.
-Follow archify's receipt fixes and references for layout and composition repairs.
-After every repair edit, rerun the complete `finalize` command.
-Count one repair round as one complete `finalize` rerun after an edit.
-Validate runs never count as repair rounds.
-Do not require validate before finalize.
-Run at most two repair rounds, then hold with remaining defects for the user's decision.
-Never use archify's extra evidence-based retry.
-
-## Rendered and source checks
-
-Follow [UI verification](../../axstack/references/ui-verification.md) for dispatch.
-Keep `finalize` as the only author browser check.
-Delegate `visual-check`, browser opening, preview, and first-screen inspection to `axstack-ui-verifier`.
-Require `axstack-ui-verifier` checks of the receipt's `artifact.sha256` bytes on desktop, 390px mobile, keyboard, reduced motion, and the text alternative.
-Include theme, search or focus, and directional reach interactions.
-Require `axstack-ui-verifier` checks with the theme set explicitly.
-Require `explainer-review` of every node and edge against source for archify output.
-Every byte change requires fresh checks.
-Keep these independent verdicts with the build receipt before delivery.

package/src/archify-pin.js

@@ -1,5 +0,0 @@
-// Pin changes require a reviewed chore PR and an upstream smoke run.
-export const ARCHIFY_PIN = Object.freeze({
-  repo: 'https://github.com/tt-a1i/archify',
-  sha: '594f6087358610bd16e64e5602976020871b6bff',
-});