wendkeep 0.66.5 → 0.67.0

package/packages/integrations/src/prompt-content.mjs

@@ -18,3 +18,126 @@ export function redactSecrets(text) {
     .replace(/\b([A-Z0-9_]*(?:TOKEN|SECRET|PASSWORD|API_KEY)[A-Z0-9_]*)\s*[:=]\s*["']?[^"'\s]+/gi, '$1=[REDACTED_SECRET]')
     .replace(/:\/\/([^:\s/@]+):([^@\s/]+)@/g, '://[REDACTED_SECRET]@');
 }
+
+function metadataPayloadLine(name, line) {
+  if (name === 'citation_entries') {
+    return /\|note=\[[^\]]*\]\s*$/i.test(line)
+      || /^[^\s<>]+:\d+(?:-\d+)?(?:\|[^\s].*)?$/i.test(line);
+  }
+  if (name === 'rollout_ids') {
+    return /^(?:[0-9a-f]{8,}(?:-[0-9a-f-]+)*|019f-[A-Za-z0-9_-]+)$/i.test(line);
+  }
+  return false;
+}
+
+function consumeTruncatedMetadata(source, name, tagEnd) {
+  let cursor = tagEnd;
+  let mode = name;
+  let openingLine = true;
+
+  while (cursor < source.length) {
+    const newline = source.indexOf('\n', cursor);
+    const lineEnd = newline === -1 ? source.length : newline;
+    const line = source.slice(cursor, lineEnd).replace(/\r$/, '');
+    const clean = line.trim();
+
+    if (!clean) {
+      if (!openingLine) return cursor;
+    } else if (/^<\/?(?:oai-mem-citation|citation_entries|rollout_ids)\b/i.test(clean)) {
+      const nested = [...clean.matchAll(/<(citation_entries|rollout_ids)\b[^>]*>/gi)].at(-1);
+      if (nested) mode = nested[1].toLowerCase();
+    } else if (!(openingLine && name !== 'oai-mem-citation') && !metadataPayloadLine(mode, clean)) {
+      return cursor;
+    }
+
+    if (newline === -1) return source.length;
+    cursor = newline + 1;
+    openingLine = false;
+  }
+  return cursor;
+}
+
+function openingPayloadLooksStructural(source, opening) {
+  const name = opening[1].toLowerCase();
+  const tagEnd = opening.index + opening[0].length;
+  const rest = source.slice(tagEnd);
+  if (new RegExp(`<\/${name}\\s*>`, 'i').test(rest)) return true;
+
+  if (name === 'oai-mem-citation') {
+    const child = /^[\t\r\n ]*<(citation_entries|rollout_ids)\b[^>]*>/i.exec(rest);
+    if (!child) return !rest.trim();
+    const childRest = rest.slice(child[0].length);
+    const lineEnd = childRest.search(/\r?\n/u);
+    const sameLine = childRest.slice(0, lineEnd === -1 ? childRest.length : lineEnd);
+    if (!sameLine.trim()) return true;
+    if (!/^[\t ]/u.test(childRest)) return true;
+    if (/^<\/?(?:oai-mem-citation|citation_entries|rollout_ids)\b/i.test(sameLine.trim())) return true;
+    return metadataPayloadLine(child[1].toLowerCase(), sameLine.trim());
+  }
+
+  const lineEnd = rest.search(/\r?\n/u);
+  const sameLine = rest.slice(0, lineEnd === -1 ? rest.length : lineEnd);
+  if (!sameLine.trim()) return true;
+  if (!/^[\t ]/u.test(rest)) return true;
+  if (/^<\/?(?:oai-mem-citation|citation_entries|rollout_ids)\b/i.test(sameLine.trim())) return true;
+  return metadataPayloadLine(name, sameLine.trim());
+}
+
+function metadataStart(source, opening) {
+  const tagStart = opening.index;
+  const before = source.slice(0, tagStart);
+  const adjacentSession = /<\/session>[\t\r\n ]*$/i.exec(before);
+  if (adjacentSession) return adjacentSession.index;
+
+  if (!openingPayloadLooksStructural(source, opening)) return -1;
+
+  const lineStart = before.lastIndexOf('\n') + 1;
+  if (!before.slice(lineStart).trim()) return tagStart;
+
+  const name = opening[1].toLowerCase();
+  if (name === 'oai-mem-citation'
+    && tagStart > 0
+    && !/\s/u.test(source[tagStart - 1])) {
+    return tagStart;
+  }
+  return -1;
+}
+
+function findAssistantMetadataRemoval(source) {
+  const openings = source.matchAll(/<(oai-mem-citation|citation_entries|rollout_ids)\b[^>]*>/gi);
+  for (const opening of openings) {
+    const start = metadataStart(source, opening);
+    if (start < 0) continue;
+
+    const name = opening[1].toLowerCase();
+    const tagEnd = opening.index + opening[0].length;
+    const closing = new RegExp(`<\/${name}\\s*>`, 'i').exec(source.slice(tagEnd));
+    const end = closing
+      ? tagEnd + closing.index + closing[0].length
+      : consumeTruncatedMetadata(source, name, tagEnd);
+    return { start, end };
+  }
+  return null;
+}
+
+function removeAssistantMetadata(source, removal) {
+  const before = source.slice(0, removal.start).trimEnd();
+  const after = source.slice(removal.end).trimStart();
+  if (!before) return after;
+  if (!after) return before;
+  return `${before}\n${after}`;
+}
+
+export function sanitizeAssistantMessage(text) {
+  let source = String(text || '');
+  if (!source) return '';
+
+  while (source) {
+    const removal = findAssistantMetadataRemoval(source);
+    if (!removal) break;
+    const next = removeAssistantMetadata(source, removal);
+    if (next.length >= source.length) break;
+    source = next;
+  }
+  return source;
+}

package/packages/integrations/src/transcripts.mjs

@@ -1,4 +1,8 @@
-import { isBootstrapPrompt, redactSecrets } from './prompt-content.mjs';
+import {
+  isBootstrapPrompt,
+  redactSecrets,
+  sanitizeAssistantMessage,
+} from './prompt-content.mjs';
 import {
   addUsage,
   emptyTokenUsage,
@@ -73,6 +77,14 @@ function addConversation(turn, role, value) {
   }
 }
 
+function addAssistantMessage(result, turn, value) {
+  const text = sanitizeAssistantMessage(value);
+  if (!text) return;
+  addUnique(result.assistantMessages, text);
+  addUnique(turn.assistantMessages, text);
+  addConversation(turn, 'Assistente', text);
+}
+
 function normalizeRoot(value) {
   return String(value || '').replace(/\\+/g, '/').replace(/\/+$/, '');
 }
@@ -207,9 +219,7 @@ export function parseCodexTranscriptContent(content, options = {}) {
       const text = event.payload.message || event.payload.text || '';
       if (text) {
         const turn = ensureTurn(event.payload.turn_id || result.latestTurnId, event.timestamp);
-        addUnique(result.assistantMessages, text);
-        addUnique(turn.assistantMessages, text);
-        addConversation(turn, 'Assistente', text);
+        addAssistantMessage(result, turn, text);
       }
       continue;
     }
@@ -234,9 +244,7 @@ export function parseCodexTranscriptContent(content, options = {}) {
         addConversation(turn, 'Usuário', text);
       }
       if (payload.role === 'assistant') {
-        addUnique(result.assistantMessages, text);
-        addUnique(turn.assistantMessages, text);
-        addConversation(turn, 'Assistente', text);
+        addAssistantMessage(result, turn, text);
       }
       continue;
     }
