mdkg 0.0.4 → 0.0.6

package/dist/commands/skill_mirror.js

@@ -0,0 +1,323 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncSkillMirrors = syncSkillMirrors;
+exports.shouldMaintainSkillMirrors = shouldMaintainSkillMirrors;
+exports.auditSkillMirrors = auditSkillMirrors;
+exports.scaffoldMirrorRoots = scaffoldMirrorRoots;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const skills_indexer_1 = require("../graph/skills_indexer");
+const errors_1 = require("../util/errors");
+const MIRROR_PRODUCTS = ["agents", "claude"];
+const MANIFEST_FILE = ".mdkg-managed.json";
+const MANAGED_ROOT_MARKERS = [
+    path_1.default.join(".mdkg", "core", "SOUL.md"),
+    path_1.default.join(".mdkg", "core", "HUMAN.md"),
+];
+const ALLOWED_ROOT_ENTRIES = ["SKILL.md", "references", "assets", "scripts"];
+function resolveMirrorTargets(root) {
+    return MIRROR_PRODUCTS.map((product) => {
+        const rootDir = path_1.default.join(root, `.${product}`);
+        const skillsRoot = path_1.default.join(rootDir, "skills");
+        return {
+            product,
+            rootDir,
+            skillsRoot,
+            manifestPath: path_1.default.join(skillsRoot, MANIFEST_FILE),
+        };
+    });
+}
+function readManifest(target) {
+    if (!fs_1.default.existsSync(target.manifestPath)) {
+        return new Set();
+    }
+    try {
+        const parsed = JSON.parse(fs_1.default.readFileSync(target.manifestPath, "utf8"));
+        if (!Array.isArray(parsed.managed_slugs)) {
+            return new Set();
+        }
+        return new Set(parsed.managed_slugs
+            .map((value) => String(value).trim().toLowerCase())
+            .filter(Boolean));
+    }
+    catch {
+        return new Set();
+    }
+}
+function writeManifest(target, managed) {
+    const payload = {
+        managed_slugs: Array.from(new Set(Array.from(managed).map((value) => value.toLowerCase()))).sort(),
+    };
+    fs_1.default.mkdirSync(target.skillsRoot, { recursive: true });
+    fs_1.default.writeFileSync(target.manifestPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+function shouldCreateMirrorRoots(root) {
+    if (MANAGED_ROOT_MARKERS.some((relPath) => fs_1.default.existsSync(path_1.default.join(root, relPath)))) {
+        return true;
+    }
+    return resolveMirrorTargets(root).some((target) => fs_1.default.existsSync(target.rootDir) || fs_1.default.existsSync(target.skillsRoot));
+}
+function listAllowedEntries(dirPath) {
+    if (!fs_1.default.existsSync(dirPath)) {
+        return [];
+    }
+    const entries = [];
+    const queue = [dirPath];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const dirEntries = fs_1.default.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of dirEntries) {
+            const fullPath = path_1.default.join(current, entry.name);
+            const relPath = path_1.default.relative(dirPath, fullPath).replace(/\\/g, "/");
+            if (entry.isDirectory()) {
+                entries.push(`${relPath}/`);
+                queue.push(fullPath);
+            }
+            else if (entry.isFile()) {
+                entries.push(relPath);
+            }
+        }
+    }
+    return entries.sort();
+}
+function resolveSkillDocPath(skillDir) {
+    const canonicalPath = path_1.default.join(skillDir, "SKILL.md");
+    const compatPath = path_1.default.join(skillDir, "SKILLS.md");
+    if (fs_1.default.existsSync(canonicalPath) && fs_1.default.existsSync(compatPath)) {
+        throw new errors_1.UsageError(`${skillDir}: both SKILL.md and SKILLS.md exist; fix the canonical skill first`);
+    }
+    if (fs_1.default.existsSync(canonicalPath)) {
+        return canonicalPath;
+    }
+    if (fs_1.default.existsSync(compatPath)) {
+        return compatPath;
+    }
+    throw new errors_1.UsageError(`${skillDir}: missing SKILL.md or SKILLS.md`);
+}
+function loadCanonicalSources(root, config) {
+    const index = (0, skills_indexer_1.buildSkillsIndex)(root, config);
+    return Object.values(index.skills)
+        .sort((a, b) => a.slug.localeCompare(b.slug))
+        .map((entry) => {
+        const docPath = path_1.default.resolve(root, entry.path);
+        return {
+            slug: entry.slug,
+            sourceDir: path_1.default.dirname(docPath),
+            docPath,
+        };
+    });
+}
+function writeFileIfChanged(srcPath, destPath) {
+    const next = fs_1.default.readFileSync(srcPath);
+    if (fs_1.default.existsSync(destPath) && fs_1.default.statSync(destPath).isFile()) {
+        const current = fs_1.default.readFileSync(destPath);
+        if (current.equals(next)) {
+            return;
+        }
+    }
+    fs_1.default.mkdirSync(path_1.default.dirname(destPath), { recursive: true });
+    fs_1.default.writeFileSync(destPath, next);
+}
+function syncDir(srcDir, destDir) {
+    fs_1.default.mkdirSync(destDir, { recursive: true });
+    const sourceEntries = fs_1.default.readdirSync(srcDir, { withFileTypes: true });
+    const sourceNames = new Set(sourceEntries.map((entry) => entry.name));
+    if (fs_1.default.existsSync(destDir)) {
+        for (const existing of fs_1.default.readdirSync(destDir)) {
+            if (!sourceNames.has(existing)) {
+                fs_1.default.rmSync(path_1.default.join(destDir, existing), { recursive: true, force: true });
+            }
+        }
+    }
+    for (const entry of sourceEntries) {
+        const srcPath = path_1.default.join(srcDir, entry.name);
+        const destPath = path_1.default.join(destDir, entry.name);
+        if (entry.isDirectory()) {
+            syncDir(srcPath, destPath);
+        }
+        else if (entry.isFile()) {
+            writeFileIfChanged(srcPath, destPath);
+        }
+    }
+}
+function materializeSkillMirror(source, destDir) {
+    fs_1.default.mkdirSync(destDir, { recursive: true });
+    const expectedRootEntries = new Set(["SKILL.md"]);
+    for (const entry of ["references", "assets", "scripts"]) {
+        const srcPath = path_1.default.join(source.sourceDir, entry);
+        if (fs_1.default.existsSync(srcPath) && fs_1.default.statSync(srcPath).isDirectory()) {
+            expectedRootEntries.add(entry);
+        }
+    }
+    for (const existing of fs_1.default.readdirSync(destDir)) {
+        if (!expectedRootEntries.has(existing)) {
+            fs_1.default.rmSync(path_1.default.join(destDir, existing), { recursive: true, force: true });
+        }
+    }
+    writeFileIfChanged(source.docPath, path_1.default.join(destDir, "SKILL.md"));
+    for (const entry of ["references", "assets", "scripts"]) {
+        const srcPath = path_1.default.join(source.sourceDir, entry);
+        const destPath = path_1.default.join(destDir, entry);
+        if (fs_1.default.existsSync(srcPath) && fs_1.default.statSync(srcPath).isDirectory()) {
+            syncDir(srcPath, destPath);
+        }
+        else if (fs_1.default.existsSync(destPath)) {
+            fs_1.default.rmSync(destPath, { recursive: true, force: true });
+        }
+    }
+}
+function collectExpectedSkillTree(source) {
+    const expected = new Map();
+    expected.set("SKILL.md", fs_1.default.readFileSync(source.docPath, "utf8"));
+    for (const entry of ["references", "assets", "scripts"]) {
+        const srcPath = path_1.default.join(source.sourceDir, entry);
+        if (!fs_1.default.existsSync(srcPath) || !fs_1.default.statSync(srcPath).isDirectory()) {
+            continue;
+        }
+        expected.set(`${entry}/`, "dir");
+        for (const relPath of listAllowedEntries(srcPath)) {
+            const absolute = path_1.default.join(srcPath, relPath.replace(/\/$/, ""));
+            expected.set(`${entry}/${relPath}`, relPath.endsWith("/") ? "dir" : fs_1.default.readFileSync(absolute, "utf8"));
+        }
+    }
+    return expected;
+}
+function collectActualSkillTree(destDir) {
+    const entries = new Map();
+    if (!fs_1.default.existsSync(destDir)) {
+        return { entries, hasUnexpectedRootEntry: false };
+    }
+    const rootEntries = fs_1.default.readdirSync(destDir, { withFileTypes: true });
+    let hasUnexpectedRootEntry = false;
+    for (const entry of rootEntries) {
+        if (!ALLOWED_ROOT_ENTRIES.includes(entry.name)) {
+            hasUnexpectedRootEntry = true;
+            continue;
+        }
+        const fullPath = path_1.default.join(destDir, entry.name);
+        if (entry.isFile()) {
+            entries.set(entry.name, fs_1.default.readFileSync(fullPath, "utf8"));
+            continue;
+        }
+        if (!entry.isDirectory()) {
+            hasUnexpectedRootEntry = true;
+            continue;
+        }
+        entries.set(`${entry.name}/`, "dir");
+        for (const relPath of listAllowedEntries(fullPath)) {
+            const absolute = path_1.default.join(fullPath, relPath.replace(/\/$/, ""));
+            entries.set(`${entry.name}/${relPath}`, relPath.endsWith("/") ? "dir" : fs_1.default.readFileSync(absolute, "utf8"));
+        }
+    }
+    return { entries, hasUnexpectedRootEntry };
+}
+function isManagedSkillTreeInSync(source, destDir) {
+    const expected = collectExpectedSkillTree(source);
+    const actual = collectActualSkillTree(destDir);
+    if (actual.hasUnexpectedRootEntry) {
+        return false;
+    }
+    if (expected.size !== actual.entries.size) {
+        return false;
+    }
+    for (const [relPath, content] of expected.entries()) {
+        if (!actual.entries.has(relPath) || actual.entries.get(relPath) !== content) {
+            return false;
+        }
+    }
+    return true;
+}
+function syncSkillMirrors(options) {
+    const sources = loadCanonicalSources(options.root, options.config);
+    const createRoots = Boolean(options.createRoots);
+    const force = Boolean(options.force);
+    const targets = resolveMirrorTargets(options.root);
+    let synced = 0;
+    let pruned = 0;
+    let touchedTargets = 0;
+    for (const target of targets) {
+        const shouldManageTarget = createRoots || fs_1.default.existsSync(target.skillsRoot) || fs_1.default.existsSync(target.rootDir);
+        if (!shouldManageTarget) {
+            continue;
+        }
+        touchedTargets += 1;
+        fs_1.default.mkdirSync(target.skillsRoot, { recursive: true });
+        const managed = readManifest(target);
+        for (const source of sources) {
+            const destDir = path_1.default.join(target.skillsRoot, source.slug);
+            const exists = fs_1.default.existsSync(destDir);
+            if (exists && !managed.has(source.slug) && !force) {
+                throw new errors_1.UsageError(`${path_1.default.relative(options.root, destDir)} already exists and is not mdkg-managed; rerun \`mdkg skill sync --force\` to replace it`);
+            }
+            materializeSkillMirror(source, destDir);
+            managed.add(source.slug);
+            synced += 1;
+        }
+        for (const slug of Array.from(managed)) {
+            if (sources.some((source) => source.slug === slug)) {
+                continue;
+            }
+            const destDir = path_1.default.join(target.skillsRoot, slug);
+            if (fs_1.default.existsSync(destDir)) {
+                fs_1.default.rmSync(destDir, { recursive: true, force: true });
+                pruned += 1;
+            }
+            managed.delete(slug);
+        }
+        writeManifest(target, managed);
+    }
+    return { synced, pruned, targets: touchedTargets };
+}
+function shouldMaintainSkillMirrors(root) {
+    return shouldCreateMirrorRoots(root);
+}
+function auditSkillMirrors(root, config) {
+    const shouldAudit = shouldCreateMirrorRoots(root);
+    if (!shouldAudit) {
+        return [];
+    }
+    const warnings = [];
+    const sources = loadCanonicalSources(root, config);
+    const sourceBySlug = new Map(sources.map((source) => [source.slug, source]));
+    for (const target of resolveMirrorTargets(root)) {
+        if (!fs_1.default.existsSync(target.skillsRoot)) {
+            warnings.push(`${path_1.default.relative(root, target.skillsRoot)}: mirror root missing; run \`mdkg skill sync\``);
+            continue;
+        }
+        const managed = readManifest(target);
+        if (!fs_1.default.existsSync(target.manifestPath)) {
+            warnings.push(`${path_1.default.relative(root, target.manifestPath)}: mirror manifest missing; run \`mdkg skill sync\``);
+        }
+        for (const source of sources) {
+            const destDir = path_1.default.join(target.skillsRoot, source.slug);
+            if (!fs_1.default.existsSync(destDir)) {
+                warnings.push(`${path_1.default.relative(root, destDir)}: missing mirrored skill; run \`mdkg skill sync\``);
+                continue;
+            }
+            if (!managed.has(source.slug)) {
+                warnings.push(`${path_1.default.relative(root, destDir)}: conflicting unmanaged mirror; rerun \`mdkg skill sync --force\` to replace it`);
+                continue;
+            }
+            if (!isManagedSkillTreeInSync(source, destDir)) {
+                warnings.push(`${path_1.default.relative(root, destDir)}: mirrored skill drift detected; run \`mdkg skill sync\``);
+            }
+        }
+        for (const slug of managed) {
+            if (!sourceBySlug.has(slug)) {
+                warnings.push(`${path_1.default.relative(root, path_1.default.join(target.skillsRoot, slug))}: stale mirrored skill; run \`mdkg skill sync\``);
+            }
+        }
+    }
+    return warnings;
+}
+function scaffoldMirrorRoots(root) {
+    for (const target of resolveMirrorTargets(root)) {
+        fs_1.default.mkdirSync(target.skillsRoot, { recursive: true });
+        if (!fs_1.default.existsSync(target.manifestPath)) {
+            writeManifest(target, []);
+        }
+    }
+}

