phronesis 1.0.0

package/vendor/core/src/index.js

@@ -0,0 +1,180 @@
+// @phronesis/core — the shared ontology/event substrate (ADR-0003; changes/0008).
+// One package, one entry point: every surface (CLI today; daemon + GUI later) imports
+// these primitives from here, so the validator, the link index, and the action types
+// can never disagree about what counts as an object, a link, or an event.
+
+export {
+  OBJECT_TYPES,
+  DOMAIN_TYPES,
+  CODEX_PRINCIPLE_TYPES,
+  ENTITY_TYPES,
+  TYPE_DIR,
+  COMPILED_DIRS,
+  ENUMS,
+  LINK_RELS,
+  RE_SLUG,
+  DATE_RE,
+  classifyTarget,
+  validateFrontmatter,
+} from './contract.js';
+
+export { checkObjectContent } from './validate-object.js';
+
+export {
+  ARTIFACT_KINDS,
+  artifactContextFor,
+  listArtifactFiles,
+  checkArtifactContent,
+  readArtifactRecord,
+  artifactPath,
+  writeArtifact,
+} from './artifacts.js';
+
+export { assertRawDestination, stageRawSource } from './ingest.js';
+
+export { contentDigest, digestFile } from './content-digest.js';
+
+export {
+  slugify,
+  serializeFrontmatter,
+  formatLogEntry,
+  appendLogBlock,
+  splitObjectSource,
+  stageValidateRename,
+  stageValidateRenameAll,
+} from './action-writers.js';
+
+export {
+  ACTION_REGISTRY,
+  listActionTypes,
+  permissionGate,
+  runAction,
+  compileAccept,
+  compileReject,
+  resumeCompileAccept,
+  CONVERGENT_COMMITTED_HOOKS,
+  defaultActionTypesSection,
+  resolveActionTypes,
+  resolveDomain,
+} from './actions.js';
+
+export {
+  buildActiveContextProjection,
+  refreshActiveContext,
+  checkActiveContextStaleness,
+} from './active-context.js';
+
+export { PERMISSION_ORDER, layoutPattern } from './action-registry.js';
+
+export {
+  HOOK_KINDS,
+  HOOK_CLASSIFICATIONS,
+  HOOK_TIMEOUT_MS,
+  resolveHooks,
+  matchingHooks,
+  executeHooksFor,
+  auditLogPath,
+  auditArchivePath,
+  readAuditLog,
+  appendAuditEntry,
+  enforceAuditRetention,
+  purgeAuditLog,
+} from './hook-executor.js';
+
+export { computeDueDecisions, runDueCheck, sweepStatus } from './session-hooks.js';
+
+export {
+  SCHEDULE_REGISTRY_REL,
+  SCHEDULE_STATE_REL,
+  SCHEDULE_KINDS,
+  parseCadenceDays,
+  loadScheduleRegistry,
+  loadScheduleState,
+  writeScheduleState,
+  validateScheduleRegistry,
+  computeScheduleDue,
+  markScheduleCompleted,
+  advanceSchedulesForSkill,
+  runScheduleDueCheck,
+  pruneOrphanScheduleState,
+  scheduleStaleness,
+} from './schedule.js';
+
+export {
+  invocationsDir,
+  activeInvocationPath,
+  readActiveInvocation,
+  clearActiveInvocation,
+  beginSkillInvocation,
+  completeActiveSkillInvocation,
+  abandonActiveSkillInvocation,
+  sweepStaleSkillInvocation,
+  resolveInvocationIdForAct,
+  meshZeroWarning,
+} from './skill-lifecycle.js';
+
+export {
+  SKILL_WEIGHTS,
+  MODEL_TIERS,
+  skillFilePath,
+  parsePromptPin,
+  resolveSkillsSection,
+  validateSkillSource,
+  loadSkills,
+} from './skill-registry.js';
+
+export { validateSubscription, matchesSubscription } from './subscription.js';
+
+export {
+  splitFrontmatter,
+  walkMarkdown,
+  contextFor,
+  listObjectFiles,
+  listRetrievableObjectFiles,
+} from './workspace-scan.js';
+
+export { LinkIndex, buildLinkIndex, buildLinkIndexFromRecords } from './link-index.js';
+
+export {
+  SearchIndex,
+  loadSearchIndex,
+  rebuildSearchIndex,
+  indexDir,
+  snapshotPath,
+} from './search.js';
+
+export {
+  DEFAULT_LINT_STALE_MONTHS,
+  LINT_BYPASS_WINDOW_DAYS,
+  LINT_BYPASS_THRESHOLD,
+  runWorkspaceLint,
+} from './lint.js';
+
+export {
+  GUARD_ID,
+  GUARD_RULESET_VERSION,
+  detectContextRelevance,
+  runContextRelevanceGuard,
+} from './guard.js';
+
+export {
+  EVENT_TYPES,
+  isKnownType,
+  isValidType,
+  isReservedType,
+  eventsDir,
+  localDateStamp,
+  makeEventId,
+  readEventLogConfig,
+  validateEventInput,
+  applyCaptureGate,
+  appendEvent,
+  listDayFiles,
+  readEvents,
+  enforceRetention,
+  purgeEvents,
+} from './event-log.js';
+
+export { findInstallRoot, resolveInstall } from './install-root.js';
+
+export { DEFAULT_DOMAIN, RAW_SUBDIRS } from './layout.js';

