wendkeep 0.58.3 → 0.59.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

@@ -13,6 +13,16 @@ export const PROJECT_CONFIG_FILE = '.wendkeep.json';
 export const PROJECT_MARKER_REL = '.brain/PROJECT.json';
 export const PROJECT_CONFIG_SCHEMA = 1;
 
+const PROJECT_VAULT_INTEGRITY_CODES = new Set([
+  'WENDKEEP_VAULT_CONFIG_INVALID',
+  'WENDKEEP_VAULT_MARKER_MISSING',
+  'WENDKEEP_VAULT_PROJECT_MISMATCH',
+]);
+
+export function isProjectVaultIntegrityError(error) {
+  return PROJECT_VAULT_INTEGRITY_CODES.has(error?.code);
+}
+
 function json(path) {
   try { return JSON.parse(readFileSync(path, 'utf8')); }
   catch (error) {
@@ -62,8 +72,23 @@ function inputStart(input = {}, fallback = '') {
     || process.cwd();
 }
 
+function bindingDiagnostic(error) {
+  return {
+    code: error?.code || 'WENDKEEP_VAULT_CONFIG_INVALID',
+    message: error?.message || 'Configuração WendKeep inválida.',
+  };
+}
+
 function vaultFromConfig(projectRoot, config) {
-  if (!config || config.schemaVersion !== PROJECT_CONFIG_SCHEMA || !config.projectId || !config.vault) {
+  const valid = config
+    && typeof config === 'object'
+    && !Array.isArray(config)
+    && config.schemaVersion === PROJECT_CONFIG_SCHEMA
+    && typeof config.projectId === 'string'
+    && config.projectId.trim()
+    && typeof config.vault === 'string'
+    && config.vault.trim();
+  if (!valid) {
     const error = new Error(
       `Configuração incompleta em "${join(projectRoot, PROJECT_CONFIG_FILE)}". `
       + 'Rode `wendkeep init --project <path> --vault <path>`.',
@@ -104,9 +129,14 @@ export function findLegacyProjectVault(start) {
           source: 'legacy-project-settings',
           configPath: settingsPath,
           projectId: '',
+          config: null,
         };
       }
-    } catch { /* init/doctor explicam JSON inválido; descoberta segue procurando */ }
+    } catch (error) {
+      const wrapped = new Error(`Configuração WendKeep legada inválida em "${settingsPath}": ${error.message}`);
+      wrapped.code = 'WENDKEEP_VAULT_CONFIG_INVALID';
+      throw wrapped;
+    }
   }
   return null;
 }
@@ -147,16 +177,30 @@ export function resolveProjectVault({
   const start = inputStart(input, startDir);
   const explicit = explicitVault || input?.obsidian_vault_path;
   if (explicit) {
+    let bindingError = null;
+    try { findProjectBinding(start); }
+    catch (error) {
+      if (error?.code !== 'WENDKEEP_VAULT_CONFIG_INVALID') throw error;
+      bindingError = bindingDiagnostic(error);
+    }
     return {
       base: isAbsolute(explicit) ? resolve(explicit) : resolve(startDirectory(start), explicit),
       source: explicitVault ? 'explicit' : 'payload',
       projectRoot: startDirectory(start),
       projectId: '',
       configPath: '',
+      config: null,
+      ...(bindingError ? { bindingError } : {}),
     };
   }
 
-  const binding = findProjectBinding(start);
+  let binding = null;
+  let bindingFailure = null;
+  try { binding = findProjectBinding(start); }
+  catch (error) {
+    if (error?.code !== 'WENDKEEP_VAULT_CONFIG_INVALID') throw error;
+    bindingFailure = error;
+  }
   if (binding) {
     const result = {
       base: binding.base,
@@ -164,6 +208,7 @@ export function resolveProjectVault({
       projectRoot: binding.projectRoot,
       projectId: binding.config.projectId,
       configPath: binding.configPath,
+      config: binding.config,
     };
     if (validateIdentity) validateMarker(result);
     return result;
@@ -171,9 +216,16 @@ export function resolveProjectVault({
 
   if (allowLegacySettings) {
     const legacy = findLegacyProjectVault(start);
-    if (legacy) return legacy;
+    if (legacy) {
+      return {
+        ...legacy,
+        ...(bindingFailure ? { bindingError: bindingDiagnostic(bindingFailure) } : {}),
+      };
+    }
   }
 
+  if (bindingFailure) throw bindingFailure;
+
   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\`.`,
@@ -188,7 +240,11 @@ function portableVaultPath(projectRoot, vaultPath) {
   return vaultPath;
 }
 
-export function bindProjectVault({ projectRoot, vaultPath }) {
+function objectRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+export function bindProjectVault({ projectRoot, vaultPath, configPatch = {} }) {
   const root = resolve(projectRoot);
   const base = isAbsolute(vaultPath) ? resolve(vaultPath) : resolve(root, vaultPath);
   const existing = readProjectBinding(root);
@@ -205,12 +261,23 @@ export function bindProjectVault({ projectRoot, vaultPath }) {
   }
 
   mkdirSync(join(base, '.brain'), { recursive: true });
+  const previousConfig = objectRecord(existing?.config);
+  const patch = objectRecord(configPatch);
   const config = {
+    ...previousConfig,
+    ...patch,
     schemaVersion: PROJECT_CONFIG_SCHEMA,
     projectId,
     vault: portableVaultPath(root, base),
   };
+  if (previousConfig.harness || patch.harness) {
+    config.harness = {
+      ...objectRecord(previousConfig.harness),
+      ...objectRecord(patch.harness),
+    };
+  }
   const marker = {
+    ...objectRecord(existingMarker?.marker),
     schemaVersion: PROJECT_CONFIG_SCHEMA,
     projectId,
     projectName: basename(root),
@@ -219,3 +286,41 @@ export function bindProjectVault({ projectRoot, vaultPath }) {
   atomicJson(join(root, PROJECT_CONFIG_FILE), config);
   return { base, projectRoot: root, projectId, config, marker };
 }
+
+export function updateProjectBinding(projectRoot, updater) {
+  const binding = readProjectBinding(projectRoot);
+  if (!binding) {
+    const error = new Error(
+      `Nenhum binding WendKeep em "${resolve(projectRoot)}". Rode \`wendkeep init\` primeiro.`,
+    );
+    error.code = 'WENDKEEP_VAULT_UNCONFIGURED';
+    throw error;
+  }
+  if (typeof updater !== 'function') {
+    throw new TypeError('updateProjectBinding exige uma função updater.');
+  }
+
+  const current = {
+    ...binding.config,
+    ...(binding.config.harness ? { harness: { ...objectRecord(binding.config.harness) } } : {}),
+  };
+  const candidate = updater(current);
+  if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+    const error = new Error('Updater do binding WendKeep deve retornar um objeto de configuração.');
+    error.code = 'WENDKEEP_VAULT_CONFIG_INVALID';
+    throw error;
+  }
+
+  const config = {
+    ...candidate,
+    schemaVersion: PROJECT_CONFIG_SCHEMA,
+    projectId: binding.config.projectId,
+    vault: binding.config.vault,
+  };
+  atomicJson(binding.configPath, config);
+  return {
+    ...binding,
+    config,
+    base: vaultFromConfig(binding.projectRoot, config),
+  };
+}

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;

package/src/skills-seed.mjs

@@ -11,18 +11,29 @@ function skill(name, description, body, files = []) {
   return { name, description, body: `---\nname: ${name}\ndescription: ${description}\n---\n${body}`, files };
 }
 
-const WORKFLOW = `# Loop a2 — o ciclo de trabalho do wendkeep
+const WORKFLOW = `# Perfis de Operação — roteador de trabalho do wendkeep
 
-Use ao começar qualquer mudança não-trivial. O loop mantém memória (vault) e prova
-(sensores) juntas, tudo linkado no grafo do Obsidian.
+Use ao começar implementação, correção ou refatoração. **Keep Core permanece sempre ativo**
+em todos os perfis: Vault, sessão, identidade, memória, lessons e persistência. Na ausência de
+configuração válida, **GOVERN é o padrão** compatível.
 
 <HARD-GATE>
-NÃO edite arquivos de código antes do passo 2 (Propose / \`wendkeep change new\`).
-Toda tarefa não-trivial passa pelo loop — planejar no chat e sair editando deixa o
-vault cego. Exceção única: mudança trivial (typo, 1 linha).
+Antes de editar, leia o **perfil efetivo** injetado pelo WendKeep e siga somente sua rota:
+- \`OFF\`: não imponha processo Wend; a governança pertence ao **harness nativo da LLM**.
+- \`FLOW\`: inicie o microcontrato com \`wendkeep flow start\` antes de editar os paths permitidos.
+- \`GUIDE\`, \`GOVERN\` ou \`ASSURE\`: não edite código antes de Propose / \`wendkeep change new\`.
+Este gate nunca transforma \`OFF\` ou \`FLOW\` silenciosamente em \`GOVERN\`.
 </HARD-GATE>
 
-## Os passos
+## Rotas por perfil
+
+- **OFF — LLM nativa:** Wend Runtime desligado; esta skill devolve a execução ao harness nativo.
+- **FLOW — E → V:** \`flow start\` → implementar com wk-tdd → \`flow finish\`; sem change/ADR/verdict.
+- **GUIDE — P → E → V:** change compacta, sem revisão formal obrigatória.
+- **GOVERN — P → R → E → V:** loop a2 atual, com design/revisão; é o padrão conservador.
+- **ASSURE — P → R → E → V → C:** GOVERN acrescido de confirmação e handoff explícitos.
+
+## Passos para GUIDE, GOVERN e ASSURE
 
 1. **Explore** — entenda o problema antes de propor. Leia o código/contexto relevante.
 2. **Propose** — \`wendkeep change new <slug>\`. Isso cria \`08-Mudanças/<slug>/\` com:
@@ -251,18 +262,29 @@ nunca tivesse visto a implementação. Contexto fresco, read-only.
 - \`verdict-template.json\` — o formato exato do \`verdict.json\` a gravar.
 `;
 
-const WORKFLOW_EN = `# The a2 loop — wendkeep's work cycle
+const WORKFLOW_EN = `# Operating Profiles — wendkeep work router
 
-Use it when starting any non-trivial change. The loop keeps memory (vault) and proof
-(sensors) together, wikilinked in the Obsidian graph.
+Use this when starting an implementation, fix, or refactor. **Keep Core is always active**
+in every profile: Vault, session, identity, memory, lessons, and persistence. With no valid
+configuration, **GOVERN is the default** for compatibility.
 
 <HARD-GATE>
-Do NOT edit code files before step 2 (Propose / \`wendkeep change new\`).
-Every non-trivial task goes through the loop — planning in chat and editing right away
-leaves the vault blind. Single exception: a trivial change (typo, one line).
+Before editing, read the injected **effective profile** and follow only its route:
+- \`OFF\`: impose no Wend process; governance belongs to the **native LLM harness**.
+- \`FLOW\`: start the microcontract with \`wendkeep flow start\` before editing allowed paths.
+- \`GUIDE\`, \`GOVERN\`, or \`ASSURE\`: do not edit code before Propose / \`wendkeep change new\`.
+This gate never silently turns \`OFF\` or \`FLOW\` into \`GOVERN\`.
 </HARD-GATE>
 
-## Steps
+## Profile routes
+
+- **OFF — native LLM:** Wend Runtime is disabled; this skill returns execution to the native harness.
+- **FLOW — E → V:** \`flow start\` → implement with wk-tdd → \`flow finish\`; no change/ADR/verdict.
+- **GUIDE — P → E → V:** a compact change with no mandatory formal review.
+- **GOVERN — P → R → E → V:** the current a2 loop with design/review; the conservative default.
+- **ASSURE — P → R → E → V → C:** GOVERN plus explicit confirmation and handoff.
+
+## Steps for GUIDE, GOVERN, and ASSURE
 
 1. **Explore** — understand the problem before proposing.
 2. **Propose** — \`wendkeep change new <slug>\` scaffolds \`08-Changes/<slug>/\`
@@ -597,7 +619,7 @@ size of the problem>
 // usuário ("implementa X", "corrige Y"), não com abstrações ("mudança não-trivial"). Gatilhos
 // concretos + instrução imperativa = a skill dispara sozinha (paridade Superpowers).
 const WK_SKILLS_PT = [
-  skill('wk-workflow', 'Use SEMPRE que o usuário pedir para implementar, criar, corrigir, refatorar, adicionar ou alterar código — qualquer tarefa de código não-trivial. Invoque ANTES de editar qualquer arquivo: orquestra o loop a2 (wendkeep change new → tarefas → verify → archive) e registra tudo no vault.', WORKFLOW),
+  skill('wk-workflow', 'Use quando o usuário pedir para implementar, criar, corrigir, refatorar, adicionar ou alterar código: leia o perfil efetivo e roteie OFF/FLOW/GUIDE/GOVERN/ASSURE ANTES de editar. Keep Core permanece ativo; GOVERN é o padrão compatível.', WORKFLOW),
   skill('wk-tdd', 'Use ao implementar qualquer comportamento — Red/Green/Refactor com testes que discriminam (derivados do spec, litmus não-raso, adequação).', TDD),
   skill('wk-debugging', 'Use quando algo falha, quebra, dá erro ou regride — depuração sistemática por hipótese antes de corrigir.', DEBUGGING),
   skill('wk-brainstorming', 'Use quando a ideia ainda é vaga ou o usuário quer discutir/planejar uma feature (inclusive em plan mode) — vira design aprovado, com closure gate e tabela out-of-scope, antes de código.', BRAINSTORMING, [{ name: 'design-template.md', content: DESIGN_TEMPLATE_PT }]),
@@ -606,7 +628,7 @@ const WK_SKILLS_PT = [
 ];
 
 const WK_SKILLS_EN = [
-  skill('wk-workflow', 'Use WHENEVER the user asks to implement, create, fix, refactor, add or change code — any non-trivial coding task. Invoke BEFORE editing any file: it orchestrates the a2 loop (wendkeep change new → tasks → verify → archive) and records everything in the vault.', WORKFLOW_EN),
+  skill('wk-workflow', 'Use when the user asks to implement, create, fix, refactor, add, or change code: read the effective profile and route OFF/FLOW/GUIDE/GOVERN/ASSURE BEFORE editing. Keep Core stays active; GOVERN is the compatible default.', WORKFLOW_EN),
   skill('wk-tdd', 'Use when implementing any behaviour — Red/Green/Refactor with tests that discriminate (spec-derived, non-shallow litmus, adequacy).', TDD_EN),
   skill('wk-debugging', 'Use when something fails, breaks, errors or regresses — systematic hypothesis-driven debugging before fixing.', DEBUGGING_EN),
   skill('wk-brainstorming', 'Use when the idea is still vague or the user wants to discuss/plan a feature (plan mode included) — turns it into an approved design, with a closure gate and out-of-scope table, before code.', BRAINSTORMING_EN, [{ name: 'design-template.md', content: DESIGN_TEMPLATE_EN }]),