@nurix/nustack 0.23.12 → 0.23.13

package/dist/vendor/harness/rules/changeRules.js

@@ -0,0 +1,162 @@
+// packages/harness/src/rules/changeRules.ts - The change rules over a tree and a change set: plan-gate, ledger,
+// frozen-record, changelog, changelog-entry and protected-file. Ported from etna harness/code/hooks/compliance.mjs,
+// check-completion-integrity.mjs, check-changelog-presence.mjs, lib/frozen.mjs and lib/exempt.mjs.
+// docs/architecture/systems/harness-records.md speaks for it (Status check and enforcement).
+import { field, frontmatter } from '../lib/frontmatter.js';
+import { basenamePosix, joinPosix } from '../lib/paths.js';
+import { backtickTokens, markdownIn, SOURCE_EXT, waiverCovers } from './context.js';
+import { inPlanScope, openGatedPlans, plansFolder, undischargedDocRows, undischargedRows } from './plans.js';
+const changedPaths = (change) => (change.status === 'R' && change.from ? [change.path, change.from] : [change.path]);
+export function planGateRule(ctx, root) {
+    const findings = [];
+    const seen = new Set();
+    const add = (finding) => {
+        const key = `${finding.id}|${finding.path}`;
+        if (!seen.has(key))
+            findings.push(finding), seen.add(key);
+    };
+    const sources = (ctx.changes ?? []).map((change) => change.path).filter((rel) => !(rel.startsWith(`${root}/`) || rel.startsWith('.claude/') || rel.endsWith('.md')) && SOURCE_EXT.test(rel));
+    if (sources.length === 0)
+        return findings;
+    const plans = openGatedPlans(ctx.head, root);
+    for (const rel of sources) {
+        for (const plan of plans) {
+            if (plan.scope.length && !inPlanScope(rel, plan.scope))
+                continue;
+            const boundary = /Boundary:\s*(\w+)/i.exec(plan.gates ?? '');
+            if (boundary && !/^passed$/i.test(boundary[1])) {
+                add({ id: /^blocked$/i.test(boundary[1]) ? 'plan-gate.boundary_blocked' : 'plan-gate.boundary_pending', path: plan.path, message: `${rel} changes inside ${plan.file}, whose Gates line reads 'Boundary: ${boundary[1]}'` });
+            }
+            if (!plan.hasLedger)
+                add({ id: 'plan-gate.no_test_ledger', path: plan.path, message: `${rel} changes inside ${plan.file}, which has no ## Test Obligations section` });
+            if (!plan.hasDocLedger)
+                add({ id: 'plan-gate.no_doc_ledger', path: plan.path, message: `${rel} changes inside ${plan.file}, which has no ## Doc Obligations section` });
+        }
+    }
+    return findings;
+}
+/** Completion integrity for every gated plan at head: discharged ledgers, active Spec docs, their checklists, an Abandoned plan's backlog. */
+export function ledgerRule(ctx, root) {
+    const findings = [];
+    const folder = plansFolder(root);
+    for (const path of markdownIn(ctx.head, folder)) {
+        const file = basenamePosix(path);
+        const text = ctx.head.read(path) ?? '';
+        if (!/^\*\*Gates:\*\*/m.test(text))
+            continue;
+        const status = /^\*\*Status:\*\*\s*(\S+)/m.exec(text)?.[1];
+        if (status === 'Complete') {
+            const docRows = undischargedDocRows(text);
+            if (docRows.length)
+                findings.push({ id: 'ledger.doc_rows_undischarged', path, message: `${file} is Complete with ${docRows.length} Doc Obligations row(s) missing a discharge outcome (${docRows.join(', ')})` });
+            const rows = undischargedRows(text);
+            if (rows.length)
+                findings.push({ id: 'ledger.test_rows_undischarged', path, message: `${file} is Complete with ${rows.length} Test Obligations row(s) missing a discharge outcome (#${rows.join(', #')})` });
+            for (const match of text.matchAll(/^\*\*Spec:\*\*\s*\[[^\]]*\]\(([^)]+)\)/gm)) {
+                const spec = match[1];
+                const specPath = joinPosix(folder, spec);
+                const specText = specPath === null ? '' : (ctx.head.read(specPath) ?? '');
+                const specStatus = String(field(frontmatter(specText), 'status') ?? '');
+                if (specText && specStatus !== 'active')
+                    findings.push({ id: 'ledger.spec_not_active', path, message: `${file} is Complete but its Spec ${spec} is status: ${specStatus || 'unknown'} (expected active)` });
+                const feature = basenamePosix(spec).replace(/\.md$/, '');
+                if (ctx.head.read(`${root}/tests/${feature}.md`) === null)
+                    findings.push({ id: 'ledger.checklist_missing', path, message: `${file} is Complete but ${root}/tests/${feature}.md (the behavioral checklist) is missing` });
+            }
+        }
+        if (status === 'Abandoned' && !/backlog/i.test(text))
+            findings.push({ id: 'ledger.abandoned_without_backlog', path, message: `${file} is Abandoned without referencing the backlog` });
+    }
+    return findings;
+}
+/** Why a path is frozen in `tree` (a committed changelog entry, a Complete or Abandoned plan, an executed runbook), or null. */
+export function frozenReason(tree, root, rel) {
+    if (rel.includes('.bkp.') || !rel.endsWith('.md'))
+        return null;
+    if (rel.startsWith(`${root}/history/changelog/`))
+        return tree.read(rel) !== null ? 'committed changelog entry' : null;
+    if (rel.startsWith(`${root}/history/plans/`))
+        return /^\*\*Status:\*\*\s*(Complete|Abandoned)\b/m.test(tree.read(rel) ?? '') ? 'plan with Status: Complete or Abandoned' : null;
+    if (rel.startsWith(`${root}/history/migrations/`))
+        return /^\*\*Executed:\*\*\s*\d{4}-\d{2}-\d{2}/m.test(tree.read(rel) ?? '') ? 'outcome-stamped migration runbook' : null;
+    return null;
+}
+/** A change to a record frozen at base. With no base tree nothing is committed, so nothing is frozen. */
+export function frozenRecordRule(ctx, root) {
+    if (!ctx.base)
+        return [];
+    const findings = [];
+    for (const change of ctx.changes ?? []) {
+        for (const rel of changedPaths(change)) {
+            if (change.status === 'A' && rel === change.path)
+                continue;
+            const reason = frozenReason(ctx.base, root, rel);
+            if (reason)
+                findings.push({ id: 'frozen-record.modified', path: rel, message: `${rel} is frozen (${reason}); a correction is a new dated record that links back` });
+        }
+    }
+    return findings;
+}
+const LOCKFILES = /^(pnpm-lock\.yaml|package-lock\.json|yarn\.lock|bun\.lockb?|Cargo\.lock)$/;
+const HARNESS_PREFIXES = ['.claude/', '.agents/', '.codex/'];
+const HARNESS_FILES = ['AGENTS.md', 'CLAUDE.md', '.mcp.json', '.vscode/settings.json', '.prettierignore', '.prettierrc.json'];
+/** The changelog rule's closed exemption list, judged per file. */
+export function changelogExemptFile(root, path) {
+    return (LOCKFILES.test(basenamePosix(path)) ||
+        HARNESS_PREFIXES.some((prefix) => path.startsWith(prefix)) ||
+        HARNESS_FILES.includes(path) ||
+        path.startsWith(`${root}/history/changelog/`) ||
+        path.includes('.bkp.') ||
+        path === `${root}/history/CHANGELOG.md`);
+}
+/** A non-exempt change set carries a changelog entry: bot authors, pure renames and exempt-only sets aside. */
+export function changelogRule(ctx, root) {
+    const changes = ctx.changes ?? [];
+    if (changes.length === 0)
+        return [];
+    const isBot = /\[bot\]|actions@github\.com/i.test(ctx.commit?.author ?? '');
+    const allRenames = changes.every((change) => change.status === 'R');
+    const allExempt = changes.every((change) => changelogExemptFile(root, change.path));
+    const hasEntry = changes.some((change) => change.status !== 'D' && change.path.startsWith(`${root}/history/changelog/`) && change.path.endsWith('.md'));
+    if (isBot || allRenames || allExempt || hasEntry)
+        return [];
+    return [{ id: 'changelog.missing_entry', message: `the change set is not exempt and carries no ${root}/history/changelog/ entry` }];
+}
+/** A plan flipped Complete in the change set needs a changelog entry at head naming its slug. */
+export function changelogEntryRule(ctx, root) {
+    const findings = [];
+    const complete = /^\*\*Status:\*\*\s*Complete\b/m;
+    const folder = `${root}/history/changelog`;
+    let entries = null;
+    for (const change of ctx.changes ?? []) {
+        if (change.status === 'D' || !change.path.startsWith(`${root}/history/plans/`) || !change.path.endsWith('.md'))
+            continue;
+        if (!complete.test(ctx.head.read(change.path) ?? ''))
+            continue;
+        if (ctx.base && complete.test(ctx.base.read(change.from ?? change.path) ?? ''))
+            continue;
+        const slug = basenamePosix(change.path).replace(/\.md$/, '');
+        entries ??= ctx.head
+            .list(`${folder}/`)
+            .filter((path) => path.endsWith('.md'))
+            .map((path) => ctx.head.read(path) ?? '');
+        if (!entries.some((text) => text.includes(slug)))
+            findings.push({ id: 'changelog-entry.missing', path: change.path, message: `${change.path} reached Status: Complete with no ${folder}/ entry naming ${slug}` });
+    }
+    return findings;
+}
+export const protectedListPath = (root) => `${root}/operations/protected-files.md`;
+/** A changed path (or a rename's source) on the protected list, read from base so a change cannot drop a path and edit it at once. */
+export function protectedFileRule(ctx, root) {
+    const listPath = protectedListPath(root);
+    const listed = new Set([listPath, ...backtickTokens((ctx.base ?? ctx.head).read(listPath) ?? '')]);
+    const findings = [];
+    for (const change of ctx.changes ?? []) {
+        for (const rel of changedPaths(change)) {
+            if (!listed.has(rel) || waiverCovers(ctx.waivers ?? [], 'protected-file', rel, ctx.today))
+                continue;
+            findings.push({ id: 'protected-file.modified', path: rel, message: `${rel} is on the protected list (${listPath})` });
+        }
+    }
+    return findings;
+}

