wendkeep 0.58.3 → 0.60.0

package/src/operating-profile.mjs

@@ -0,0 +1,133 @@
+export const OPERATING_PROFILES = Object.freeze([
+  'OFF',
+  'FLOW',
+  'GUIDE',
+  'GOVERN',
+  'ASSURE',
+]);
+export const DEFAULT_OPERATING_PROFILE = 'GOVERN';
+
+const PROFILE_SET = new Set(OPERATING_PROFILES);
+
+function policy(profile, route, options) {
+  return Object.freeze({
+    profile,
+    route: Object.freeze(route),
+    keepCore: true,
+    ...options,
+  });
+}
+
+export const OPERATING_PROFILE_POLICIES = Object.freeze({
+  OFF: policy('OFF', ['LLM'], {
+    harness: false,
+    contract: 'native',
+    requiresChange: false,
+    requiresReview: false,
+    requiresConfirmation: false,
+  }),
+  FLOW: policy('FLOW', ['E', 'V'], {
+    harness: true,
+    contract: 'flow',
+    requiresChange: false,
+    requiresReview: false,
+    requiresConfirmation: false,
+  }),
+  GUIDE: policy('GUIDE', ['P', 'E', 'V'], {
+    harness: true,
+    contract: 'simple-change',
+    requiresChange: true,
+    requiresReview: false,
+    requiresConfirmation: false,
+  }),
+  GOVERN: policy('GOVERN', ['P', 'R', 'E', 'V'], {
+    harness: true,
+    contract: 'change',
+    requiresChange: true,
+    requiresReview: true,
+    requiresConfirmation: false,
+  }),
+  ASSURE: policy('ASSURE', ['P', 'R', 'E', 'V', 'C'], {
+    harness: true,
+    contract: 'change',
+    requiresChange: true,
+    requiresReview: true,
+    requiresConfirmation: true,
+  }),
+});
+
+function invalidProfileError(value) {
+  const rendered = typeof value === 'string' ? `"${value}"` : String(value);
+  const error = new Error(
+    `Perfil de Operação inválido: ${rendered}. Use ${OPERATING_PROFILES.join(', ')}.`,
+  );
+  error.code = 'WENDKEEP_OPERATING_PROFILE_INVALID';
+  return error;
+}
+
+function canonicalProfile(value) {
+  if (typeof value !== 'string') return '';
+  return value.trim().toUpperCase();
+}
+
+export function normalizeOperatingProfile(value, { strict = false } = {}) {
+  const normalized = canonicalProfile(value);
+  if (PROFILE_SET.has(normalized)) return normalized;
+  if (strict) throw invalidProfileError(value);
+  return DEFAULT_OPERATING_PROFILE;
+}
+
+export function resolveOperatingProfile(config = {}) {
+  const harness = config && typeof config === 'object' && !Array.isArray(config)
+    && config.harness && typeof config.harness === 'object' && !Array.isArray(config.harness)
+    ? config.harness
+    : null;
+  const configured = !!harness && Object.prototype.hasOwnProperty.call(harness, 'profile');
+  if (!configured) {
+    return {
+      profile: DEFAULT_OPERATING_PROFILE,
+      source: 'default',
+      valid: true,
+      configured: false,
+      raw: null,
+    };
+  }
+
+  const raw = harness.profile;
+  const normalized = canonicalProfile(raw);
+  if (PROFILE_SET.has(normalized)) {
+    return {
+      profile: normalized,
+      source: 'project-binding',
+      valid: true,
+      configured: true,
+      raw,
+    };
+  }
+  return {
+    profile: DEFAULT_OPERATING_PROFILE,
+    source: 'default-invalid',
+    valid: false,
+    configured: true,
+    raw,
+  };
+}
+
+export function operatingProfilePolicy(value) {
+  return OPERATING_PROFILE_POLICIES[normalizeOperatingProfile(value)];
+}
+
+export function setOperatingProfile(config = {}, value) {
+  const profile = normalizeOperatingProfile(value, { strict: true });
+  const base = config && typeof config === 'object' && !Array.isArray(config) ? config : {};
+  const harness = base.harness && typeof base.harness === 'object' && !Array.isArray(base.harness)
+    ? base.harness
+    : {};
+  return {
+    ...base,
+    harness: {
+      ...harness,
+      profile,
+    },
+  };
+}