package/vendor/core/src/ingest.js

@@ -0,0 +1,286 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { link, readFile, readdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import fse from 'fs-extra';
+import yaml from 'js-yaml';
+import { RE_SLUG } from './contract.js';
+import { localDateStamp } from './event-log.js';
+import { RAW_SUBDIRS } from './layout.js';
+import { serializeFrontmatter, slugify } from './action-writers.js';
+import { matchFrontmatterBlock } from './workspace-scan.js';
+
+const EXT_RE = /^[A-Za-z0-9]+$/;
+const CONNECTOR_BRIDGE_PROVENANCE_FIELDS = new Set(['source_connector', 'source_external_id', 'source_timestamp']);
+const CONNECTOR_BRIDGE_IGNORED_FIELDS = new Set([
+  'trust_tier',
+  'fetched_at',
+  'fetched_by',
+  'content_hash',
+  'source_file',
+  'source_path',
+  'source_url',
+  'content_type',
+  'retrieval_tool',
+  'operator_affirmed_trusted',
+]);
+
+function plainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function normalizeExt(ext = 'md') {
+  const normalized = String(ext || 'md').replace(/^\./, '').toLowerCase();
+  if (!EXT_RE.test(normalized)) {
+    throw new Error(`raw source ext "${ext}" is invalid (expected letters/numbers only).`);
+  }
+  return normalized;
+}
+
+function clippedSlug(input) {
+  const base = slugify(input);
+  if (!base) return '';
+  return base.slice(0, 80).replace(/-+$/g, '');
+}
+
+function deriveSlug({ slug, provenance, body }) {
+  const candidates = [
+    slug,
+    provenance.slug,
+    provenance.source_title,
+    provenance.title,
+    provenance.source_external_id,
+    String(body || '').split(/\r?\n/).find((line) => line.trim()),
+    'source',
+  ];
+  for (const candidate of candidates) {
+    const derived = clippedSlug(candidate);
+    if (derived) return derived;
+  }
+  return 'source';
+}
+
+function rawSourcePath({ domain, lane, dateStamp, slug, ext }) {
+  if (!RE_SLUG.test(domain)) throw new Error(`domain "${domain}" is not a valid slug.`);
+  assertRawLane(lane);
+  if (!RE_SLUG.test(slug)) throw new Error(`raw source slug "${slug}" is not a valid slug.`);
+  return `domains/${domain}/raw/${lane}/${dateStamp}-${slug}.${ext}`;
+}
+
+function assertRawLane(lane) {
+  if (!RAW_SUBDIRS.includes(lane)) {
+    throw new Error(`lane "${lane}" is not a raw lane (allowed: ${RAW_SUBDIRS.join(', ')}).`);
+  }
+}
+
+function rawSlugCandidates({ baseSlug, provenance, body }) {
+  const hash = createHash('sha256')
+    .update(`${provenance.source_connector}\0${provenance.source_external_id}\0${body}`)
+    .digest('hex')
+    .slice(0, 8);
+  const prefix = baseSlug.slice(0, Math.max(1, 80 - hash.length - 1)).replace(/-+$/g, '') || 'source';
+  return [...new Set([baseSlug, `${prefix}-${hash}`])];
+}
+
+function normalizedBody(body) {
+  return body.endsWith('\n') ? body : `${body}\n`;
+}
+
+function bodyContentHash(body) {
+  return `sha256:${createHash('sha256').update(normalizedBody(body)).digest('hex')}`;
+}
+
+function legacyBodyContentHashes(body) {
+  const hashes = new Set([bodyContentHash(body)]);
+  if (body.startsWith('\n')) hashes.add(bodyContentHash(body.slice(1)));
+  if (body.startsWith('\r\n')) hashes.add(bodyContentHash(body.slice(2)));
+  return hashes;
+}
+
+function isPartialRawWriteName(name) {
+  return /\.partial-\d+-[a-f0-9]{8}$/i.test(name);
+}
+
+async function assertRegisteredDomain(installRoot, domain) {
+  let registry;
+  try {
+    registry = JSON.parse(await readFile(join(installRoot, '.phronesis', 'registry.json'), 'utf8'));
+  } catch (error) {
+    throw new Error(`could not read the install registry (.phronesis/registry.json): ${error.message}`);
+  }
+  const registered = Array.isArray(registry.domains) ? registry.domains : [];
+  if (!registered.includes(domain)) {
+    throw new Error(
+      `domain "${domain}" is not registered in this installation (registered: ${registered.join(', ') || 'none'}). Refusing — ingest never creates a domain as a side effect.`,
+    );
+  }
+}
+
+function parseRawSource(content) {
+  const block = matchFrontmatterBlock(content);
+  if (!block) return null;
+  try {
+    const fm = yaml.load(block[1], { schema: yaml.JSON_SCHEMA });
+    return plainObject(fm) ? { fm, body: content.slice(block[0].length) } : null;
+  } catch {
+    return null;
+  }
+}
+
+async function findExistingSource({ installRoot, domain, lanes = RAW_SUBDIRS, sourceExternalId, sourceConnector, contentHash }) {
+  if (!sourceExternalId) return null;
+  for (const lane of lanes) {
+    const laneRoot = join(installRoot, 'domains', domain, 'raw', lane);
+    let entries;
+    try {
+      entries = await readdir(laneRoot, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile() || isPartialRawWriteName(entry.name)) continue;
+      const relPath = `domains/${domain}/raw/${lane}/${entry.name}`;
+      const content = await readFile(join(installRoot, relPath), 'utf8').catch(() => null);
+      if (content === null) continue;
+      const parsed = parseRawSource(content);
+      if (!parsed) continue;
+      const { fm, body: existingBody } = parsed;
+      if (fm.source_external_id !== sourceExternalId) continue;
+      if (sourceConnector && fm.source_connector !== sourceConnector) continue;
+      if (contentHash) {
+        if (typeof fm.content_hash === 'string' && fm.content_hash.trim()) {
+          if (fm.content_hash !== contentHash) continue;
+        } else if (!legacyBodyContentHashes(existingBody).has(contentHash)) {
+          continue;
+        }
+      }
+      return relPath;
+    }
+  }
+  return null;
+}
+
+function connectorBridgeFrontmatter({ provenance, now, body }) {
+  for (const key of Object.keys(provenance)) {
+    if (!CONNECTOR_BRIDGE_PROVENANCE_FIELDS.has(key) && !CONNECTOR_BRIDGE_IGNORED_FIELDS.has(key)) {
+      throw new Error(`connector bridge provenance field "${key}" is not allowed.`);
+    }
+  }
+
+  const fm = {
+    source_connector: provenance.source_connector,
+    source_external_id: provenance.source_external_id,
+    source_timestamp: provenance.source_timestamp,
+    trust_tier: 'untrusted',
+    fetched_at: now.toISOString(),
+    fetched_by: 'phronesis-ingest-cli@0.0.0',
+    content_hash: bodyContentHash(body),
+  };
+  for (const field of ['source_connector', 'source_external_id', 'source_timestamp', 'fetched_at', 'fetched_by', 'content_hash']) {
+    if (typeof fm[field] !== 'string' || fm[field].trim() === '') {
+      throw new Error(`raw source provenance requires non-empty ${field}.`);
+    }
+  }
+  return fm;
+}
+
+function provenanceFrontmatter({ provenance, now, body, provenanceMode }) {
+  if (!plainObject(provenance)) throw new Error('raw source provenance must be a mapping.');
+  if (provenanceMode === 'connector-bridge') return connectorBridgeFrontmatter({ provenance, now, body });
+  if (provenanceMode !== 'manual') throw new Error(`raw source provenance mode "${provenanceMode}" is invalid.`);
+
+  const fetchedAt = provenance.fetched_at || now.toISOString();
+  const trustTier = provenance.trust_tier || 'untrusted';
+  if (!['trusted', 'untrusted'].includes(trustTier)) {
+    throw new Error(`trust_tier "${trustTier}" is invalid (expected trusted | untrusted).`);
+  }
+
+  const fm = {
+    source_connector: provenance.source_connector || 'manual',
+    source_external_id: provenance.source_external_id,
+    source_timestamp: provenance.source_timestamp || fetchedAt,
+    trust_tier: trustTier,
+    fetched_at: fetchedAt,
+    fetched_by: provenance.fetched_by || 'phronesis-ingest-cli@0.0.0',
+  };
+  for (const [key, value] of Object.entries(provenance)) {
+    if (value !== undefined && fm[key] === undefined) fm[key] = value;
+  }
+  for (const field of ['source_connector', 'source_external_id', 'source_timestamp', 'fetched_at', 'fetched_by']) {
+    if (typeof fm[field] !== 'string' || fm[field].trim() === '') {
+      throw new Error(`raw source provenance requires non-empty ${field}.`);
+    }
+  }
+  return fm;
+}
+
+export async function assertRawDestination({ installRoot, domain, lane = 'inbox' } = {}) {
+  if (typeof installRoot !== 'string' || installRoot.trim() === '') {
+    throw new Error('stageRawSource requires installRoot.');
+  }
+  if (typeof domain !== 'string' || domain.trim() === '') {
+    throw new Error('stageRawSource requires a domain.');
+  }
+  await assertRegisteredDomain(installRoot, domain);
+  assertRawLane(lane);
+}
+
+export async function stageRawSource({
+  installRoot,
+  domain,
+  lane = 'inbox',
+  slug,
+  ext = 'md',
+  body,
+  provenance,
+  provenanceMode = 'manual',
+  now = new Date(),
+} = {}) {
+  if (typeof body !== 'string' || body.trim() === '') {
+    throw new Error('stageRawSource requires a non-empty body.');
+  }
+  await assertRawDestination({ installRoot, domain, lane });
+
+  const fm = provenanceFrontmatter({ provenance, now, body, provenanceMode });
+  const existing = await findExistingSource({
+    installRoot,
+    domain,
+    sourceExternalId: fm.source_external_id,
+    sourceConnector: fm.source_connector,
+    contentHash: fm.content_hash,
+  });
+  if (existing) return { ok: true, path: existing, deduped: true, written: false };
+
+  const rawSlug = deriveSlug({ slug, provenance: fm, body });
+  const normalizedExt = normalizeExt(ext);
+  const content = `${serializeFrontmatter(fm)}\n${normalizedBody(body)}`;
+  let lastCollision = null;
+
+  await fse.ensureDir(join(installRoot, 'domains', domain, 'raw', lane));
+  for (const candidateSlug of rawSlugCandidates({ baseSlug: rawSlug, provenance: fm, body })) {
+    const relPath = rawSourcePath({
+      domain,
+      lane,
+      dateStamp: localDateStamp(now),
+      slug: candidateSlug,
+      ext: normalizedExt,
+    });
+    const absolute = join(installRoot, relPath);
+    const temporary = `${absolute}.partial-${process.pid}-${randomBytes(4).toString('hex')}`;
+    try {
+      await writeFile(temporary, content, { encoding: 'utf8', flag: 'wx' });
+      try {
+        await link(temporary, absolute);
+      } catch (error) {
+        if (error?.code === 'EEXIST') {
+          lastCollision = relPath;
+          continue;
+        }
+        throw error;
+      }
+      return { ok: true, path: relPath, deduped: false, written: true };
+    } finally {
+      await fse.remove(temporary).catch(() => {});
+    }
+  }
+  throw new Error(`${lastCollision || rawSlug} already exists — refusing to overwrite raw source material.`);
+}

package/vendor/core/src/install-root.js

@@ -0,0 +1,42 @@
+// findInstallRoot — resolve the installation root from any working directory inside it.
+//
+// Surfaces run from domains/{slug}/ (the active door's cwd), but the event log, registry,
+// and config live at the INSTALLATION root. Every install-scoped command needs to discover
+// that root: walk up from cwd to the nearest dir holding .phronesis/registry.json — the
+// ownership marker init writes last (rules.md: the marker is the final write). Shared so the
+// daemon (T4.1) and future commands resolve the install the same way the event CLI does.
+
+import { resolve, dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
+
+// Returns the absolute install root, or null if cwd is not inside a Phronesis installation.
+// Stops at the filesystem root — never an unbounded walk.
+export function findInstallRoot(startDir = process.cwd()) {
+  let dir = resolve(startDir);
+  for (;;) {
+    if (existsSync(join(dir, '.phronesis', 'registry.json'))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null; // reached the filesystem root with no marker
+    dir = parent;
+  }
+}
+
+// Resolve the installation an install-scoped command should act on: an explicit `dir`
+// wins; otherwise walk up from cwd to the marker. BOTH paths require the
+// .phronesis/registry.json ownership marker — `dir` is an override of WHERE to look,
+// not a waiver of the check (rules.md: the explicit path must fail closed like the
+// implicit one; a typo'd --dir must never scatter a phantom tree outside any install).
+// Shared by the event CLI and the action spine (core-0008). Returns { root } or { error }.
+export function resolveInstall({ dir, cwd = process.cwd() } = {}) {
+  if (dir) {
+    const root = resolve(cwd, dir);
+    if (existsSync(join(root, '.phronesis', 'registry.json'))) return { root };
+    return { error: `--dir ${dir} is not a Phronesis installation (no .phronesis/registry.json).` };
+  }
+  const root = findInstallRoot(cwd);
+  if (root) return { root };
+  return {
+    error:
+      'Not inside a Phronesis installation (no .phronesis/registry.json found walking up from the current directory). Pass --dir <install>.',
+  };
+}

package/vendor/core/src/layout.js

@@ -0,0 +1,13 @@
+// The shared path-layout subset (specs/workspace-substrate.md). Only what every
+// surface needs to resolve paths in an installation lives here — init/scaffold
+// concerns (registry/config templates, .gitignore, export excludes) are CLI-init
+// territory and stay in apps/cli/src/layout.js, which re-exports this constant.
+// TYPE_DIR / COMPILED_DIRS already live in contract.js (one source — rules.md);
+// localDateStamp lives in event-log.js.
+
+// Default V1 configuration: a single PM door plus the shared codex.
+export const DEFAULT_DOMAIN = 'pm';
+
+// Raw content-type lanes (change 0024): source identity lives in provenance,
+// never in the folder name.
+export const RAW_SUBDIRS = ['transcripts', 'threads', 'inbox', 'meetings', 'research', 'degraded'];