@@ -356,9 +364,7 @@ export function parseClaudeTranscriptContent(content, options = {}) {
       const blocks = Array.isArray(event.message?.content) ? event.message.content : [];
       for (const block of blocks) {
         if (block?.type === 'text' && block.text && block.text.trim()) {
-          addUnique(result.assistantMessages, block.text);
-          addUnique(turn.assistantMessages, block.text);
-          addConversation(turn, 'Assistente', block.text);
+          addAssistantMessage(result, turn, block.text);
         } else if (block?.type === 'tool_use') {
           const name = block.name || 'tool_use';
           addUnique(result.tools, name);

package/src/profile.mjs

@@ -3,10 +3,12 @@
 import { mutateSessionRegistry, readSessionRegistry } from '../hooks/obsidian-common.mjs';
 import {
   DEFAULT_OPERATING_PROFILE,
+  evaluateTaskOperatingProfileLease,
   normalizeOperatingProfile,
   resolveOperatingProfile,
   setOperatingProfile,
 } from './operating-profile.mjs';
+import { setSessionTaskOperatingProfile } from '../hooks/operating-profile-task-store.mjs';
 import { resolve } from 'node:path';
 import { findProjectBinding, resolveProjectVault, updateProjectBinding } from './project-vault.mjs';
 
@@ -14,12 +16,14 @@ export const PROFILE_HELP = `wendkeep profile <subcommand>
 
   status [--session <id>]
   use <OFF|FLOW|GUIDE|GOVERN|ASSURE> [--session <id>]
+  route <FLOW|GUIDE|GOVERN|ASSURE> --session <id> --reason <text>
 
-Common options: --project <path> --vault <path> --session <id> --json
+Common options: --project <path> --vault <path> --session <id> --json --reason <text>
+route creates a task-scoped choice for the current request; it never selects OFF.
 The Keep Core (Vault, session, and memory) remains active under every profile.
 `;
 
-const VALUE_OPTIONS = new Set(['--project', '--vault', '--session']);
+const VALUE_OPTIONS = new Set(['--project', '--vault', '--session', '--reason']);
 const FLAG_OPTIONS = new Set(['--json']);
 
 function optionValue(argv, name) {
@@ -32,8 +36,8 @@ 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 (['--project', '--vault', '--session', '--reason'].includes(value)) { index += 1; continue; }
+    if (value.startsWith('--project=') || value.startsWith('--vault=') || value.startsWith('--session=') || value.startsWith('--reason=')) continue;
     if (value === '--json') continue;
     values.push(value);
   }
@@ -76,8 +80,15 @@ function canonicalPath(value) {
 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`);
+    const scope = payload.scope === 'task'
+      ? `task ${payload.session_id}`
+      : payload.scope === 'session' ? `session ${payload.session_id}` : 'project';
+    const details = [scope, payload.source];
+    if (payload.session_id && payload.base_profile && payload.task_lease?.state) {
+      details.push(`base=${payload.base_profile}/${payload.base_source}`);
+      details.push(`lease=${payload.task_lease.state}`);
+    }
+    process.stdout.write(`${payload.profile} (${details.join('; ')})\n`);
   }
   if (payload.binding_error) {
     const code = payload.binding_error.code || 'WENDKEEP_VAULT_CONFIG_INVALID';
@@ -129,10 +140,7 @@ export function setSessionOperatingProfile(vaultBase, sessionId, profile, { now
   });
 }
 
-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];
+function sessionBaseProfile(entry, projectResolved) {
   if (Object.hasOwn(entry, 'operating_profile')) {
     try {
       return {
@@ -149,6 +157,44 @@ function sessionProfile(vaultBase, sessionId, projectResolved) {
   return { profile: projectResolved.profile, source: projectResolved.source };
 }
 
+function sessionProfile(vaultBase, sessionId, projectResolved) {
+  const sessions = readSessionRegistry(vaultBase).sessions || {};
+  if (!Object.hasOwn(sessions, sessionId)) throw new Error(`sessão não encontrada: ${sessionId}`);
+  return sessionBaseProfile(sessions[sessionId], projectResolved);
+}
+
+function sessionProfileStatus(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];
+  const base = sessionBaseProfile(entry, projectResolved);
+  const taskLease = evaluateTaskOperatingProfileLease(entry.operating_profile_task, {
+    sessionId,
+    turnId: entry.last_prompt_turn_id || '',
+    turnSequence: entry.last_turn_sequence,
+  });
+  return {
+    profile: taskLease.state === 'active' ? taskLease.profile : base.profile,
+    source: taskLease.state === 'active' ? 'task-lease' : base.source,
+    scope: taskLease.state === 'active' ? 'task' : 'session',
+    baseProfile: base.profile,
+    baseSource: base.source,
+    taskLease,
+  };
+}
+
+function sessionOutputPayload(effective, sessionId) {
+  return {
+    profile: effective.profile,
+    source: effective.source,
+    scope: effective.scope,
+    session_id: sessionId,
+    base_profile: effective.baseProfile,
+    base_source: effective.baseSource,
+    task_lease: effective.taskLease,
+  };
+}
+
 export function runProfile(argv = []) {
   try { validateArgv(argv); }
   catch (error) { return fail(error.message); }
@@ -156,6 +202,8 @@ export function runProfile(argv = []) {
   const sub = args[0] || 'status';
   const json = argv.includes('--json');
   const sessionId = optionValue(argv, '--session') || '';
+  const reason = optionValue(argv, '--reason');
+  if (sub !== 'route' && reason) return fail('--reason só é aceito por profile route');
 
   let state;
   try { state = context(argv); }
@@ -166,20 +214,50 @@ export function runProfile(argv = []) {
     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 };
+        ? sessionProfileStatus(state.vaultBase, sessionId, projectResolved)
+        : { profile: projectResolved.profile, source: projectResolved.source, scope: 'project' };
       output({
-        profile: effective.profile,
-        source: effective.source,
-        scope: sessionId ? 'session' : 'project',
-        session_id: sessionId || null,
+        ...(sessionId ? sessionOutputPayload(effective, sessionId) : {
+          profile: effective.profile,
+          source: effective.source,
+          scope: 'project',
+          session_id: 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 (sub === 'route') {
+    if (args.length !== 2) return fail('route requer exatamente um perfil');
+    if (!sessionId) return fail('route requer --session <id>');
+    if (!reason) return fail('route requer --reason <text>');
+    try {
+      const base = sessionProfile(state.vaultBase, sessionId, projectResolved);
+      const lease = setSessionTaskOperatingProfile(
+        state.vaultBase,
+        sessionId,
+        args[1],
+        { reason },
+      );
+      output({
+        profile: lease.profile,
+        source: 'task-lease',
+        scope: 'task',
+        session_id: sessionId,
+        base_profile: base.profile,
+        base_source: base.source,
+        task_lease: lease,
+        ...(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> | route <FLOW|GUIDE|GOVERN|ASSURE>');
+  }
   if (args.length !== 2) return fail(`${sub} requer exatamente um perfil`);
   let profile;
   try { profile = normalizeOperatingProfile(args[1], { strict: true }); }

package/src/skills-seed.mjs

@@ -17,6 +17,24 @@ Use ao começar implementação, correção ou refatoração. **Keep Core perman
 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.
 
+## Seleção temporária por solicitação
+
+Antes de editar, classifique a implementação atual e registre a escolha auditável com
+\`wendkeep profile route <FLOW|GUIDE|GOVERN|ASSURE> --session <id> --reason <texto>\`.
+A lease vale somente para a solicitação atual; ao encerrá-la, o perfil persistente da
+sessão/projeto volta a valer. **OFF nunca é uma escolha automática da LLM**: somente uma pessoa
+pode persistir \`profile use OFF\` explicitamente.
+
+- **FLOW:** ajuste local, reversível e de escopo fechado, sem contrato/spec, segurança,
+  dependência, CI/release ou policy.
+- **GUIDE:** mudança compacta de comportamento que precisa de change/spec, sem revisão formal.
+- **GOVERN:** escolha conservadora em caso de dúvida ou risco e para superfícies sensíveis.
+- **ASSURE:** GOVERN quando confirmação explícita e handoff fazem parte do contrato.
+
+O harness da LLM faz essa classificação semântica; o Wend Runtime valida e aplica a lease.
+Se não houver uma sessão causal identificada ou o comando falhar, não fabrique estado: use o
+perfil efetivo já injetado e trate \`GOVERN\` como fallback conservador quando ele for o padrão.
+
 <HARD-GATE>
 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**.
@@ -268,6 +286,24 @@ Use this when starting an implementation, fix, or refactor. **Keep Core is alway
 in every profile: Vault, session, identity, memory, lessons, and persistence. With no valid
 configuration, **GOVERN is the default** for compatibility.
 
+## Temporary selection per request
+
+Before editing, classify the current implementation and record the auditable choice with
+\`wendkeep profile route <FLOW|GUIDE|GOVERN|ASSURE> --session <id> --reason <text>\`.
+The lease applies only to the current request; after it ends, the persistent session/project
+profile becomes effective again. **OFF is never an automatic LLM choice**: only a human can
+persist it explicitly through \`profile use OFF\`.
+
+- **FLOW:** a local, reversible, bounded adjustment with no contract/spec, security, dependency,
+  CI/release, or policy impact.
+- **GUIDE:** a compact behavior change that needs a change/spec but no formal review.
+- **GOVERN:** the conservative choice when uncertain or risky, and for sensitive surfaces.
+- **ASSURE:** GOVERN when explicit confirmation and handoff are part of the contract.
+
+The LLM harness owns semantic classification; Wend Runtime validates and applies the lease. If
+there is no causally identified session or the command fails, do not fabricate state: use the
+already injected effective profile, with \`GOVERN\` as the conservative configured fallback.
+
 <HARD-GATE>
 Before editing, read the injected **effective profile** and follow only its route:
 - \`OFF\`: impose no Wend process; governance belongs to the **native LLM harness**.
@@ -619,7 +655,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 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-workflow', 'Use quando o usuário pedir para implementar, criar, corrigir, refatorar, adicionar ou alterar código: classifique e registre a rota temporária FLOW/GUIDE/GOVERN/ASSURE ANTES de editar, então siga o perfil efetivo. Keep Core permanece ativo; OFF nunca é automático.', 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 }]),
@@ -628,7 +664,7 @@ const WK_SKILLS_PT = [
 ];
 
 const WK_SKILLS_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-workflow', 'Use when the user asks to implement, create, fix, refactor, add, or change code: classify and record the temporary FLOW/GUIDE/GOVERN/ASSURE route BEFORE editing, then follow the effective profile. Keep Core stays active; OFF is never automatic.', 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 }]),

package/src/sync-defs.mjs

@@ -62,7 +62,12 @@ function renderAgentsSection(skills, sourceHash = '') {
 
 This project uses the [wendkeep](https://github.com/rogersialves/wendkeep) harness. **Keep Core is always active**
 in every profile: Vault, session, identity, memory, lessons, and persistence integrations.
-The effective profile is selected explicitly; missing or invalid configuration uses **GOVERN as the default**.
+The persistent profile is selected explicitly; missing or invalid configuration uses **GOVERN as the default**.
+
+Before an implementation, the native LLM harness classifies the current request and may create a
+task-scoped lease with \`wendkeep profile route <FLOW|GUIDE|GOVERN|ASSURE> --session <id> --reason <text>\`.
+The lease expires when that request ends and the persistent session/project profile becomes
+effective again. **OFF is never selected adaptively**; only a human can persist \`profile use OFF\`.
 
 Route work by the effective profile:
 - **OFF** — Wend Runtime is disabled and governance belongs to the native LLM harness; Keep Core stays active.