avorelo 0.3.8 → 0.4.0-rc.2

package/scripts/lib/context-source-registry.js

@@ -0,0 +1,393 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const SCHEMA_VERSION = "avorelo.sourceOfTruthRef.v1";
+
+const VALID_SOURCE_TYPES = new Set([
+  "release_doc",
+  "internal_doc",
+  "public_article",
+  "public_web_source",
+  "dogfood_artifact",
+  "proof_artifact",
+  "capability_manifest",
+  "source_code",
+  "design_source",
+  "browser_proof",
+  "reentry_memory",
+  "next_run_report",
+  "planning_doc",
+  "handoff",
+  "screenshot_ref",
+]);
+
+const VALID_AUTHORITY = new Set(["high", "medium", "low"]);
+const VALID_FRESHNESS = new Set(["fresh", "possibly_stale", "stale"]);
+
+function fileExists(abs) {
+  try { fs.accessSync(abs); return true; } catch { return false; }
+}
+
+function buildSourceRef(partial) {
+  const ref = {
+    schemaVersion: SCHEMA_VERSION,
+    id: partial.id || "",
+    ref: partial.ref || "",
+    type: partial.type || "source_code",
+    scope: Array.isArray(partial.scope) ? partial.scope : [],
+    authority: VALID_AUTHORITY.has(partial.authority) ? partial.authority : "medium",
+    freshness: VALID_FRESHNESS.has(partial.freshness) ? partial.freshness : "fresh",
+    publicSafe: Boolean(partial.publicSafe),
+    internalOnly: Boolean(partial.internalOnly),
+    allowedForClaims: Boolean(partial.allowedForClaims),
+    allowedForPrompt: partial.allowedForPrompt !== false,
+    evidenceRefs: Array.isArray(partial.evidenceRefs) ? partial.evidenceRefs : [],
+    reasonCodes: Array.isArray(partial.reasonCodes) ? partial.reasonCodes : [],
+  };
+  if (!VALID_SOURCE_TYPES.has(ref.type)) ref.type = "source_code";
+  return ref;
+}
+
+function discoverReleaseDocs(repoRoot) {
+  const dir = path.join(repoRoot, "docs", "releases");
+  if (!fileExists(dir)) return [];
+  const refs = [];
+  try {
+    for (const name of fs.readdirSync(dir)) {
+      if (!name.endsWith(".md")) continue;
+      const rel = `docs/releases/${name}`;
+      const id = name.replace(/\.md$/, "");
+      refs.push(buildSourceRef({
+        id: `release-${id}`,
+        ref: rel,
+        type: "release_doc",
+        scope: [id.replace(/-v\d+$/, "")],
+        authority: "high",
+        freshness: "fresh",
+        publicSafe: true,
+        internalOnly: false,
+        allowedForClaims: true,
+        reasonCodes: ["release_source"],
+      }));
+    }
+  } catch { /* empty dir or inaccessible */ }
+  return refs;
+}
+
+function discoverInternalDocs(repoRoot) {
+  const dir = path.join(repoRoot, "docs", "internal");
+  if (!fileExists(dir)) return [];
+  const refs = [];
+  try {
+    for (const name of fs.readdirSync(dir)) {
+      if (!name.endsWith(".md")) continue;
+      const rel = `docs/internal/${name}`;
+      const id = name.replace(/\.md$/, "");
+      refs.push(buildSourceRef({
+        id: `internal-${id}`,
+        ref: rel,
+        type: "internal_doc",
+        scope: [id],
+        authority: "medium",
+        freshness: "fresh",
+        publicSafe: false,
+        internalOnly: true,
+        allowedForClaims: false,
+        reasonCodes: ["internal_architecture"],
+      }));
+    }
+  } catch { /* */ }
+  return refs;
+}
+
+function discoverArticles(repoRoot) {
+  const dir = path.join(repoRoot, "docs", "articles");
+  if (!fileExists(dir)) return [];
+  const refs = [];
+  try {
+    for (const name of fs.readdirSync(dir)) {
+      if (!name.endsWith(".md")) continue;
+      const rel = `docs/articles/${name}`;
+      const id = name.replace(/\.md$/, "");
+      refs.push(buildSourceRef({
+        id: `article-${id}`,
+        ref: rel,
+        type: "public_article",
+        scope: [id],
+        authority: "medium",
+        freshness: "fresh",
+        publicSafe: true,
+        internalOnly: false,
+        allowedForClaims: true,
+        reasonCodes: ["public_content"],
+      }));
+    }
+  } catch { /* */ }
+  return refs;
+}
+
+function discoverPublicWebSources(repoRoot) {
+  const dir = path.join(repoRoot, "apps", "public-web");
+  if (!fileExists(dir)) return [];
+  const refs = [];
+  try {
+    const distDir = path.join(dir, "dist");
+    if (fileExists(distDir)) {
+      refs.push(buildSourceRef({
+        id: "public-web-dist",
+        ref: "apps/public-web/dist",
+        type: "public_web_source",
+        scope: ["public-website"],
+        authority: "high",
+        freshness: "fresh",
+        publicSafe: true,
+        internalOnly: false,
+        allowedForClaims: true,
+        reasonCodes: ["public_web_source", "current_build"],
+      }));
+    }
+  } catch { /* */ }
+  return refs;
+}
+
+function discoverDogfoodArtifacts(repoRoot) {
+  const dir = path.join(repoRoot, "docs", "dogfood");
+  if (!fileExists(dir)) return [];
+  const refs = [];
+  try {
+    for (const name of fs.readdirSync(dir)) {
+      if (!name.endsWith(".md")) continue;
+      const rel = `docs/dogfood/${name}`;
+      const id = name.replace(/\.md$/, "");
+      refs.push(buildSourceRef({
+        id: `dogfood-${id}`,
+        ref: rel,
+        type: "dogfood_artifact",
+        scope: [id.replace(/-dogfood$/, "")],
+        authority: "medium",
+        freshness: "fresh",
+        publicSafe: false,
+        internalOnly: true,
+        allowedForClaims: false,
+        evidenceRefs: [rel],
+        reasonCodes: ["dogfood_evidence"],
+      }));
+    }
+  } catch { /* */ }
+  return refs;
+}
+
+function discoverProofArtifacts(repoRoot) {
+  const base = path.join(repoRoot, "artifacts");
+  if (!fileExists(base)) return [];
+  const refs = [];
+  try {
+    for (const sub of fs.readdirSync(base)) {
+      const subDir = path.join(base, sub);
+      let stat;
+      try { stat = fs.statSync(subDir); } catch { continue; }
+      if (!stat.isDirectory()) continue;
+      try {
+        for (const name of fs.readdirSync(subDir)) {
+          if (!name.endsWith(".json")) continue;
+          const rel = `artifacts/${sub}/${name}`;
+          refs.push(buildSourceRef({
+            id: `proof-${sub}-${name.replace(/\.json$/, "")}`,
+            ref: rel,
+            type: "proof_artifact",
+            scope: [sub],
+            authority: "high",
+            freshness: "fresh",
+            publicSafe: false,
+            internalOnly: true,
+            allowedForClaims: true,
+            evidenceRefs: [rel],
+            reasonCodes: ["proof_artifact", "evidence_backed"],
+          }));
+        }
+      } catch { /* */ }
+    }
+  } catch { /* */ }
+  return refs;
+}
+
+function discoverPlanningDocs(repoRoot) {
+  const dir = path.join(repoRoot, "docs", "product");
+  if (!fileExists(dir)) return [];
+  const refs = [];
+  function walk(dirPath, relBase) {
+    try {
+      for (const name of fs.readdirSync(dirPath)) {
+        const full = path.join(dirPath, name);
+        const rel = `${relBase}/${name}`;
+        let stat;
+        try { stat = fs.statSync(full); } catch { continue; }
+        if (stat.isDirectory()) { walk(full, rel); continue; }
+        if (!name.endsWith(".md")) continue;
+        const id = rel.replace(/^docs\/product\//, "").replace(/\.md$/, "").replace(/\//g, "-");
+        refs.push(buildSourceRef({
+          id: `planning-${id}`,
+          ref: rel,
+          type: "planning_doc",
+          scope: [id],
+          authority: "low",
+          freshness: "possibly_stale",
+          publicSafe: false,
+          internalOnly: true,
+          allowedForClaims: false,
+          reasonCodes: ["internal_planning"],
+        }));
+      }
+    } catch { /* */ }
+  }
+  walk(dir, "docs/product");
+  return refs;
+}
+
+function discoverCapabilityManifestRefs(repoRoot) {
+  try {
+    const { getCapabilities } = require("./capability-kernel-registry");
+    const caps = getCapabilities();
+    return caps.map((cap) => buildSourceRef({
+      id: `capability-${cap.id}`,
+      ref: `scripts/lib/capability-kernel-registry.js#${cap.id}`,
+      type: "capability_manifest",
+      scope: [cap.id, cap.category],
+      authority: "high",
+      freshness: "fresh",
+      publicSafe: false,
+      internalOnly: false,
+      allowedForClaims: true,
+      evidenceRefs: cap.dogfood ? [cap.dogfood.artifactPath] : [],
+      reasonCodes: ["capability_registry", "kernel_source"],
+    }));
+  } catch {
+    return [];
+  }
+}
+
+function discoverBrowserProofRefs(repoRoot) {
+  const reportRel = ".claude/cco/reports/browser-proof";
+  const dir = path.join(repoRoot, reportRel);
+  if (!fileExists(dir)) return [];
+  const refs = [];
+  try {
+    for (const name of fs.readdirSync(dir)) {
+      if (!name.endsWith(".json")) continue;
+      refs.push(buildSourceRef({
+        id: `browser-proof-${name.replace(/\.json$/, "")}`,
+        ref: `${reportRel}/${name}`,
+        type: "browser_proof",
+        scope: ["browser-proof", "ui-validation"],
+        authority: "medium",
+        freshness: "fresh",
+        publicSafe: false,
+        internalOnly: true,
+        allowedForClaims: false,
+        evidenceRefs: [`${reportRel}/${name}`],
+        reasonCodes: ["browser_proof_artifact"],
+      }));
+    }
+  } catch { /* */ }
+  return refs;
+}
+
+function discoverNextRunRefs(repoRoot) {
+  const reportRel = ".claude/cco/reports/next-run-continuity/latest-report.json";
+  const abs = path.join(repoRoot, reportRel);
+  if (!fileExists(abs)) return [];
+  return [buildSourceRef({
+    id: "next-run-latest",
+    ref: reportRel,
+    type: "next_run_report",
+    scope: ["next-run-continuity"],
+    authority: "medium",
+    freshness: "fresh",
+    publicSafe: false,
+    internalOnly: true,
+    allowedForClaims: false,
+    reasonCodes: ["next_run_report"],
+  })];
+}
+
+function discoverReentryMemoryRefs(repoRoot) {
+  const storeRel = ".claude/cco/state/reentry-memory.jsonl";
+  const abs = path.join(repoRoot, storeRel);
+  if (!fileExists(abs)) return [];
+  return [buildSourceRef({
+    id: "reentry-memory-store",
+    ref: storeRel,
+    type: "reentry_memory",
+    scope: ["reentry-memory"],
+    authority: "low",
+    freshness: "fresh",
+    publicSafe: false,
+    internalOnly: true,
+    allowedForClaims: false,
+    reasonCodes: ["reentry_memory_store"],
+  })];
+}
+
+function discoverAllSources(repoRoot) {
+  const root = repoRoot || process.cwd();
+  const all = [
+    ...discoverReleaseDocs(root),
+    ...discoverInternalDocs(root),
+    ...discoverArticles(root),
+    ...discoverPublicWebSources(root),
+    ...discoverDogfoodArtifacts(root),
+    ...discoverProofArtifacts(root),
+    ...discoverPlanningDocs(root),
+    ...discoverCapabilityManifestRefs(root),
+    ...discoverBrowserProofRefs(root),
+    ...discoverNextRunRefs(root),
+    ...discoverReentryMemoryRefs(root),
+  ];
+  return validateAndMarkMissing(root, all);
+}
+
+function validateAndMarkMissing(repoRoot, refs) {
+  return refs.map((ref) => {
+    if (path.isAbsolute(ref.ref)) {
+      ref.ref = path.relative(repoRoot, ref.ref).replace(/\\/g, "/");
+    }
+    ref.ref = ref.ref.replace(/\\/g, "/");
+    const abs = path.join(repoRoot, ref.ref);
+    if (ref.ref.includes("#") || ref.ref.startsWith(".claude/")) {
+      return ref;
+    }
+    if (!fileExists(abs) && !fs.existsSync(abs)) {
+      ref.freshness = "stale";
+      if (!ref.reasonCodes.includes("missing_file")) {
+        ref.reasonCodes.push("missing_file");
+      }
+    }
+    for (let i = 0; i < ref.evidenceRefs.length; i++) {
+      ref.evidenceRefs[i] = ref.evidenceRefs[i].replace(/\\/g, "/");
+    }
+    return ref;
+  });
+}
+
+module.exports = {
+  SCHEMA_VERSION,
+  VALID_SOURCE_TYPES,
+  VALID_AUTHORITY,
+  VALID_FRESHNESS,
+  buildSourceRef,
+  discoverReleaseDocs,
+  discoverInternalDocs,
+  discoverArticles,
+  discoverPublicWebSources,
+  discoverDogfoodArtifacts,
+  discoverProofArtifacts,
+  discoverPlanningDocs,
+  discoverCapabilityManifestRefs,
+  discoverBrowserProofRefs,
+  discoverNextRunRefs,
+  discoverReentryMemoryRefs,
+  discoverAllSources,
+  validateAndMarkMissing,
+};

package/scripts/lib/context-task-profiles.js

@@ -0,0 +1,147 @@
+"use strict";
+
+const SCHEMA_VERSION = "avorelo.taskProfile.v1";
+
+const PROFILES = [
+  {
+    id: "capability-development",
+    preferredSourceTypes: ["capability_manifest", "release_doc", "internal_doc", "proof_artifact", "dogfood_artifact"],
+    blockedSourceTypes: ["screenshot_ref", "handoff"],
+    requiresPublicSafe: false,
+    requiresProofForClaims: false,
+    allowInternalSources: true,
+    maxRefs: 12,
+    maxEstimatedTokens: 2000,
+  },
+  {
+    id: "release-doc-update",
+    preferredSourceTypes: ["release_doc", "proof_artifact", "dogfood_artifact", "capability_manifest"],
+    blockedSourceTypes: ["planning_doc", "screenshot_ref", "handoff"],
+    requiresPublicSafe: false,
+    requiresProofForClaims: true,
+    allowInternalSources: true,
+    maxRefs: 10,
+    maxEstimatedTokens: 1800,
+  },
+  {
+    id: "dogfood-review",
+    preferredSourceTypes: ["dogfood_artifact", "proof_artifact", "release_doc", "capability_manifest"],
+    blockedSourceTypes: ["planning_doc", "screenshot_ref"],
+    requiresPublicSafe: false,
+    requiresProofForClaims: false,
+    allowInternalSources: true,
+    maxRefs: 10,
+    maxEstimatedTokens: 1800,
+  },
+  {
+    id: "public-web-copy",
+    preferredSourceTypes: ["public_article", "release_doc", "dogfood_artifact", "public_web_source", "proof_artifact"],
+    blockedSourceTypes: ["internal_doc", "planning_doc", "reentry_memory", "handoff", "screenshot_ref"],
+    requiresPublicSafe: true,
+    requiresProofForClaims: true,
+    allowInternalSources: false,
+    maxRefs: 8,
+    maxEstimatedTokens: 1500,
+  },
+  {
+    id: "article-writing",
+    preferredSourceTypes: ["public_article", "release_doc", "proof_artifact", "dogfood_artifact"],
+    blockedSourceTypes: ["internal_doc", "planning_doc", "reentry_memory", "handoff"],
+    requiresPublicSafe: true,
+    requiresProofForClaims: true,
+    allowInternalSources: false,
+    maxRefs: 8,
+    maxEstimatedTokens: 1500,
+  },
+  {
+    id: "landing-page-update",
+    preferredSourceTypes: ["public_web_source", "public_article", "release_doc", "proof_artifact"],
+    blockedSourceTypes: ["internal_doc", "planning_doc", "reentry_memory", "handoff", "screenshot_ref"],
+    requiresPublicSafe: true,
+    requiresProofForClaims: true,
+    allowInternalSources: false,
+    maxRefs: 8,
+    maxEstimatedTokens: 1500,
+  },
+  {
+    id: "dashboard-ui-update",
+    preferredSourceTypes: ["source_code", "design_source", "browser_proof", "release_doc"],
+    blockedSourceTypes: ["planning_doc", "handoff"],
+    requiresPublicSafe: false,
+    requiresProofForClaims: false,
+    allowInternalSources: true,
+    maxRefs: 10,
+    maxEstimatedTokens: 1800,
+  },
+  {
+    id: "product-home-update",
+    preferredSourceTypes: ["source_code", "capability_manifest", "release_doc", "proof_artifact", "browser_proof"],
+    blockedSourceTypes: ["planning_doc", "handoff", "screenshot_ref"],
+    requiresPublicSafe: false,
+    requiresProofForClaims: false,
+    allowInternalSources: true,
+    maxRefs: 10,
+    maxEstimatedTokens: 1800,
+  },
+  {
+    id: "claim-safety-review",
+    preferredSourceTypes: ["public_article", "public_web_source", "release_doc", "proof_artifact"],
+    blockedSourceTypes: ["planning_doc", "reentry_memory", "handoff"],
+    requiresPublicSafe: true,
+    requiresProofForClaims: true,
+    allowInternalSources: false,
+    maxRefs: 8,
+    maxEstimatedTokens: 1200,
+  },
+  {
+    id: "next-run-continuation",
+    preferredSourceTypes: ["next_run_report", "reentry_memory", "release_doc", "proof_artifact", "capability_manifest"],
+    blockedSourceTypes: ["screenshot_ref", "handoff"],
+    requiresPublicSafe: false,
+    requiresProofForClaims: false,
+    allowInternalSources: true,
+    maxRefs: 10,
+    maxEstimatedTokens: 1800,
+  },
+  {
+    id: "production-readiness-review",
+    preferredSourceTypes: ["proof_artifact", "release_doc", "capability_manifest", "dogfood_artifact", "browser_proof"],
+    blockedSourceTypes: ["planning_doc", "screenshot_ref", "handoff"],
+    requiresPublicSafe: false,
+    requiresProofForClaims: true,
+    allowInternalSources: true,
+    maxRefs: 12,
+    maxEstimatedTokens: 2000,
+  },
+];
+
+function getProfile(id) {
+  return PROFILES.find((p) => p.id === id) || null;
+}
+
+function getAllProfiles() {
+  return PROFILES.slice();
+}
+
+function getProfileIds() {
+  return PROFILES.map((p) => p.id);
+}
+
+function validateProfile(profile) {
+  const errors = [];
+  if (!profile || typeof profile !== "object") return { valid: false, errors: ["profile must be an object"] };
+  if (!profile.id) errors.push("missing id");
+  if (!Array.isArray(profile.preferredSourceTypes)) errors.push("missing preferredSourceTypes");
+  if (typeof profile.maxRefs !== "number" || profile.maxRefs < 1) errors.push("maxRefs must be >= 1");
+  if (typeof profile.maxEstimatedTokens !== "number" || profile.maxEstimatedTokens < 1) errors.push("maxEstimatedTokens must be >= 1");
+  return { valid: errors.length === 0, errors };
+}
+
+module.exports = {
+  SCHEMA_VERSION,
+  PROFILES,
+  getProfile,
+  getAllProfiles,
+  getProfileIds,
+  validateProfile,
+};