@deftai/directive-core 0.105.0 → 0.106.0

package/dist/intake/clause-derivation.js

@@ -9,6 +9,8 @@ import { ENV_RUN_SUMMARY_PATH, RunSummaryEmitter, } from "../run-summary/index.j
 import { deriveAcceptanceClauses, readAcceptanceClauses, serializeAcceptanceClauses, } from "../verify-ac/clauses.js";
 /** One-line remediation when a stamp has no statement-traceable clause (#3398). */
 export const CLAUSE_STAMP_IMPLEMENTATION_ONLY_REMEDIATION = "derive clauses from the statement's testable constraints";
+export const MISSING_AMBIGUITY_ATTESTATION_CAUSE = "missing_ambiguity_attestation";
+export const AMBIGUITY_ATTESTATION_REMEDIATION = "record ambiguity readings or attest none_found";
 const NARRATIVE_KEYS = [
     "Overview",
     "Description",
@@ -165,12 +167,22 @@ export function prepareClauseStamp(clauses, statement) {
         ambiguity_attestation: traced.some(hasAmbiguousReadings) ? undefined : "none_found",
     };
 }
-const AMBIGUITY_ATTESTATION_MISSING = "verify:ac config error: missing ambiguity attestation; record at least one ambiguous: true clause with readings, or set ambiguity_attestation: none_found";
+const AMBIGUITY_ATTESTATION_MISSING = `verify:ac config error: missing ambiguity attestation; ${AMBIGUITY_ATTESTATION_REMEDIATION}`;
+function missingAttestationCheck() {
+    return {
+        ok: false,
+        attested: false,
+        kind: "missing",
+        message: AMBIGUITY_ATTESTATION_MISSING,
+        cause: MISSING_AMBIGUITY_ATTESTATION_CAUSE,
+        remediation: AMBIGUITY_ATTESTATION_REMEDIATION,
+    };
+}
 /** Config-error surface for verify:ac: attestation or an ambiguous clause with readings. */
 export function evaluateAmbiguityAttestation(acceptance) {
     const rec = asRecord(acceptance);
     if (rec === null) {
-        return { ok: false, attested: false, kind: "missing", message: AMBIGUITY_ATTESTATION_MISSING };
+        return missingAttestationCheck();
     }
     const clauses = readAcceptanceClauses(rec);
     if (clauses.some(hasAmbiguousReadings)) {
@@ -179,7 +191,22 @@ export function evaluateAmbiguityAttestation(acceptance) {
     if (rec.ambiguity_attestation === "none_found") {
         return { ok: true, attested: true, kind: "none_found", message: "" };
     }
-    return { ok: false, attested: false, kind: "missing", message: AMBIGUITY_ATTESTATION_MISSING };
+    return missingAttestationCheck();
+}
+/**
+ * Fail-closed check for a *stamped* plan.acceptance (#3559).
+ * Command-only / empty floor blocks are not stamps; they keep the empty-resolution path.
+ */
+export function stampedAmbiguityAttestationError(acceptance) {
+    const rec = asRecord(acceptance);
+    if (rec === null) {
+        return null;
+    }
+    if (readAcceptanceClauses(rec).length === 0) {
+        return null;
+    }
+    const check = evaluateAmbiguityAttestation(rec);
+    return check.ok ? null : check;
 }
 function serializeTracedClauses(clauses) {
     return serializeAcceptanceClauses(clauses).map((row, index) => ({

package/dist/lifecycle-visible/evaluate.d.ts

@@ -0,0 +1,98 @@
+/**
+ * verify:lifecycle-visible — detect ignore/index flags that hide lifecycle roots (#3505).
+ *
+ * Warn-only by default (exit 0). Pass --enforce to fail closed.
+ * Not a task-check gate: this is a per-clone environment property.
+ */
+import { type GitRunner } from "../session/git.js";
+export declare const LIFECYCLE_ROOT_PREFIXES: readonly ["xbrief", "vbrief"];
+export declare const LIFECYCLE_STAGE_DIRS: readonly ["proposed", "pending", "active", "completed", "cancelled"];
+export type LifecycleHideKind = "ignored" | "skip-worktree" | "assume-unchanged";
+export interface LifecycleHideFinding {
+    readonly path: string;
+    readonly kind: LifecycleHideKind;
+    readonly source: string;
+    readonly line: number | null;
+    readonly rule: string;
+    readonly raw: string;
+}
+export interface LifecycleVisibleOptions {
+    readonly projectRoot: string;
+    readonly enforce?: boolean;
+    readonly runGit?: GitRunner;
+}
+export interface LifecycleVisibleResult {
+    readonly code: 0 | 1 | 2;
+    readonly message: string;
+    readonly stream: "stdout" | "stderr";
+    readonly findings: readonly LifecycleHideFinding[];
+    readonly enforce: boolean;
+    readonly failOpen: boolean;
+}
+export interface CheckIgnoreMatch {
+    readonly source: string;
+    readonly line: number;
+    readonly pattern: string;
+    readonly path: string;
+}
+export interface LsFilesVerboseRecord {
+    readonly tag: string;
+    readonly path: string;
+}
+/** Ignore globs from one file, with the directory Git applies them against. */
+export interface IgnorePatternSource {
+    readonly baseDir: string;
+    readonly patterns: readonly string[];
+}
+/** Canonical lifecycle root pathspecs (`xbrief/active/`, `vbrief/pending/`, …). */
+export declare function lifecycleRootRelPaths(): string[];
+/** Fills `*` in ignore globs so a derived probe still matches the rule. */
+export declare const LIFECYCLE_PROBE_STEM = "lifecycle-visible";
+/**
+ * Date-prefixed brief-shaped fallback when no ignore-rule date glob exists.
+ * Date globs emit their own matching names (`2026-07-*` → a July file, `2025-*` → 2025).
+ */
+export declare const LIFECYCLE_PROBE_SENTINEL = "2026-01-01-lifecycle-visible.xbrief.json";
+/** Legacy vbrief filename so `*.vbrief.json` / `2026-*.vbrief.json` cannot report clean. */
+export declare const LIFECYCLE_PROBE_SENTINEL_VBRIEF = "2026-01-01-lifecycle-visible.vbrief.json";
+/** Stage dirs plus one matching-extension sentinel under each. */
+export declare function lifecycleIgnoreProbeRelPaths(): string[];
+/** True when an ignore glob could hide a convention-valid brief. */
+export declare function ignorePatternLooksLifecycleRelevant(pattern: string): boolean;
+/** Linear `[abc]` expansion — avoid nested regex quantifiers (CodeQL js/polynomial-redos). */
+export declare function expandGitignoreCharClasses(body: string): string;
+/**
+ * Expand one gitignore glob into a single concrete pathname that still matches it.
+ * `*` becomes {@link LIFECYCLE_PROBE_STEM}; `**` collapses; `?` becomes `0`.
+ */
+export declare function expandGitignoreGlobToConcrete(pattern: string): string | null;
+/** Join a glob-expanded probe to the ignore file's directory (Git's match root). */
+export declare function joinIgnoreFileBase(baseDir: string, concrete: string): string;
+/**
+ * One derived probe per relevant ignore-rule line (bounded by ignore-file size, not a numeric cap).
+ * Date globs keep their year/month so `2026-07-*` probes a July name, not the January fallback.
+ * Slash patterns keep the ignore-file directory; stage wildcards expand onto real stages.
+ */
+export declare function derivedLifecycleIgnoreProbesFromSources(sources: readonly IgnorePatternSource[]): string[];
+/** Ignore-file globs → check-ignore pathspecs (one per relevant rule line). */
+export declare function derivedLifecycleIgnoreProbes(projectRoot: string, runGit: GitRunner): string[];
+/** Map a check-ignore pathname back to its canonical stage root, or null if outside. */
+export declare function lifecycleRootForRelPath(relPosix: string): string | null;
+/** Deliberate hybrid ignores under a visible root must not trip the check (#1144). */
+export declare function isSelectiveLifecyclePath(relPosix: string): boolean;
+/** Map git check-ignore source paths to the actionable display form. */
+export declare function displayIgnoreSource(source: string, projectRoot: string): string;
+/**
+ * Parse one `git check-ignore -v` line: `<source>:<linenum>:<pattern>\\t<pathname>`.
+ * Source may be a Windows absolute path with a drive colon.
+ */
+export declare function parseCheckIgnoreVerboseLine(line: string): CheckIgnoreMatch | null;
+/** Parse one `git ls-files -v` record (`S path` / `h path`). */
+export declare function parseLsFilesVerboseRecord(record: string): LsFilesVerboseRecord | null;
+/** Index flag encoded by the `ls-files -v` status tag. */
+export declare function indexFlagKind(tag: string): "skip-worktree" | "assume-unchanged" | null;
+/** Session:start advisory lines — silent when clean. */
+export declare function formatLifecycleVisibleSessionLines(result: LifecycleVisibleResult): string[];
+/** Evaluate whether lifecycle roots are hidden by ignore rules or index flags (#3505). */
+export declare function evaluateLifecycleVisible(options: LifecycleVisibleOptions): LifecycleVisibleResult;
+//# sourceMappingURL=evaluate.d.ts.map