package/dist/commands/skill_support.js

@@ -51,6 +51,7 @@ function registryTemplate() {
         "This directory stores Agent Skills packages used by mdkg tooling and orchestrators.",
         "",
         "Use `mdkg skill new <slug> \"<name>\" --description \"...\"` to scaffold a new skill from the built-in Anthropic-aligned template.",
+        "Use `mdkg skill sync` to mirror canonical skills into `.agents/skills/` and `.claude/skills/` when agent bootstrap is enabled.",
         "Use `CLI_COMMAND_MATRIX.md` as the canonical command and flag reference when updating skill procedures.",
         "",
         "## Conventions",

package/dist/commands/task.js

@@ -169,6 +169,12 @@ function ensureSkillsExist(root, node, slugs) {
 function updateUpdatedDate(frontmatter, now) {
     frontmatter.updated = (0, date_1.formatDate)(now);
 }
+function maybeWarnEventsDisabled(root, config, ws) {
+    if ((0, event_support_1.isEventLoggingEnabled)(root, config, ws)) {
+        return;
+    }
+    console.error(`note: events.jsonl is missing for workspace ${ws}; run mdkg event enable --ws ${ws} to restore JSONL provenance`);
+}
 function runTaskStartCommand(options) {
     const loaded = loadMutableTaskNode(options.root, options.id, options.ws);
     const now = options.now ?? new Date();
@@ -186,6 +192,7 @@ function runTaskStartCommand(options) {
         runId: options.runId,
         now,
     });
+    maybeWarnEventsDisabled(options.root, loaded.config, loaded.ws);
     console.log(`task started: ${loaded.qid}`);
 }
 function runTaskUpdateCommand(options) {
@@ -266,5 +273,6 @@ function runTaskDoneCommand(options) {
         });
     }
     maybeReindex(options.root, loaded.config);
