wendkeep 0.72.1 → 0.74.0

package/src/observer-sql-store.mjs

@@ -4,9 +4,12 @@ import { createRequire } from 'node:module';
 import { join, basename, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { decodeTranscript, encodeTranscript } from './observer-transcript-store.mjs';
+import {
+  chunkMarkdownDocument, recallEvidence, recallTerms,
+} from '../packages/vault/src/evidence-recall.mjs';
 
 export const OBSERVER_SQL_FILE = 'observer.sqlite';
-export const OBSERVER_SQL_SCHEMA_VERSION = 3;
+export const OBSERVER_SQL_SCHEMA_VERSION = 4;
 export const OBSERVER_EVENT_SCHEMA_VERSION = 1;
 
 const SCHEMA_DIR = fileURLToPath(new URL('../schema/observer/', import.meta.url));
@@ -117,12 +120,106 @@ export function migrateObserverDatabase(db) {
       throw error;
     }
   }
+  rebuildSqlEvidenceIndex(db, { missingOnly: true });
   return {
     version: Number(db.prepare('SELECT COALESCE(MAX(version), 0) AS version FROM schema_migrations').get().version || 0),
     applied: db.prepare('SELECT version, name, applied_at FROM schema_migrations ORDER BY version').all(),
   };
 }
 