package/dist/vendor/harness/rules/context.js

@@ -0,0 +1,38 @@
+// packages/harness/src/rules/context.ts - The rule library's shared shapes: the tree a rule reads, the change set,
+// the context, the result, waivers and the session facts a hook supplies. Imports no node: module, so the Worker
+// runs every rule. docs/architecture/systems/harness-records.md speaks for it (Status check and enforcement).
+import { resolveDocsRoot } from './docsRoot.js';
+export const docsRootOf = (ctx) => ctx.docsRoot?.trim().replace(/\/+$/, '') || resolveDocsRoot(ctx.head);
+export const waiverExpiry = (row) => /expires=(\d{4}-\d{2}-\d{2})/.exec(row.body)?.[1] ?? null;
+/** Unexpired waived rows for a finding kind. */
+export function unexpiredWaivers(rows, kind, today) {
+    return rows.filter((row) => {
+        if (row.kind !== 'waived')
+            return false;
+        if (kind && !row.body.includes(kind))
+            return false;
+        const expires = waiverExpiry(row);
+        return !!expires && expires >= today;
+    });
+}
+/** True when an unexpired waiver of `kind` names the subject in backticks; a bare substring never covers. */
+export function waiverCovers(rows, kind, subject, today) {
+    return unexpiredWaivers(rows, kind, today).some((row) => row.body.includes(`\`${subject}\``));
+}
+/** Space-free backticked tokens in markdown, `./` stripped: the grammar of path-carrying prose. */
+export function backtickTokens(text) {
+    const out = [];
+    for (const match of String(text || '').matchAll(/`([^`\n]+)`/g)) {
+        const candidate = match[1].trim().replace(/^\.\//, '');
+        if (candidate && !candidate.includes(' '))
+            out.push(candidate);
+    }
+    return out;
+}
+/** One definition of a source file: the plan gate and the drift detector agree on it. */
+export const SOURCE_EXT = /\.(m?[jt]sx?|py|rs|go|rb|java|kt|swift|c|h|cpp|hpp|cs|sh|sql|css|scss|vue|svelte)$/;
+/** The markdown files directly inside a folder of the tree. */
+export const markdownIn = (tree, folder) => tree
+    .list(`${folder}/`)
+    .filter((path) => path.endsWith('.md') && !path.slice(folder.length + 1).includes('/'))
+    .sort();

package/dist/vendor/harness/rules/docsRoot.js

@@ -0,0 +1,34 @@
+// packages/harness/src/rules/docsRoot.ts - The repository's docs root: `.nustack/workspace.json` docsRoot, else
+// `.claude/harness.json` docsRoot, else `docs`. One function for the rules and the mount, applying the declaration
+// rule the `project-contract` conformance seam binds every reader to. docs/architecture/systems/harness-records.md
+// speaks for it.
+export const DEFAULT_DOCS_ROOT = 'docs';
+export const DOCS_ROOT_SOURCES = ['.nustack/workspace.json', '.claude/harness.json'];
+/** A `docsRoot` value as a declaration: trimmed, trailing slashes stripped; empty, absolute or `..`-segmented is none. */
+export function docsRootDeclaration(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim().replace(/[\\/]+$/, '');
+    if (trimmed === '' || /^([A-Za-z]:)?[\\/]/.test(trimmed))
+        return null;
+    return trimmed.split(/[\\/]/).includes('..') ? null : trimmed;
+}
+function declaredRoot(text) {
+    if (!text)
+        return null;
+    try {
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? docsRootDeclaration(parsed.docsRoot) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveDocsRoot(tree) {
+    for (const source of DOCS_ROOT_SOURCES) {
+        const root = declaredRoot(tree.read(source));
+        if (root)
+            return root;
+    }
+    return DEFAULT_DOCS_ROOT;
+}

package/dist/vendor/harness/rules/index.js

@@ -0,0 +1,109 @@
+// packages/harness/src/rules/index.ts - The one rule library (program ruling R14): runRule over a RuleContext, the
+// append-only RULE_IDS with their scopes, delegations and reads, and the ownership helpers ported from etna. Imports
+// no node: module, so the Worker runs it over a repo mirror. docs/architecture/systems/harness-records.md speaks for it
+// (Status check and enforcement).
+import { docsRootOf } from './context.js';
+import { changelogEntryRule, changelogRule, frozenRecordRule, ledgerRule, planGateRule, protectedFileRule } from './changeRules.js';
+import { outputGateRule } from './outputGate.js';
+import { ownershipRule } from './ownership.js';
+import { packageTableRule } from './packageTable.js';
+import { branchWorktreeRule, commitClaimRule, exitStopRule, foreignClaimRule, liveCommandRule, openDenialsRule, queueRule } from './sessionWalls.js';
+export * from './context.js';
+export { resolveDocsRoot, docsRootDeclaration, DEFAULT_DOCS_ROOT, DOCS_ROOT_SOURCES } from './docsRoot.js';
+export { scanOwningDocs, listRepoFiles, deadGlobs, overlaps, owningDoc, owningDocs, scanDocEdges, globToRegExp, specificity } from './ownership.js';
+export { listPlans, openGatedPlans, planScopePaths, inPlanScope, undischargedRows, undischargedDocRows } from './plans.js';
+export { changelogExemptFile, frozenReason, protectedListPath } from './changeRules.js';
+export { approvedPackages, rejectedPackages, APPROVED_TABLE_PATH } from './packageTable.js';
+export { AGENT_BRANCH_PREFIX, parseAgentRef } from './outputGate.js';
+/** Every rule id, append-only: an id is never renamed or removed. The last six delegate to other rules. */
+export const RULE_IDS = [
+    'ownership',
+    'plan-gate',
+    'ledger',
+    'frozen-record',
+    'changelog',
+    'changelog-entry',
+    'package-table',
+    'protected-file',
+    'output-gate',
+    'branch-worktree',
+    'live-command',
+    'commit-claim',
+    'foreign-claim',
+    'open-denials',
+    'exit-stop',
+    'queue',
+    'completion-integrity',
+    'changelog-presence',
+    'commit-gate',
+    'file-gate',
+    'bash-write-screen',
+    'harness-checks',
+];
+export const isRuleId = (value) => RULE_IDS.includes(value);
+/** Seed ids naming a check another rule already makes: each runs its targets, whose findings keep their own ids. */
+export const RULE_ALIASES = {
+    'completion-integrity': ['ledger'],
+    'changelog-presence': ['changelog'],
+    'commit-gate': ['changelog'],
+    'file-gate': ['plan-gate'],
+    'bash-write-screen': ['frozen-record', 'protected-file'],
+    'harness-checks': ['ownership', 'ledger', 'changelog'],
+};
+const SESSION_RULES = ['branch-worktree', 'live-command', 'commit-claim', 'foreign-claim', 'open-denials', 'exit-stop', 'queue'];
+/** Change rules judge trees and a change set; session rules judge one session's action or facts, at the hook. */
+export const RULE_SCOPES = Object.fromEntries(RULE_IDS.map((id) => [id, SESSION_RULES.includes(id) ? 'session' : 'change']));
+const DOCS_SOURCES = ['.nustack/workspace.json', '.claude/harness.json'];
+const DIRECT_READS = {
+    ownership: ['**'],
+    'plan-gate': [...DOCS_SOURCES, '@docs/history/plans/*.md'],
+    ledger: [...DOCS_SOURCES, '@docs/**/*.md'],
+    'frozen-record': [...DOCS_SOURCES, '@docs/history/plans/**/*.md', '@docs/history/changelog/**/*.md', '@docs/history/migrations/**/*.md'],
+    changelog: [...DOCS_SOURCES],
+    'changelog-entry': [...DOCS_SOURCES, '@docs/history/plans/**/*.md', '@docs/history/changelog/**/*.md'],
+    'package-table': ['**/package.json', '.claude/hooks/approved-packages.md', '.claude/rules/general.md', '.claude/rules/testing.md'],
+    'protected-file': [...DOCS_SOURCES, '@docs/operations/protected-files.md'],
+};
+/** The path patterns each rule reads, docs-root-relative ones written `@docs/…`; a delegating id's is its targets' union. */
+export const RULE_READS = Object.fromEntries(RULE_IDS.map((id) => [id, [...new Set((RULE_ALIASES[id] ?? [id]).flatMap((target) => DIRECT_READS[target] ?? []))]]));
+const RULES = {
+    ownership: (ctx) => ownershipRule(ctx, docsRootOf(ctx)),
+    'plan-gate': (ctx) => planGateRule(ctx, docsRootOf(ctx)),
+    ledger: (ctx) => ledgerRule(ctx, docsRootOf(ctx)),
+    'frozen-record': (ctx) => frozenRecordRule(ctx, docsRootOf(ctx)),
+    changelog: (ctx) => changelogRule(ctx, docsRootOf(ctx)),
+    'changelog-entry': (ctx) => changelogEntryRule(ctx, docsRootOf(ctx)),
+    'package-table': packageTableRule,
+    'protected-file': (ctx) => protectedFileRule(ctx, docsRootOf(ctx)),
+    'output-gate': outputGateRule,
+    'branch-worktree': branchWorktreeRule,
+    'live-command': liveCommandRule,
+    'commit-claim': commitClaimRule,
+    'foreign-claim': foreignClaimRule,
+    'open-denials': openDenialsRule,
+    'exit-stop': exitStopRule,
+    queue: queueRule,
+};
+export class UnknownRuleError extends Error {
+    constructor(id) {
+        super(`unknown rule id ${JSON.stringify(id)}; RULE_IDS lists the rules this library runs`);
+        this.name = 'UnknownRuleError';
+    }
+}
+const RANK = { pass: 0, flag: 1, block: 2 };
+/** Runs one rule: pass with no findings, else the configuration's rung (default block). An unknown id throws. */
+export function runRule(id, ctx) {
+    if (!isRuleId(id))
+        throw new UnknownRuleError(id);
+    const targets = RULE_ALIASES[id];
+    if (targets) {
+        const results = targets.map((target) => runRule(target, ctx));
+        const verdict = results.reduce((worst, result) => (RANK[result.verdict] > RANK[worst] ? result.verdict : worst), 'pass');
+        const findings = results.flatMap((result) => result.findings);
+        return results.every((result) => result.notApplicable) ? { verdict, findings, notApplicable: true } : { verdict, findings };
+    }
+    if (RULE_SCOPES[id] === 'session' && (ctx.at ?? 'change') === 'change')
+        return { verdict: 'pass', findings: [], notApplicable: true };
+    const findings = RULES[id](ctx);
+    return { verdict: findings.length === 0 ? 'pass' : (ctx.rung ?? 'block'), findings };
+}

package/dist/vendor/harness/rules/node.js

@@ -0,0 +1,144 @@
+// packages/harness/src/rules/node.ts - nodeRuleContext: a RuleContext over a local git repository. Trees come from
+// `git ls-files` (the working tree, untracked files included) or `git ls-tree`/`git cat-file` at a ref, the change set
+// from `git diff --name-status -M`, and the pull request's head ref from the checked-out branch. Also
+// readBookkeepingWaivers, the `waived:` rows of the bookkeeping queue every local caller passes as waivers. Node only.
+// docs/architecture/systems/harness-records.md speaks for it (Status check and enforcement).
+import { execFileSync } from 'node:child_process';
+import { readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { isSafeRelativePath } from '../lib/paths.js';
+import { resolveDocsRoot } from './docsRoot.js';
+const MAX_BUFFER = 512 * 1024 * 1024;
+function git(root, args) {
+    try {
+        return execFileSync('git', args, { cwd: root, encoding: 'utf8', maxBuffer: MAX_BUFFER, stdio: ['ignore', 'pipe', 'ignore'] });
+    }
+    catch {
+        return null;
+    }
+}
+const nulList = (out) => (out ?? '').split('\0').filter(Boolean);
+/** A tree over the files committed at `ref`. */
+export function gitRefTree(root, ref) {
+    const files = nulList(git(root, ['ls-tree', '-r', '-z', '--name-only', ref])).sort();
+    const known = new Set(files);
+    const cache = new Map();
+    return {
+        read(path) {
+            if (!known.has(path))
+                return null;
+            if (!cache.has(path))
+                cache.set(path, git(root, ['cat-file', 'blob', `${ref}:${path}`]));
+            return cache.get(path);
+        },
+        list: (prefix) => files.filter((path) => path.startsWith(prefix)),
+    };
+}
+/** A tree over the working tree: tracked and untracked-but-not-ignored files that exist; any safe path reads from disk. */
+export function workingTree(root) {
+    const files = [...new Set(nulList(git(root, ['ls-files', '-z', '--cached', '--others', '--exclude-standard'])))]
+        .filter((path) => {
+        try {
+            return statSync(join(root, path)).isFile();
+        }
+        catch {
+            return false;
+        }
+    })
+        .sort();
+    return {
+        read(path) {
+            if (!isSafeRelativePath(path))
+                return null;
+            try {
+                return readFileSync(join(root, path), 'utf8');
+            }
+            catch {
+                return null;
+            }
+        },
+        list: (prefix) => files.filter((path) => path.startsWith(prefix)),
+    };
+}
+/** `git diff --name-status -M -z` parsed; copies count as adds. */
+function parseNameStatus(out) {
+    const fields = nulList(out);
+    const changes = [];
+    for (let i = 0; i < fields.length;) {
+        const status = fields[i];
+        const kind = status[0];
+        if (kind === 'R' || kind === 'C') {
+            const from = fields[i + 1];
+            const path = fields[i + 2];
+            changes.push(kind === 'R' ? { path, status: 'R', from } : { path, status: 'A' });
+            i += 3;
+        }
+        else {
+            changes.push({ path: fields[i + 1], status: kind === 'A' ? 'A' : kind === 'D' ? 'D' : 'M' });
+            i += 2;
+        }
+    }
+    return changes;
+}
+/**
+ * A rule context over the repository at `root`. With `headRef`, head is that commit and base is `baseRef` when given;
+ * without it, head is the working tree and base is `baseRef`, else HEAD.
+ */
+export function nodeRuleContext(options) {
+    const { root, headRef } = options;
+    const hasHead = git(root, ['rev-parse', '--verify', '--quiet', 'HEAD']) !== null;
+    const baseRef = options.baseRef ?? (headRef || !hasHead ? undefined : 'HEAD');
+    const head = headRef ? gitRefTree(root, headRef) : workingTree(root);
+    const base = baseRef ? gitRefTree(root, baseRef) : undefined;
+    let changes = [];
+    if (baseRef) {
+        changes = parseNameStatus(git(root, ['diff', '--name-status', '-M', '-z', baseRef, ...(headRef ? [headRef] : [])]));
+        if (!headRef) {
+            const tracked = new Set(changes.map((change) => change.path));
+            for (const path of nulList(git(root, ['ls-files', '-z', '--others', '--exclude-standard'])))
+                if (!tracked.has(path))
+                    changes.push({ path, status: 'A' });
+        }
+    }
+    const log = git(root, ['log', '-1', '--format=%an <%ae>%x00%B', headRef ?? 'HEAD']);
+    const [author, message] = log ? [log.slice(0, log.indexOf('\0')), log.slice(log.indexOf('\0') + 1).trimEnd()] : ['', ''];
+    const branch = (git(root, ['rev-parse', '--abbrev-ref', 'HEAD']) ?? '').trim();
+    return {
+        head,
+        ...(base ? { base } : {}),
+        changes,
+        commit: { author, message },
+        today: options.today ?? new Date().toISOString().slice(0, 10),
+        pullRequest: { headRef: branch, baseRef: options.baseRef ?? '' },
+    };
+}
+/** The bookkeeping queue, relative to the docs root. */
+export const BOOKKEEPING_QUEUE_PATH = 'operations/bookkeeping.md';
+const QUEUE_ROW = /^-\s+(auto|note|needs-session|waived):\s+(.*)$/;
+/**
+ * The `waived:` rows of `<docs root>/operations/bookkeeping.md` as RuleWaivers, ported from etna's `readQueue`: one
+ * per row, its body trimmed. `scripts/verify/check-ownership.mjs` and `nustack check` both pass these, so the two
+ * never read waivers differently. None when the queue is absent.
+ */
+export function readBookkeepingWaivers(root) {
+    const read = (path) => {
+        if (!isSafeRelativePath(path))
+            return null;
+        try {
+            return readFileSync(join(root, path), 'utf8');
+        }
+        catch {
+            return null;
+        }
+    };
+    const text = read(`${resolveDocsRoot({ read })}/${BOOKKEEPING_QUEUE_PATH}`);
+    if (text === null)
+        return [];
+    const waivers = [];
+    for (const line of text.split(/\r?\n/)) {
+        const match = QUEUE_ROW.exec(line.trim());
+        if (match && match[1] === 'waived')
+            waivers.push({ kind: 'waived', body: match[2].trim() });
+    }
+    return waivers;
+}

package/dist/vendor/harness/rules/outputGate.js

@@ -0,0 +1,28 @@
+export const AGENT_BRANCH_PREFIX = 'nustack/agent/';
+const SEGMENT = /^[A-Za-z0-9_-]+$/;
+/** `nustack/agent/<slug>/<runId>` split, or null when a ref under the prefix does not parse. */
+export function parseAgentRef(ref) {
+    if (!ref.startsWith(AGENT_BRANCH_PREFIX))
+        return null;
+    const parts = ref.slice(AGENT_BRANCH_PREFIX.length).split('/');
+    return parts.length === 2 && SEGMENT.test(parts[0]) && SEGMENT.test(parts[1]) ? { agentSlug: parts[0], runId: parts[1] } : null;
+}
+export function outputGateRule(ctx) {
+    if (!ctx.pullRequest)
+        return [{ id: 'output-gate.context_missing', message: 'no pull request refs were passed; the output gate fails closed' }];
+    const ref = ctx.pullRequest.headRef;
+    const run = ctx.agentRun;
+    const namespaced = ref.startsWith(AGENT_BRANCH_PREFIX);
+    const parsed = parseAgentRef(ref);
+    const findings = [];
+    if (run && !namespaced) {
+        findings.push({ id: 'output-gate.outside_namespace', message: `agent ${run.agentSlug} run ${run.runId} opened ${ref}, outside ${AGENT_BRANCH_PREFIX}${run.agentSlug}/` });
+    }
+    if (namespaced && !parsed)
+        findings.push({ id: 'output-gate.malformed_ref', message: `${ref} is under ${AGENT_BRANCH_PREFIX} but is not <slug>/<runId>` });
+    if (parsed && run && parsed.agentSlug !== run.agentSlug)
+        findings.push({ id: 'output-gate.foreign_namespace', message: `${ref} is ${parsed.agentSlug}'s namespace, but the run is ${run.agentSlug}'s` });
+    if (namespaced && run === null)
+        findings.push({ id: 'output-gate.unclaimed_ref', message: `${ref} is in the agent namespace but no agent run claims it` });
+    return findings;
+}