package/src/profile.mjs

@@ -0,0 +1,224 @@
+// Public operating-profile CLI. Keep project binding and session override mutations atomic,
+// while profile policy itself remains pure in operating-profile.mjs.
+import { mutateSessionRegistry, readSessionRegistry } from '../hooks/obsidian-common.mjs';
+import {
+  DEFAULT_OPERATING_PROFILE,
+  normalizeOperatingProfile,
+  resolveOperatingProfile,
+  setOperatingProfile,
+} from './operating-profile.mjs';
+import { resolve } from 'node:path';
+import { findProjectBinding, resolveProjectVault, updateProjectBinding } from './project-vault.mjs';
+
+export const PROFILE_HELP = `wendkeep profile <subcommand>
+
+  status [--session <id>]
+  use <OFF|FLOW|GUIDE|GOVERN|ASSURE> [--session <id>]
+
+Common options: --project <path> --vault <path> --session <id> --json
+The Keep Core (Vault, session, and memory) remains active under every profile.
+`;
+
+const VALUE_OPTIONS = new Set(['--project', '--vault', '--session']);
+const FLAG_OPTIONS = new Set(['--json']);
+
+function optionValue(argv, name) {
+  const index = argv.indexOf(name);
+  if (index >= 0) return argv[index + 1] || '';
+  return argv.find((item) => item.startsWith(`${name}=`))?.slice(name.length + 1) || '';
+}
+
+function commandArgs(argv) {
+  const values = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (['--project', '--vault', '--session'].includes(value)) { index += 1; continue; }
+    if (value.startsWith('--project=') || value.startsWith('--vault=') || value.startsWith('--session=')) continue;
+    if (value === '--json') continue;
+    values.push(value);
+  }
+  return values;
+}
+
+function validateArgv(argv) {
+  const seen = new Set();
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (FLAG_OPTIONS.has(value)) {
+      if (seen.has(value)) throw new Error(`opção duplicada: ${value}`);
+      seen.add(value);
+      continue;
+    }
+    if (VALUE_OPTIONS.has(value)) {
+      if (seen.has(value)) throw new Error(`opção duplicada: ${value}`);
+      seen.add(value);
+      const next = argv[index + 1];
+      if (!next || next.startsWith('--')) throw new Error(`${value} requer um valor`);
+      index += 1;
+      continue;
+    }
+    if (value.startsWith('--')) {
+      const name = value.split('=', 1)[0];
+      if (!VALUE_OPTIONS.has(name)) throw new Error(`opção desconhecida: ${name}`);
+      if (seen.has(name)) throw new Error(`opção duplicada: ${name}`);
+      seen.add(name);
+      const inlineValue = value.slice(name.length + 1);
+      if (!inlineValue || inlineValue.startsWith('--')) throw new Error(`${name} requer um valor`);
+    }
+  }
+}
+
+function canonicalPath(value) {
+  const path = resolve(value).replaceAll('\\', '/');
+  return process.platform === 'win32' ? path.toLowerCase() : path;
+}
+
+function output(payload, json) {
+  if (json) process.stdout.write(`${JSON.stringify(payload)}\n`);
+  else {
+    const scope = payload.scope === 'session' ? `session ${payload.session_id}` : 'project';
+    process.stdout.write(`${payload.profile} (${scope}; ${payload.source})\n`);
+  }
+  if (payload.binding_error) {
+    const code = payload.binding_error.code || 'WENDKEEP_VAULT_CONFIG_INVALID';
+    process.stderr.write(`wendkeep profile: ${code}: ${payload.binding_error.message || 'binding WendKeep inválido'}\n`);
+  }
+}
+
+function fail(message) {
+  process.stderr.write(`wendkeep profile: ${message}\n`);
+  return 2;
+}
+
+function context(argv) {
+  const explicitVault = optionValue(argv, '--vault');
+  const startDir = optionValue(argv, '--project') || process.cwd();
+  const resolved = resolveProjectVault({ startDir, explicitVault });
+  let binding = null;
+  try { binding = findProjectBinding(startDir); }
+  catch (error) {
+    if (!explicitVault) throw error;
+  }
+  const matchingBinding = binding && canonicalPath(binding.base) === canonicalPath(resolved.base) ? binding : null;
+  const projectConfig = resolved.config || matchingBinding?.config || {};
+  return {
+    resolved: {
+      ...resolved,
+      projectRoot: matchingBinding?.projectRoot || (resolved.config ? resolved.projectRoot : null),
+    },
+    projectConfig,
+    vaultBase: resolved.base,
+  };
+}
+
+export function setSessionOperatingProfile(vaultBase, sessionId, profile, { now } = {}) {
+  const selected = normalizeOperatingProfile(profile, { strict: true });
+  const updatedAt = now || new Date().toISOString();
+  return mutateSessionRegistry(vaultBase, (registry) => {
+    const sessions = registry.sessions || (registry.sessions = {});
+    if (!Object.hasOwn(sessions, sessionId)) throw new Error(`sessão não encontrada: ${sessionId}`);
+    const current = sessions[sessionId];
+    sessions[sessionId] = {
+      ...current,
+      operating_profile: selected,
+      operating_profile_source: 'explicit-cli',
+      operating_profile_updated_at: updatedAt,
+      updated_at: updatedAt,
+    };
+    return sessions[sessionId];
+  });
+}
+
+function sessionProfile(vaultBase, sessionId, projectResolved) {
+  const sessions = readSessionRegistry(vaultBase).sessions || {};
+  if (!Object.hasOwn(sessions, sessionId)) throw new Error(`sessão não encontrada: ${sessionId}`);
+  const entry = sessions[sessionId];
+  if (Object.hasOwn(entry, 'operating_profile')) {
+    try {
+      return {
+        profile: normalizeOperatingProfile(entry.operating_profile, { strict: true }),
+        source: 'session-registry',
+      };
+    } catch {
+      return {
+        profile: DEFAULT_OPERATING_PROFILE,
+        source: 'session-override-invalid',
+      };
+    }
+  }
+  return { profile: projectResolved.profile, source: projectResolved.source };
+}
+
+export function runProfile(argv = []) {
+  try { validateArgv(argv); }
+  catch (error) { return fail(error.message); }
+  const args = commandArgs(argv);
+  const sub = args[0] || 'status';
+  const json = argv.includes('--json');
+  const sessionId = optionValue(argv, '--session') || '';
+
+  let state;
+  try { state = context(argv); }
+  catch (error) { return fail(error.message); }
+
+  const projectResolved = resolveOperatingProfile(state.projectConfig);
+  if (sub === 'status' || sub === 'show') {
+    if (args.length > 1) return fail(`${sub} não aceita argumentos posicionais adicionais`);
+    try {
+      const effective = sessionId
+        ? sessionProfile(state.vaultBase, sessionId, projectResolved)
+        : { profile: projectResolved.profile, source: projectResolved.source };
+      output({
+        profile: effective.profile,
+        source: effective.source,
+        scope: sessionId ? 'session' : 'project',
+        session_id: sessionId || null,
+        ...(state.resolved.bindingError ? { binding_error: state.resolved.bindingError } : {}),
+      }, json);
+      return 0;
+    } catch (error) { return fail(error.message); }
+  }
+
+  if (sub !== 'use' && sub !== 'set') return fail('use status | use <OFF|FLOW|GUIDE|GOVERN|ASSURE>');
+  if (args.length !== 2) return fail(`${sub} requer exatamente um perfil`);
+  let profile;
+  try { profile = normalizeOperatingProfile(args[1], { strict: true }); }
+  catch { return fail('perfil inválido; use OFF, FLOW, GUIDE, GOVERN ou ASSURE'); }
+
+  if (sessionId) {
+    try { setSessionOperatingProfile(state.vaultBase, sessionId, profile); }
+    catch (error) { return fail(error.message); }
+    output({
+      profile,
+      source: 'session-registry',
+      scope: 'session',
+      session_id: sessionId,
+      ...(state.resolved.bindingError ? { binding_error: state.resolved.bindingError } : {}),
+    }, json);
+    return 0;
+  }
+
+  if (!state.resolved.projectRoot) return fail('binding de projeto necessário para alterar o perfil padrão');
+  try {
+    const updatedAt = new Date().toISOString();
+    updateProjectBinding(state.resolved.projectRoot, (current) => {
+      const next = setOperatingProfile(current, profile);
+      return {
+        ...next,
+        harness: {
+          ...next.harness,
+          profileSource: 'explicit-cli',
+          profileUpdatedAt: updatedAt,
+        },
+      };
+    });
+  } catch (error) { return fail(error.message); }
+  output({
+    profile,
+    source: 'project-binding',
+    scope: 'project',
+    session_id: null,
+    ...(state.resolved.bindingError ? { binding_error: state.resolved.bindingError } : {}),
+  }, json);
+  return 0;
+}

