wendkeep 0.66.5 → 0.67.1

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(/\/+$/, '');
 }
@@ -158,6 +170,16 @@ function jsonLines(content) {
   }).filter(Boolean);
 }
 
+export function completedCodexTurnIdsContent(content = '') {
+  const completed = new Set();
+  for (const event of jsonLines(content)) {
+    if (event.type !== 'event_msg' || event.payload?.type !== 'task_complete') continue;
+    const turnId = String(event.payload?.turn_id || event.turn_id || '').trim();
+    if (turnId) completed.add(turnId);
+  }
+  return completed;
+}
+
 export function parseCodexTranscriptContent(content, options = {}) {
   const result = createResult('codex');
   const eventUserPrompts = [];
@@ -207,9 +229,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 +254,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 +374,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,22 @@ 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 every implementation, the native LLM harness **MUST run the routing gate**:
+1. Inspect \`wendkeep profile status\`.
+2. Classify the request and choose FLOW, GUIDE, GOVERN, or ASSURE from its scope and risk.
+3. Register the choice with
+   \`wendkeep profile route <FLOW|GUIDE|GOVERN|ASSURE> --session <id> --reason <text>\`.
+4. Re-check \`wendkeep profile status\` and follow the effective profile before editing.
+
+The persistent profile is only the base restored after the task lease; it is not an immutable
+decision for the current task. A base OFF does not block a temporary FLOW/GUIDE/GOVERN/ASSURE
+lease, while a base GOVERN does not prevent choosing FLOW or GUIDE for bounded work. An explicit
+user choice for the request takes precedence. If no causal session is available or routing fails,
+do not invent lease state: follow the effective profile and use GOVERN only as the conservative
+fallback when configuration is missing or invalid. The lease expires when the request ends.
+**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.