+    maybeWarnEventsDisabled(options.root, loaded.config, loaded.ws);
     console.log(`task done: ${loaded.qid}`);
 }

package/dist/commands/validate.js

@@ -13,6 +13,7 @@ const skills_indexer_1 = require("../graph/skills_indexer");
 const workspace_files_1 = require("../graph/workspace_files");
 const validate_graph_1 = require("../graph/validate_graph");
 const errors_1 = require("../util/errors");
+const skill_mirror_1 = require("./skill_mirror");
 const RECOMMENDED_HEADINGS = {
     task: [
         "Overview",
@@ -290,6 +291,7 @@ function runValidateCommand(options) {
             warnings.push(`${path_1.default.relative(options.root, compatPath)}: using legacy SKILLS.md compatibility file`);
         }
     }
+    warnings.push(...(0, skill_mirror_1.auditSkillMirrors)(options.root, config));
     validateEventsJsonl(options.root, config, errors);
     const uniqueWarnings = Array.from(new Set(warnings));
     const uniqueErrors = Array.from(new Set(errors));

package/dist/init/AGENTS.md

@@ -1,43 +1,9 @@
-# Agent Guidelines
+# AGENTS
 
-This repo uses mdkg for tasks, decisions, and context packs.
+Read `AGENT_START.md` first.
 
-## Quickstart
-
-- `mdkg init --llm`
-- `mdkg index`
-- `mdkg new task "..." --status todo --priority 1`
-- `mdkg list --status todo`
-- `mdkg pack <id> --verbose`
-- `mdkg validate`
-
-## Core commands
-
-- `mdkg init` (scaffold .mdkg and optional agent docs)
-- `mdkg guide` (print the repo guide)
-- `mdkg new <type> "<title>"` (create nodes)
-- `mdkg list` / `mdkg show` / `mdkg search`
-- `mdkg pack` (context bundles)
-- `mdkg next` (priority/chain)
-- `mdkg validate` / `mdkg format`
-
-## Getting context
-
-- Run `mdkg list --status todo` to find work items.
-- Before coding, run `mdkg pack <task-id> --verbose`.
-- Read linked rules and decisions in the pack.
-
-## Editing rules
-
-- Keep frontmatter valid and lowercase.
-- Update `updated: YYYY-MM-DD` when you make changes.
-- Use `links:` and `artifacts:` for anything you want searchable.
-
-## Validation
-
-- Run `mdkg validate` after edits.
-- Run `mdkg format` if frontmatter drifts.
-
-## Project-specific notes
-
-Add repo-specific build/test commands and conventions here.
+Codex/OpenAI conventions for this repo:
+- use `AGENT_START.md` as the startup contract
+- use `.agents/skills/` for product-facing mirrored skills when present
+- use `mdkg skill ...` as the canonical skill command family
+- use `mdkg task ...` for structured task fields and markdown edits for narrative/body changes

package/dist/init/AGENT_START.md

@@ -0,0 +1,47 @@
+# AGENT_START
+
+This repository uses mdkg for deterministic project memory.
+
+Read these files in order:
+1. `.mdkg/core/SOUL.md` if it exists
+2. `.mdkg/core/HUMAN.md` if it exists
+3. `.mdkg/README.md`
+4. `CLI_COMMAND_MATRIX.md`
+
+Trust order:
+- source code
+- mdkg rules, design docs, decisions, and work nodes
+- SOUL/HUMAN collaboration anchors
+- relevant skills
+- chat history
+
+If the active task is known:
+- `mdkg pack <id>`
+- `mdkg task start <id>` when durable work begins
+- `mdkg task update <id> ...` as evidence accumulates
+- `mdkg task done <id>` when work is complete
+- `mdkg validate`
+
+If no task is known:
+- `mdkg search "..."`
+- `mdkg show <id>`
+- `mdkg next`
+- then use `mdkg pack <id>`
+
+Skill discovery:
+- `mdkg skill list --tags stage:plan --json`
+- `mdkg skill list --tags stage:execute --json`
+- `mdkg skill list --tags stage:review --json`
+- `mdkg skill show select-work-and-ground-context`
+
+Conventions:
+- `AGENTS.md` is the Codex/OpenAI-oriented wrapper doc.
+- `CLAUDE.md` is the Claude-oriented wrapper doc.
+- `.agents/skills/` and `.claude/skills/` mirror canonical skills from `.mdkg/skills/` when agent bootstrap is enabled.
+- mdkg does not execute skill scripts; runtimes decide when and whether to do that.
+- Prefer packs over ad-hoc file lists.
+- Prefer task/event commands for structured work-state changes and use markdown edits for narrative/body updates.
+- Use `mdkg task done <id> --checkpoint "<title>"` for milestone compression, not every routine task completion.
+- Prefer checkpoints for feat/epic closeout summaries; parent status edits remain manual.
+- If `events.jsonl` is missing, `mdkg task start` and `mdkg task done` will remind you how to recreate it.
+- Files outside mdkg-managed skill mirrors, such as local tool permission files, are not managed by mdkg unless documented explicitly.

package/dist/init/CLAUDE.md

@@ -1,37 +1,8 @@
-# Claude Instructions
+# CLAUDE
 
-This project uses mdkg to manage tasks and context.
+Read `AGENT_START.md` first.
 
-## Quickstart
-
-- `mdkg init --llm`
-- `mdkg index`
-- `mdkg new task "..." --status todo --priority 1`
-- `mdkg list --status todo`
-- `mdkg pack <id> --verbose`
-- `mdkg validate`
-
-## Core commands
-
-- `mdkg init` (scaffold .mdkg and optional agent docs)
-- `mdkg guide` (print the repo guide)
-- `mdkg new <type> "<title>"` (create nodes)
-- `mdkg list` / `mdkg show` / `mdkg search`
-- `mdkg pack` (context bundles)
-- `mdkg next` (priority/chain)
-- `mdkg validate` / `mdkg format`
-
-## Before making changes
-
-- Run `mdkg pack <task-id> --verbose`.
-- Follow linked rules and decisions.
-
-## After making changes
-
-- Update frontmatter fields and `updated: YYYY-MM-DD`.
-- Run `mdkg validate` and fix any errors.
-- If frontmatter is inconsistent, run `mdkg format`.
-
-## Repo-specific notes
-
-Add build, test, and release instructions here.
+Claude conventions for this repo:
+- use `AGENT_START.md` as the startup contract
+- use `.claude/skills/` for product-facing mirrored skills when present
+- use `mdkg skill ...` as the canonical skill command family

package/dist/init/CLI_COMMAND_MATRIX.md

@@ -0,0 +1,29 @@
+# CLI Command Matrix
+
+This file is the canonical command reference for mdkg in this repository.
+
+Verify live help with:
+- `mdkg --help`
+- `mdkg help <command>`
+
+Primary commands:
+- `mdkg init`
+- `mdkg new`
+- `mdkg show`
+- `mdkg list`
+- `mdkg search`
+- `mdkg pack`
+- `mdkg skill`
+- `mdkg task`
+- `mdkg validate`
+
+Agent bootstrap:
+- `mdkg init --llm`
+- `mdkg init --agent`
+- `mdkg init --llm --agent`
+
+Skill discovery:
+- `mdkg skill list --tags stage:plan --json`
+- `mdkg skill search "<query>" --json`
+- `mdkg skill show <slug> --json`
+- `mdkg skill sync`

package/dist/init/README.md

@@ -14,13 +14,15 @@ This repository is initialized for mdkg.
 ## First Commands
 
 ```bash
-mdkg index
-mdkg new task "..." --status todo --priority 1
-mdkg list --status todo
-mdkg pack <id> --verbose
+mdkg init --llm --agent
+mdkg search "..."
+mdkg show <id>
+mdkg pack <id>
 mdkg validate
 ```
 
+Read `AGENT_START.md` first when this repo includes it.
+
 ## Pack Profiles
 
 - `--pack-profile standard`: full body (current default behavior)

package/dist/init/core/HUMAN.md

@@ -0,0 +1,36 @@
+---
+id: rule-human
+type: rule
+title: human working profile and collaboration preferences
+tags: [human, collaboration, preferences]
+owners: []
+links: []
+artifacts: []
+relates: []
+refs: []
+aliases: [human]
+created: 2026-03-10
+updated: 2026-03-10
+---
+
+# Purpose
+
+Capture stable collaboration preferences and boundaries so agents can work with less ambiguity.
+
+# Scope
+
+Applies to planning, implementation, and review interactions in this repository.
+
+# Requirements
+
+- Keep top goals, boundaries, and style preferences current.
+- Include ask-before-doing constraints for risky or high-impact actions.
+- Record preferred environment assumptions and validation commands.
+
+# Notes
+
+Suggested prompts:
+- What are your top 3 goals in this repo right now?
+- What should never happen without confirmation?
+- What coding/review style should the agent prefer?
+- What OS/runtime/test commands should be assumed?