package/src/project-vault.mjs

@@ -1,221 +1,2 @@
-import { randomUUID } from 'node:crypto';
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  statSync,
-  writeFileSync,
-} from 'node:fs';
-import { basename, dirname, isAbsolute, join, parse, relative, resolve } from 'node:path';
-
-export const PROJECT_CONFIG_FILE = '.wendkeep.json';
-export const PROJECT_MARKER_REL = '.brain/PROJECT.json';
-export const PROJECT_CONFIG_SCHEMA = 1;
-
-function json(path) {
-  try { return JSON.parse(readFileSync(path, 'utf8')); }
-  catch (error) {
-    const wrapped = new Error(`Configuração WendKeep inválida em "${path}": ${error.message}`);
-    wrapped.code = 'WENDKEEP_VAULT_CONFIG_INVALID';
-    throw wrapped;
-  }
-}
-
-function atomicJson(path, value) {
-  mkdirSync(dirname(path), { recursive: true });
-  const content = `${JSON.stringify(value, null, 2)}\n`;
-  if (existsSync(path) && readFileSync(path, 'utf8') === content) return false;
-  const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
-  writeFileSync(temp, content, 'utf8');
-  renameSync(temp, path);
-  return true;
-}
-
-function startDirectory(value) {
-  const candidate = resolve(String(value || process.cwd()));
-  try { return statSync(candidate).isFile() ? dirname(candidate) : candidate; }
-  catch { return candidate; }
-}
-
-function walkParents(start) {
-  const result = [];
-  let current = startDirectory(start);
-  const root = parse(current).root;
-  while (true) {
-    result.push(current);
-    if (current === root) break;
-    const parent = dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  return result;
-}
-
-function inputStart(input = {}, fallback = '') {
-  return input.cwd
-    || input.project_dir
-    || input.projectDir
-    || input.workspace?.cwd
-    || process.env.CLAUDE_PROJECT_DIR
-    || fallback
-    || process.cwd();
-}
-
-function vaultFromConfig(projectRoot, config) {
-  if (!config || config.schemaVersion !== PROJECT_CONFIG_SCHEMA || !config.projectId || !config.vault) {
-    const error = new Error(
-      `Configuração incompleta em "${join(projectRoot, PROJECT_CONFIG_FILE)}". `
-      + 'Rode `wendkeep init --project <path> --vault <path>`.',
-    );
-    error.code = 'WENDKEEP_VAULT_CONFIG_INVALID';
-    throw error;
-  }
-  return isAbsolute(config.vault) ? resolve(config.vault) : resolve(projectRoot, config.vault);
-}
-
-export function readProjectBinding(projectRoot) {
-  const root = resolve(projectRoot);
-  const path = join(root, PROJECT_CONFIG_FILE);
-  if (!existsSync(path)) return null;
-  const config = json(path);
-  return { config, configPath: path, projectRoot: root, base: vaultFromConfig(root, config) };
-}
-
-export function findProjectBinding(start) {
-  for (const projectRoot of walkParents(start)) {
-    const found = readProjectBinding(projectRoot);
-    if (found) return found;
-  }
-  return null;
-}
-
-export function findLegacyProjectVault(start) {
-  for (const projectRoot of walkParents(start)) {
-    const settingsPath = join(projectRoot, '.claude', 'settings.json');
-    if (!existsSync(settingsPath)) continue;
-    try {
-      const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
-      const raw = settings?.env?.OBSIDIAN_VAULT_PATH;
-      if (typeof raw === 'string' && raw.trim()) {
-        return {
-          base: isAbsolute(raw) ? resolve(raw) : resolve(projectRoot, raw),
-          projectRoot,
-          source: 'legacy-project-settings',
-          configPath: settingsPath,
-          projectId: '',
-        };
-      }
-    } catch { /* init/doctor explicam JSON inválido; descoberta segue procurando */ }
-  }
-  return null;
-}
-
-export function readVaultMarker(vaultPath) {
-  const markerPath = join(resolve(vaultPath), ...PROJECT_MARKER_REL.split('/'));
-  if (!existsSync(markerPath)) return null;
-  return { marker: json(markerPath), markerPath };
-}
-
-function validateMarker(result) {
-  const found = readVaultMarker(result.base);
-  if (!found) {
-    const error = new Error(
-      `O vault "${result.base}" ainda não possui ${PROJECT_MARKER_REL}. `
-      + `Rode \`wendkeep init --project "${result.projectRoot}" --vault "${result.base}" --yes\`.`,
-    );
-    error.code = 'WENDKEEP_VAULT_MARKER_MISSING';
-    throw error;
-  }
-  if (found.marker?.projectId !== result.projectId) {
-    const error = new Error(
-      `Vault de outro projeto: configuração "${result.projectId}" aponta para marcador `
-      + `"${found.marker?.projectId || 'ausente'}" em "${found.markerPath}".`,
-    );
-    error.code = 'WENDKEEP_VAULT_PROJECT_MISMATCH';
-    throw error;
-  }
-}
-
-export function resolveProjectVault({
-  input = {},
-  startDir = '',
-  explicitVault = '',
-  allowLegacySettings = true,
-  validateIdentity = true,
-} = {}) {
-  const start = inputStart(input, startDir);
-  const explicit = explicitVault || input?.obsidian_vault_path;
-  if (explicit) {
-    return {
-      base: isAbsolute(explicit) ? resolve(explicit) : resolve(startDirectory(start), explicit),
-      source: explicitVault ? 'explicit' : 'payload',
-      projectRoot: startDirectory(start),
-      projectId: '',
-      configPath: '',
-    };
-  }
-
-  const binding = findProjectBinding(start);
-  if (binding) {
-    const result = {
-      base: binding.base,
-      source: 'project-config',
-      projectRoot: binding.projectRoot,
-      projectId: binding.config.projectId,
-      configPath: binding.configPath,
-    };
-    if (validateIdentity) validateMarker(result);
-    return result;
-  }
-
-  if (allowLegacySettings) {
-    const legacy = findLegacyProjectVault(start);
-    if (legacy) return legacy;
-  }
-
-  const error = new Error(
-    `Nenhum vault WendKeep vinculado ao projeto em "${startDirectory(start)}". `
-    + `Crie ${PROJECT_CONFIG_FILE} com \`wendkeep init --project "${startDirectory(start)}" --vault <path> --yes\`.`,
-  );
-  error.code = 'WENDKEEP_VAULT_UNCONFIGURED';
-  throw error;
-}
-
-function portableVaultPath(projectRoot, vaultPath) {
-  const rel = relative(projectRoot, vaultPath);
-  if (rel && !rel.startsWith('..') && !isAbsolute(rel)) return rel.replaceAll('\\', '/');
-  return vaultPath;
-}
-
-export function bindProjectVault({ projectRoot, vaultPath }) {
-  const root = resolve(projectRoot);
-  const base = isAbsolute(vaultPath) ? resolve(vaultPath) : resolve(root, vaultPath);
-  const existing = readProjectBinding(root);
-  const existingMarker = readVaultMarker(base);
-  const projectId = existing?.config?.projectId || existingMarker?.marker?.projectId || randomUUID();
-
-  if (existingMarker?.marker?.projectId && existingMarker.marker.projectId !== projectId) {
-    const error = new Error(
-      `Não é seguro vincular "${root}" ao vault de outro projeto: `
-      + `esperado "${projectId}", encontrado "${existingMarker.marker.projectId}".`,
-    );
-    error.code = 'WENDKEEP_VAULT_PROJECT_MISMATCH';
-    throw error;
-  }
-
-  mkdirSync(join(base, '.brain'), { recursive: true });
-  const config = {
-    schemaVersion: PROJECT_CONFIG_SCHEMA,
-    projectId,
-    vault: portableVaultPath(root, base),
-  };
-  const marker = {
-    schemaVersion: PROJECT_CONFIG_SCHEMA,
-    projectId,
-    projectName: basename(root),
-  };
-  atomicJson(join(base, ...PROJECT_MARKER_REL.split('/')), marker);
-  atomicJson(join(root, PROJECT_CONFIG_FILE), config);
-  return { base, projectRoot: root, projectId, config, marker };
-}
+// Compatibility facade during the physical package migration.
+export * from '../packages/vault/src/project-vault.mjs';

package/src/rebuild-costs.mjs

@@ -4,6 +4,7 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { readSessionRegistry } from '../hooks/obsidian-common.mjs';
 import { updateSessionObservability } from '../hooks/session-observability.mjs';
+import { assertVaultPathSafe } from '../hooks/vault-path-safety.mjs';
 
 export function rebuildSessionCosts(vaultBase, { apply = false, session = '', limit = 0 } = {}) {
   const registry = readSessionRegistry(vaultBase);
@@ -14,14 +15,20 @@ export function rebuildSessionCosts(vaultBase, { apply = false, session = '', li
   for (const entry of entries) {
     if (limit && report.scanned >= limit) break;
     report.scanned += 1;
-    const note = join(vaultBase, entry.session_file);
-    if (!entry.transcript_path || !existsSync(note) || !existsSync(entry.transcript_path)) {
-      report.missing.push({ sessionId: entry.sessionId, session: entry.session_file, note: existsSync(note), transcript: !!entry.transcript_path && existsSync(entry.transcript_path), transcriptPath: entry.transcript_path || '' });
+    const checkedNote = assertVaultPathSafe(vaultBase, join(vaultBase, entry.session_file), {
+      expectedType: 'file', label: 'nota de sessão do rebuild de custos',
+    });
+    const note = checkedNote.target;
+    if (!entry.transcript_path || !checkedNote.exists || !existsSync(entry.transcript_path)) {
+      report.missing.push({ sessionId: entry.sessionId, session: entry.session_file, note: checkedNote.exists, transcript: !!entry.transcript_path && existsSync(entry.transcript_path), transcriptPath: entry.transcript_path || '' });
       continue;
     }
     const before = readFileSync(note, 'utf8');
     try {
-      updateSessionObservability({ sessionPath: note, transcriptPath: entry.transcript_path, caller: 'cost-rebuild', canonicalConversationId: entry.sessionId });
+      updateSessionObservability({
+        vaultBase, sessionPath: note, transcriptPath: entry.transcript_path,
+        caller: 'cost-rebuild', canonicalConversationId: entry.sessionId,
+      });
       const after = readFileSync(note, 'utf8');
       const changed = before !== after;
       if (changed) report.changed += 1; else report.unchanged += 1;