+export function observerFts5Support(db) {
+  try {
+    db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS evidence_chunks_fts USING fts5(
+      chunk_id UNINDEXED,
+      project_id UNINDEXED,
+      logical_path,
+      title,
+      heading,
+      content,
+      tokenize = 'unicode61 remove_diacritics 2'
+    )`);
+    return { supported: true, engine: 'fts5' };
+  } catch (error) {
+    return { supported: false, engine: 'lexical-fallback', reason: text(error?.message || error) };
+  }
+}
+
+function synchronizeSqlFts(db) {
+  const support = observerFts5Support(db);
+  if (!support.supported) return support;
+  const chunks = Number(db.prepare('SELECT COUNT(*) AS count FROM document_chunks').get().count || 0);
+  const indexed = Number(db.prepare('SELECT COUNT(*) AS count FROM evidence_chunks_fts').get().count || 0);
+  if (chunks === indexed) return support;
+  db.exec(`DELETE FROM evidence_chunks_fts;
+    INSERT INTO evidence_chunks_fts(chunk_id, project_id, logical_path, title, heading, content)
+    SELECT chunk_id, project_id, logical_path, title, heading, content
+    FROM document_chunks;`);
+  return { ...support, rebuilt: true, chunks };
+}
+
+function writeSqlDocumentChunks(db, {
+  projectId, logicalPath, content, metadata = {}, entityType = 'document', capturedAt = '',
+} = {}) {
+  const chunks = chunkMarkdownDocument({
+    projectId,
+    logicalPath,
+    content,
+    metadata: { ...metadata, observed_at: metadata.observed_at || capturedAt },
+    entityType,
+  });
+  db.prepare('DELETE FROM document_chunks WHERE project_id = ? AND logical_path = ?').run(projectId, logicalPath);
+  const fts = observerFts5Support(db);
+  if (fts.supported) {
+    db.prepare('DELETE FROM evidence_chunks_fts WHERE project_id = ? AND logical_path = ?').run(projectId, logicalPath);
+  }
+  const insert = db.prepare(`INSERT INTO document_chunks(
+    chunk_id, project_id, logical_path, title, heading, entity_type, change_slug,
+    session_id, work_session_id, authority, observed_at, validity, content_hash, ordinal, content
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+  const insertFts = fts.supported
+    ? db.prepare('INSERT INTO evidence_chunks_fts(chunk_id, project_id, logical_path, title, heading, content) VALUES (?, ?, ?, ?, ?, ?)')
+    : null;
+  for (const chunk of chunks) {
+    insert.run(
+      chunk.chunk_id, chunk.project_id, chunk.logical_path, chunk.title, chunk.heading,
+      chunk.entity_type, chunk.change_slug, chunk.session_id, chunk.work_session_id,
+      chunk.authority, chunk.observed_at, chunk.validity, chunk.content_hash,
+      chunk.ordinal, chunk.content,
+    );
+    insertFts?.run(chunk.chunk_id, chunk.project_id, chunk.logical_path, chunk.title, chunk.heading, chunk.content);
+  }
+  return { chunks: chunks.length, fts };
+}
+
+export function rebuildSqlEvidenceIndex(db, { missingOnly = false } = {}) {
+  const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'document_chunks'").get();
+  if (!table) return { documents: 0, chunks: 0, fts: { supported: false, engine: 'unavailable' } };
+  const documents = db.prepare(`SELECT d.project_id, d.logical_path, d.content, d.metadata_json, d.entity_type, d.captured_at
+    FROM documents d
+    WHERE d.deleted_at IS NULL
+      AND (? = 0 OR NOT EXISTS (
+        SELECT 1 FROM document_chunks c
+        WHERE c.project_id = d.project_id AND c.logical_path = d.logical_path
+      ))
+    ORDER BY d.project_id, d.logical_path`).all(missingOnly ? 1 : 0);
+  let chunks = 0;
+  let fts = observerFts5Support(db);
+  for (const document of documents) {
+    const result = writeSqlDocumentChunks(db, {
+      projectId: document.project_id,
+      logicalPath: document.logical_path,
+      content: document.content,
+      metadata: parseJson(document.metadata_json),
+      entityType: document.entity_type,
+      capturedAt: document.captured_at,
+    });
+    chunks += result.chunks;
+    fts = result.fts;
+  }
+  fts = synchronizeSqlFts(db);
+  return { documents: documents.length, chunks, fts };
+}
+
 export function ensureObserverDatabase(dataDir) {
   const db = openObserverDatabase(dataDir);
   try {
@@ -266,6 +363,14 @@ function applyDocument(db, event) {
     VALUES (?, ?, ?, ?, 'upsert', ?, ?, ?, ?, ?, ?)
   `).run(event.event_id, event.project_id, text(p.entity_type || p.entityType, 'memory'), logicalPath, revision, contentHash,
     text(p.source_session_id || p.sourceSessionId), text(p.source_turn_id || p.sourceTurnId), event.occurred_at, json(p));
+  writeSqlDocumentChunks(db, {
+    projectId: event.project_id,
+    logicalPath,
+    content,
+    metadata: p.metadata,
+    entityType: text(p.entity_type || p.entityType, 'memory'),
+    capturedAt: text(p.captured_at || event.occurred_at),
+  });
   return { stale: false };
 }
 
@@ -279,6 +384,10 @@ function applyDocumentDelete(db, event) {
     VALUES (?, ?, ?, ?, 'delete', ?, '', ?, ?, ?, ?)
   `).run(event.event_id, event.project_id, text(event.payload.entity_type || event.payload.entityType, 'memory'), logicalPath,
     integer(event.payload.revision, 1), text(event.payload.source_session_id || event.payload.sourceSessionId), text(event.payload.source_turn_id || event.payload.sourceTurnId), event.occurred_at, json(event.payload));
+  db.prepare('DELETE FROM document_chunks WHERE project_id = ? AND logical_path = ?').run(event.project_id, logicalPath);
+  if (observerFts5Support(db).supported) {
+    db.prepare('DELETE FROM evidence_chunks_fts WHERE project_id = ? AND logical_path = ?').run(event.project_id, logicalPath);
+  }
   return { stale: false };
 }
 
@@ -542,11 +651,38 @@ export function readSqlTree(db, projectId, prefix = '') {
   return { schema_version: OBSERVER_SQL_SCHEMA_VERSION, project_id: projectId, prefix, documents: rows };
 }
 
-export function searchSqlDocuments(db, projectId, query = '') {
+export function searchSqlDocuments(db, projectId, query = '', { forceLexical = false } = {}) {
   requireProject(db, projectId);
-  const q = `%${text(query).replace(/[%_]/g, '\\$&')}%`;
-  const rows = db.prepare(`SELECT logical_path, entity_type, title, content_hash, revision, captured_at, source_session_id, content FROM documents WHERE project_id = ? AND deleted_at IS NULL AND (logical_path LIKE ? ESCAPE '\\' OR title LIKE ? ESCAPE '\\' OR content LIKE ? ESCAPE '\\') ORDER BY captured_at DESC, logical_path LIMIT 100`).all(projectId, q, q, q);
-  return rows.map((row) => ({ ...row, excerpt: row.content.slice(0, 240) }));
+  const terms = recallTerms(query);
+  if (!terms.length) return [];
+  const fts = forceLexical
+    ? { supported: false, engine: 'lexical-fallback' }
+    : observerFts5Support(db);
+  const columns = `c.chunk_id, c.project_id, c.logical_path, c.title, c.heading,
+    c.entity_type, c.change_slug, c.session_id, c.work_session_id, c.authority,
+    c.observed_at, c.validity, c.content_hash AS chunk_content_hash, c.ordinal, c.content,
+    d.content_hash, d.revision, d.captured_at, d.source_session_id`;
+  let rows;
+  if (fts.supported) {
+    const expression = [...new Set(terms)]
+      .map((term) => `"${term.replaceAll('"', '""')}"`)
+      .join(' OR ');
+    rows = db.prepare(`SELECT ${columns} FROM evidence_chunks_fts f
+      JOIN document_chunks c ON c.chunk_id = f.chunk_id
+      JOIN documents d ON d.project_id = c.project_id AND d.logical_path = c.logical_path
+      WHERE evidence_chunks_fts MATCH ? AND c.project_id = ? AND d.deleted_at IS NULL
+      ORDER BY bm25(evidence_chunks_fts, 0, 0, 1.5, 3.0, 2.5, 1.0), c.observed_at DESC
+      LIMIT 200`).all(expression, projectId);
+  } else {
+    // FTS5 may be unavailable in a valid Observer runtime. Rank the complete project corpus
+    // instead of truncating by recency before matching, which would make old exact evidence
+    // permanently unreachable.
+    rows = db.prepare(`SELECT ${columns} FROM document_chunks c
+      JOIN documents d ON d.project_id = c.project_id AND d.logical_path = c.logical_path
+      WHERE c.project_id = ? AND d.deleted_at IS NULL
+      ORDER BY c.observed_at DESC, c.logical_path, c.ordinal`).all(projectId);
+  }
+  return recallEvidence(rows, query, { topK: 5 });
 }
 
 export function readSqlSync(db, projectId) {

package/src/release-provenance.mjs

@@ -1,3 +1,8 @@
+import { execFileSync } from 'node:child_process';
+import { cpSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, join } from 'node:path';
+
 const DEPENDENCY_FIELDS = Object.freeze([
   'dependencies',
   'devDependencies',
@@ -5,6 +10,48 @@ const DEPENDENCY_FIELDS = Object.freeze([
   'peerDependencies',
 ]);
 
+export function parsePackIntegrity(raw) {
+  const text = String(raw || '');
+  const start = text.indexOf('[');
+  const end = text.lastIndexOf(']');
+  if (start < 0 || end < start) return '';
+  try {
+    return String(JSON.parse(text.slice(start, end + 1))[0]?.integrity || '');
+  } catch {
+    return '';
+  }
+}
+
+export function packIntegrityInIsolatedCopy(root, { execute = execFileSync } = {}) {
+  const tempRoot = mkdtempSync(join(tmpdir(), 'wendkeep-release-pack-'));
+  const packageRoot = join(tempRoot, 'package');
+  const ignored = new Set(['.git', 'node_modules']);
+  try {
+    const binding = JSON.parse(readFileSync(join(root, '.wendkeep.json'), 'utf8'));
+    const vault = String(binding.vault || '');
+    if (vault && !vault.includes('/') && !vault.includes('\\')) ignored.add(vault);
+  } catch { /* unbound package: nothing else to exclude */ }
+  try {
+    cpSync(root, packageRoot, {
+      recursive: true,
+      filter(source) {
+        if (source === root) return true;
+        const relativeName = basename(source);
+        return !ignored.has(relativeName);
+      },
+    });
+    const command = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const raw = execute(command, ['pack', '--dry-run', '--json'], {
+      cwd: packageRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return parsePackIntegrity(raw);
+  } finally {
+    rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
 export function packageHasSelfDependency(pkg = {}) {
   const name = String(pkg.name || '');
   if (!name) return false;

package/src/skills-seed.mjs

@@ -27,10 +27,15 @@ 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.
+- **GUIDE:** implementação compacta com change, sem spec/design/ADR automáticos quando contract_impact é none.
 - **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.
 
+Classifique também o work kind: inspection, maintenance, implementation, delivery ou recovery.
+Risco operacional e impacto de contrato são independentes. Merge, push, tag e publish de código
+já aprovado usam delivery + ASSURE sem criar outra change; registre com delivery start e conclua
+com delivery finish para gerar receipt.
+
 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.
@@ -39,6 +44,7 @@ perfil efetivo já injetado e trate \`GOVERN\` como fallback conservador quando
 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.
+- \`delivery\`: inicie \`wendkeep delivery start\` antes das operações autorizadas; não crie change.
 - \`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>
@@ -47,14 +53,16 @@ Este gate nunca transforma \`OFF\` ou \`FLOW\` silenciosamente em \`GOVERN\`.
 
 - **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.
+- **GUIDE — P → E → V:** change new --guide, sem design/spec/ADR automáticos quando não há impacto de contrato.
 - **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:
+2. **Propose** — GUIDE usa \`wendkeep change new <slug> --guide\`; GOVERN/ASSURE usam
+   \`wendkeep change new <slug>\`. O GUIDE compacto exige objetivo, critérios de aceite, áreas
+   afetadas, testes e resultado. GOVERN/ASSURE criam \`08-Mudanças/<slug>/\` com:
    - \`proposta.md\` — *por quê* e *o que muda* (o WHAT).
    - \`design.md\` — a abordagem técnica.
    - \`tarefas.md\` — a lista de tarefas \`- [ ] N.N descrição\`.
@@ -83,7 +91,7 @@ Este gate nunca transforma \`OFF\` ou \`FLOW\` silenciosamente em \`GOVERN\`.
    \`[req:]\`) recebe verdict automático — pula este passe.
 6. **Archive** — \`wendkeep change archive <slug>\`. O *gate* exige sensores verdes **E**
    \`verdict.json\` cobrindo os \`[req:]\`. Passando, promove os deltas pro \`07-Specs\`,
-   move a change pro \`_arquivo\` e gera um ADR em \`04-Decisões/\`.
+   move a change pro \`_arquivo\`; GUIDE com contract_impact none não gera ADR automático.
 
 ## Regras
 
@@ -296,10 +304,15 @@ 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.
+- **GUIDE:** compact implementation with a change, but no automatic spec/design/ADR when contract impact is none.
 - **GOVERN:** the conservative choice when uncertain or risky, and for sensitive surfaces.
 - **ASSURE:** GOVERN when explicit confirmation and handoff are part of the contract.
 
+Also classify work kind as inspection, maintenance, implementation, delivery, or recovery.
+Operational risk and contract impact are independent. Merge, push, tag, and publish for
+already-approved code use delivery + ASSURE without another change; use delivery start and
+delivery finish to produce a receipt.
+
 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.
@@ -308,6 +321,7 @@ already injected effective profile, with \`GOVERN\` as the conservative configur
 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.
+- \`delivery\`: run \`wendkeep delivery start\` before authorized operations; do not create a change.
 - \`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>
@@ -316,15 +330,16 @@ This gate never silently turns \`OFF\` or \`FLOW\` into \`GOVERN\`.
 
 - **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.
+- **GUIDE — P → E → V:** change new --guide, with no automatic design/spec/ADR when contract impact is none.
 - **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>/\`
-   (proposta/design/tarefas + a \`specs/\` delta). The change becomes *current* through global
+2. **Propose** — GUIDE uses \`wendkeep change new <slug> --guide\`; GOVERN/ASSURE use
+   \`wendkeep change new <slug>\`. Compact GUIDE requires objective, acceptance criteria,
+   affected areas, tests, and result. The change becomes *current* through global
    \`.brain/CURRENT_CHANGE.md\`. Multiple changes may stay open; hooks and \`change list/status\`
    show every pending task, while commands without \`--change\` use only the current change.
    Before implementation, resolve \`spec_impact\`: \`required\` needs the capability listed in
@@ -341,7 +356,8 @@ This gate never silently turns \`OFF\` or \`FLOW\` into \`GOVERN\`.
 5. **Verify deep** — the **wk-verify** skill (fresh, author≠verifier) writes \`verdict.json\`.
    A trivial change (no \`[req:]\`) gets an auto verdict.
 6. **Archive** — \`wendkeep change archive <slug>\`. The gate needs green sensors AND a
-   verdict AND no open tasks. It promotes the delta into \`07-Specs\` and mints an ADR.
+   verdict AND no open tasks. It promotes the delta into \`07-Specs\`; compact GUIDE does not
+   mint an automatic ADR.
 
 ## Rules
 - Multiple changes may stay open. \`CURRENT_CHANGE.md\` marks one current change without hiding

package/src/sync-defs.mjs

@@ -66,7 +66,7 @@ The persistent profile is selected explicitly; missing or invalid configuration
 
 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.
+2. Classify work kind, contract impact, and operation risk independently; then choose the profile.
 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.
@@ -82,12 +82,15 @@ fallback when configuration is missing or invalid. The lease expires when the re
 Route work by the effective profile:
 - **OFF** — Wend Runtime is disabled and governance belongs to the native LLM harness; Keep Core stays active.
 - **FLOW** — Execute → Validate through \`wendkeep flow start/finish\`, without creating a change.
-- **GUIDE** — Plan → Execute → Validate through a compact change.
+- **GUIDE** — Plan → Execute → Validate through \`change new --guide\`; no automatic spec/design/ADR for contract_impact none.
 - **GOVERN** — the default a2 loop: \`wendkeep change new <slug>\` → review → implement tasks test-first
   (tag proof \`[sensor:id]\` and requirement \`[req:ID]\`) → \`wendkeep verify\` →
   \`wendkeep verify --deep\` + independent read-only verdict → \`wendkeep change archive\`.
 - **ASSURE** — GOVERN plus explicit confirmation and handoff.
 
+Delivery of already-approved behavior uses \`wendkeep delivery start/status/finish/abandon\` with
+ASSURE authorization and an append-only receipt. It does not create a new change, spec, or ADR.
+
 Inspect with \`wendkeep profile status\` / \`wendkeep change status\` /
 \`spec effective --change <slug>\` / \`sensors list\`. Author specs only in
 \`08-Mudanças/<slug>/specs/\`; \`07-Specs\` is generated and must not be edited directly.

package/src/sync.mjs

@@ -81,11 +81,11 @@ export async function runSync(argv) {
   // código é propagado sem ser tratado como falha da cadeia.
   step(3, 'doctor');
   const { runDoctor } = await import('./doctor.mjs');
-  const doctorCode = runDoctor(['--vault', vaultBase, '--project', projectPath]);
+  const doctorCode = runDoctor(['--vault', vaultBase, '--project', projectPath, '--scope', 'core']);
 
   // Nunca afirmar "tudo em dia": o doctor sai 0 mesmo tendo listado órfãos, seções
   // desatualizadas ou modelos sem preço — essas checagens não são fatais. Uma linha final
   // otimista contradiria o relatório logo acima dela.
-  process.stdout.write(`\nwendkeep sync: 3 passo(s) concluído(s)${doctorCode ? ' — doctor reportou erros' : ' — veja o relatório do doctor acima'}\n`);
+  process.stdout.write(`\nwendkeep sync: ${doctorCode ? 'falhou — Keep Core comprometido' : 'concluído — Keep Core saudável'}\n`);
   return doctorCode;
 }

package/src/taxonomy.mjs

@@ -65,6 +65,8 @@ export const HOOK_FILES = [
   'subagent-usage.mjs',
   'pricing.json',
   'brain-core.mjs',
+  'evidence-recall.mjs',
+  'memory-scope.mjs',
   'memory-schema.mjs',
   'memory-store.mjs',
   'memory-handoff.mjs',
@@ -83,6 +85,7 @@ export const HOOK_FILES = [
   'harness-doctor.mjs',
   'lessons-core.mjs',
   'brain-inject.mjs',
+  'evidence-context.mjs',
   'brain-recall.mjs',
   'brain-reindex.mjs',
   'session-backfill.mjs',
@@ -114,6 +117,7 @@ export const RUNNABLE_HOOKS = [
   'subagent-stop',
   'task-log',
   'brain-inject',
+  'evidence-context',
   'brain-recall',
   'brain-reindex',
   'vault-health',

package/src/work-kind.mjs

@@ -0,0 +1,62 @@
+export const WORK_KINDS = Object.freeze([
+  'inspection',
+  'maintenance',
+  'implementation',
+  'delivery',
+  'recovery',
+]);
+
+export const CONTRACT_IMPACTS = Object.freeze(['none', 'internal', 'public']);
+
+function normalize(value, values, code, label) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (values.includes(normalized)) return normalized;
+  const error = new Error(`${label} inválido: ${String(value || '(vazio)')}. Use ${values.join(', ')}.`);
+  error.code = code;
+  throw error;
+}
+
+export function normalizeWorkKind(value) {
+  return normalize(value, WORK_KINDS, 'WENDKEEP_WORK_KIND_INVALID', 'work kind');
+}
+
+export function normalizeContractImpact(value) {
+  return normalize(value, CONTRACT_IMPACTS, 'WENDKEEP_CONTRACT_IMPACT_INVALID', 'contract impact');
+}
+
+export function createWorkRoute({
+  workKind,
+  profile = '',
+  contractImpact = 'none',
+  operationRisk = [],
+  sourceChange = '',
+  sourceCommit = '',
+} = {}) {
+  const kind = normalizeWorkKind(workKind);
+  const impact = normalizeContractImpact(contractImpact);
+  const risks = [...new Set((Array.isArray(operationRisk) ? operationRisk : [operationRisk])
+    .map((item) => String(item || '').trim()).filter(Boolean))];
+  if (kind === 'delivery' && impact !== 'none') {
+    const error = new Error('delivery só aceita contract_impact none; alteração de contrato exige implementation.');
+    error.code = 'WENDKEEP_DELIVERY_CONTRACT_IMPACT';
+    throw error;
+  }
+  return {
+    work_kind: kind,
+    profile: String(profile || (kind === 'delivery' ? 'ASSURE' : '')).trim().toUpperCase(),
+    contract_impact: impact,
+    operation_risk: risks,
+    ...(sourceChange ? { source_change: String(sourceChange) } : {}),
+    ...(sourceCommit ? { source_commit: String(sourceCommit) } : {}),
+  };
+}
+
+export function classifyWorkRequest(prompt) {
+  const text = String(prompt || '').toLowerCase();
+  if (/acompanhar|acompanhe|status|actions|diff|inspecion/.test(text)) return 'inspection';
+  if (/token\s+(?:expir|venc)|credencial.*(?:expir|venc)/.test(text)) return 'recovery';
+  if (/corrig|corrij|alter|implementar|package\.json.*errad|workflow.*(?:errad|falh)/.test(text)) return 'implementation';
+  if (/merge|push|public|publish|tag|release/.test(text)) return 'delivery';
+  if (/texto|formata|manuten/.test(text)) return 'maintenance';
+  return 'implementation';
+}